Added RegionQueryCache, which will be used to for cached regions-contain-point lookups.

RuleLists abstract events, and provide a way to unify WorldGuard's various code paths eventually.

There's also a general cleanup of everything and added support for changing the per-world configurations and blacklists (fixes WORLDGUARD-2232). WORLDGUARD-2203 is implicitly fixed by this, although not entirely fully as this does not yet replace blacklists.

Most configuration settings have been rewritten as RuleList rules and can be found in src/main/resources/builtin_rules.yml. Some configuration changes were made: anti-wolf-dumbness was deprecated in favor of wolves-practically-invincible, and ocelots-practically-invincible was added.

Sponges can now re-place water when they are removed, fixing WORLDGUARD-2202.

.gitattributes

@@ -0,0 +1,2 @@
+*.java   diff=java
+

.gitignore

@@ -0,0 +1,6 @@
+.classpath
+.project
+.settings
+target
+
+.DS_Store

.travis.yml

@@ -0,0 +1,7 @@
+language: java
+jdk:
+  - oraclejdk7
+  - openjdk7
+  - openjdk6
+notifications:
+  email: false

CHANGELOG.txt

@@ -1,3 +1,144 @@
+5.6:
+- Added official support for Minecraft 1.4. Support for 1.3.2 (and below) is still
+    provided in this release.
+- Added support for new and existing explosion types.
+- Added support for blocking withers with the following settings:
+    mobs:
+        block-wither-explosions: false
+        block-wither-block-damage: false
+        block-wither-skull-explosions: false
+        block-wither-skull-block-damage: true
+- Added support for blocking item frames (and their use) in protected regions.
+- Added item frame destruction region flags (if you wish to disable item frame 
+    destruction completely).
+- (Re-)added support for priority R-tree region indexes. This means quicker region lookup,
+    and better support for servers with thousands of regions.
+- Improved /region info output for -g group flags.
+- Allowed removing of -g group flags with /region flag.
+- Allowed /region flag to set group and value at once.
+- Deleting a region flag now also deletes group flag.
+- Fixed detection of attack by projectiles to be more accurate.
+- Fixed support for saving non-string flags in the MySQL region support.
+- Fixed spurious comma in "Flags:" /region info output.
+- Fixed players who are not in god mode not receiving damage in PVP areas from
+    enderpearls.
+- Players will now be told that they are in a no-PvP area if they are in one and
+    attempting to attack someone, or that the player they are attacking is in a
+    no-PvP area, if that is the case instead.
+- Fixed an issue where region.getId() was lowercase'd each pass of a for loop in
+    MySQLDatabase.updatePoly2dPoints().
+- Fixed mob damage from projectiles not being properly blocked in regions where
+    applicable.
+- Changed default region wand to leather (#334).
+
+Thank you to the following individuals for their contribution:
+thvortex, Rutr, Glitchfinder, and DarthAndroid.
+
+5.5.4:
+- Minecraft 1.3 support.
+- Fixed /stack dupe bugs.
+- Added regions.use-creature-spawn-event.
+- Update for Async chat issue.
+- Add use flag to cakes.
+- Report number of plugins loaded in report writer.
+- Updated fireblal item blocking.
+- Fixed permissions for /region reload.
+
+5.5.3:
+- Added game mode flag.
+- Added item drop pickup flag to regions.
+- Added support for fireball item blocking (385).
+- Added configuration option to allow creature spawns from plugins.
+- Added host key check.
+- Added a new line split feature to region greetings.
+- Prevented commands in the allow commands list from being blocked and
+    vice versa.
+
+5.5.2:
+- Added potion-splash flag to block splash potions
+- Add entity-painting-destroy which can be used to prevent entities from destroying
+    paintings (skeletons firing arrows)
+- Added send-chat and receive-chat flags
+- Fixed having regions in multiple worlds with the same name not working with MySQL
+- A cancellable event is now fired if WorldGuard disallows PvP. (for developers!)
+- Made /region setparent check worldguard.region.setparent.own/member.<parent> instead
+    of worldguard.region.setparent.own/member.<child>.
+- Allowed passing #<index> in place of a region ID, where <index> is the index as
+    displayed by /region list.
+- Fixed an error that occured when clearing a non-existant region's parent.
+- Added a -s flag to /region teleport, which sends you to the spawn point instead of the
+    teleport point of a region.
+- Added region/role-based permissions to /region teleport.
+- BREAKING CHANGE: Added a LocationFlag class and made the teleport and spawn flags
+    use it.
+- /region info -s now selects the region being queried.
+- Added /region teleport <id>.
+- Vector flags can now be set to the current location with the value "here" and to a
+    specific position with x,y,z.
+- Made /region info show the region you're in if you don't specify an id explicitly.
+- Prevent block ignition from lightning strikes if lightning is blocked in region. Fixes
+    #1175
+- Correctly check both WEPIF and superperms in WorldGurdPlugin.broadcastNotification()
+- Destroy fire blocks when fire-spread is disallowed
+- Added a construct flag that can be used to restrict block placing/destroying in zones
+    to certain roles.
+- Added FallingSand to list of intensive entities to be removed with /halt-activiy.
+- Replaced all usage of CreatureType by EntityType.
+- Updated to support Bukkit 1.2-R0.3 and newer
+- Made auto-god-mode disabled by default again.
+- Added sign protection check disable.
+- Cleaned up javadoc, deprecated duplicate methods, other cleanup
+- Added a RegionGroupFlag to evey region flag Using the /region flag command with -g,
+    the region group that the region flag applies to can be set.
+
+5.5.1:
+- Fixed attacking with arrows from non-PVP to PVP areas
+- Compatibility with Bukkit 1.1-R5
+- Removed broken suppress-tick-sync-warnings config option. See bukkit.yml's setings.warn-on-overload option instead.
+- Add region and 'can build' information to CommandBook's /whois
+
+Contributions thanks to: NolanSyKinsley
+
+5.5:
+- Removed WorldEdit.jar from the classpath to stop conflicts with Bukkit's plugin loader
+- Now using Bukkit's tagged logging
+- Updated to new event system
+- Flush player flag state cache on world change
+- Improved compatibility with versions of CommandBook without GodComponent and updated pom dep for 2.0
+- Added MySQL region storage method.
+- Made explosions display their animations even when the event was blocked.
+- Added fallback support for those who don't have a version of CommandBook with GodComponent
+- Added LIGHTNING flag to DefaultFlag's flagsList Fixes #1026
+- Removed /god, /heal, /locate, and /stack from WorldGuard to CommandBook. CommandBook is now checked to see whether a player is godded.
+- Removed remaining usages of org.bukkit.util.config.Configuration
+- Removed some unused configuration options
+- Added permission worldguard.region.wand to the region wand
+- Fixed ProtectedRegion.compareTo.
+- Fixed FlatRegionManager.getApplicableRegions to return parent regions as well.
+- Added exp-drops flag to disable experience drops per-region.
+- Fixed some warnings.
+- Updated dependency version for WorldGuard from 5.0 to 5.1-SNAPSHOT.
+- Added support for fireballs shot by players being blocked by the PVP flag.
+- Now using dynamic command registration
+- Split off ender dragon block damage from creeper block damage.
+
+Contributions thanks to: narthollis, DarkArc, Wolvereness, and skeight
+
+5.4:
+- Fixed configuration generation on Windows
+- Fixed intersection calculation for regions
+- Fixed timer and feeding delay for food flags
+- Fixed region managers not being created properly (This caused errors related to CREATURE_SPAWN)
+- Added support for Minecraft 1.0.1 blocks
+- Added support for enchantments and tool damage (worldguard.stack.damaged is the node) with /stack
+- Made being in the wg-invincible group respect the configuration's auto-invincible setting
+- Added per-group region claim limit maximum
+- Added worldguard.region.addowner.unclaimed.* permission for non-economy region 'buying'
+- Checking allowed/blocked commands now occurs earlier to override more plugins
+- Made PVP flag check whether either player is in a pvp deny region for blocking
+
+Contributions thanks to: epuidokas, wizjany, Turtle9598, and DerFlash
+
 5.3:
 - Added new config options and flags to better handle explosions of all types
 - Added config options and flags for snow, ice, mushroom spread, grass spread,

CONTRIBUTING.md

@@ -0,0 +1,69 @@
+Contributing
+============
+
+Thank you for your interest in contributing to WorldGuard! We appreciate your 
+effort, but to make sure that the inclusion of your patch is a smooth process, we
+ask that you make note of the following guidelines.
+
+* **Follow the [Oracle coding conventions](http://www.oracle.com/technetwork/java/codeconv-138413.html).**
+  We can't stress this enough; if your code has notable issues, it may delay
+  the process significantly.
+* **Target Java 6 for source and compilation.** Make sure to mark methods with
+  ` @Override` that override methods of parent classes, or that implement
+  methods of interfaces (Java 6+).
+* **Use only spaces for indentation.** Our indents are 4-spaces long, and tabs
+  are unacceptable.
+* **Wrap code to a 89 column limit.** We do this to make side by side diffs
+  and other such tasks easier. Ignore this guideline if it makes the code
+  too unreadable.
+* **Write complete Javadocs.** Do so only for public methods, and make sure
+  that your `@param` and `@return` fields are not just blank.
+* **Don't tag classes with @author.** Some legacy classes may have this tag,
+  but we are phasing it out.
+* **Make sure the code is efficient.** One way you can achieve this is to spend
+  around ten minutes to think about what the code is doing and whether it
+  seems awfully roundabout. If you had to copy the same large piece of
+  code in several places, that's bad.
+* **Keep commit summaries under 70 characters.** For more details, place two
+  new lines after the summary line and write away!
+* **Test your code.** We're not interested in broken code, for the obvious reasons.
+* **Write unit tests.** While this is strictly optional, we recommend it for
+  complicated algorithms.
+
+
+Checklist
+---------
+
+Ready to submit? Perform the checklist below:
+
+1. Have all tabs been replaced into four spaces? Are indentations 4-space wide?
+2. Have I written proper Javadocs for my public methods? Are the @param and
+   @return fields actually filled out?
+3. Have I `git rebase`d my pull request to the latest commit of the target
+   branch?
+4. Have I combined my commits into a reasonably small number (if not one)
+   commit using `git rebase`?
+5. Have I made my pull request too large? Pull requests should introduce
+   small sets of changes at a time. Major changes should be discussed with
+   the team prior to starting work.
+6. Are my commit messages descriptive?
+
+You should be aware of [`git rebase`](http://learn.github.com/p/rebasing.html).
+It allows you to modify existing commit messages, and combine, break apart, or
+adjust past changes.
+
+Example
+-------
+
+This is **GOOD:**
+
+    if (var.func(param1, param2)) {
+        // do things
+    }
+
+This is **EXTREMELY BAD:**
+
+    if(var.func( param1, param2 ))
+    {
+        // do things
+    }

README.html

@@ -1,116 +1,232 @@
 <!DOCTYPE html>
 <html>
 <head>
-<title>WorldGuard ${version}</title>
+<title>${project.name} ${version}</title>
+<link href="http://fonts.googleapis.com/css?family=Source+Sans+Pro:400,700|Ropa+Sans" rel="stylesheet" type="text/css">
 <style>
 body {
-  margin: 0;
-  padding: 20px;
-  background: #efefef;
-  color: #333;
+    margin: 0;
+    padding: 3em 1em;
+    background: #efefef;
+    color: #333;
+    line-height: 1.5;
 }
 #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;
+    width: 600px;
+    margin: auto;
 }
 body, th, td, input {
-  font: 13px/17px "Lucida Grande", "Lucida Sans Unicode", Arial, Verdana, sans-serif;
+    font: 14px 'Source Sans Pro', Arial, sans-serifsans-serif;
+}
+.section {
+	background: #fff;
+	position: relative;
+	padding: 2em 2.4em;
+	margin: 3em auto 4em auto;
+    width: 80%;
+    -webkit-box-shadow: 0 1px 4px rgba(0, 0, 0, 0.1);
+    -moz-box-shadow: 0 1px 4px rgba(0, 0, 0, 0.1);
+    box-shadow: 0 1px 4px rgba(0, 0, 0, 0.1);
+}
+.section:before, .section:after {
+	content: "";
+	position: absolute;
+	z-index: -2;
+}
+.section {
+    -moz-border-radius: 4px;
+    border-radius: 4px;
+}
+.section:before, .section:after {
+	bottom: 15px;
+	left: 10px;
+	width: 50%;
+	height: 20%;
+	max-width: 300px;
+	max-height: 100px;
+    -webkit-box-shadow: 0 15px 10px rgba(0, 0, 0, 0.5);
+    -moz-box-shadow: 0 15px 10px rgba(0, 0, 0, 0.5);
+    box-shadow: 0 15px 10px rgba(0, 0, 0, 0.5);
+    -webkit-transform: rotate(-1deg);
+    -moz-transform: rotate(-1deg);
+    -ms-transform: rotate(-1deg);
+    -o-transform: rotate(-1deg);
+    transform: rotate(-1deg);
+}
+.section:after {
+    right: 10px;
+    left: auto;
+    -webkit-transform: rotate(1deg);
+    -moz-transform: rotate(1deg);
+    -ms-transform: rotate(1deg);
+    -o-transform: rotate(1deg);
+    transform: rotate(1deg);
 }
 a:link, a:visited {
-  color: #00688f;
-  text-decoration: underline;
+    color: #0004b2;   
+    text-decoration: none;
 }
-a:hover, a:active {
-  color: #000;
-  border: 0;
+a:hover {
+    color: #ac0000;
+    text-decoration: none;
+    border-bottom: 1px solid #999;
 }
 h1 {
-  font: 170% "Trebuchet MS", Georgia, serif;
-  font-weight: bold;
-  color: #b90000;
-  margin: 15px 0 5px 0;
+    font: 2.7em 'Ropa Sans', 'Trebuchet MS', Helvetica, Arial, sans-serif;
+    color: #000;
+    margin: 0 0;
+    padding: 0 0 0.2em 0;
+    font-weight: normal;
+    text-align: center;
+    text-shadow: 2px 2px #FFF;
 }
 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;
+    font-size: 1.3em;
+    color: #FFF;
+    margin: -2.5em 0 0.8em 0;
+    float: left;
+    background: #0049FF;
+    padding: 0.4em 0.8em;
+    border-radius: 0.2em;
+    font-weight: normal;
+    text-align: center; 
 }
-.warning {
-  background: #fffedf;
-  padding: 8px;
-  border: 1px dashed #ccc;
-  border-radius: 4px;
-  -moz-border-radius: 4px;
-  -webkit-border-radius: 4px;
-  font-size: 90%;
+h3 {
+    text-transform: uppercase;
+    font-weight: bold;
 }
-.subtle {
-  color: #999;
+h2 + * {
+    clear: both;
 }
-.optional {
-  background: none repeat scroll 0 0 #FFE081;
-  border-radius: 3px 3px 3px 3px;
-  font-size: 80%;
-	font-weight: normal;
-  padding: 1px 4px;
+@media (max-width: 650px) {
+    #wrapper {
+        width: 100%;
+    }
 }
 </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>
+    <h1>${project.name} ${version}</h1>
+    <div class="section">
+        <h2>Getting Started</h2>
+        <p>
+            Thanks for choosing ${project.name}! When you first install ${project.name},
+            nothing will be enabled, so you will need to switch on the features
+            that you need to use, whenever it is convenient for you.
+        </p>
+        <ul>
+            <li><a href="http://wiki.sk89q.com/wiki/${project.name}/Installation">How do I install ${project.name}?</a></li>
+            <li><a href="http://wiki.sk89q.com/wiki/${project.name}/Upgrading">How do I update ${project.name}?</a></li>
+            <li><a href="http://wiki.sk89q.com/wiki/${project.name}#Usage">How do I use ${project.name}?</a></li>
+        </ul>
+        <p>
+            Need help?
+            <a href="http://wiki.sk89q.com/wiki/${project.name}/Support">See the ways that you can get assistance</a>.
+        </p>
+    </div>
+    <div class="section">
+        <h2>Common Issues</h2>
+        
+        <h3>What are the other files that come with the download?</h3>
+        <p>
+            Inside the folder "contrib" of the download are the following files:
+        </p>
+        <ul>
+            <li>blacklist_table.sql is for using a database with the 
+              <a href="http://wiki.sk89q.com/wiki/${project.name}/Blacklist">blacklist feature</a>.</li>
+            <li>region_storage.sql is for using a database with the
+                <a href="http://wiki.sk89q.com/wiki/${project.name}/Regions">region protection feature</a>.</li>
+            <li>region_storage_update_20110325.sql is for updating your region protection
+                database (if you're using it) if your database was made before March 25, 2011.</li>
+        </ul>
+        
+        <h3>${project.name} doesn't seem to work.</h3>
+        <p>
+            Two common mistakes include forgetting to install WorldEdit
+            (${project.name} needs it), or making
+            a syntax error in one of ${project.name}'s configuration files (this is very
+            fatal unfortunately, and can be caused by a single character typed in the wrong place). Try 
+            <a href="http://wiki.sk89q.com/wiki/${project.name}/Support">asking in IRC</a>
+            to see whether anyone can help you.
+        </p>
+        
+        <h3>How do I protect my spawn, or another area?</h3>
+        <p>
+            Read the <a href="http://wiki.sk89q.com/wiki/${project.name}/Regions/Tutorial">area protection tutorial</a>
+            on our wiki. For more detailed information, be sure to read about
+            <a href="http://wiki.sk89q.com/wiki/WorldGuard/Regions">region protection on the wiki</a>. Note
+            that if you can't build in spawn, don't forget that Minecraft comes with its own
+            limited spawn protection that you have to disable (see below).
+        </p>
+        
+        <h3>I or others don't have permission to build.</h3>
+        <p>
+            Unless you copied configuration files from an older installation of 
+            ${project.name}, your problem is either caused by another plugin, or by not
+            disabling the built-in spawn protection of the Minecraft server.
+        </p>
+        
+        <h3>No one can build in a region I made!</h3>
+        <p>
+            Make sure that:
+        </p>
+        <ul>
+            <li>You didn't change the 'build' flag, because protection is on by default
+                when a new region is made. Setting the build flag to 'deny' means that
+                no one can modify the things inside the region.</li>
+            <li>That you added the player as an owner or member of the region. If you are using
+                a group (g:groupName), you may have to give the group the permission of
+                group.groupName for ${project.name} to recognize it.</li>
+            <li>That you disabled spawn protection. The Minecraft server has an automatic
+                spawn protection feature where only 'ops' can build in a definable
+                radius around spawn (by default, it is 16 blocks). If you are on Minecraft
+                1.4 or newer, edit "spawn-protection" in server.properties; otherwise, modify bukkit.yml
+                and change the spawn-radius setting.</li>
+            <li>That it's not another plugin causing you trouble. The error messages of ${project.name} are of
+                a dark red shade. If the color of the "no permission" message is not
+                that color, it is not ${project.name}.</li>
+        </ul>
+        
+        <h3>Everyone can build in a region I made!</h3>
+        <p>
+            Make sure that:
+        </p>
+        <ul>
+            <li>You didn't change the 'build' flag, because protection is on by default
+                when a new region is made. Setting the build flag to 'allow' means that
+                anyone can modify the things inside the region.</li>
+            <li>That it's not caused by another plugin. If players are getting a dark red
+                permission denied message, but they can still build, another plugin
+                is likely causing the conflict.</li>
+        </ul>
+        
+        <h3>Where do I report bugs or suggest ideas?</h3>
+        <p>
+            Make sure you are using the latest version of ${project.name}, try asking in
+            IRC first (see "Need help?" above) if it's a problem, and if you think you've
+            found a bug or have a great suggestion to provide, please
+            report it to <a href="http://youtrack.sk89q.com/issues/WORLDGUARD">our issue tracker</a>.
+        </p>
+        
+        <p>
+            Still need help?
+            <a href="http://wiki.sk89q.com/wiki/${project.name}/Support">See the ways that you can get assistance</a>.
+        </p>
+    </div>
+    <div class="section">
+        <h2>Contributing</h2>
+        <p>
+            Did you know that ${project.name} is open source? That means that you can
+            read the code and learn from it, as well as modify it and submit back
+            changes to help the community!
+        </p>
+        <ul>
+            <li><a href="https://github.com/sk89q/worldguard">View the source code</a></li>
+            <li><a href="http://wiki.sk89q.com/wiki/${project.name}/Development">More information</a></li>
+        </ul>
+    </div>
 </div>
 </body>
 </html>

README.md

@@ -1,25 +1,35 @@
-WorldGuard
+![WorldGuard](http://static.sk89q.com/readme/worldguard.png)
 ==========
 
-WorldGuard protects your Minecraft server. As Minecraft's oldest surviving world protection mod, you know you're in safe hands.
+WorldGuard is a toolbox of various functions, useful for multiplayer servers, that lets you:
+
+* Protect your server from a number of problems.
+* Block fire spread, lava spread, endermen, and more.
+* Flag areas as "no PVP" or "no TNT."
+* Assign ownership to areas so only selected individuals can build.
+* Use a number of useful commands.
+
+WorldGuard is open source and is available under the GNU General Public License v3.
 
 Compiling
 ---------
 
-You need to have Maven installed (http://maven.apache.org). Once installed,
-simply run:
+The project is written for Java 6 and our build process makes use of [Maven](http://maven.apache.org). Detailed compilation information [can be found on the wiki](http://wiki.sk89q.com/wiki/WorldGuard/Development#Compiling).
 
-    mvn clean install
-    
-Maven will automatically download dependencies for you. Note: For that to work,
-be sure to add Maven to your "PATH".
+Dependencies are automatically handled by Maven.
 
 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.
+We happily accept contributions, especially through pull requests on GitHub. Submissions 
+must be licensed under the GNU General Public License v3.
 
-By submitting code, you agree to place to license your code under the 
-GNU General Public License v3.
+Please read CONTRIBUTING.md for important guidelines to follow.
+
+Links
+-----
+
+* [IRC channel](http://skq.me/irc/irc.esper.net/sk89q/) (#sk89q on irc.esper.net)
+* [Issue tracker](http://youtrack.sk89q.com/issues/WORLDGUARD)
+* [Continuous integration](http://build.sk89q.com) [![Build Status](https://secure.travis-ci.org/sk89q/worldguard.png)](http://travis-ci.org/sk89q/worldguard)
+* [End-user documentation](http://wiki.sk89q.com/wiki/WorldGuard)

contrib/blacklist_table.sql

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

contrib/region_storage.sql

@@ -0,0 +1,217 @@
+SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0;
+SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0;
+SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='TRADITIONAL';
+
+-- -----------------------------------------------------
+-- Table `group`
+-- -----------------------------------------------------
+CREATE  TABLE IF NOT EXISTS `group` (
+  `id` INT(10) UNSIGNED NOT NULL AUTO_INCREMENT ,
+  `name` VARCHAR(64) CHARACTER SET 'utf8' COLLATE 'utf8_bin' NOT NULL ,
+  PRIMARY KEY (`id`) ,
+  UNIQUE INDEX `name` (`name` ASC) )
+ENGINE = InnoDB
+AUTO_INCREMENT = 5
+DEFAULT CHARACTER SET = utf8
+COLLATE = utf8_bin;
+
+
+-- -----------------------------------------------------
+-- Table `world`
+-- -----------------------------------------------------
+CREATE  TABLE IF NOT EXISTS `world` (
+  `id` INT(10) UNSIGNED NOT NULL AUTO_INCREMENT ,
+  `name` VARCHAR(128) CHARACTER SET 'utf8' COLLATE 'utf8_bin' NOT NULL ,
+  PRIMARY KEY (`id`) ,
+  UNIQUE INDEX `name` (`name` ASC) )
+ENGINE = InnoDB
+AUTO_INCREMENT = 9
+DEFAULT CHARACTER SET = utf8
+COLLATE = utf8_bin;
+
+
+-- -----------------------------------------------------
+-- Table `region`
+-- -----------------------------------------------------
+CREATE  TABLE IF NOT EXISTS `region` (
+  `id` VARCHAR(128) CHARACTER SET 'utf8' COLLATE 'utf8_bin' NOT NULL ,
+  `world_id` INT(10) UNSIGNED NOT NULL ,
+  `type` ENUM('cuboid','poly2d','global') CHARACTER SET 'utf8' COLLATE 'utf8_bin' NOT NULL ,
+  `priority` SMALLINT(6) NOT NULL DEFAULT '0' ,
+  `parent` VARCHAR(128) CHARACTER SET 'utf8' COLLATE 'utf8_bin' NULL DEFAULT NULL ,
+  PRIMARY KEY (`id`, `world_id`) ,
+  INDEX `fk_region_world` (`world_id` ASC) ,
+  INDEX `parent` (`parent` ASC) ,
+  CONSTRAINT `fk_region_world1`
+    FOREIGN KEY (`world_id` )
+    REFERENCES `world` (`id` )
+    ON DELETE CASCADE
+    ON UPDATE CASCADE,
+  CONSTRAINT `parent`
+    FOREIGN KEY (`parent` )
+    REFERENCES `region` (`id` )
+    ON DELETE SET NULL
+    ON UPDATE CASCADE)
+ENGINE = InnoDB
+DEFAULT CHARACTER SET = utf8
+COLLATE = utf8_bin;
+
+
+-- -----------------------------------------------------
+-- Table `region_cuboid`
+-- -----------------------------------------------------
+CREATE  TABLE IF NOT EXISTS `region_cuboid` (
+  `region_id` VARCHAR(128) CHARACTER SET 'utf8' COLLATE 'utf8_bin' NOT NULL ,
+  `world_id` INT(10) UNSIGNED NOT NULL ,
+  `min_x` BIGINT(20) NOT NULL ,
+  `min_y` BIGINT(20) NOT NULL ,
+  `min_z` BIGINT(20) NOT NULL ,
+  `max_x` BIGINT(20) NOT NULL ,
+  `max_y` BIGINT(20) NOT NULL ,
+  `max_z` BIGINT(20) NOT NULL ,
+  PRIMARY KEY (`region_id`, `world_id`) ,
+  INDEX `fk_region_cuboid_region` (`region_id` ASC) ,
+  CONSTRAINT `fk_region_cuboid_region`
+    FOREIGN KEY (`region_id` , `world_id` )
+    REFERENCES `region` (`id` , `world_id` )
+    ON DELETE CASCADE
+    ON UPDATE CASCADE)
+ENGINE = InnoDB
+DEFAULT CHARACTER SET = utf8
+COLLATE = utf8_bin;
+
+
+-- -----------------------------------------------------
+-- Table `region_flag`
+-- -----------------------------------------------------
+CREATE  TABLE IF NOT EXISTS `region_flag` (
+  `id` INT(10) UNSIGNED NOT NULL AUTO_INCREMENT ,
+  `region_id` VARCHAR(128) CHARACTER SET 'utf8' COLLATE 'utf8_bin' NOT NULL ,
+  `world_id` INT(10) UNSIGNED NOT NULL ,
+  `flag` VARCHAR(45) CHARACTER SET 'utf8' COLLATE 'utf8_bin' NOT NULL ,
+  `value` VARCHAR(256) CHARACTER SET 'utf8' COLLATE 'utf8_bin' NOT NULL ,
+  PRIMARY KEY (`id`) ,
+  INDEX `fk_flags_region` (`region_id` ASC, `world_id` ASC) ,
+  CONSTRAINT `fk_flags_region`
+    FOREIGN KEY (`region_id` , `world_id` )
+    REFERENCES `region` (`id` , `world_id` )
+    ON DELETE CASCADE
+    ON UPDATE CASCADE)
+ENGINE = InnoDB
+AUTO_INCREMENT = 3246
+DEFAULT CHARACTER SET = utf8
+COLLATE = utf8_bin;
+
+
+-- -----------------------------------------------------
+-- Table `region_groups`
+-- -----------------------------------------------------
+CREATE  TABLE IF NOT EXISTS `region_groups` (
+  `region_id` VARCHAR(128) CHARACTER SET 'utf8' COLLATE 'utf8_bin' NOT NULL ,
+  `world_id` INT(10) UNSIGNED NOT NULL ,
+  `group_id` INT(10) UNSIGNED NOT NULL ,
+  `owner` TINYINT(1) NOT NULL ,
+  PRIMARY KEY (`region_id`, `world_id`, `group_id`) ,
+  INDEX `fk_region_groups_region` (`region_id` ASC) ,
+  INDEX `fk_region_groups_group` (`group_id` ASC) ,
+  CONSTRAINT `fk_region_groups_group`
+    FOREIGN KEY (`group_id` )
+    REFERENCES `group` (`id` )
+    ON DELETE CASCADE
+    ON UPDATE CASCADE,
+  CONSTRAINT `fk_region_groups_region`
+    FOREIGN KEY (`region_id` , `world_id` )
+    REFERENCES `region` (`id` , `world_id` )
+    ON DELETE CASCADE
+    ON UPDATE CASCADE)
+ENGINE = InnoDB
+DEFAULT CHARACTER SET = utf8
+COLLATE = utf8_bin;
+
+
+-- -----------------------------------------------------
+-- Table `user`
+-- -----------------------------------------------------
+CREATE  TABLE IF NOT EXISTS `user` (
+  `id` INT(10) UNSIGNED NOT NULL AUTO_INCREMENT ,
+  `name` VARCHAR(64) CHARACTER SET 'utf8' COLLATE 'utf8_bin' NOT NULL ,
+  PRIMARY KEY (`id`) ,
+  UNIQUE INDEX `name` (`name` ASC) )
+ENGINE = InnoDB
+AUTO_INCREMENT = 82
+DEFAULT CHARACTER SET = utf8
+COLLATE = utf8_bin;
+
+
+-- -----------------------------------------------------
+-- Table `region_players`
+-- -----------------------------------------------------
+CREATE  TABLE IF NOT EXISTS `region_players` (
+  `region_id` VARCHAR(128) CHARACTER SET 'utf8' COLLATE 'utf8_bin' NOT NULL ,
+  `world_id` INT(10) UNSIGNED NOT NULL ,
+  `user_id` INT(10) UNSIGNED NOT NULL ,
+  `owner` TINYINT(1) NOT NULL ,
+  PRIMARY KEY (`region_id`, `world_id`, `user_id`) ,
+  INDEX `fk_region_players_region` (`region_id` ASC) ,
+  INDEX `fk_region_users_user` (`user_id` ASC) ,
+  CONSTRAINT `fk_region_users_region`
+    FOREIGN KEY (`region_id` , `world_id` )
+    REFERENCES `region` (`id` , `world_id` )
+    ON DELETE CASCADE
+    ON UPDATE CASCADE,
+  CONSTRAINT `fk_region_users_user`
+    FOREIGN KEY (`user_id` )
+    REFERENCES `user` (`id` )
+    ON DELETE CASCADE
+    ON UPDATE CASCADE)
+ENGINE = InnoDB
+DEFAULT CHARACTER SET = utf8
+COLLATE = utf8_bin;
+
+
+-- -----------------------------------------------------
+-- Table `region_poly2d`
+-- -----------------------------------------------------
+CREATE  TABLE IF NOT EXISTS `region_poly2d` (
+  `region_id` VARCHAR(128) CHARACTER SET 'utf8' COLLATE 'utf8_bin' NOT NULL ,
+  `world_id` INT(10) UNSIGNED NOT NULL ,
+  `min_y` INT(11) NOT NULL ,
+  `max_y` INT(11) NOT NULL ,
+  PRIMARY KEY (`region_id`, `world_id`) ,
+  INDEX `fk_region_poly2d_region` (`region_id` ASC) ,
+  CONSTRAINT `fk_region_poly2d_region`
+    FOREIGN KEY (`region_id` , `world_id` )
+    REFERENCES `region` (`id` , `world_id` )
+    ON DELETE CASCADE
+    ON UPDATE CASCADE)
+ENGINE = InnoDB
+DEFAULT CHARACTER SET = utf8
+COLLATE = utf8_bin;
+
+
+-- -----------------------------------------------------
+-- Table `region_poly2d_point`
+-- -----------------------------------------------------
+CREATE  TABLE IF NOT EXISTS `region_poly2d_point` (
+  `id` BIGINT(20) UNSIGNED NOT NULL AUTO_INCREMENT ,
+  `region_id` VARCHAR(128) CHARACTER SET 'utf8' COLLATE 'utf8_bin' NOT NULL ,
+  `world_id` INT(10) UNSIGNED NOT NULL ,
+  `x` BIGINT(20) NOT NULL ,
+  `z` BIGINT(20) NOT NULL ,
+  PRIMARY KEY (`id`) ,
+  INDEX `fk_region_poly2d_point_region_poly2d` (`region_id` ASC, `world_id` ASC) ,
+  CONSTRAINT `fk_region_poly2d_point_region_poly2d`
+    FOREIGN KEY (`region_id` , `world_id` )
+    REFERENCES `region_poly2d` (`region_id` , `world_id` )
+    ON DELETE CASCADE
+    ON UPDATE CASCADE)
+ENGINE = InnoDB
+AUTO_INCREMENT = 15
+DEFAULT CHARACTER SET = utf8
+COLLATE = utf8_bin;
+
+
+
+SET SQL_MODE=@OLD_SQL_MODE;
+SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS;
+SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS;

contrib/region_storage_update_20110325.sql

@@ -0,0 +1,106 @@
+SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0;
+SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0;
+SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='TRADITIONAL';
+
+ALTER TABLE `region_cuboid` DROP FOREIGN KEY `fk_region_cuboid_region` ;
+
+ALTER TABLE `region_flag` DROP FOREIGN KEY `fk_flags_region1` ;
+
+ALTER TABLE `region_groups` DROP FOREIGN KEY `fk_region_groups_region` ;
+
+ALTER TABLE `region_players` DROP FOREIGN KEY `fk_region_players_user` , DROP FOREIGN KEY `fk_region_players_region` ;
+
+ALTER TABLE `region_poly2d` DROP FOREIGN KEY `fk_region_poly2d_region` ;
+
+ALTER TABLE `region_poly2d_point` DROP FOREIGN KEY `fk_region_poly2d_point_region_poly2d` ;
+
+ALTER TABLE `group` COLLATE = utf8_bin ;
+
+ALTER TABLE `region_cuboid` COLLATE = utf8_bin , ADD COLUMN `world_id` INT(10) UNSIGNED NOT NULL  AFTER `region_id` , CHANGE COLUMN `min_x` `min_x` BIGINT(20) NOT NULL  AFTER `world_id` , CHANGE COLUMN `min_y` `min_y` BIGINT(20) NOT NULL  AFTER `min_x` , CHANGE COLUMN `max_x` `max_x` BIGINT(20) NOT NULL  AFTER `min_z` , CHANGE COLUMN `max_y` `max_y` BIGINT(20) NOT NULL  AFTER `max_x` , 
+  ADD CONSTRAINT `fk_region_cuboid_region`
+  FOREIGN KEY (`region_id` , `world_id` )
+  REFERENCES `region` (`id` , `world_id` )
+  ON DELETE CASCADE
+  ON UPDATE CASCADE
+, DROP PRIMARY KEY 
+, ADD PRIMARY KEY (`region_id`, `world_id`) ;
+
+ALTER TABLE `region_flag` COLLATE = utf8_bin , ADD COLUMN `world_id` INT(10) UNSIGNED NOT NULL  AFTER `region_id` , CHANGE COLUMN `flag` `flag` VARCHAR(45) CHARACTER SET 'utf8' COLLATE 'utf8_bin' NOT NULL  , 
+  ADD CONSTRAINT `fk_flags_region`
+  FOREIGN KEY (`region_id` , `world_id` )
+  REFERENCES `region` (`id` , `world_id` )
+  ON DELETE CASCADE
+  ON UPDATE CASCADE
+, DROP INDEX `fk_flags_region` 
+, ADD INDEX `fk_flags_region` (`region_id` ASC, `world_id` ASC) ;
+
+ALTER TABLE `region_groups` COLLATE = utf8_bin , ADD COLUMN `world_id` INT(10) UNSIGNED NOT NULL  AFTER `region_id` , DROP FOREIGN KEY `fk_region_groups_group` ;
+
+ALTER TABLE `region_groups` 
+  ADD CONSTRAINT `fk_region_groups_group`
+  FOREIGN KEY (`group_id` )
+  REFERENCES `group` (`id` )
+  ON DELETE CASCADE
+  ON UPDATE CASCADE, 
+  ADD CONSTRAINT `fk_region_groups_region`
+  FOREIGN KEY (`region_id` , `world_id` )
+  REFERENCES `region` (`id` , `world_id` )
+  ON DELETE CASCADE
+  ON UPDATE CASCADE
+, DROP PRIMARY KEY 
+, ADD PRIMARY KEY (`region_id`, `world_id`, `group_id`) ;
+
+ALTER TABLE `region_players` COLLATE = utf8_bin , ADD COLUMN `world_id` INT(10) UNSIGNED NOT NULL  AFTER `region_id` , 
+  ADD CONSTRAINT `fk_region_users_region`
+  FOREIGN KEY (`region_id` , `world_id` )
+  REFERENCES `region` (`id` , `world_id` )
+  ON DELETE CASCADE
+  ON UPDATE CASCADE, 
+  ADD CONSTRAINT `fk_region_users_user`
+  FOREIGN KEY (`user_id` )
+  REFERENCES `user` (`id` )
+  ON DELETE CASCADE
+  ON UPDATE CASCADE
+, DROP PRIMARY KEY 
+, ADD PRIMARY KEY (`region_id`, `world_id`, `user_id`) 
+, ADD INDEX `fk_region_users_user` (`user_id` ASC) 
+, DROP INDEX `fk_region_players_user` ;
+
+ALTER TABLE `region_poly2d` COLLATE = utf8_bin , ADD COLUMN `world_id` INT(10) UNSIGNED NOT NULL  AFTER `region_id` , CHANGE COLUMN `min_y` `min_y` INT(11) NOT NULL  AFTER `world_id` , 
+  ADD CONSTRAINT `fk_region_poly2d_region`
+  FOREIGN KEY (`region_id` , `world_id` )
+  REFERENCES `region` (`id` , `world_id` )
+  ON DELETE CASCADE
+  ON UPDATE CASCADE
+, DROP PRIMARY KEY 
+, ADD PRIMARY KEY (`region_id`, `world_id`) ;
+
+ALTER TABLE `region_poly2d_point` COLLATE = utf8_bin , ADD COLUMN `world_id` INT(10) UNSIGNED NOT NULL  AFTER `region_id` , CHANGE COLUMN `x` `x` BIGINT(20) NOT NULL  AFTER `world_id` , 
+  ADD CONSTRAINT `fk_region_poly2d_point_region_poly2d`
+  FOREIGN KEY (`region_id` , `world_id` )
+  REFERENCES `region_poly2d` (`region_id` , `world_id` )
+  ON DELETE CASCADE
+  ON UPDATE CASCADE
+, DROP INDEX `fk_region_poly2d_point_region_poly2d` 
+, ADD INDEX `fk_region_poly2d_point_region_poly2d` (`region_id` ASC, `world_id` ASC) ;
+
+ALTER TABLE `user` COLLATE = utf8_bin ;
+
+ALTER TABLE `world` COLLATE = utf8_bin ;
+
+
+UPDATE `region_cuboid` AS c SET c.`world_id` = (SELECT p.`world_id` FROM `region` AS p WHERE p.`id` = c.`region_id`);
+
+UPDATE `region_flag` AS c SET c.`world_id` = (SELECT p.`world_id` FROM `region` AS p WHERE p.`id` = c.`region_id`);
+
+UPDATE `region_groups` AS c SET c.`world_id` = (SELECT p.`world_id` FROM `region` AS p WHERE p.`id` = c.`region_id`);
+
+UPDATE `region_players` AS c SET c.`world_id` = (SELECT p.`world_id` FROM `region` AS p WHERE p.`id` = c.`region_id`);
+
+UPDATE `region_poly2d` AS c SET c.`world_id` = (SELECT p.`world_id` FROM `region` AS p WHERE p.`id` = c.`region_id`);
+
+UPDATE `region_poly2d_point` AS c SET c.`world_id` = (SELECT p.`world_id` FROM `region` AS p WHERE p.`id` = c.`region_id`);
+
+SET SQL_MODE=@OLD_SQL_MODE;
+SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS;
+SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS;

pom.xml

@@ -1,192 +1,247 @@
-<!--
-  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.3</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.7</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>
-    <dependency>
-      <groupId>junit</groupId>
-      <artifactId>junit</artifactId>
-      <version>4.8.1</version>
-      <scope>test</scope>
-    </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>
+<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.7-SNAPSHOT</version>
+  <name>WorldGuard</name>
+  <description>WorldGuard protects your Minecraft servers.</description>
+  <licenses>
+    <license>
+      <name>GNU General Public License 2.0</name>
+      <url>LICENSE.txt</url>
+      <distribution>repo</distribution>
+      <comments>License on all contributions</comments>
+    </license>
+  </licenses>
+  <scm>
+    <connection>scm:git:git://github.com/sk89q/worldguard.git</connection>
+    <url>https://github.com/sk89q/worldguard</url>
+    <tag>master</tag>
+    <developerConnection>scm:git:git@github.com:sk89q/worldguard.git</developerConnection>
+  </scm>
+  <properties>
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+  </properties>
+  <repositories>
+    <repository>
+      <id>sk89q-repo</id>
+      <url>http://maven.sk89q.com/repo/</url>
+    </repository>
+    <repository>
+      <id>zml-repo</id>
+      <url>http://files.zachsthings.com/repo</url>
+    </repository>
+    <repository>
+      <id>bukkit-repo</id>
+      <url>http://repo.bukkit.org/content/groups/public</url>
+    </repository>
+  </repositories>
+  <dependencies>
+    <dependency>
+      <groupId>com.sk89q</groupId>
+      <artifactId>worldedit</artifactId>
+      <version>5.4.4</version>
+      <scope>compile</scope>
+    </dependency>
+    <dependency>
+      <groupId>com.sk89q</groupId>
+      <artifactId>rebar</artifactId>
+      <version>4.1.0-SNAPSHOT</version>
+      <scope>compile</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.bukkit</groupId>
+      <artifactId>bukkit</artifactId>
+      <version>1.4.2-R0.2-SNAPSHOT</version>
+      <scope>compile</scope>
+    </dependency>
+    <dependency>
+      <groupId>com.sk89q</groupId>
+      <artifactId>commandbook</artifactId>
+      <version>2.1</version>
+      <scope>compile</scope>
+      <exclusions>
+        <exclusion>
+          <groupId>com.zachsthings.libcomponents</groupId>
+          <artifactId>libcomponents-bukkit</artifactId>
+        </exclusion>
+        <exclusion>
+          <groupId>org.spout</groupId>
+          <artifactId>spoutapi</artifactId>
+        </exclusion>
+      </exclusions>
+    </dependency>
+    <dependency>
+      <groupId>com.nijikokun</groupId>
+      <artifactId>iconomy</artifactId>
+      <version>5.0</version>
+      <scope>compile</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.khelekore</groupId>
+      <artifactId>prtree</artifactId>
+      <version>1.5.0</version>
+      <scope>compile</scope>
+    </dependency>
+    <dependency>
+      <groupId>net.sf.opencsv</groupId>
+      <artifactId>opencsv</artifactId>
+      <version>2.0</version>
+      <scope>compile</scope>
+    </dependency>
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <version>4.8.1</version>
+      <scope>test</scope>
+    </dependency>
+  </dependencies>
+  <distributionManagement>
+    <site>
+      <id>sk89q-docs-upload</id>
+      <url>ftp://sk89q-maven-deploy/worldguard/</url>
+    </site>
+  </distributionManagement>
+  <build>
+    <defaultGoal>install</defaultGoal>
+    <sourceDirectory>${basedir}/src/main/java</sourceDirectory>
+    
+    <extensions>
+      <extension>
+        <groupId>org.apache.maven.wagon</groupId>
+         <artifactId>wagon-ftp</artifactId>
+         <version>1.0-beta-6</version>
+      </extension>
+    </extensions>
+
+    <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>blacklist.txt</include>
+          <include>builtin_rules.yml</include>
+          <include>rulelist.yml</include>
+        </includes>
+      </resource>
+    </resources>
+
+    <plugins>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-compiler-plugin</artifactId>
+        <version>2.3.2</version>
+        <configuration>
+          <source>1.6</source>
+          <target>1.6</target>
+        </configuration>
+      </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>WorldGuard/WorldEdit.jar lib/WorldEdit.jar ../lib/WorldEdit.jar ../WorldEdit.jar</Class-Path>
+            </manifestEntries>
+          </archive>
+        </configuration>
+      </plugin>
+      
+      <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>
+                <includes>
+                  <include>net.sf.opencsv:opencsv</include>
+                  <include>org.khelekore:prtree</include>
+                  <include>com.sk89q:rebar</include>
+                </includes>
+              </artifactSet>
+            </configuration>
+          </execution>
+        </executions>
+      </plugin>
+      
+      <plugin>
+        <artifactId>maven-assembly-plugin</artifactId>
+        <version>2.2-beta-2</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>
+      
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-release-plugin</artifactId>
+        <version>2.2.2</version>
+        <configuration>
+          <preparationGoals>assembly:assembly</preparationGoals>
+          <goals>assembly:assembly</goals>
+          <tagNameFormat>@{project.version}</tagNameFormat>
+        </configuration>
+      </plugin>
+      
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-site-plugin</artifactId>
+        <version>3.1</version>
+        <configuration>
+          <reportPlugins>
+          <plugin>
+            <groupId>org.apache.maven.plugins</groupId>
+            <artifactId>maven-project-info-reports-plugin</artifactId>
+            <version>2.5</version>
+            <reportSets>
+              <reportSet>
+                <reports>
+                  <report>license</report>
+                  <report>index</report>
+                </reports>
+              </reportSet>
+            </reportSets>
+          </plugin>
+            <plugin>
+              <groupId>org.apache.maven.plugins</groupId>
+              <artifactId>maven-javadoc-plugin</artifactId>
+              <version>2.8.1</version>
+            </plugin>
+          </reportPlugins>
+        </configuration>
+      </plugin>
+    </plugins>
+  </build>
+</project>

src/main/assembly/default.xml

@@ -28,7 +28,10 @@
       <includes>
         <include>LICENSE.txt</include>
         <include>NOTICE.txt</include>
-        <include>blacklist_table.sql</include>
+        <include>CHANGELOG.txt</include>
+        <include>contrib/blacklist_table.sql</include>
+        <include>contrib/region_storage.sql</include>
+        <include>contrib/region_storage_update_20110325.sql</include>
       </includes>
     </fileSet>
   </fileSets>

src/main/java/com/sk89q/rulelists/Action.java

@@ -0,0 +1,35 @@
+// $Id$
+/*
+ * This file is a part of WorldGuard.
+ * Copyright (c) sk89q <http://www.sk89q.com>
+ * Copyright (c) the WorldGuard team and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free Software 
+ * (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 
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package com.sk89q.rulelists;
+
+/**
+ * An action that will be performed if the conditions are matched of the rule.
+ * 
+ * @param <T> implementation-specific context object
+ */
+public interface Action<T extends Context> {
+    
+    /**
+     * Apply the action.
+     * 
+     * @param context implementation-specific context object
+     */
+    void apply(T context);
+    
+}

src/main/java/com/sk89q/rulelists/Attachment.java

@@ -0,0 +1,40 @@
+// $Id$
+/*
+ * This file is a part of WorldGuard.
+ * Copyright (c) sk89q <http://www.sk89q.com>
+ * Copyright (c) the WorldGuard team and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free Software 
+ * (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 
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package com.sk89q.rulelists;
+
+/**
+ * An object that can learn rules and possibly implement them. Attachments can be
+ * analogous to events that occur in the game. An attachment, for example, would be
+ * a block break event.
+ */
+public interface Attachment {
+
+    /**
+     * Learn a rule.
+     *
+     * @param rule rule
+     */
+    public void learn(Rule<?> rule);
+
+    /**
+     * Forget all previously learned rules.
+     */
+    public void forgetRules();
+
+}

src/main/java/com/sk89q/rulelists/AttachmentManager.java

@@ -0,0 +1,62 @@
+// $Id$
+/*
+ * This file is a part of WorldGuard.
+ * Copyright (c) sk89q <http://www.sk89q.com>
+ * Copyright (c) the WorldGuard team and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free Software 
+ * (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 
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package com.sk89q.rulelists;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Manages known attachment points.
+ *
+ * @see Attachment
+ */
+public class AttachmentManager {
+
+    private final Map<String, Attachment> attachments = new HashMap<String, Attachment>();
+
+    /**
+     * Register an {@link Attachment}.
+     *
+     * @param name name of the attachment (used in a rule's 'when' clause) (case insensitive)
+     * @param attachment attachment
+     */
+    public void register(String name, Attachment attachment) {
+        attachments.put(name.toLowerCase(), attachment);
+    }
+
+    /**
+     * Get an attachment.
+     *
+     * @param name name of the attachment (case insensitive)
+     * @return attachment
+     */
+    public Attachment get(String name) {
+        return attachments.get(name.toLowerCase());
+    }
+
+    /**
+     * Forget all the rules in the registered attachments.
+     */
+    public void forgetRules() {
+        for (Attachment attachment : attachments.values()) {
+            attachment.forgetRules();
+        }
+    }
+
+}

src/main/java/com/sk89q/rulelists/Context.java

@@ -0,0 +1,88 @@
+// $Id$
+/*
+ * This file is a part of WorldGuard.
+ * Copyright (c) sk89q <http://www.sk89q.com>
+ * Copyright (c) the WorldGuard team and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free Software 
+ * (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 
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package com.sk89q.rulelists;
+
+/**
+ * A context has some shared variables that may be used by a number of different
+ * events. Because the context contains common information, criteria and
+ * actions do not have to be custom tailored to specific implementation-specific
+ * events, and can refer to the the properties set on the context. The place
+ * where the information is known as to what is considered the proper valid
+ * value of a common property is during the initial handling of
+ * the event in the implementation.
+ * </p>
+ * Implementations need to have custom contexts that can carry more
+ * information than offered in this abstract implementation. Criteria and
+ * actions can be implement-specific by tailoring themselves to one of these
+ * implementation-specific contexts.
+ * 
+ * @author sk89q
+ */
+public abstract class Context {
+    
+    private boolean matches = false;
+    private boolean cancelled = false;
+
+    /**
+     * Gets whether the event associated with this context has been set to
+     * be cancelled.
+     * 
+     * @return true if the event is set to be cancelled
+     */
+    public boolean isCancelled() {
+        return cancelled;
+    }
+    
+    /**
+     * Set the event associated with this context to be cancelled, if possible.
+     */
+    public void cancel() {
+        setCancelled(true);
+    }
+
+    /**
+     * Set the event associated with this context to be cancelled, if possible.
+     * 
+     * @param cancelled true to cancel
+     */
+    public void setCancelled(boolean cancelled) {
+        this.cancelled = cancelled;
+    }
+
+    /**
+     * Set as to whether all the conditions associated with this context have
+     * evaluated to being true.
+     * 
+     * @param matches match state
+     */
+    void setMatches(boolean matches) {
+        this.matches = matches;
+    }
+    
+    /**
+     * Returns whether all the conditions associated with this context
+     * have been evaluated to true.
+     * 
+     * @return true if all the conditions have been true
+     */
+    public boolean matches() {
+        return matches;
+    }
+
+}

src/main/java/com/sk89q/rulelists/Criteria.java

@@ -0,0 +1,37 @@
+// $Id$
+/*
+ * This file is a part of WorldGuard.
+ * Copyright (c) sk89q <http://www.sk89q.com>
+ * Copyright (c) the WorldGuard team and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free Software 
+ * (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 
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package com.sk89q.rulelists;
+
+/**
+ * A criteria that is evaluated to decide whether the rule should undergo
+ * further processing.
+ * 
+ * @param <T> an implementation-specific context
+ */
+public interface Criteria<T extends Context> {
+
+    /**
+     * Returns whether the current event / context matches this criteria.
+     * 
+     * @param context context to verify
+     * @return true if it matches
+     */
+    boolean matches(T context);
+
+}

src/main/java/com/sk89q/rulelists/DefinedRule.java

@@ -0,0 +1,99 @@
+// $Id$
+/*
+ * This file is a part of WorldGuard.
+ * Copyright (c) sk89q <http://www.sk89q.com>
+ * Copyright (c) the WorldGuard team and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free Software 
+ * (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 
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package com.sk89q.rulelists;
+
+import java.util.LinkedList;
+import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * A {@link Rule} implementation with a list of {@link Criteria} and
+ * {@link Action}s.
+ *
+ * @param <T> underlying implementation-specific context
+ */
+public class DefinedRule<T extends Context> implements Rule<T> {
+    
+    private static Logger logger = Logger.getLogger(Rule.class.getCanonicalName());
+
+    private final List<Criteria<T>> criterion = new LinkedList<Criteria<T>>();
+    private final List<Action<T>> actions = new LinkedList<Action<T>>();
+    
+    /**
+     * Add a criteria to this rule.
+     * 
+     * @param criteria the criteria
+     */
+    public void add(Criteria<T> criteria) {
+        criterion.add(criteria);
+    }
+    
+    /**
+     * Add an action to this rule.
+     * 
+     * @param action the action
+     */
+    public void add(Action<T> action) {
+        actions.add(action);
+    }
+    
+    /**
+     * Returns whether criteria are defined.
+     * 
+     * @return true if there are criteria
+     */
+    public boolean hasCriterion() {
+        return criterion.size() > 0;
+    }
+    
+    /**
+     * Returns whether actions are defined.
+     * 
+     * @return true if there are actions
+     */
+    public boolean hasActions() {
+        return actions.size() > 0;
+    }
+    
+    @Override
+    public boolean matches(T context) {
+        for (Criteria<T> criteria : criterion) {
+            if (!criteria.matches(context)) {
+                context.setMatches(false);
+                return false;
+            }
+        }
+
+        context.setMatches(true);
+        return true;
+    }
+    
+    @Override
+    public void apply(T context) {
+        for (Action<T> action : actions) {
+            try {
+                action.apply(context);
+            } catch (Throwable t) {
+                logger.log(Level.WARNING, "Failed to apply action of rule", t);
+            }
+        }
+    }
+    
+}

src/main/java/com/sk89q/rulelists/DefinitionException.java

@@ -0,0 +1,42 @@
+// $Id$
+/*
+ * This file is a part of WorldGuard.
+ * Copyright (c) sk89q <http://www.sk89q.com>
+ * Copyright (c) the WorldGuard team and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free Software 
+ * (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 
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package com.sk89q.rulelists;
+
+import com.sk89q.rebar.config.LoaderBuilderException;
+
+public class DefinitionException extends LoaderBuilderException {
+
+    private static final long serialVersionUID = -5429457695711163632L;
+
+    public DefinitionException() {
+    }
+
+    public DefinitionException(String message) {
+        super(message);
+    }
+
+    public DefinitionException(Throwable cause) {
+        super(cause);
+    }
+
+    public DefinitionException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+}

src/main/java/com/sk89q/rulelists/DefinitionInitializeEvent.java

@@ -0,0 +1,47 @@
+// $Id$
+/*
+ * This file is a part of WorldGuard.
+ * Copyright (c) sk89q <http://www.sk89q.com>
+ * Copyright (c) the WorldGuard team and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free Software 
+ * (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 
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package com.sk89q.rulelists;
+
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+
+public class DefinitionInitializeEvent extends Event {
+
+    private static final HandlerList handlers = new HandlerList();
+    
+    private final RuleListsManager ruleListsManager;
+    
+    public DefinitionInitializeEvent(RuleListsManager ruleListsManager) {
+        this.ruleListsManager = ruleListsManager;
+    }
+    
+    public RuleListsManager getManager() {
+        return ruleListsManager;
+    }
+    
+    @Override
+    public HandlerList getHandlers() {
+        return handlers;
+    }
+
+    public static HandlerList getHandlerList() {
+        return handlers;
+    }
+
+}

src/main/java/com/sk89q/rulelists/DefinitionManager.java

@@ -0,0 +1,76 @@
+// $Id$
+/*
+ * This file is a part of WorldGuard.
+ * Copyright (c) sk89q <http://www.sk89q.com>
+ * Copyright (c) the WorldGuard team and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free Software 
+ * (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 
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package com.sk89q.rulelists;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import com.sk89q.rebar.config.ConfigurationNode;
+import com.sk89q.rebar.config.ConfigurationValue;
+import com.sk89q.rebar.config.Loader;
+
+/**
+ * Manages loaders for definitions of the given generic type.
+ *
+ * @author sk89q
+ * @param <V> type to create
+ */
+public class DefinitionManager<V> {
+
+    /**
+     * Map of factories.
+     */
+    private Map<String, Loader<? extends V>> factories = new HashMap<String, Loader<? extends V>>();
+
+    /**
+     * Register a loader.
+     *
+     * @param id ID, case does not matter
+     * @param factory factory
+     */
+    public void register(String id, Loader<? extends V> factory) {
+        factories.put(id.toLowerCase(), factory);
+    }
+
+    /**
+     * Create a new instance.
+     *
+     * @param id type
+     * @param node configuration node
+     * @param value short-hand value, possibly null
+     * @return an object
+     * @throws DefinitionException thrown on error when parsing or instantiating
+     */
+    V newInstance(String id, ConfigurationNode node, ConfigurationValue value) throws DefinitionException {
+        Loader<? extends V> factory;
+
+        if (value != null) {
+            node = node.clone();
+            node.set("_", value.get());
+        }
+
+        if ((factory = factories.get(id)) != null) {
+            return factory.read(node);
+        }
+
+        throw new DefinitionException("Don't know what '" + id
+                + "' is (typo? criteria/action doesn't exist?)");
+    }
+
+}

src/main/java/com/sk89q/rulelists/ExpressionParser.java

@@ -0,0 +1,35 @@
+// $Id$
+/*
+ * This file is a part of WorldGuard.
+ * Copyright (c) sk89q <http://www.sk89q.com>
+ * Copyright (c) the WorldGuard team and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free Software 
+ * (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 
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package com.sk89q.rulelists;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class ExpressionParser {
+
+    private static final char COLOR_CHAR = '\u00A7';
+    private static final Pattern classicColors = Pattern.compile("&[A-Fa-z0-9klmnor]");
+
+    public String format(Context context, String string) {
+        Matcher m = classicColors.matcher(string);
+        string = m.replaceAll(COLOR_CHAR + "$1");
+        return string;
+    }
+
+}

src/main/java/com/sk89q/rulelists/InvertedCriteria.java

@@ -0,0 +1,40 @@
+// $Id$
+/*
+ * This file is a part of WorldGuard.
+ * Copyright (c) sk89q <http://www.sk89q.com>
+ * Copyright (c) the WorldGuard team and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free Software 
+ * (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 
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package com.sk89q.rulelists;
+
+/**
+ * A criteria wrapper that inverts the condition.
+ * 
+ * @author sk89q
+ * @param <T> underlying criteria
+ */
+public class InvertedCriteria<T extends Context> implements Criteria<T> {
+    
+    private final Criteria<T> criteria;
+    
+    public InvertedCriteria(Criteria<T> criteria) {
+        this.criteria = criteria;
+    }
+
+    @Override
+    public boolean matches(T context) {
+        return !criteria.matches(context);
+    }
+
+}

src/main/java/com/sk89q/rulelists/KnownAttachment.java

@@ -0,0 +1,89 @@
+// $Id$
+/*
+ * This file is a part of WorldGuard.
+ * Copyright (c) sk89q <http://www.sk89q.com>
+ * Copyright (c) the WorldGuard team and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free Software
+ * (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
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package com.sk89q.rulelists;
+
+import java.util.EnumSet;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Contains names of standard attachments.
+ */
+public enum KnownAttachment {
+
+    BLOCK_BREAK("block-break"),
+    BLOCK_PLACE("block-place"),
+    BLOCK_SPREAD("block-spread"),
+    BLOCK_PHYSICS("block-physics"),
+    BLOCK_INTERACT("block-interact"),
+    BLOCK_FADE("block-fade"),
+    BLOCK_FORM("block-form"),
+    PLAYER_JOIN("player-join"),
+    PLAYER_RESPAWN("player-respawn"),
+    PLAYER_QUIT("player-quit"),
+    ENTITY_EXPLODE("entity-explode"),
+    ENTITY_DAMAGE("entity-damage"),
+    ENTITY_DEATH("entity-death"),
+    ENTITY_IGNITE("entity-ignite"),
+    ENTITY_SPAWN("entity-spawn"),
+    ENTITY_STRIKE("entity-strike"),
+    ENTITY_INTERACT("entity-interact"),
+    ITEM_DROP("item-drop"),
+    ITEM_PICKUP("item-pickup"),
+    ITEM_USE("item-use"),
+    WEATHER_PHENOMENON("weather-phenomenon"),
+    WEATHER_TRANSITION("weather-transition"),
+    WORLD_LOAD("world-load"),
+    WORLD_UNLOAD("world-unload"),
+    WORLD_SAVE("world-save");
+
+    private final static Map<String, KnownAttachment> ids = new HashMap<String, KnownAttachment>();
+
+    static {
+        for (KnownAttachment attachment : EnumSet.allOf(KnownAttachment.class)) {
+            ids.put(attachment.getId().toLowerCase(), attachment);
+        }
+    }
+
+    private final String id;
+
+    KnownAttachment(String id) {
+        this.id = id;
+    }
+
+    /**
+     * Get the attachment's string ID.
+     *
+     * @return string ID
+     */
+    public String getId() {
+        return id;
+    }
+
+    /**
+     * Get an attachment from a given string ID. Not case sensitive.
+     *
+     * @param id string ID
+     * @return attachment name
+     */
+    public static KnownAttachment fromId(String id) {
+        return ids.get(id.toLowerCase());
+    }
+
+}

src/main/java/com/sk89q/rulelists/KnownAttachmentRules.java

@@ -0,0 +1,52 @@
+// $Id$
+/*
+ * This file is a part of WorldGuard.
+ * Copyright (c) sk89q <http://www.sk89q.com>
+ * Copyright (c) the WorldGuard team and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free Software 
+ * (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 
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package com.sk89q.rulelists;
+
+import java.util.EnumMap;
+import java.util.Map;
+
+/**
+ * Holds known attachment rule sets for every {@link KnownAttachment}.
+ */
+public class KnownAttachmentRules {
+    
+    private Map<KnownAttachment, RuleSet> ruleSets = 
+            new EnumMap<KnownAttachment, RuleSet>(KnownAttachment.class);
+    
+    /**
+     * Build a new instance, with every attachment having an empty {@link RuleSet}
+     * defined for it.
+     */
+    public KnownAttachmentRules() {
+        for (KnownAttachment attachment : KnownAttachment.values()) {
+            ruleSets.put(attachment, new RuleSet());
+        }
+    }
+    
+    /**
+     * Get a rule set for a given attachment.
+     * 
+     * @param attachment the attachment
+     * @return the rule set
+     */
+    public RuleSet get(KnownAttachment attachment) {
+        return ruleSets.get(attachment);
+    }
+    
+}

src/main/java/com/sk89q/rulelists/Resolver.java

@@ -0,0 +1,30 @@
+// $Id$
+/*
+ * This file is a part of WorldGuard.
+ * Copyright (c) sk89q <http://www.sk89q.com>
+ * Copyright (c) the WorldGuard team and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free Software 
+ * (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 
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package com.sk89q.rulelists;
+
+/**
+ * Attempts to resolve the requested object from other objects. For
+ * example, a block place event can have multiple 'relevant' blocks, such as
+ * the target block or the source block. A resolver is used to figure out
+ * which block is requested, and then the resolver would return the object
+ * requested by accessing it through a given context.
+ */
+public interface Resolver {
+
+}

src/main/java/com/sk89q/rulelists/ResolverManager.java

@@ -0,0 +1,63 @@
+// $Id$
+/*
+ * This file is a part of WorldGuard.
+ * Copyright (c) sk89q <http://www.sk89q.com>
+ * Copyright (c) the WorldGuard team and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free Software 
+ * (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 
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package com.sk89q.rulelists;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class ResolverManager {
+
+    private final Map<Class<? extends Resolver>, Map<String, Resolver>> resolvers
+            = new HashMap<Class<? extends Resolver>, Map<String, Resolver>>();
+    private final Map<Resolver, String> reverse = new HashMap<Resolver, String>();
+
+    public <T extends Resolver> void register(Class<T> clazz, String id, T resolver) {
+        Map<String, Resolver> map = resolvers.get(clazz);
+        if (map == null) {
+            map = new HashMap<String, Resolver>();
+            resolvers.put(clazz, map);
+        }
+
+        reverse.put(resolver, id);
+
+        map.put(id.toLowerCase(), resolver);
+    }
+
+    public String getId(Object object) {
+        return reverse.get(object);
+    }
+
+    @SuppressWarnings("unchecked")
+    public <T extends Resolver> T get(Class<T> clazz, String id) throws DefinitionException {
+        Map<String, Resolver> map = resolvers.get(clazz);
+        if (map == null) {
+            throw new DefinitionException("Don't know how to resolve "
+                    + clazz.getCanonicalName());
+        }
+
+        Resolver resolver = map.get(id);
+        if (resolver == null) {
+            throw new DefinitionException("Don't know how to resolve "
+                    + clazz.getCanonicalName());
+        }
+
+        return (T) resolver;
+    }
+
+}

src/main/java/com/sk89q/rulelists/Rule.java

@@ -0,0 +1,35 @@
+// $Id$
+/*
+ * This file is a part of WorldGuard.
+ * Copyright (c) sk89q <http://www.sk89q.com>
+ * Copyright (c) the WorldGuard team and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free Software 
+ * (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 
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package com.sk89q.rulelists;
+
+/**
+ * A rule that may match a number of events and can be applied in
+ * a situation. See {@link DefinedRule} for a rule implementation that
+ * consists of constituent {@link Criteria}s and {@link Action}s.
+ * 
+ * @author sk89q
+ * @param <T> implementation-specific context
+ */
+public interface Rule<T extends Context> {
+    
+    boolean matches(T context);
+    
+    void apply(T context);
+    
+}

src/main/java/com/sk89q/rulelists/RuleEntry.java

@@ -0,0 +1,60 @@
+// $Id$
+/*
+ * This file is a part of WorldGuard.
+ * Copyright (c) sk89q <http://www.sk89q.com>
+ * Copyright (c) the WorldGuard team and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free Software 
+ * (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 
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package com.sk89q.rulelists;
+
+import java.util.List;
+
+/**
+ * A pair of attachment/event names a rule.
+ */
+public class RuleEntry {
+    
+    private final List<String> attachmentNames;
+    private final Rule<?> rule;
+    
+    /**
+     * Construct the rule entry with the list of attachment names and rules.
+     * 
+     * @param attachmentNames attachment names
+     * @param rule rules
+     */
+    public RuleEntry(List<String> attachmentNames, Rule<?> rule) {
+        this.attachmentNames = attachmentNames;
+        this.rule = rule;
+    }
+
+    /**
+     * Get the list of attachment names.
+     * 
+     * @return attachment names
+     */
+    public List<String> getAttachmentNames() {
+        return attachmentNames;
+    }
+
+    /**
+     * Get the rule.
+     * 
+     * @return rule
+     */
+    public Rule<?> getRule() {
+        return rule;
+    }
+
+}

src/main/java/com/sk89q/rulelists/RuleEntryLoader.java

@@ -0,0 +1,172 @@
+// $Id$
+/*
+ * This file is a part of WorldGuard.
+ * Copyright (c) sk89q <http://www.sk89q.com>
+ * Copyright (c) the WorldGuard team and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free Software
+ * (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
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package com.sk89q.rulelists;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.logging.Logger;
+
+import com.sk89q.rebar.config.AbstractNodeLoader;
+import com.sk89q.rebar.config.ConfigurationNode;
+import com.sk89q.rebar.config.ConfigurationValue;
+import com.sk89q.rebar.config.LoaderBuilderException;
+import com.sk89q.rebar.util.LoggerUtils;
+
+/**
+ * A loader that will load rule definitions for the RuleLists.
+ */
+public class RuleEntryLoader extends AbstractNodeLoader<RuleEntry> {
+
+    public static final String INLINE = "_";
+    private static Logger logger = LoggerUtils.getLogger(RuleEntryLoader.class, "[WorldGuard] RuleList: ");
+
+    private final DefinitionLoader<Criteria<?>> criteriaLoader;
+    private final DefinitionLoader<Action<?>> actionLoader;
+
+    /**
+     * Construct the loader.
+     *
+     * @param ruleListsManager the action lists manager
+     */
+    public RuleEntryLoader(RuleListsManager ruleListsManager) {
+        criteriaLoader = new DefinitionLoader<Criteria<?>>(ruleListsManager.getCriterion(), true);
+        actionLoader = new DefinitionLoader<Action<?>>(ruleListsManager.getActions(), false);
+    }
+
+    @Override
+    @SuppressWarnings({ "rawtypes", "unchecked" })
+    public RuleEntry read(ConfigurationNode node) {
+        if (node.size() == 0) {
+            return null;
+        }
+
+        List<String> when = node.getStringList("when", new ArrayList<String>());
+
+        // Check to see if the rule has any events defined
+        if (when.size() == 0) {
+            logger.warning("A rule has missing 'when' clause:\n" + node.toString());
+            return null;
+        }
+
+        try {
+            DefinedRule rule = new DefinedRule();
+
+            // Get criterion from the 'if' subnode
+            for (Criteria criteria : node.listOf("if", criteriaLoader)) {
+                rule.add(criteria);
+            }
+
+            // Get actions from the 'then' subnode
+            for (Action action : node.listOf("then", actionLoader)) {
+                rule.add(action);
+            }
+
+            // A rule needs actions!
+            if (rule.hasActions()) {
+                return new RuleEntry(when, rule);
+            } else {
+                logger.warning("The following rule has no actions in:\n" + node.toString());
+                return null;
+            }
+        } catch (LoaderBuilderException e) {
+            logger.warning("A rule had the error '" + e.getMessage() + ", and the rule is:\n" + node.toString());
+            return null;
+        }
+    }
+
+    /**
+     * Inverts an criteria, wrapping it in a {@link InvertedCriteria}.
+     *
+     * @param criteria to invert
+     * @param inverted true to invert (false to not)
+     * @return
+     */
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    private static <V> V invertCriteria(V object, boolean inverted) {
+        if (object instanceof Criteria && inverted) {
+            return (V) new InvertedCriteria((Criteria<?>) object);
+        }
+
+        return object;
+    }
+
+    /**
+     * Loads specific definitions (criterion or actions) defined.
+     *
+     * @param <T> type of definition ({@link Action} or {@link Criteria})
+     */
+    private class DefinitionLoader<T> extends AbstractNodeLoader<T> {
+
+        private final DefinitionManager<T> manager;
+        private final boolean strict;
+
+        /**
+         * Construct the object.
+         *
+         * @param manager the definition manager
+         * @param strict true to throw exceptions on error
+         */
+        public DefinitionLoader(DefinitionManager<T> manager, boolean strict) {
+            this.manager = manager;
+            this.strict = strict;
+        }
+
+        @Override
+        public T read(ConfigurationNode node) {
+            String id = node.getString("?");
+            boolean inverted = node.getBoolean("negate", false);
+
+            try {
+                // Check for long hand notation (?: class)
+                if (id != null) {
+                    return invertCriteria(manager.newInstance(id, node, null), inverted);
+                }
+
+                // Check for short-hand notation (?class: value)
+                for (String key : node.getKeys(ConfigurationNode.ROOT)) {
+                    if (key.startsWith("?")) {
+                        id = key;
+
+                        Object value = node.get(key);
+                        return invertCriteria(
+                                manager.newInstance(key.substring(1), node, new ConfigurationValue(value)), inverted);
+                    }
+                }
+
+                // No class defined!
+                logger.warning("EventListeners: Missing '?' parameter in definition " +
+                		"(to define what kind of criteria/action it is)");
+
+                return null;
+            } catch (DefinitionException e) {
+                logger.warning("EventListeners: Invalid definition " +
+                        "identified by type '" + id + "': " + e.getMessage());
+
+                // Throw an exception in strict mode
+                if (strict) {
+                    throw new LoaderBuilderException();
+                }
+
+                return null;
+            }
+        }
+
+    }
+
+}

src/main/java/com/sk89q/rulelists/RuleListUtils.java

@@ -0,0 +1,65 @@
+// $Id$
+/*
+ * This file is a part of WorldGuard.
+ * Copyright (c) sk89q <http://www.sk89q.com>
+ * Copyright (c) the WorldGuard team and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free Software
+ * (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
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package com.sk89q.rulelists;
+
+import java.util.List;
+import java.util.logging.Logger;
+
+import com.sk89q.rebar.config.ConfigurationNode;
+
+/**
+ * RuleList-related utility methods.
+ */
+public class RuleListUtils {
+
+    private RuleListUtils() {
+    }
+
+    /**
+     * Warn of unknown directives in a rule list block.
+     *
+     * @param node node
+     * @param logger the logger to send to
+     * @param expected expected keys
+     */
+    public static void warnUnknown(ConfigurationNode node, Logger logger, String ... expected) {
+        List<String> keys = node.getKeys(ConfigurationNode.ROOT);
+
+        for (String key : keys) {
+            boolean found = false;
+
+            if (key.equals("?")) continue;
+            if (key.equals("negate")) continue;
+            if (key.equals("_")) continue;
+            if (key.length() > 0 && key.charAt(0) == '?') continue;
+
+            for (String expect : expected) {
+                if (expect.equals(key)) {
+                    found = true;
+                    break;
+                }
+            }
+
+            if (!found) {
+                logger.warning("[WorldGuard] RuleList: Unexpected parameter of '" + key + "' in " + node);
+            }
+        }
+    }
+
+}

src/main/java/com/sk89q/rulelists/RuleListsManager.java

@@ -0,0 +1,77 @@
+// $Id$
+/*
+ * This file is a part of WorldGuard.
+ * Copyright (c) sk89q <http://www.sk89q.com>
+ * Copyright (c) the WorldGuard team and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free Software 
+ * (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 
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package com.sk89q.rulelists;
+
+/**
+ * Manages action lists and details relevant to them.
+ */
+public class RuleListsManager {
+
+    private final AttachmentManager attachments = new AttachmentManager();
+    private final DefinitionManager<Criteria<?>> criterion = new DefinitionManager<Criteria<?>>();
+    private final DefinitionManager<Action<?>> actions = new DefinitionManager<Action<?>>();
+    private final ResolverManager subjectResolvers = new ResolverManager();
+    private final ExpressionParser exprParser = new ExpressionParser();
+
+    /**
+     * Get the attachment manager.
+     *
+     * @return the attachment manager
+     */
+    public AttachmentManager getAttachments() {
+        return attachments;
+    }
+
+    /**
+     * Get the criterion manager.
+     *
+     * @return criteron manager
+     */
+    public DefinitionManager<Criteria<?>> getCriterion() {
+        return criterion;
+    }
+
+    /**
+     * Get the actions manager.
+     *
+     * @return actions manager
+     */
+    public DefinitionManager<Action<?>> getActions() {
+        return actions;
+    }
+
+    /**
+     * Get the subject resolvers manager.
+     *
+     * @return the subject resolvers manager
+     */
+    public ResolverManager getResolvers() {
+        return subjectResolvers;
+    }
+
+    /**
+     * Get the expression parser.
+     *
+     * @return the expression parser
+     */
+    public ExpressionParser getParser() {
+        return exprParser;
+    }
+
+}

src/main/java/com/sk89q/rulelists/RuleSet.java

@@ -0,0 +1,61 @@
+// $Id$
+/*
+ * This file is a part of WorldGuard.
+ * Copyright (c) sk89q <http://www.sk89q.com>
+ * Copyright (c) the WorldGuard team and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free Software 
+ * (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 
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package com.sk89q.rulelists;
+
+import java.util.LinkedList;
+import java.util.List;
+
+public class RuleSet implements Attachment {
+    
+    private List<Rule<?>> rules = new LinkedList<Rule<?>>();
+
+    @Override
+    public void learn(Rule<?> rule) {
+        rules.add(rule);
+    }
+
+    @Override
+    public void forgetRules() {
+        rules.clear();
+    }
+    
+    public boolean hasRules() {
+        return rules.size() > 0;
+    }
+    
+    public List<Rule<?>> getRules() {
+        return rules;
+    }
+    
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    public boolean process(Context context) {
+        if (context.isCancelled()) {
+            return true; // Ignore cancelled events for now
+        }
+        
+        for (Rule rule : rules) {
+            if (rule.matches(context)) {
+                rule.apply(context);
+            }
+        }
+        
+        return context.isCancelled();
+    }
+
+}

src/main/java/com/sk89q/rulelists/RuleTemplateEntryLoader.java

@@ -0,0 +1,131 @@
+// $Id$
+/*
+ * This file is a part of WorldGuard.
+ * Copyright (c) sk89q <http://www.sk89q.com>
+ * Copyright (c) the WorldGuard team and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free Software
+ * (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
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package com.sk89q.rulelists;
+
+import java.util.ArrayList;
+import java.util.List;
+import com.sk89q.rebar.config.AbstractNodeLoader;
+import com.sk89q.rebar.config.ConfigurationNode;
+import com.sk89q.rebar.config.LoaderBuilderException;
+import com.sk89q.rebar.config.types.StringLoaderBuilder;
+
+/**
+ * A loader that will load the built-in rules used. It handles a slightly different
+ * format that also stores parameter information and other goodies.
+ */
+public class RuleTemplateEntryLoader extends AbstractNodeLoader<List<RuleEntry>> {
+
+    private static final StringLoaderBuilder stringLoader = new StringLoaderBuilder();
+
+    private final ConfigurationNode config;
+    private final RuleEntryLoader entryLoader;
+
+    /**
+     * Construct the loader with the given rule lists manager.
+     *
+     * @param manager the manager
+     * @param config the configuration node to read settings from
+     */
+    public RuleTemplateEntryLoader(RuleListsManager manager, ConfigurationNode config) {
+        entryLoader = new RuleEntryLoader(manager);
+        this.config = config;
+    }
+
+    @Override
+    public List<RuleEntry> read(ConfigurationNode node) throws LoaderBuilderException {
+        List<RuleEntry> rules = new ArrayList<RuleEntry>();
+
+        List<String> settings = node.listOf("setting", stringLoader);
+        if (settings.size() == 0) {
+            throw new LoaderBuilderException("No 'setting' value in:\n" + node.toString());
+        }
+
+        String selectedSetting = settings.get(0);
+        String type = node.getString("type", "boolean");
+
+        if (settings.size() > 1) {
+            boolean migrate = false;
+            boolean found = false;
+            Object value = null;
+
+            for (String setting : settings) {
+                if (config.contains(setting)) {
+                    value = config.get(setting);
+                    found = true;
+                    break;
+                } else {
+                    migrate = true;
+                }
+            }
+
+            if (found && migrate) {
+                config.set(settings.get(0), value);
+
+                int i = 0;
+                for (String setting : settings) {
+                    if (i++ != 0) {
+                        config.remove(setting);
+                    }
+                }
+            }
+        }
+
+        boolean active = false;
+
+        // See if the setting is active
+        if (type.equals("boolean")) {
+            boolean negate = node.getBoolean("negate", false);
+            boolean enabled = config.getBoolean(selectedSetting, negate);
+
+            if (negate) {
+                enabled = !enabled;
+            }
+
+            if (enabled) {
+                active = true;
+            }
+        } else if (type.equals("list")) {
+            Object val = config.get(selectedSetting);
+
+            if (val == null) {
+                config.set(selectedSetting, new ArrayList<Object>());
+            } else if (val instanceof List<?> && ((List<?>) val).size() > 0) {
+                active = true;
+            }
+        }
+
+        // Load the setting
+        if (active) {
+            List<String> paramPaths = node.getStringList("parameters.target", new ArrayList<String>());
+            if (paramPaths.size() > 0) {
+                Object val = config.get(selectedSetting);
+                for (String path : paramPaths) {
+                    node.set(path, val);
+                }
+            }
+
+            for (RuleEntry rule : node.listOf("rules", entryLoader)) {
+                rules.add(rule);
+            }
+        }
+
+        return rules;
+    }
+
+}

src/main/java/com/sk89q/worldguard/LocalPlayer.java

@@ -25,68 +25,66 @@ public abstract class LocalPlayer {
     /**
      * Get a player's name.
      * 
-     * @return
+     * @return The player's name
      */
     public abstract String getName();
     
     /**
      * Returns true if the player is inside a group.
      * 
-     * @param group
-     * @return
+     * @param group The group to check
+     * @return Whether this player is in {@code group}
      */
     public abstract boolean hasGroup(String group);
     
     /**
      * Get the player's position.
      * 
-     * @return
+     * @return The player's position
      */
     public abstract Vector getPosition();
     
     /**
      * Kick the player.
      * 
-     * @param msg
+     * @param msg The message to kick the player with
      */
     public abstract void kick(String msg);
     
     /**
      * Ban the player.
      * 
-     * @param msg
+     * @param msg The message to ban the player with
      */
     public abstract void ban(String msg);
     
     /**
      * Send the player a message;
      * 
-     * @param msg
+     * @param msg The message to send to the player
      */
     public abstract void printRaw(String msg);
     
     /**
      * Get the player's list of groups.
      * 
-     * @return
+     * @return The groups this player is in
      */
     public abstract String[] getGroups();
     
     /**
      * Returns whether a player has permission.
      * 
-     * @param perm 
-     * @return 
+     * @param perm The permission to check
+     * @return Whether this player has {@code perm}
      */
     public abstract boolean hasPermission(String perm);
     
     @Override
     public boolean equals(Object obj) {
-        if (!(obj instanceof LocalPlayer)) {
-            return false;
-        }
-        
-        return ((LocalPlayer)obj).getName().equals(getName());
+
+        return obj instanceof LocalPlayer && ((LocalPlayer) obj).getName().equals(getName());
+
     }
     
     @Override

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

@@ -41,10 +41,6 @@ import com.sk89q.worldguard.blacklist.events.BlacklistEvent;
  * @author sk89q
  */
 public abstract class Blacklist {
-    /**
-     * Logger.
-     */
-    private static final Logger logger = Logger.getLogger("Minecraft.WorldGuard");
 
     /**
      * List of entries by block ID.
@@ -67,14 +63,17 @@ public abstract class Blacklist {
 
     private boolean useAsWhitelist;
 
-    public Blacklist(Boolean useAsWhitelist) {
+    private final Logger logger;
+
+    public Blacklist(Boolean useAsWhitelist, Logger logger) {
         this.useAsWhitelist = useAsWhitelist;
+        this.logger = logger;
     }
 
     /**
      * Returns whether the list is empty.
      *
-     * @return
+     * @return whether the blacklist is empty
      */
     public boolean isEmpty() {
         return blacklist.isEmpty();
@@ -83,8 +82,8 @@ public abstract class Blacklist {
     /**
      * Get the entries for an item or list.
      *
-     * @param id
-     * @return
+     * @param id The item id to get blacklist information for
+     * @return The blacklist entries for {@code id}
      */
     public List<BlacklistEntry> getEntries(int id) {
         return blacklist.get(id);
@@ -93,7 +92,7 @@ public abstract class Blacklist {
     /**
      * Get the number of individual items that have blacklist entries.
      *
-     * @return
+     * @return The number of items in the blacklist
      */
     public int getItemCount() {
         return blacklist.size();
@@ -102,7 +101,7 @@ public abstract class Blacklist {
     /**
      * Returns whether the blacklist is used as a whitelist.
      *
-     * @return
+     * @return whether the blacklist is be used as a whitelist
      */
     public boolean isWhitelist() {
         return useAsWhitelist;
@@ -111,7 +110,7 @@ public abstract class Blacklist {
     /**
      * Get the logger.
      *
-     * @return
+     * @return The logger used in this blacklist
      */
     public BlacklistLogger getLogger() {
         return blacklistLogger;
@@ -120,10 +119,10 @@ public abstract class Blacklist {
     /**
      * Method to handle the event.
      *
-     * @param event
-     * @param forceRepeat
-     * @param silent
-     * @return
+     * @param event The event to check
+     * @param forceRepeat Whether to force quickly repeating notifications
+     * @param silent Whether to force-deny notifications
+     * @return Whether the event is allowed
      */
     public boolean check(BlacklistEvent event, boolean forceRepeat, boolean silent) {
         List<BlacklistEntry> entries = getEntries(event.getType());
@@ -142,8 +141,8 @@ public abstract class Blacklist {
     /**
      * Load the blacklist.
      *
-     * @param file
-     * @throws IOException
+     * @param file The file to load from
+     * @throws IOException if an error occurred reading from the file
      */
     public void load(File file) throws IOException {
         FileReader input = null;
@@ -171,14 +170,14 @@ public abstract class Blacklist {
                     currentEntries = new ArrayList<BlacklistEntry>();
 
                     for (String item : items) {
-                        int id = 0;
+                        int id;
 
                         try {
                             id = Integer.parseInt(item.trim());
                         } catch (NumberFormatException e) {
                             id = getItemID(item.trim());
                             if (id == 0) {
-                                logger.log(Level.WARNING, "WorldGuard: Unknown block name: "
+                                logger.log(Level.WARNING, "Unknown block name: "
                                         + item);
                                 break;
                             }
@@ -249,7 +248,7 @@ public abstract class Blacklist {
                 if (input != null) {
                     input.close();
                 }
-            } catch (IOException e2) {
+            } catch (IOException ignore) {
             }
         }
     }
@@ -257,7 +256,7 @@ public abstract class Blacklist {
     /**
      * Get the last event.
      *
-     * @return
+     * @return The last event
      */
     public BlacklistEvent getLastEvent() {
         return lastEvent;
@@ -266,8 +265,8 @@ public abstract class Blacklist {
     /**
      * Notify administrators.
      *
-     * @param event
-     * @param comment
+     * @param event The event to notify about
+     * @param comment The comment to notify with
      */
     public void notify(BlacklistEvent event, String comment) {
         lastEvent = event;
@@ -283,14 +282,14 @@ public abstract class Blacklist {
     /**
      * Sends a notification to all subscribing users.
      *
-     * @param msg
+     * @param msg The message to broadcast
      */
     public abstract void broadcastNotification(String msg);
 
     /**
      * Forget a player.
      *
-     * @param player
+     * @param player The player to forget
      */
     public void forgetPlayer(LocalPlayer player) {
         lastAffected.remove(player.getName());
@@ -306,7 +305,8 @@ public abstract class Blacklist {
     /**
      * Get an item's ID from its name.
      *
-     * @param name
+     * @param name the name of the item to look up
+     * @return the id for name if contained in ItemId, else -1
      */
     private static int getItemID(String name) {
         ItemType type = ItemType.lookup(name);
@@ -320,7 +320,8 @@ public abstract class Blacklist {
     /**
      * Get an item's friendly name with its ID.
      *
-     * @param id
+     * @param id The id to look up
+     * @return The item's friendly name
      */
     private static String getFriendlyItemName(int id) {
         ItemType type = ItemType.fromID(id);

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

@@ -19,6 +19,7 @@
 
 package com.sk89q.worldguard.blacklist;
 
+import java.util.Collections;
 import java.util.HashSet;
 import java.util.Set;
 
@@ -69,7 +70,7 @@ public class BlacklistEntry {
     /**
      * Construct the object.
      *
-     * @param blacklist
+     * @param blacklist The blacklist that contains this entry
      */
     public BlacklistEntry(Blacklist blacklist) {
         this.blacklist = blacklist;
@@ -105,105 +106,103 @@ public class BlacklistEntry {
      */
     public void setIgnorePermissions(String[] ignorePermissions) {
         Set<String> ignorePermissionsSet = new HashSet<String>();
-        for (String perm : ignorePermissions) {
-            ignorePermissionsSet.add(perm);
-        }
+        Collections.addAll(ignorePermissionsSet, ignorePermissions);
         this.ignorePermissions = ignorePermissionsSet;
     }
 
     /**
-     * @return
+     * @return The actions that occur when breaking
      */
     public String[] getBreakActions() {
         return breakActions;
     }
 
     /**
-     * @param actions
+     * @param actions The actions to occur when breaking
      */
     public void setBreakActions(String[] actions) {
         this.breakActions = actions;
     }
 
     /**
-     * @return
+     * @return The actions that occur when destroying with a specific item
      */
     public String[] getDestroyWithActions() {
         return destroyWithActions;
     }
 
     /**
-     * @param actions
+     * @param actions The actions to occur when destroying with an item
      */
     public void setDestroyWithActions(String[] actions) {
         this.destroyWithActions = actions;
     }
 
     /**
-     * @return
+     * @return The actions that will occur when placing
      */
     public String[] getPlaceActions() {
         return placeActions;
     }
 
     /**
-     * @param actions
+     * @param actions The actions to occur when placing
      */
     public void setPlaceActions(String[] actions) {
         this.placeActions = actions;
     }
 
     /**
-     * @return
+     * @return The actions that will occur when interacting
      */
     public String[] getInteractActions() {
         return interactActions;
     }
 
     /**
-     * @param actions
+     * @param actions The actions to occur when interacting
      */
     public void setInteractActions(String[] actions) {
         this.interactActions = actions;
     }
 
     /**
-     * @return
+     * @return The actions that will occur when using
      */
     public String[] getUseActions() {
         return useActions;
     }
 
     /**
-     * @param actions
+     * @param actions The actions to occur when using
      */
     public void setUseActions(String[] actions) {
         this.useActions = actions;
     }
 
     /**
-     * @return
+     * @return The actions that will occur when dropping
      */
     public String[] getDropActions() {
         return dropActions;
     }
 
     /**
-     * @param actions
+     * @param actions The actions to occur when dropping
      */
     public void setDropActions(String[] actions) {
         this.dropActions = actions;
     }
 
     /**
-     * @return
+     * @return The actions that will occur when acquiring
      */
     public String[] getAcquireActions() {
         return acquireActions;
     }
 
     /**
-     * @param actions
+     * @param actions The actions to occur when acquiring
      */
     public void setAcquireActions(String[] actions) {
         this.acquireActions = actions;
@@ -240,8 +239,8 @@ public class BlacklistEntry {
     /**
      * Returns true if this player should be ignored.
      *
-     * @param player
-     * @return
+     * @param player The player to check
+     * @return whether this player should be ignored for blacklist blocking
      */
     public boolean shouldIgnore(LocalPlayer player) {
         if (ignoreGroups != null) {
@@ -266,8 +265,8 @@ public class BlacklistEntry {
     /**
      * Get the associated actions with an event.
      *
-     * @param event
-     * @return
+     * @param event The event to check
+     * @return The actions for the given event
      */
     private String[] getActions(BlacklistEvent event) {
         if (event instanceof BlockBreakBlacklistEvent) {
@@ -299,11 +298,11 @@ public class BlacklistEntry {
     /**
      * Method to handle the event.
      *
-     * @param useAsWhitelist
-     * @param event
-     * @param forceRepeat
-     * @param silent
-     * @return
+     * @param useAsWhitelist Whether this entry is buing used in a whitelist
+     * @param event The event to check
+     * @param forceRepeat Whether to force repeating notifications even within the delay limit
+     * @param silent Whether to prevent notifications from happening
+     * @return Whether the action was allowed
      */
     public boolean check(boolean useAsWhitelist, BlacklistEvent event, boolean forceRepeat, boolean silent) {
         LocalPlayer player = event.getPlayer();
@@ -329,11 +328,11 @@ public class BlacklistEntry {
         String actions[] = getActions(event);
 
 
-        boolean ret = useAsWhitelist ? false : true;
+        boolean ret = !useAsWhitelist;
 
         // Nothing to do
         if (actions == null) {
-            return useAsWhitelist ? false : true;
+            return ret;
         }
 
         for (String action : actions) {
@@ -412,7 +411,7 @@ public class BlacklistEntry {
     /**
      * Get an item's friendly name with its ID.
      *
-     * @param id
+     * @param id The id to get a name for
      */
     private static String getFriendlyItemName(int id) {
         ItemType type = ItemType.fromID(id);

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

@@ -39,16 +39,16 @@ public class BlacklistLogger implements BlacklistLoggerHandler {
     /**
      * Add a handler.
      *
-     * @param handler
+     * @param handler The handler to add
      */
     public void addHandler(BlacklistLoggerHandler handler) {
         handlers.add(handler);
     }
 
     /**
-     * Add a handler.
+     * Remove a handler.
      *
-     * @param handler
+     * @param handler The handler to remove
      */
     public void removeHandler(BlacklistLoggerHandler handler) {
         handlers.remove(handler);
@@ -64,7 +64,7 @@ public class BlacklistLogger implements BlacklistLoggerHandler {
     /**
      * Log an event.
      *
-     * @param event
+     * @param event The event to log
      */
     public void logEvent(BlacklistEvent event, String comment) {
         for (BlacklistLoggerHandler handler : handlers) {

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

@@ -32,8 +32,8 @@ public class BlacklistTrackedEvent {
     /**
      * Construct the object.
      *
-     * @param event
-     * @param time
+     * @param event The event tracked
+     * @param time The time at which the event occurred
      */
     public BlacklistTrackedEvent(BlacklistEvent event, long time) {
         this.event = event;

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

@@ -39,9 +39,9 @@ public abstract class BlacklistEvent {
     /**
      * Construct the object.
      * 
-     * @param player
-     * @param pos
-     * @param type
+     * @param player The player associated with this event
+     * @param pos The position the event occurred at
+     * @param type The type of item used
      */
     public BlacklistEvent(LocalPlayer player, Vector pos, int type) {
         this.player = player;
@@ -51,8 +51,8 @@ public abstract class BlacklistEvent {
     
     /**
      * Get the player.
-     * 
-     * @return
+     *
+     * @return The player associated with this event
      */
     public LocalPlayer getPlayer() {
         return player;
@@ -61,16 +61,16 @@ public abstract class BlacklistEvent {
     /**
      * Get the position.
      * 
-     * @return
+     * @return The position of this event
      */
     public Vector getPosition() {
         return pos;
     }
     
     /**
-     * Get the type.
+     * Get the item type.
      * 
-     * @return
+     * @return The type associated with this event
      */
     public int getType() {
         return type;
@@ -79,7 +79,7 @@ public abstract class BlacklistEvent {
     /**
      * Get a short description such as "break" or "destroy with."
      * 
-     * @return
+     * @return The event description
      */
     public abstract String getDescription();
 }

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

@@ -26,12 +26,7 @@ public class BlockBreakBlacklistEvent extends BlockBlacklistEvent {
     public BlockBreakBlacklistEvent(LocalPlayer player, Vector pos, int type) {
         super(player, pos, type);
     }
-    
-    /**
-     * Get a short description such as "break" or "destroy with."
-     * 
-     * @return
-     */
+
     @Override
     public String getDescription() {
         return "break";

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

@@ -26,12 +26,7 @@ public class BlockInteractBlacklistEvent extends BlockBlacklistEvent {
     public BlockInteractBlacklistEvent(LocalPlayer player, Vector pos, int type) {
         super(player, pos, type);
     }
-    
-    /**
-     * Get a short description such as "break" or "destroy with."
-     * 
-     * @return
-     */
+
     @Override
     public String getDescription() {
         return "interact with";

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

@@ -26,12 +26,7 @@ public class BlockPlaceBlacklistEvent extends BlockBlacklistEvent {
     public BlockPlaceBlacklistEvent(LocalPlayer player, Vector pos, int type) {
         super(player, pos, type);
     }
-    
-    /**
-     * Get a short description such as "break" or "destroy with."
-     * 
-     * @return
-     */
+
     @Override
     public String getDescription() {
         return "place";

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

@@ -26,12 +26,7 @@ public class DestroyWithBlacklistEvent extends BlacklistEvent {
     public DestroyWithBlacklistEvent(LocalPlayer player, Vector pos, int type) {
         super(player, pos, type);
     }
-    
-    /**
-     * Get a short description such as "break" or "destroy with."
-     * 
-     * @return
-     */
+
     @Override
     public String getDescription() {
         return "destroy with";

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

@@ -26,12 +26,7 @@ public class ItemAcquireBlacklistEvent extends ItemBlacklistEvent {
     public ItemAcquireBlacklistEvent(LocalPlayer player, Vector pos, int type) {
         super(player, pos, type);
     }
-    
-    /**
-     * Get a short description such as "break" or "destroy with."
-     * 
-     * @return
-     */
+
     @Override
     public String getDescription() {
         return "acquire";

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

@@ -26,12 +26,7 @@ public class ItemDropBlacklistEvent extends ItemBlacklistEvent {
     public ItemDropBlacklistEvent(LocalPlayer player, Vector pos, int type) {
         super(player, pos, type);
     }
-    
-    /**
-     * Get a short description such as "break" or "destroy with."
-     * 
-     * @return
-     */
+
     @Override
     public String getDescription() {
         return "drop";

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

@@ -26,12 +26,7 @@ public class ItemUseBlacklistEvent extends ItemBlacklistEvent {
     public ItemUseBlacklistEvent(LocalPlayer player, Vector pos, int type) {
         super(player, pos, type);
     }
-    
-    /**
-     * Get a short description such as "break" or "destroy with."
-     * 
-     * @return
-     */
+
     @Override
     public String getDescription() {
         return "use";

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

@@ -37,77 +37,70 @@ import com.sk89q.worldguard.blacklist.events.ItemUseBlacklistEvent;
  * @author sk89q
  */
 public class ConsoleLoggerHandler implements BlacklistLoggerHandler {
-    /**
-     * Logger.
-     */
-    private static final Logger logger = Logger.getLogger("Minecraft.WorldGuard");
 
 
     private String worldName;
+	
+    private final Logger logger;
 
-    public ConsoleLoggerHandler(String worldName)
-    {
-       this.worldName = worldName;
+    public ConsoleLoggerHandler(String worldName, Logger logger) {
+        this.worldName = worldName;
+	    this.logger = logger;
     }
 
-    /**
-     * Log an event.
-     *
-     * @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, "[" + worldName + "] " + 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, "[" + worldName + "] " + 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, "[" + worldName + "] " + 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, "[" + worldName + "] " + 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, "[" + worldName + "] " + 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, "[" + worldName + "] " + 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, "[" + worldName + "] " + 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, "[" + worldName + "] " + event.getPlayer().getName()
                     + " caught unknown event: " + event.getClass().getCanonicalName());
         }
     }
@@ -115,14 +108,15 @@ public class ConsoleLoggerHandler implements BlacklistLoggerHandler {
     /**
      * Get an item's friendly name with its ID.
      *
-     * @param id
+     * @param id The item id
+     * @return The friendly name of the item
      */
     private static String getFriendlyItemName(int id) {
         ItemType type = ItemType.fromID(id);
         if (type != null) {
             return type.getName() + " (#" + id + ")";
         } else {
-            return "#" + id + "";
+            return "#" + id;
         }
     }
 

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

@@ -42,58 +42,58 @@ import com.sk89q.worldguard.blacklist.events.ItemUseBlacklistEvent;
  * @author sk89q
  */
 public class DatabaseLoggerHandler implements BlacklistLoggerHandler {
-    /**
-     * Logger.
-     */
-    private static final Logger logger = Logger.getLogger("Minecraft.WorldGuard");
 
     /**
      * DSN.
      */
-    private String dsn;
+    private final String dsn;
     /**
      * Username.
      */
-    private String user;
+    private final String user;
     /**
      * Password.
      */
-    private String pass;
+    private final String pass;
     /**
      * Table.
      */
-    private String table;
+    private final String table;
     /**
      * World name.
      */
-    private String worldName;
+    private final String worldName;
     /**
      * Database connection.
      */
     private Connection conn;
+    
+    private final Logger logger;
 
     /**
      * Construct the object.
      *
-     * @param dsn
-     * @param user
-     * @param pass
-     * @param table
-     * @param worldName
+     * @param dsn The DSN for the connection
+     * @param user The username to connect with
+     * @param pass The password to connect with
+     * @param table The table to log to
+     * @param worldName The name of the world to log
+     * @param logger The logger to log errors to
      */
-    public DatabaseLoggerHandler(String dsn, String user, String pass, String table, String worldName) {
+    public DatabaseLoggerHandler(String dsn, String user, String pass, String table, String worldName, Logger logger) {
         this.dsn = dsn;
         this.user = user;
         this.pass = pass;
         this.table = table;
         this.worldName = worldName;
+        this.logger = logger;
     }
 
     /**
      * Gets the database connection.
      *
-     * @return
-     * @throws SQLException
+     * @return The database connection
+     * @throws SQLException when the connection cannot be created
      */
     private Connection getConnection() throws SQLException {
         if (conn == null || conn.isClosed()) {
@@ -105,13 +105,11 @@ public class DatabaseLoggerHandler implements BlacklistLoggerHandler {
     /**
      * Log an event to the database.
      *
-     * @param event
-     * @param name
-     * @param x
-     * @param y
-     * @param z
-     * @param item
-     * @param comment
+     * @param event The event to log
+     * @param player The player associated with the event
+     * @param pos The location of the event
+     * @param item The item used
+     * @param comment The comment associated with the event
      */
     private void logEvent(String event, LocalPlayer player, Vector pos, int item,
             String comment) {
@@ -140,7 +138,7 @@ public class DatabaseLoggerHandler implements BlacklistLoggerHandler {
     /**
      * Log an event.
      *
-     * @param event
+     * @param event The event to log
      */
     public void logEvent(BlacklistEvent event, String comment) {
         // Block break
@@ -200,7 +198,7 @@ public class DatabaseLoggerHandler implements BlacklistLoggerHandler {
             if (conn != null && !conn.isClosed()) {
                 conn.close();
             }
-        } catch (SQLException e) {
+        } catch (SQLException ignore) {
 
         }
     }

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

@@ -39,23 +39,12 @@ import com.sk89q.worldedit.Vector;
 import com.sk89q.worldedit.blocks.ItemType;
 import com.sk89q.worldguard.LocalPlayer;
 import com.sk89q.worldguard.blacklist.events.BlacklistEvent;
-import com.sk89q.worldguard.blacklist.events.BlockBreakBlacklistEvent;
-import com.sk89q.worldguard.blacklist.events.BlockInteractBlacklistEvent;
-import com.sk89q.worldguard.blacklist.events.BlockPlaceBlacklistEvent;
-import com.sk89q.worldguard.blacklist.events.DestroyWithBlacklistEvent;
-import com.sk89q.worldguard.blacklist.events.ItemAcquireBlacklistEvent;
-import com.sk89q.worldguard.blacklist.events.ItemDropBlacklistEvent;
-import com.sk89q.worldguard.blacklist.events.ItemUseBlacklistEvent;
 
 /**
  *
  * @author sk89q
  */
 public class FileLoggerHandler implements BlacklistLoggerHandler {
-    /**
-     * Logger.
-     */
-    private static final Logger logger = Logger.getLogger("Minecraft.WorldGuard");
     /**
      * Regex for patterns in the path.
      */
@@ -83,38 +72,45 @@ public class FileLoggerHandler implements BlacklistLoggerHandler {
      */
     private TreeMap<String,FileLoggerWriter> writers =
             new TreeMap<String,FileLoggerWriter>();
+    
+    private final Logger logger;
 
     /**
      * Construct the object.
      *
-     * @param pathPattern
-     * @param worldName
+     * @param pathPattern The pattern for the logflie path
+     * @param worldName The name of the world
+     * @param logger The logger used to log errors
      */
-    public FileLoggerHandler(String pathPattern, String worldName) {
+    public FileLoggerHandler(String pathPattern, String worldName, Logger logger) {
         this.pathPattern = pathPattern;
         this.worldName = worldName;
+        this.logger = logger;
     }
 
     /**
      * Construct the object.
      *
-     * @param pathPattern
-     * @param cacheSize
-     * @param worldName
+     * @param pathPattern The pattern for logfile paths
+     * @param cacheSize The size of the file cache
+     * @param worldName The name of the associated world
+     * @param logger The logger to log errors with
      */
-    public FileLoggerHandler(String pathPattern, int cacheSize, String worldName) {
+    public FileLoggerHandler(String pathPattern, int cacheSize, String worldName, Logger logger) {
         if (cacheSize < 1) {
             throw new IllegalArgumentException("Cache size cannot be less than 1");
         }
         this.pathPattern = pathPattern;
         this.cacheSize = cacheSize;
         this.worldName = worldName;
+        this.logger = logger;
     }
 
     /**
      * Build the path.
      *
-     * @return
+     * @param playerName The name of the playername
+     * @return The path for the logfile
      */
     private String buildPath(String playerName) {
         GregorianCalendar calendar = new GregorianCalendar();
@@ -171,8 +167,9 @@ public class FileLoggerHandler implements BlacklistLoggerHandler {
     /**
      * Log a message.
      *
-     * @param player
-     * @param message
+     * @param player The player to log
+     * @param message The message to log
+     * @param comment The comment associated with the logged event
      */
     private void log(LocalPlayer player, String message, String comment) {
         String path = buildPath(player.getName());
@@ -220,7 +217,7 @@ public class FileLoggerHandler implements BlacklistLoggerHandler {
                     Map.Entry<String,FileLoggerWriter> entry = it.next();
                     try {
                         entry.getValue().getWriter().close();
-                    } catch (IOException e) {
+                    } catch (IOException ignore) {
                     }
                     it.remove();
 
@@ -240,8 +237,8 @@ public class FileLoggerHandler implements BlacklistLoggerHandler {
     /**
      * Gets the coordinates in text form for the log.
      *
-     * @param pos
-     * @return
+     * @param pos The position to get coordinates for
+     * @return The position's coordinates in human-readable form
      */
     private String getCoordinates(Vector pos) {
         return "@" + pos.getBlockX() + "," + pos.getBlockY() + "," + pos.getBlockZ();
@@ -255,55 +252,17 @@ public class FileLoggerHandler implements BlacklistLoggerHandler {
     /**
      * Log an event.
      *
-     * @param event
+     * @param event The event to log
      */
     public void logEvent(BlacklistEvent event, String comment) {
-        // Block break
-        if (event instanceof BlockBreakBlacklistEvent) {
-            BlockBreakBlacklistEvent evt = (BlockBreakBlacklistEvent)event;
-            logEvent(event, "break", evt.getType(), evt.getPosition(), comment);
-
-        // Block place
-        } else if (event instanceof BlockPlaceBlacklistEvent) {
-            BlockPlaceBlacklistEvent evt = (BlockPlaceBlacklistEvent)event;
-            logEvent(event, "place", evt.getType(), evt.getPosition(), comment);
-
-        // Block interact
-        } else if (event instanceof BlockInteractBlacklistEvent) {
-            BlockInteractBlacklistEvent evt = (BlockInteractBlacklistEvent)event;
-            logEvent(event, "interact with", evt.getType(), evt.getPosition(), comment);
-
-        // Destroy with
-        } else if (event instanceof DestroyWithBlacklistEvent) {
-            DestroyWithBlacklistEvent evt = (DestroyWithBlacklistEvent)event;
-            logEvent(event, "destroy with", evt.getType(), evt.getPosition(), comment);
-
-        // Acquire
-        } else if (event instanceof ItemAcquireBlacklistEvent) {
-            ItemAcquireBlacklistEvent evt = (ItemAcquireBlacklistEvent)event;
-            logEvent(event, "acquire", evt.getType(), evt.getPosition(), comment);
-
-        // Drop
-        } else if (event instanceof ItemDropBlacklistEvent) {
-            ItemDropBlacklistEvent evt = (ItemDropBlacklistEvent)event;
-            logEvent(event, "drop", evt.getType(), evt.getPosition(), comment);
-
-        // Use
-        } else if (event instanceof ItemUseBlacklistEvent) {
-            ItemUseBlacklistEvent evt = (ItemUseBlacklistEvent)event;
-            logEvent(event, "use", evt.getType(), evt.getPosition(), comment);
-
-        // Unknown
-        } else {
-            log(event.getPlayer(), "Unknown event: "
-                    + event.getClass().getCanonicalName(), comment);
-        }
+        logEvent(event, event.getDescription(), event.getType(), event.getPosition(), comment);
     }
 
     /**
      * Get an item's friendly name with its ID.
      *
-     * @param id
+     * @param id The id to get a friendly name for
+     * @return The friendly name
      */
     private static String getFriendlyItemName(int id) {
         ItemType type = ItemType.fromID(id);
@@ -321,7 +280,7 @@ public class FileLoggerHandler implements BlacklistLoggerHandler {
         for (Map.Entry<String,FileLoggerWriter> entry : writers.entrySet()) {
             try {
                 entry.getValue().getWriter().close();
-            } catch (IOException e) {
+            } catch (IOException ignore) {
             }
         }
 

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

@@ -42,8 +42,8 @@ public class FileLoggerWriter implements Comparable<FileLoggerWriter> {
     /**
      * Construct the object.
      *
-     * @param path
-     * @param writer
+     * @param path The path to write to
+     * @param writer The writer for the file
      */
     public FileLoggerWriter(String path, BufferedWriter writer) {
         this.path = path;
@@ -54,14 +54,14 @@ public class FileLoggerWriter implements Comparable<FileLoggerWriter> {
     /**
      * File path.
      *
-     * @return
+     * @return The path the logger is logging to
      */
     public String getPath() {
         return path;
     }
 
     /**
-     * @return the writer
+     * @return the writer being logged to
      */
     public BufferedWriter getWriter() {
         return writer;
@@ -81,12 +81,6 @@ public class FileLoggerWriter implements Comparable<FileLoggerWriter> {
         lastUse = System.currentTimeMillis();
     }
 
-    /**
-     * Comparison function.
-     *
-     * @param other
-     * @return
-     */
     public int compareTo(FileLoggerWriter other) {
         if (lastUse > other.lastUse) {
             return 1;

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

@@ -25,7 +25,7 @@ public class BukkitBlacklist extends Blacklist {
     private WorldGuardPlugin plugin;
     
     public BukkitBlacklist(Boolean useAsWhitelist, WorldGuardPlugin plugin) {
-        super(useAsWhitelist);
+        super(useAsWhitelist, plugin.getLogger());
         this.plugin = plugin;
     }
     

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

@@ -0,0 +1,103 @@
+// $Id$
+/*
+ * This file is a part of WorldGuard.
+ * Copyright (c) sk89q <http://www.sk89q.com>
+ * Copyright (c) the WorldGuard team and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free Software
+ * (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
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package com.sk89q.worldguard.bukkit;
+
+import org.bukkit.block.BlockState;
+import org.bukkit.entity.Entity;
+import org.bukkit.event.Event;
+import org.bukkit.inventory.ItemStack;
+
+import com.sk89q.rulelists.Context;
+
+public class BukkitContext extends Context {
+
+    private final Event event;
+    private String message;
+    private Entity sourceEntity;
+    private Entity targetEntity;
+    private ItemStack item;
+    private BlockState sourceBlock;
+    private BlockState targetBlock;
+    private BlockState replacedTargetBlock;
+
+    public BukkitContext(Event event) {
+        this.event = event;
+    }
+
+    public String getMessage() {
+        return message;
+    }
+
+    public void setMessage(String message) {
+        this.message = message;
+    }
+
+    public Entity getSourceEntity() {
+        return sourceEntity;
+    }
+
+    public void setSourceEntity(Entity sourceEntity) {
+        this.sourceEntity = sourceEntity;
+    }
+
+    public Entity getTargetEntity() {
+        return targetEntity;
+    }
+
+    public void setTargetEntity(Entity targetEntity) {
+        this.targetEntity = targetEntity;
+    }
+
+    public ItemStack getItem() {
+        return item;
+    }
+
+    public void setItem(ItemStack item) {
+        this.item = item;
+    }
+
+    public BlockState getSourceBlock() {
+        return sourceBlock;
+    }
+
+    public void setSourceBlock(BlockState block) {
+        this.sourceBlock = block;
+    }
+
+    public BlockState getTargetBlock() {
+        return targetBlock;
+    }
+
+    public void setTargetBlock(BlockState targetBlock) {
+        this.targetBlock = targetBlock;
+    }
+
+    public BlockState getPlacedBlock() {
+        return replacedTargetBlock;
+    }
+
+    public void setPlacedBlock(BlockState replacedTargetBlock) {
+        this.replacedTargetBlock = replacedTargetBlock;
+    }
+
+    public Event getEvent() {
+        return event;
+    }
+
+}

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

@@ -57,6 +57,7 @@ public class BukkitPlayer extends LocalPlayer {
 
     @Override
     public void ban(String msg) {
+        player.setBanned(true);
         player.kickPlayer(msg);
     }
 

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

@@ -0,0 +1,99 @@
+// $Id$
+/*
+ * This file is a part of WorldGuard.
+ * Copyright (c) sk89q <http://www.sk89q.com>
+ * Copyright (c) the WorldGuard team and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free Software
+ * (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
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package com.sk89q.worldguard.bukkit;
+
+import org.bukkit.Location;
+import org.bukkit.World;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Entity;
+import org.bukkit.event.Event;
+
+import com.sk89q.worldedit.Vector;
+import com.sk89q.worldguard.protection.ApplicableRegionSet;
+import com.sk89q.worldguard.protection.GlobalRegionManager;
+import com.sk89q.worldguard.protection.RegionQueryCache;
+
+/**
+ * An implementation of {@link RegionQueryCache} for Bukkit. This implementation is
+ * thread-safe.
+ */
+public class BukkitRegionQueryCache extends RegionQueryCache {
+
+    private final WorldGuardPlugin plugin;
+
+    /**
+     * Construct the cache with the given plugin instance.
+     *
+     * @param plugin plugin instance
+     */
+    public BukkitRegionQueryCache(WorldGuardPlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    /**
+     * Get an {@link ApplicableRegionSet} for a given location. The result may have been
+     * temporarily cached for the given event, or null if region protection has
+     * been disabled for the the world of the given location.
+     *
+     * @param event the event to cache against
+     * @param location the location to check
+     * @return the set, or null if region protection is disabled for the given location
+     */
+    public ApplicableRegionSet lookup(Event event, Location location) {
+        World world = location.getWorld();
+        Vector vector = BukkitUtil.toVector(location);
+
+        ConfigurationManager config = plugin.getGlobalStateManager();
+        WorldConfiguration worldConfig = config.get(world);
+        GlobalRegionManager regionManager = plugin.getGlobalRegionManager();
+
+        if (!worldConfig.useRegions) {
+            return null;
+        }
+
+        return get(event).lookup(regionManager.get(world), vector);
+    }
+
+    /**
+     * Get an {@link ApplicableRegionSet} for a given block. The result may have been
+     * temporarily cached for the given event, or null if region protection has
+     * been disabled for the the world of the given block.
+     *
+     * @param event the event to cache against
+     * @param block the block to check
+     * @return the set, or null if region protection is disabled for the given block
+     */
+    public ApplicableRegionSet lookup(Event event, Block block) {
+        return lookup(event, block.getLocation());
+    }
+
+    /**
+     * Get an {@link ApplicableRegionSet} for a given entity. The result may have been
+     * temporarily cached for the given event, or null if region protection has
+     * been disabled for the the world of the given entity.
+     *
+     * @param event the event to cache against
+     * @param entity the entity to check
+     * @return the set, or null if region protection is disabled for the given entity
+     */
+    public ApplicableRegionSet lookup(Event event, Entity entity) {
+        return lookup(event, entity.getLocation());
+    }
+
+}

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

@@ -19,58 +19,52 @@
 
 package com.sk89q.worldguard.bukkit;
 
-import java.util.List;
-
+import com.sk89q.worldedit.BlockVector;
+import com.sk89q.worldedit.Vector;
+import com.sk89q.worldedit.blocks.BlockID;
+import com.sk89q.worldedit.blocks.BlockType;
+import com.sk89q.worldedit.blocks.ItemID;
 import org.bukkit.ChatColor;
 import org.bukkit.Location;
-import org.bukkit.Material;
 import org.bukkit.Server;
 import org.bukkit.World;
 import org.bukkit.block.Block;
-import org.bukkit.entity.Entity;
-import org.bukkit.entity.ExperienceOrb;
-import org.bukkit.entity.Item;
-import org.bukkit.entity.LivingEntity;
-import org.bukkit.entity.Player;
-import org.bukkit.entity.TNTPrimed;
-import org.bukkit.entity.Tameable;
+import org.bukkit.entity.*;
 import org.bukkit.inventory.ItemStack;
 
-import com.sk89q.worldedit.BlockVector;
-import com.sk89q.worldedit.Vector;
-import com.sk89q.worldedit.blocks.BlockType;
+import java.util.List;
 
 public class BukkitUtil {
 
     private BukkitUtil()  {
-    	
+
     }
-    
+
     /**
      * Converts the location of a Bukkit block to a WorldEdit vector.
-     * 
-     * @param block
-     * @return
+     *
+     * @param block The block to convert
+     * @return The block's location as a BlockVector
      */
     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
+     *
+     * @param loc A Bukkit Location
+     * @return A Vector with the location's x, y, and z values
      */
     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
+     *
+     * @param vector The Bukkit vector
+     * @return A WorldEdit vector with the same values as the Bukkit vector.
      */
     public static Vector toVector(org.bukkit.util.Vector vector) {
         return new Vector(vector.getX(), vector.getY(), vector.getZ());
@@ -78,22 +72,24 @@ public class BukkitUtil {
 
     /**
      * Converts a WorldEdit vector to a Bukkit location.
-     * 
-     * @param world
-     * @param vec 
-     * @return
+     *
+     * @param world The World to create the new Location with
+     * @param vec The vector to use for coordinates
+     * @return The Vector as a location with a World of world
      */
     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
+     *
+     * @param server The server to check
+     * @param name The name to attempt to match
+     * @deprecated see {@link WorldGuardPlugin#matchSinglePlayer(org.bukkit.command.CommandSender, String)}
+     * @return The matched player if any, otherwise null
      */
+    @Deprecated
     public static Player matchSinglePlayer(Server server, String name) {
         List<Player> players = server.matchPlayer(name);
         if (players.size() == 0) {
@@ -101,22 +97,24 @@ public class BukkitUtil {
         }
         return players.get(0);
     }
-    
+
     /**
      * Drops a sign item and removes a sign.
-     * 
-     * @param block
+     *
+     * @param block The block
+     * @deprecated see {@link org.bukkit.block.Block#breakNaturally()}
      */
+    @Deprecated
     public static void dropSign(Block block) {
         block.setTypeId(0);
         block.getWorld().dropItemNaturally(block.getLocation(),
-                new ItemStack(Material.SIGN, 1));
+                new ItemStack(ItemID.SIGN, 1));
     }
 
     /**
      * Sets the given block to fluid water.
      * Used by addSpongeWater()
-     * 
+     *
      * @param world
      * @param ox
      * @param oy
@@ -132,21 +130,17 @@ public class BukkitUtil {
 
     /**
      * Checks if the given block is water
-     * 
-     * @param world
-     * @param ox
-     * @param oy
-     * @param oz
-     * @return 
+     *
+     * @param world the world
+     * @param ox x
+     * @param oy y
+     * @param oz z
+     * @return true if it's water
      */
     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;
-        }
+        return id == 8 || id == 9;
     }
 
     /**
@@ -167,7 +161,7 @@ public class BukkitUtil {
 
         byte free = 0;
 
-        while (y <= 129) {
+        while (y <= world.getMaxHeight() + 1) {
             if (BlockType.canPassThrough(world.getBlockTypeIdAt(x, y, z))) {
                 free++;
             } else {
@@ -179,7 +173,7 @@ public class BukkitUtil {
                     loc.setX(x + 0.5);
                     loc.setY(y);
                     loc.setZ(z + 0.5);
-                    if (y <= 2 && world.getBlockAt(x,0,z).getType() == Material.AIR) {
+                    if (y <= 2 && world.getBlockAt(x,0,z).getTypeId() == BlockID.AIR) {
                         world.getBlockAt(x,0,z).setTypeId(20);
                         loc.setY(2);
                     }
@@ -232,17 +226,35 @@ public class BukkitUtil {
     }
 
     /**
-     * Returns whether an entity should be removed for the halt activity mode.
+     * Returns whether our running CraftBukkit already supports
+     * the HangingEvent instead of the PaintingEvent
      *
-     * @param entity
-     * @return
+     * @return true if the hanging event is supported
      */
-    public static boolean isIntensiveEntity(Entity entity) {
-        return entity instanceof Item
-                || entity instanceof TNTPrimed
-                || entity instanceof ExperienceOrb
-                || (entity instanceof LivingEntity
-                && !(entity instanceof Tameable)
-                && !(entity instanceof Player));
+    public static boolean hasHangingEvent() {
+        Class<?> tmp = null;
+        try {
+            tmp = Class.forName("org.bukkit.event.hanging.HangingEvent");
+        } catch (ClassNotFoundException ignored) { }
+        return (tmp != null);
+    }
+
+    /**
+     * Search an enum for a value, and return the first one found. Return null if the
+     * enum entry is not found.
+     *
+     * @param enumType enum class
+     * @param values values to test
+     * @return a value in the enum or null
+     */
+    public static <T extends Enum<T>> T tryEnum(Class<T> enumType, String ... values) {
+        for (String val : values) {
+            try {
+                return Enum.valueOf(enumType, val);
+            } catch (IllegalArgumentException e) {
+            }
+        }
+
+        return null;
     }
 }

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

@@ -19,115 +19,146 @@
 package com.sk89q.worldguard.bukkit;
 
 import java.io.File;
+import java.io.IOException;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Map;
 import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.logging.Level;
+import java.util.logging.Logger;
 
 import org.bukkit.World;
 import org.bukkit.entity.Player;
-import org.bukkit.util.config.Configuration;
+import org.yaml.snakeyaml.DumperOptions.FlowStyle;
 
+import com.sk89q.commandbook.CommandBook;
+import com.sk89q.commandbook.GodComponent;
+import com.sk89q.rebar.config.ConfigurationException;
+import com.sk89q.rebar.config.PairedKeyValueLoaderBuilder;
+import com.sk89q.rebar.config.YamlConfigurationFile;
+import com.sk89q.rebar.config.YamlStyle;
+import com.sk89q.rebar.config.types.LowercaseStringLoaderBuilder;
+import com.sk89q.rebar.config.types.StringLoaderBuilder;
+import com.sk89q.rebar.util.LoggerUtils;
+import com.sk89q.rulelists.RuleEntryLoader;
 import com.sk89q.worldguard.LocalPlayer;
 import com.sk89q.worldguard.blacklist.Blacklist;
 
 /**
  * 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 most settings 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";
+    private static Logger logger = LoggerUtils.getLogger(RuleEntryLoader.class, "[WorldGuard] ");
+
+    private static final String DEFAULT_RULELIST_PATH = "rulelist.yml";
+    private static final String DEFAULT_BLACKLIST_PATH = "worlds/%world%/blacklist.txt";
+    private static final String DEFAULT_WORLD_CONFIG_PATH = "worlds/%world%/config.yml";
+
+    static final YamlStyle YAML_STYLE = new YamlStyle(FlowStyle.BLOCK);
 
-    /**
-     * Reference to the plugin.
-     */
     private WorldGuardPlugin plugin;
+    private ConcurrentMap<String, WorldConfiguration> worlds;
+    private YamlConfigurationFile config;
 
-    /**
-     * Holds configurations for different worlds.
-     */
-    private Map<String, WorldConfiguration> worlds;
+    private Map<String, String> ruleLists = new HashMap<String, String>();
+    private Map<String, String> blacklists = new HashMap<String, String>();
+    private Map<String, String> worldConfigs = new HashMap<String, String>();
 
-    /**
-     * List of people with god mode.
-     */
+    @Deprecated
     private Set<String> hasGodMode = new HashSet<String>();
-
-    /**
-     * List of people who can breathe underwater.
-     */
     private Set<String> hasAmphibious = new HashSet<String>();
 
-    public boolean suppressTickSyncWarnings;
+    private boolean hasCommandBookGodMode = false;
+
+    /* Configuration data start */
     public boolean useRegionsScheduler;
-    public boolean activityHaltToggle = false;
-    public boolean autoGodMode;
+    public boolean useRegionsCreatureSpawnEvent;
     public boolean usePlayerMove;
+    public Map<String, String> hostKeys = new HashMap<String, String>();
+
+    public boolean useSqlDatabase = false;
+    public String sqlDsn;
+    public String sqlUsername;
+    public String sqlPassword;
+    /* Configuration data end */
 
     /**
      * Construct the object.
      *
-     * @param plugin
+     * @param plugin the plugin instance
      */
     public ConfigurationManager(WorldGuardPlugin plugin) {
         this.plugin = plugin;
-        this.worlds = new HashMap<String, WorldConfiguration>();
+        this.worlds = new ConcurrentHashMap<String, WorldConfiguration>();
     }
 
     /**
      * Load the configuration.
      */
     public void load() {
-        // Create the default configuration file
-        plugin.createDefaultConfiguration(
-                new File(plugin.getDataFolder(), "config.yml"), "config.yml");
+        loadConfig();
 
-        Configuration config = plugin.getConfiguration();
-        config.load();
+        // Regions settings
+        useRegionsScheduler = config.getBoolean("regions.use-scheduler", true);
+        useRegionsCreatureSpawnEvent = config.getBoolean("regions.use-creature-spawn-event", true);
 
-        suppressTickSyncWarnings = config.getBoolean(
-                "suppress-tick-sync-warnings", false);
-        useRegionsScheduler = config.getBoolean(
-                "regions.use-scheduler", true);
-        autoGodMode = config.getBoolean(
-                "auto-invincible-permission", false);
-        usePlayerMove = config.getBoolean(
-                "use-player-move-event", true);
+        // Regions SQL settings
+        useSqlDatabase = config.getBoolean("regions.sql.use", false);
+        sqlDsn = config.getString("regions.sql.dsn", "jdbc:mysql://localhost/worldguard");
+        sqlUsername = config.getString("regions.sql.username", "worldguard");
+        sqlPassword = config.getString("regions.sql.password", "worldguard");
+
+        // Other settings
+        usePlayerMove = config.getBoolean("use-player-move-event", true);
+
+        // Load host keys
+        hostKeys = config.mapOf("host-keys",
+                PairedKeyValueLoaderBuilder.build(
+                        new LowercaseStringLoaderBuilder(), new StringLoaderBuilder()));
+
+        // Load rule list filenames
+        if (config.contains("rulelists")) {
+            ruleLists = config.mapOf("rulelists",
+                    PairedKeyValueLoaderBuilder.build(
+                            new LowercaseStringLoaderBuilder(), new StringLoaderBuilder()));
+        } else {
+            config.setNode("rulelists").set("__default__", DEFAULT_RULELIST_PATH);
+            ruleLists = new HashMap<String, String>();
+            ruleLists.put("__default__", DEFAULT_RULELIST_PATH);
+        }
+
+        // Load blacklist filenames
+        if (config.contains("blacklists")) {
+            blacklists = config.mapOf("blacklists",
+                    PairedKeyValueLoaderBuilder.build(
+                            new LowercaseStringLoaderBuilder(), new StringLoaderBuilder()));
+        } else {
+            config.setNode("blacklists").set("__default__", DEFAULT_BLACKLIST_PATH);
+            blacklists = new HashMap<String, String>();
+            blacklists.put("__default__", DEFAULT_BLACKLIST_PATH);
+        }
+
+        // Load world config filenames
+        if (config.contains("world-configs")) {
+            worldConfigs = config.mapOf("world-configs",
+                    PairedKeyValueLoaderBuilder.build(
+                            new LowercaseStringLoaderBuilder(), new StringLoaderBuilder()));
+        } else {
+            config.setNode("world-configs").set("__default__", DEFAULT_WORLD_CONFIG_PATH);
+            worldConfigs = new HashMap<String, String>();
+            worldConfigs.put("__default__", DEFAULT_WORLD_CONFIG_PATH);
+        }
 
         // Load configurations for each world
         for (World world : plugin.getServer().getWorlds()) {
             get(world);
         }
 
-        try {
-            config.setHeader(CONFIG_HEADER);
-        } catch (Throwable t) {
-        }
-
-        config.save();
+        saveConfig();
     }
 
     /**
@@ -137,30 +168,148 @@ public class ConfigurationManager {
         worlds.clear();
     }
 
+    /**
+     * Load the configuration from file.
+     */
+    private void loadConfig() {
+        config = new YamlConfigurationFile(new File(plugin.getDataFolder(), "config.yml"), YAML_STYLE);
+
+        try {
+            config.load();
+        } catch (IOException e) {
+            logger.log(Level.SEVERE, "Error reading config.yml for global config", e);
+        } catch (ConfigurationException e) {
+            logger.log(Level.SEVERE, "Error reading config.yml for global config", e);
+        }
+    }
+
+    /**
+     * Save the configuration to file.
+     */
+    private void saveConfig() {
+        config.setHeader(
+                "# GLOBAL CONFIGURATION FILE\r\n" +
+                "#\r\n" +
+                "# Everything in here applies to all worlds. For world-specific settings, edit \r\n" +
+                "# the files in plugins/WorldGuard/worlds/WORLD_NAME_HERE/config.yml\r\n" +
+                "#\r\n" +
+                "# The official format of this file is called YAML. If you've never had to\r\n" +
+                "# edit one before, you should REALLY read http://wiki.sk89q.com/wiki/Editing_YAML\r\n");
+
+        try {
+            config.save();
+        } catch (IOException e) {
+            logger.log(Level.SEVERE, "Failed to save configuration", e);
+        }
+    }
+
     /**
      * Get the configuration for a world.
      *
-     * @param world
-     * @return
+     * @param world The world to get the configuration for
+     * @return {@code world}'s configuration
      */
     public WorldConfiguration get(World world) {
         String worldName = world.getName();
         WorldConfiguration config = worlds.get(worldName);
+        WorldConfiguration newConfig = null;
 
-        if (config == null) {
-            config = new WorldConfiguration(plugin, worldName);
-            worlds.put(worldName, config);
+        while (config == null) {
+            if (newConfig == null) {
+                newConfig = new WorldConfiguration(plugin, worldName, this, this.config);
+            }
+            worlds.putIfAbsent(world.getName(), newConfig);
+            config = worlds.get(world.getName());
         }
 
         return config;
     }
 
+    /**
+     * Get the RuleList file for the given world.
+     *
+     * @param worldName world
+     * @return file (which may or may not exist)
+     */
+    File getRuleListFile(String worldName) {
+        String path = ruleLists.get(worldName.toLowerCase());
+
+        if (path == null) {
+            path = ruleLists.get("__default__");
+        }
+
+        if (path == null) {
+            path = DEFAULT_RULELIST_PATH;
+        }
+
+        path = path.replace("%world%", worldName);
+        File file = new File(plugin.getDataFolder(), path);
+
+        if (!file.exists()) {
+            plugin.createDefaultConfiguration(file, "rulelist.yml");
+        }
+
+        return file;
+    }
+
+    /**
+     * Get the blacklist file for the given world.
+     *
+     * @param worldName world
+     * @return file (which may or may not exist)
+     */
+    File getBlacklistFile(String worldName) {
+        String path = blacklists.get(worldName.toLowerCase());
+        File file;
+
+        if (path == null) {
+            path = blacklists.get("__default__");
+        }
+
+        if (path == null) {
+            path = DEFAULT_BLACKLIST_PATH;
+        }
+
+        path = path.replace("%world%", worldName);
+        file = new File(plugin.getDataFolder(), path);
+
+        if (!file.exists()) {
+            plugin.createDefaultConfiguration(file, "blacklist.txt");
+        }
+
+        return file;
+    }
+
+    /**
+     * Get the world configuration file for the given world.
+     *
+     * @param worldName world
+     * @return file (which may or may not exist)
+     */
+    File getWorldConfigFile(String worldName) {
+        String path = worldConfigs.get(worldName.toLowerCase());
+        File file;
+
+        if (path == null) {
+            path = worldConfigs.get("__default__");
+        }
+
+        if (path == null) {
+            path = DEFAULT_WORLD_CONFIG_PATH;
+        }
+
+        path = path.replace("%world%", worldName);
+        file = new File(plugin.getDataFolder(), path);
+
+        return file;
+    }
+
     /**
      * Forget a player.
      *
-     * @param player
+     * @param player The player to forget about
      */
-    public void forgetPlayer(LocalPlayer player) {
+    void forgetPlayer(LocalPlayer player) {
         for (Map.Entry<String, WorldConfiguration> entry
                 : worlds.entrySet()) {
 
@@ -178,8 +327,9 @@ public class ConfigurationManager {
     /**
      * Enable god mode for a player.
      *
-     * @param player
+     * @param player The player to enable god mode for.
      */
+    @Deprecated
     public void enableGodMode(Player player) {
         hasGodMode.add(player.getName());
     }
@@ -187,8 +337,9 @@ public class ConfigurationManager {
     /**
      * Disable god mode for a player.
      *
-     * @param player
+     * @param player The player to disable godmode for
      */
+    @Deprecated
     public void disableGodMode(Player player) {
         hasGodMode.remove(player.getName());
     }
@@ -196,17 +347,23 @@ public class ConfigurationManager {
     /**
      * Check to see if god mode is enabled for a player.
      *
-     * @param player
-     * @return
+     * @param player The player to check
+     * @return Whether the player has godmode through WorldGuard or CommandBook
      */
     public boolean hasGodMode(Player player) {
+        if (hasCommandBookGodMode) {
+            GodComponent god = CommandBook.inst().getComponentManager().getComponent(GodComponent.class);
+            if (god != null) {
+                return god.hasGodMode(player);
+            }
+        }
         return hasGodMode.contains(player.getName());
     }
 
     /**
      * Enable amphibious mode for a player.
      *
-     * @param player
+     * @param player The player to enable amphibious mode for
      */
     public void enableAmphibiousMode(Player player) {
         hasAmphibious.add(player.getName());
@@ -215,19 +372,42 @@ public class ConfigurationManager {
     /**
      * Disable amphibious mode  for a player.
      *
-     * @param player
+     * @param player The player to disable amphibious mode for
      */
     public void disableAmphibiousMode(Player player) {
         hasAmphibious.remove(player.getName());
     }
 
     /**
-     * Check to see if amphibious mode  is enabled for a player.
+     * Check to see if amphibious mode is enabled for a player.
      *
-     * @param player
-     * @return
+     * @param player The player to check
+     * @return Whether {@code player} has amphibious mode
      */
     public boolean hasAmphibiousMode(Player player) {
         return hasAmphibious.contains(player.getName());
     }
+
+    /**
+     * Check and store whether CommandBook is installed.
+     */
+    void updateCommandBookGodMode() {
+        try {
+            if (plugin.getServer().getPluginManager().isPluginEnabled("CommandBook")) {
+                Class.forName("com.sk89q.commandbook.GodComponent");
+                hasCommandBookGodMode = true;
+                return;
+            }
+        } catch (ClassNotFoundException ignore) {}
+        hasCommandBookGodMode = false;
+    }
+
+    /**
+     * Return whether CommandBook is available for God mode usage.
+     *
+     * @return true if it available
+     */
+    boolean hasCommandBookGodMode() {
+        return hasCommandBookGodMode;
+    }
 }

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

@@ -36,46 +36,47 @@ import com.sk89q.worldguard.protection.managers.RegionManager;
 /**
  * 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
+     *
+     * @param plugin The plugin instance
      */
     public FlagStateManager(WorldGuardPlugin plugin) {
         this.plugin = plugin;
-        
+
         states = new HashMap<String, PlayerFlagState>();
     }
 
     /**
      * Run the task.
      */
+    @Override
     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);
@@ -87,7 +88,7 @@ public class FlagStateManager implements Runnable {
                     .get(player.getWorld());
             ApplicableRegionSet applicable = regionManager
                     .getApplicableRegions(playerLocation);
-            
+
             if (!RegionQueryUtil.isInvincible(plugin, player, applicable)
                     && !plugin.getGlobalStateManager().hasGodMode(player)
                     && !(player.getGameMode() == GameMode.CREATIVE)) {
@@ -96,28 +97,28 @@ public class FlagStateManager implements Runnable {
             }
         }
     }
-    
+
     /**
      * Process healing for a player.
-     * 
-     * @param applicable
-     * @param player
-     * @param state
+     *
+     * @param applicable The set of applicable regions
+     * @param player The player to process healing flags on
+     * @param state The player's 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);
         Integer minHealth = applicable.getFlag(DefaultFlag.MIN_HEAL);
         Integer maxHealth = applicable.getFlag(DefaultFlag.MAX_HEAL);
-        
+
         if (healAmount == null || healDelay == null || healAmount == 0 || healDelay < 0) {
             return;
         }
@@ -127,7 +128,7 @@ public class FlagStateManager implements Runnable {
         if (player.getHealth() >= maxHealth && healAmount > 0) {
             return;
         }
-        
+
         if (healDelay <= 0) {
             player.setHealth(healAmount > 0 ? maxHealth : minHealth); // this will insta-kill if the flag is unset
             state.lastHeal = now;
@@ -137,22 +138,24 @@ public class FlagStateManager implements Runnable {
             state.lastHeal = now;
         }
     }
-    
+
     /**
      * Process restoring hunger for a player.
-     * 
-     * @param applicable
-     * @param player
-     * @param state
+     *
+     * @param applicable The set of applicable regions
+     * @param player The player to process hunger flags on
+     * @param state The player's state
      */
     private void processFeed(ApplicableRegionSet applicable, Player player,
             PlayerFlagState state) {
 
+        long now = System.currentTimeMillis();
+
         Integer feedAmount = applicable.getFlag(DefaultFlag.FEED_AMOUNT);
         Integer feedDelay = applicable.getFlag(DefaultFlag.FEED_DELAY);
         Integer minHunger = applicable.getFlag(DefaultFlag.MIN_FOOD);
         Integer maxHunger = applicable.getFlag(DefaultFlag.MAX_FOOD);
-        
+
         if (feedAmount == null || feedDelay == null || feedAmount == 0 || feedDelay < 0) {
             return;
         }
@@ -164,17 +167,19 @@ public class FlagStateManager implements Runnable {
         }
 
         if (feedDelay <= 0) {
-            player.setFoodLevel(feedAmount > 0 ? maxHunger : minHunger); // this will insta-kill if the flag is unset
-        } else {
+            player.setFoodLevel(feedAmount > 0 ? maxHunger : minHunger);
+            state.lastFeed = now;
+        } else if (now - state.lastFeed > feedDelay * 1000) {
             // clamp health between minimum and maximum
             player.setFoodLevel(Math.min(maxHunger, Math.max(minHunger, player.getFoodLevel() + feedAmount)));
+            state.lastFeed = now;
         }
     }
 
     /**
      * Forget a player.
-     * 
-     * @param player
+     *
+     * @param player The player to forget
      */
     public synchronized void forget(Player player) {
         states.remove(player.getName());
@@ -188,32 +193,35 @@ public class FlagStateManager implements Runnable {
     }
 
     /**
-     * Get a player's flag state.
-     * 
-     * @param player
-     * @return
+     * Get a player's flag state. A new state will be created if there is no existing
+     * state for the player.
+     *
+     * @param player The player to get a state for
+     * @return The {@code player}'s state
      */
     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 long lastFeed;
         public String lastGreeting;
         public String lastFarewell;
         public Boolean lastExitAllowed = null;
         public Boolean notifiedForLeave = false;
         public Boolean notifiedForEnter = false;
+        public GameMode lastGameMode;
         public World lastWorld;
         public int lastBlockX;
         public int lastBlockY;

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

@@ -0,0 +1,305 @@
+// $Id$
+/*
+ * This file is a part of WorldGuard.
+ * Copyright (c) sk89q <http://www.sk89q.com>
+ * Copyright (c) the WorldGuard team and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free Software
+ * (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
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package com.sk89q.worldguard.bukkit;
+
+import java.util.logging.Logger;
+
+import org.bukkit.ChatColor;
+import org.bukkit.Chunk;
+import org.bukkit.Server;
+import org.bukkit.World;
+import org.bukkit.entity.Animals;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.ExperienceOrb;
+import org.bukkit.entity.FallingBlock;
+import org.bukkit.entity.Item;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.TNTPrimed;
+import org.bukkit.entity.Tameable;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.BlockBurnEvent;
+import org.bukkit.event.block.BlockFormEvent;
+import org.bukkit.event.block.BlockFromToEvent;
+import org.bukkit.event.block.BlockIgniteEvent;
+import org.bukkit.event.block.BlockPhysicsEvent;
+import org.bukkit.event.block.BlockSpreadEvent;
+import org.bukkit.event.block.LeavesDecayEvent;
+import org.bukkit.event.entity.CreatureSpawnEvent;
+import org.bukkit.event.entity.EntityExplodeEvent;
+import org.bukkit.event.entity.ExplosionPrimeEvent;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.event.world.ChunkLoadEvent;
+import org.bukkit.plugin.PluginManager;
+
+import com.sk89q.rebar.util.LoggerUtils;
+
+/**
+ * Handles the "stop lag" mode.
+ */
+public class LagStopMode implements Listener {
+
+    private static final Logger logger = LoggerUtils.getLogger(LagStopMode.class,
+            "[WorldGuard] Lag Stop Mode: ");
+
+    private final WorldGuardPlugin plugin;
+    private boolean enabled = false;
+    private boolean removeAnimals = true;
+
+    LagStopMode(WorldGuardPlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    /**
+     * Register this class's events.
+     */
+    void registerEvents() {
+        PluginManager pm = plugin.getServer().getPluginManager();
+        pm.registerEvents(this, plugin);
+    }
+
+    /**
+     * Get whether the lag stop mode is enabled.
+     *
+     * @return true if it's enabled
+     */
+    public boolean isEnabled() {
+        return enabled;
+    }
+
+    /**
+     * Enable the lag stop mode. This will start the process and emit messages.
+     *
+     * @param unloadChunks true to unload chunks
+     */
+    public void enable(boolean unloadChunks) {
+        if (!enabled) {
+            Server server = plugin.getServer();
+
+            server.broadcastMessage(ChatColor.GRAY
+                    + "(WorldGuard's 'lag stop' mode has been enabled. Some parts of the game may be 'frozen'. Keep calm and carry on.)");
+
+            // Remove entities
+            server.broadcastMessage(ChatColor.GRAY + "(Please wait... removing entities...)");
+            for (World world : server.getWorlds()) {
+                freeUp(world);
+            }
+
+            // Unloading chunks
+            if (unloadChunks) {
+                server.broadcastMessage(ChatColor.GRAY + "(Please wait... garbage collecting chunks...)");
+                for (World world : server.getWorlds()) {
+                    Chunk[] chunks = world.getLoadedChunks();
+
+                    for (Chunk chunk : chunks) {
+                        chunk.unload(true, true);
+                    }
+                }
+            }
+
+            server.broadcastMessage(ChatColor.GRAY + "(Completed. Lag stop mode is still enabled.)");
+        }
+
+        this.enabled = true;
+
+    }
+
+    /**
+     * Disable the lag stop mode.
+     */
+    public void disable() {
+        if (enabled) {
+            Server server = plugin.getServer();
+            server.broadcastMessage(ChatColor.GRAY
+                    + "(WorldGuard's 'lag stop' mode is now off. Everything should proceed to start working again.)");
+        }
+
+        this.enabled = false;
+
+    }
+
+    /**
+     * Returns whether animals are being removed.
+     *
+     * @return true if animals are being removed
+     */
+    public boolean isRemovingAnimals() {
+        return removeAnimals;
+    }
+
+    /**
+     * Set whether animals should be removed.
+     *
+     * @param removeAnimals true to remove animals
+     */
+    public void setRemoveAnimals(boolean removeAnimals) {
+        this.removeAnimals = removeAnimals;
+    }
+
+    /**
+     * Remove items and other things within the chunk.
+     *
+     * @param plugin the plugin
+     * @param chunk the chunk to halt
+     */
+    private void freeUp(Chunk chunk) {
+        int removed = 0;
+
+        for (Entity entity : chunk.getEntities()) {
+            if (shouldRemove(entity)) {
+                entity.remove();
+                removed++;
+            }
+        }
+
+        if (removed > 50) {
+            logger.info(removed + " entities (>50) auto-removed from " + chunk.toString());
+        }
+    }
+
+    /**
+     * Remove items and other things within the world.
+     *
+     * @param plugin the plugin
+     * @param world the world to halt
+     */
+    private void freeUp(World world) {
+        int removed = 0;
+
+        for (Entity entity : world.getEntities()) {
+            if (shouldRemove(entity)) {
+                entity.remove();
+                removed++;
+            }
+        }
+
+        if (removed > 50) {
+            logger.info(removed + " entities (>50) auto-removed from " + world.toString());
+        }
+    }
+
+    /**
+     * Returns whether an entity should be removed.
+     *
+     * @param entity the entity to check
+     * @return true if it should be removed
+     */
+    private boolean shouldRemove(Entity entity) {
+        return entity instanceof Item
+                || entity instanceof TNTPrimed
+                || entity instanceof ExperienceOrb
+                || entity instanceof FallingBlock
+                || (entity instanceof LivingEntity
+                    && !(entity instanceof Tameable)
+                    && !(entity instanceof Player)
+                    && (removeAnimals || !(entity instanceof Animals)));
+    }
+
+    @EventHandler(priority = EventPriority.LOWEST)
+    public void onPlayerJoin(PlayerJoinEvent event) {
+        Player player = event.getPlayer();
+        World world = player.getWorld();
+
+        if (enabled) {
+            player.sendMessage(ChatColor.GRAY
+                    + "WorldGuard's 'lag stop' mode has been enabled. Some parts of the game may be 'frozen'.");
+            freeUp(world);
+        }
+    }
+
+    @EventHandler(priority = EventPriority.LOWEST)
+    public void onBlockFromTo(BlockFromToEvent event) {
+        if (enabled) {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler(priority = EventPriority.LOWEST)
+    public void onBlockIgnite(BlockIgniteEvent event) {
+        if (enabled) {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler(priority = EventPriority.LOWEST)
+    public void onBlockBurn(BlockBurnEvent event) {
+        if (enabled) {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler(priority = EventPriority.LOWEST)
+    public void onBlockPhysics(BlockPhysicsEvent event) {
+        if (enabled) {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler(priority = EventPriority.LOWEST)
+    public void onBlockForm(BlockFormEvent event) {
+        if (enabled) {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler(priority = EventPriority.LOWEST)
+    public void onLeavesDecay(LeavesDecayEvent event) {
+        if (enabled) {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler(priority = EventPriority.LOWEST)
+    public void onBlockSpread(BlockSpreadEvent event) {
+        if (enabled) {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler(priority = EventPriority.LOWEST)
+    public void onEntityExplode(EntityExplodeEvent event) {
+        if (enabled) {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler(priority = EventPriority.LOWEST)
+    public void onExplosionPrime(ExplosionPrimeEvent event) {
+        if (enabled) {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler(priority = EventPriority.LOWEST)
+    public void onCreatureSpawn(CreatureSpawnEvent event) {
+        if (enabled) {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler(priority = EventPriority.LOWEST)
+    public void onChunkLoad(ChunkLoadEvent event) {
+        if (enabled) {
+            freeUp(event.getChunk());
+        }
+    }
+
+}

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

@@ -1,87 +0,0 @@
-package com.sk89q.worldguard.bukkit;
-
-import java.util.Set;
-
-import org.bukkit.Server;
-import org.bukkit.command.CommandSender;
-import org.bukkit.permissions.Permission;
-import org.bukkit.permissions.PermissionAttachment;
-import org.bukkit.permissions.PermissionAttachmentInfo;
-import org.bukkit.plugin.Plugin;
-
-/**
-* Console sender.
-*
-* @author sk89q
-*/
-class LegacyConsoleSender implements CommandSender {
-    private Server server;
-
-    public LegacyConsoleSender(Server server) {
-        this.server = server;
-    }
-
-    public void sendMessage(String message) {
-        WorldGuardPlugin.logger.info(message);
-    }
-
-    public Server getServer() {
-        return server;
-    }
-
-    public String getName() {
-        return "CONSOLE";
-    }
-
-    public boolean isPermissionSet(String name) {
-        return true;
-    }
-
-    public boolean isPermissionSet(Permission perm) {
-        return true;
-    }
-
-    public boolean hasPermission(String name) {
-        return true;
-    }
-
-    public boolean hasPermission(Permission perm) {
-        return true;
-    }
-
-    public PermissionAttachment addAttachment(Plugin plugin, String name,
-            boolean value) {
-        throw new UnsupportedOperationException("Fake legacy console command sender does not support this");
-    }
-
-    public PermissionAttachment addAttachment(Plugin plugin) {
-        throw new UnsupportedOperationException("Fake legacy console command sender does not support this");
-    }
-
-    public PermissionAttachment addAttachment(Plugin plugin, String name,
-            boolean value, int ticks) {
-        throw new UnsupportedOperationException("Fake legacy console command sender does not support this");
-    }
-
-    public PermissionAttachment addAttachment(Plugin plugin, int ticks) {
-        throw new UnsupportedOperationException("Fake legacy console command sender does not support this");
-    }
-
-    public void removeAttachment(PermissionAttachment attachment) {
-        throw new UnsupportedOperationException("Fake legacy console command sender does not support this");
-    }
-
-    public void recalculatePermissions() {
-    }
-
-    public Set<PermissionAttachmentInfo> getEffectivePermissions() {
-        throw new UnsupportedOperationException("Fake legacy console command sender does not support this");
-    }
-
-    public boolean isOp() {
-        return true;
-    }
-
-    public void setOp(boolean value) {
-    }
-}

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

@@ -26,10 +26,9 @@ import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
-import java.util.logging.Logger;
-
 import org.bukkit.World;
 
+import com.sk89q.worldguard.protection.databases.ProtectionDatabaseException;
 import com.sk89q.worldguard.protection.databases.CSVDatabase;
 import com.sk89q.worldguard.protection.managers.RegionManager;
 
@@ -39,15 +38,11 @@ import com.sk89q.worldguard.protection.managers.RegionManager;
  * @author sk89q
  */
 public class LegacyWorldGuardMigration {
-    /**
-     * Logger for messages.
-     */
-    protected static final Logger logger = Logger.getLogger("Minecraft.WorldGuard");
     
     /**
      * Port over the blacklist.
      * 
-     * @param plugin
+     * @param plugin The plugin instance
      */
     public static void migrateBlacklist(WorldGuardPlugin plugin) {
         World mainWorld = plugin.getServer().getWorlds().get(0);
@@ -58,7 +53,7 @@ public class LegacyWorldGuardMigration {
         File newFile = new File(plugin.getDataFolder(), newPath);
         
         if (!newFile.exists() && oldFile.exists()) {
-            logger.warning("WorldGuard: WorldGuard will now update your blacklist "
+            plugin.getLogger().warning("WorldGuard will now update your blacklist "
                     + "from an older version of WorldGuard.");
             
             // Need to make root directories
@@ -68,9 +63,9 @@ public class LegacyWorldGuardMigration {
                 oldFile.renameTo(new File(plugin.getDataFolder(),
                         "blacklist.txt.old"));
             } else {
-                logger.warning("WorldGuard: blacklist.txt has been converted " +
+                plugin.getLogger().warning("blacklist.txt has been converted " +
                         "for the main world at " + newPath + "");
-                logger.warning("WorldGuard: Your other worlds currently have no " +
+                plugin.getLogger().warning("Your other worlds currently have no " +
                 		"blacklist defined!");
             }
             
@@ -80,22 +75,22 @@ public class LegacyWorldGuardMigration {
     /**
      * Migrate region settings.
      * 
-     * @param plugin
+     * @param plugin The plugin instance
      */
     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. "
+            plugin.getLogger().info("The regions database has changed in 5.x. "
                     + "Your old regions database will be converted to the new format "
-                    + "and set as your primarily world's database.");
+                    + "and set as your primary 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);
+            CSVDatabase db = new CSVDatabase(oldDatabase, plugin.getLogger());
             db.load();
             
             // Then save the new database
@@ -104,10 +99,9 @@ public class LegacyWorldGuardMigration {
             
             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: "
+            plugin.getLogger().info("Regions database converted!");
+        } catch (ProtectionDatabaseException e) {
+            plugin.getLogger().warning("Failed to load regions: "
                     + e.getMessage());
         }
     }
@@ -115,8 +109,8 @@ public class LegacyWorldGuardMigration {
     /**
      * Copies a file.
      * 
-     * @param from
-     * @param to
+     * @param from The source file
+     * @param to The destination file
      * @return true if successful
      */
     private static boolean copyFile(File from, File to) {
@@ -137,20 +131,20 @@ public class LegacyWorldGuardMigration {
             out.close();
             
             return true;
-        } catch (FileNotFoundException ex) {
-        } catch (IOException e) {
+        } catch (FileNotFoundException ignore) {
+        } catch (IOException ignore) {
         } finally {
             if (in != null) {
                 try {
                     in.close();
-                } catch (IOException e) {
+                } catch (IOException ignore) {
                 }
             }
             
             if (out != null) {
                 try {
                     out.close();
-                } catch (IOException e) {
+                } catch (IOException ignore) {
                 }
             }
         }

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

@@ -20,6 +20,7 @@
 package com.sk89q.worldguard.bukkit;
 
 import java.util.logging.Handler;
+import java.util.logging.Level;
 import java.util.logging.LogRecord;
 
 import org.bukkit.ChatColor;
@@ -27,8 +28,6 @@ import org.bukkit.command.CommandSender;
 
 /**
  * Sends all logger messages to a player.
- *
- * @author sk89q
  */
 public class LoggerToChatHandler extends Handler {
     /**
@@ -64,7 +63,12 @@ public class LoggerToChatHandler extends Handler {
      */
     @Override
     public void publish(LogRecord record) {
-        player.sendMessage(ChatColor.GRAY + record.getLevel().getName() + ": "
-                + ChatColor.WHITE + record.getMessage());
+        if (record.getLevel().intValue() >= Level.WARNING.intValue()) {
+            player.sendMessage(ChatColor.RED + record.getLevel().getName() + ": "
+                    + ChatColor.YELLOW + record.getMessage());
+        } else {
+            player.sendMessage(ChatColor.GRAY + record.getLevel().getName() + ": "
+                    + ChatColor.WHITE + record.getMessage());
+        }
     }
 }

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

@@ -59,7 +59,7 @@ public class RegionQueryUtil {
                 set = mgr.getApplicableRegions(vec);
             }
 
-            state.wasInvincible = set.allows(DefaultFlag.INVINCIBILITY);
+            state.wasInvincible = set.allows(DefaultFlag.INVINCIBILITY, plugin.wrapPlayer(player));
         }
 
         return state.wasInvincible;
@@ -71,11 +71,11 @@ public class RegionQueryUtil {
         Vector vec = new Vector(state.lastInvincibleX, state.lastInvincibleY, state.lastInvincibleZ);
 
         StateFlag.State regionState = plugin.getGlobalRegionManager().get(world).
-                getApplicableRegions(vec).getFlag(DefaultFlag.INVINCIBILITY);
+                getApplicableRegions(vec).getFlag(DefaultFlag.INVINCIBILITY, plugin.wrapPlayer(player));
         if (regionState == StateFlag.State.ALLOW) {
-            return true;
+            return Boolean.TRUE;
         } else if (regionState == StateFlag.State.DENY) {
-            return false;
+            return Boolean.FALSE;
         } else {
             return null;
         }

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

@@ -127,7 +127,7 @@ public class ReportWriter {
                 configLog.put(field.getName(), val);
             } catch (IllegalArgumentException e) {
                 e.printStackTrace();
-            } catch (IllegalAccessException e) {
+            } catch (IllegalAccessException ignore) {
             }
         }
         
@@ -166,7 +166,7 @@ public class ReportWriter {
     }
     
     private void appendPluginInformation(Plugin[] plugins) {
-        appendHeader("Plugins");
+        appendHeader("Plugins (" + plugins.length + ")");
         
         LogListBlock log = new LogListBlock();
         
@@ -274,7 +274,7 @@ public class ReportWriter {
                     configLog.put(field.getName(), String.valueOf(val));
                 } catch (IllegalArgumentException e) {
                     e.printStackTrace();
-                } catch (IllegalAccessException e) {
+                } catch (IllegalAccessException ignore) {
                 }
             }
             
@@ -324,7 +324,7 @@ public class ReportWriter {
             if (writer != null) {
                 try {
                     writer.close();
-                } catch (IOException e) {
+                } catch (IOException ignore) {
                 }
             }
         }

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

@@ -0,0 +1,196 @@
+// $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.Material;
+import org.bukkit.World;
+import org.bukkit.block.Block;
+
+import com.sk89q.worldedit.blocks.BlockID;
+
+/**
+ * An applicator of the sponge feature.
+ */
+class SpongeApplicator {
+
+    private final int spongeRadius;
+    private final boolean useRedstone;
+    private final boolean refillArea;
+
+    /**
+     * Construct a new applicator.
+     *
+     * @param spongeRadius the radius of the sponge's effect
+     * @param useRedstone use Redstone
+     * @param refillArea refill the area if a sponge is removed
+     */
+    public SpongeApplicator(int spongeRadius, boolean useRedstone, boolean refillArea) {
+        this.spongeRadius = spongeRadius;
+        this.useRedstone = useRedstone;
+        this.refillArea = refillArea;
+    }
+
+    /**
+     * Returns whether the block at the given position is water.
+     *
+     * @param world world
+     * @param x x
+     * @param y y
+     * @param z z
+     * @return true if it's water
+     */
+    private static boolean isWater(World world, int x, int y, int z) {
+        int type = world.getBlockTypeIdAt(x, y, z);
+        return type == BlockID.WATER || type == BlockID.STATIONARY_WATER;
+    }
+
+    /**
+     * Returns whether the given sponge is an active sponge.
+     *
+     * @param block block to check
+     * @return true if it's active
+     */
+    public boolean isActiveSponge(Block block) {
+        return block.getType() == Material.SPONGE
+                && (!useRedstone || !block.isBlockIndirectlyPowered());
+    }
+
+    /**
+     * Return true if a given block near an active sponge.
+     *
+     * @param blockTo location of the block
+     * @return true if it's near a sponge (and water should be cancelled)
+     */
+    public boolean isNearSponge(Block blockTo) {
+        World world = blockTo.getWorld();
+        int ox = blockTo.getX();
+        int oy = blockTo.getY();
+        int oz = blockTo.getZ();
+
+        for (int cx = -spongeRadius; cx <= spongeRadius; cx++) {
+            for (int cy = -spongeRadius; cy <= spongeRadius; cy++) {
+                for (int cz = -spongeRadius; cz <= spongeRadius; cz++) {
+                    Block sponge = world.getBlockAt(ox + cx, oy + cy, oz + cz);
+                    if (isActiveSponge(sponge)) {
+                        return true;
+                    }
+                }
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Remove water due to a sponge from the given position.
+     *
+     * @param block the block
+     */
+    public void clearWater(Block block) {
+        World world = block.getWorld();
+        int ox = block.getX();
+        int oy = block.getY();
+        int oz = block.getZ();
+
+        for (int cx = -spongeRadius; cx <= spongeRadius; cx++) {
+            for (int cy = -spongeRadius; cy <= spongeRadius; cy++) {
+                for (int cz = -spongeRadius; cz <= spongeRadius; cz++) {
+                    if (isWater(world, ox + cx, oy + cy, oz + cz)) {
+                        world.getBlockAt(ox + cx, oy + cy, oz + cz).setTypeId(0);
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Add water due to a sponge from the given position.
+     *
+     * @param block the block
+     */
+    public void placeWater(Block block) {
+        if (!refillArea) return;
+
+        World world = block.getWorld();
+        int ox = block.getX();
+        int oy = block.getY();
+        int oz = block.getZ();
+
+        // The negative x edge
+        int cx = ox - spongeRadius - 1;
+        for (int cy = oy - spongeRadius - 1; cy <= oy + spongeRadius + 1; cy++) {
+            for (int cz = oz - spongeRadius - 1; cz <= oz + spongeRadius + 1; cz++) {
+                if (isWater(world, cx, cy, cz)) {
+                     world.getBlockAt(cx + 1, cy, cz).setType(Material.STATIONARY_WATER);
+                }
+            }
+        }
+
+        // The positive x edge
+        cx = ox + spongeRadius + 1;
+        for (int cy = oy - spongeRadius - 1; cy <= oy + spongeRadius + 1; cy++) {
+            for (int cz = oz - spongeRadius - 1; cz <= oz + spongeRadius + 1; cz++) {
+                if (isWater(world, cx, cy, cz)) {
+                     world.getBlockAt(cx - 1, cy, cz).setType(Material.STATIONARY_WATER);
+                }
+            }
+        }
+
+        // The negative y edge
+        int cy = oy - spongeRadius - 1;
+        for (cx = ox - spongeRadius - 1; cx <= ox + spongeRadius + 1; cx++) {
+            for (int cz = oz - spongeRadius - 1; cz <= oz + spongeRadius + 1; cz++) {
+                if (isWater(world, cx, cy, cz)) {
+                     world.getBlockAt(cx, cy + 1, cz).setType(Material.STATIONARY_WATER);
+                }
+            }
+        }
+
+        // The positive y edge
+        cy = oy + spongeRadius + 1;
+        for (cx = ox - spongeRadius - 1; cx <= ox + spongeRadius + 1; cx++) {
+            for (int cz = oz - spongeRadius - 1; cz <= oz + spongeRadius + 1; cz++) {
+                if (isWater(world, cx, cy, cz)) {
+                     world.getBlockAt(cx, cy - 1, cz).setType(Material.STATIONARY_WATER);
+                }
+            }
+        }
+
+        // The negative z edge
+        int cz = oz - spongeRadius - 1;
+        for (cx = ox - spongeRadius - 1; cx <= ox + spongeRadius + 1; cx++) {
+            for (cy = oy - spongeRadius - 1; cy <= oy + spongeRadius + 1; cy++) {
+                if (isWater(world, cx, cy, cz)) {
+                     world.getBlockAt(cx, cy, cz + 1).setType(Material.STATIONARY_WATER);
+                }
+            }
+        }
+
+        // The positive z edge
+        cz = oz + spongeRadius + 1;
+        for (cx = ox - spongeRadius - 1; cx <= ox + spongeRadius + 1; cx++) {
+            for (cy = oy - spongeRadius - 1; cy <= oy + spongeRadius + 1; cy++) {
+                if (isWater(world, cx, cy, cz)) {
+                     world.getBlockAt(cx, cy, cz - 1).setType(Material.STATIONARY_WATER);
+                }
+            }
+        }
+    }
+}

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

@@ -1,126 +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.isBlockWater;
-import static com.sk89q.worldguard.bukkit.BukkitUtil.setBlockToWater;
-
-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

@@ -22,18 +22,24 @@ package com.sk89q.worldguard.bukkit;
 import java.io.File;
 import java.io.FileNotFoundException;
 import java.io.IOException;
-import java.util.ArrayList;
-import java.util.HashSet;
+import java.util.HashMap;
 import java.util.List;
-import java.util.Set;
+import java.util.Map;
 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;
 
+import com.sk89q.rebar.config.ConfigurationException;
+import com.sk89q.rebar.config.ConfigurationNode;
+import com.sk89q.rebar.config.YamlConfigurationFile;
+import com.sk89q.rebar.util.LoggerUtils;
+import com.sk89q.rulelists.KnownAttachment;
+import com.sk89q.rulelists.KnownAttachmentRules;
+import com.sk89q.rulelists.RuleEntry;
+import com.sk89q.rulelists.RuleEntryLoader;
+import com.sk89q.rulelists.RuleTemplateEntryLoader;
 import com.sk89q.worldguard.blacklist.Blacklist;
 import com.sk89q.worldguard.blacklist.BlacklistLogger;
 import com.sk89q.worldguard.blacklist.loggers.ConsoleLoggerHandler;
@@ -44,416 +50,254 @@ import com.sk89q.worldguard.chest.SignChestProtection;
 
 /**
  * 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 Logger logger = LoggerUtils.getLogger(WorldConfiguration.class, "[WorldGuard] ");
 
-    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 final WorldGuardPlugin plugin;
+    private final ConfigurationManager configMan;
+    private final YamlConfigurationFile config;
+    private final String worldName;
 
     private Blacklist blacklist;
+    private KnownAttachmentRules ruleList = new KnownAttachmentRules();
     private ChestProtection chestProtection = new SignChestProtection();
+    private SpongeApplicator spongeApplicator = null;
 
     /* 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 disableExpDrops;
-    public boolean pumpkinScuba;
-    public boolean redstoneSponges;
-    public boolean noPhysicsGravel;
-    public boolean noPhysicsSand;
-    public boolean allowPortalAnywhere;
-    public Set<Integer> preventWaterDamage;
-    public boolean blockLighter;
-    public boolean disableFireSpread;
-    public Set<Integer> disableFireSpreadBlocks;
-    public boolean preventLavaFire;
-    public Set<Integer> allowedLavaSpreadOver;
-    public boolean blockTNTExplosions;
-    public boolean blockTNTBlockDamage;
-    public boolean blockCreeperExplosions;
-    public boolean blockCreeperBlockDamage;
-    public boolean blockFireballExplosions;
-    public boolean blockFireballBlockDamage;
-    // 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 int regionWand;
+    public boolean regionInvinciblityRemovesMobs;
     // 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;
-    public boolean disableGrassGrowth;
-    public boolean disableEndermanGriefing;
-    public boolean regionInvinciblityRemovesMobs;
-    public boolean disableDeathMessages;
-    public boolean disableObsidianGenerators;
-
+    public boolean disableSignChestProtectionCheck;
+    private Map<String, Integer> maxRegionCounts;
+    public boolean fireSpreadDisableToggle;
     /* Configuration data end */
 
     /**
      * Construct the object.
      *
-     * @param plugin
-     * @param worldName
+     * @param plugin the plugin instance
+     * @param worldName name of the world that this object is for
+     * @param configMan configuration manager
+     * @param parentConfig parent configuration
      */
-    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");
-
+    public WorldConfiguration(WorldGuardPlugin plugin, String worldName,
+            ConfigurationManager configMan, ConfigurationNode parentConfig) {
         this.plugin = plugin;
         this.worldName = worldName;
-        this.parentConfig = plugin.getConfiguration();
+        this.configMan = configMan;
 
-        plugin.createDefaultConfiguration(configFile, "config_world.yml");
-        plugin.createDefaultConfiguration(blacklistFile, "blacklist.txt");
+        File file = configMan.getWorldConfigFile(worldName);
+        config = new YamlConfigurationFile(file, ConfigurationManager.YAML_STYLE);
+        config.setParent(parentConfig);
 
-        config = new Configuration(this.configFile);
-        loadConfiguration();
-
-        logger.info("WorldGuard: Loaded configuration for world '" + worldName + '"');
-    }
-
-    private boolean getBoolean(String node, boolean def) {
-        boolean val = parentConfig.getBoolean(node, def);
-
-        if (config.getProperty(node) != null) {
-            return config.getBoolean(node, def);
-        } else {
-            return val;
-        }
-    }
-
-    private String getString(String node, String def) {
-        String val = parentConfig.getString(node, def);
-
-        if (config.getProperty(node) != null) {
-            return config.getString(node, def);
-        } else {
-            return val;
-        }
-    }
-
-    private int getInt(String node, int def) {
-        int val = parentConfig.getInt(node, def);
-
-        if (config.getProperty(node) != null) {
-            return config.getInt(node, def);
-        } else {
-            return val;
-        }
-    }
-
-    private double getDouble(String node, double def) {
-        double val = parentConfig.getDouble(node, def);
-
-        if (config.getProperty(node) != null) {
-            return config.getDouble(node, def);
-        } else {
-            return val;
-        }
-    }
-
-    private List<Integer> getIntList(String node, List<Integer> def) {
-        List<Integer> res = parentConfig.getIntList(node, def);
-
-        if (res == null || res.size() == 0) {
-            parentConfig.setProperty(node, new ArrayList<Integer>());
-        }
-
-        if (config.getProperty(node) != null) {
-            res = config.getIntList(node, def);
-        }
-
-        return res;
-    }
-
-    private List<String> getStringList(String node, List<String> def) {
-        List<String> res = parentConfig.getStringList(node, def);
-
-        if (res == null || res.size() == 0) {
-            parentConfig.setProperty(node, new ArrayList<String>());
-        }
-
-        if (config.getProperty(node) != null) {
-            res = config.getStringList(node, def);
-        }
-
-        return res;
+        load();
     }
 
     /**
      * Load the configuration.
      */
-    private void loadConfiguration() {
-        config.load();
+    private void load() {
+        logger.info("Loading configuration for '" + worldName + "'...");
 
-        opPermissions = getBoolean("op-permissions", true);
+        loadConfig();
 
-        enforceOneSession = getBoolean("protection.enforce-single-session", true);
-        itemDurability = getBoolean("protection.item-durability", true);
-        removeInfiniteStacks = getBoolean("protection.remove-infinite-stacks", false);
-        disableExpDrops = getBoolean("protection.disable-xp-orb-drops", false);
-        disableObsidianGenerators = getBoolean("protection.disable-obsidian-generators", false);
+        // Load rule lists
+        loadBuiltInRules();
+        loadUserRules();
+        loadBlacklist();
 
-        // 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);
+        // Load other rules
+        opPermissions = config.getBoolean("op-permissions", true);
 
-        pumpkinScuba = getBoolean("default.pumpkin-scuba", false);
-        disableHealthRegain = getBoolean("default.disable-health-regain", false);
+        boolean simulateSponge = config.getBoolean("simulation.sponge.enable", true);
+        int spongeRadius = Math.max(1, config.getInt("simulation.sponge.radius", 3)) - 1;
+        boolean redstoneSponges = config.getBoolean("simulation.sponge.redstone", false);
+        boolean refillArea = config.getBoolean("simulation.sponge.refill-area", false);
+        if (simulateSponge) {
+            spongeApplicator = new SpongeApplicator(spongeRadius, redstoneSponges, refillArea);
+        }
 
-        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));
+        signChestProtection = config.getBoolean("chest-protection.enable", false);
+        disableSignChestProtectionCheck = config.getBoolean("chest-protection.disable-off-check", false);
 
-        blockTNTExplosions = getBoolean("ignition.block-tnt", false);
-        blockTNTBlockDamage = getBoolean("ignition.block-tnt-block-damage", false);
-        blockLighter = getBoolean("ignition.block-lighter", false);
+        useRegions = config.getBoolean("regions.enable", true);
+        regionInvinciblityRemovesMobs = config.getBoolean("regions.invincibility-removes-mobs", false);
+        highFreqFlags = config.getBoolean("regions.high-frequency-flags", false);
+        regionWand = config.getInt("regions.wand", 287);
+        maxClaimVolume = config.getInt("regions.max-claim-volume", 30000);
+        claimOnlyInsideExistingRegions = config.getBoolean("regions.claim-only-inside-existing-regions", 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));
+        maxRegionCountPerPlayer = config.getInt("regions.max-region-count-per-player.default", 7);
+        maxRegionCounts = new HashMap<String, Integer>();
+        maxRegionCounts.put(null, maxRegionCountPerPlayer);
 
-        blockCreeperExplosions = getBoolean("mobs.block-creeper-explosions", false);
-        blockCreeperBlockDamage = getBoolean("mobs.block-creeper-block-damage", false);
-        blockFireballExplosions = getBoolean("mobs.block-fireball-explosions", false);
-        blockFireballBlockDamage = getBoolean("mobs.block-fireball-block-damage", false);
-        antiWolfDumbness = getBoolean("mobs.anti-wolf-dumbness", false);
-        disableEndermanGriefing = getBoolean("mobs.disable-enderman-griefing", 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);
-        disableDeathMessages = getBoolean("player-damage.disable-death-messages", 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);
-        disableGrassGrowth = getBoolean("dynamics.disable-grass-growth", false);
-
-        useRegions = getBoolean("regions.enable", true);
-        regionInvinciblityRemovesMobs = getBoolean("regions.invincibility-removes-mobs", false);
-        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);
+        for (String key : config.getKeys("regions.max-region-count-per-player")) {
+            if (!key.equalsIgnoreCase("default")) {
+                Object val = config.get("regions.max-region-count-per-player." + key);
+                if (val != null && val instanceof Number) {
+                    maxRegionCounts.put(key, ((Number) val).intValue());
+                }
+            }
+        }
 
         // 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);
+        saveConfig();
+    }
 
-            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
+    /**
+     * Load the configuration from file.
+     */
+    private void loadConfig() {
+        try {
+            config.load();
+        } catch (IOException e) {
+            logger.log(Level.SEVERE, "Error reading configuration for world " + worldName, e);
+        } catch (ConfigurationException e) {
+            logger.log(Level.SEVERE, "Error reading configuration for world " + worldName, e);
+        }
+    }
+
+    /**
+     * Save the configuration to file.
+     */
+    private void saveConfig() {
+        config.setHeader(
+                "# CONFIGURATION FILE FOR ONLY THIS WORLD\r\n" +
+                "#\r\n" +
+                "# Everything in here applies to ONLY this world. For global settings, edit \r\n" +
+                "# the file in plugins/WorldGuard/config.yml\r\n" +
+                "#\r\n" +
+                "# How do you use this file? Copy potions of the global configuration file into this file.\r\n" +
+                "#\r\n" +
+                "# EXAMPLE (remove the # in front):\r\n" +
+                "#physics:\r\n" +
+                "#    block-tnt-damage: false");
+
+        try {
+            config.save();
+        } catch (IOException e) {
+            logger.log(Level.SEVERE, "Failed to save configuration", e);
+        }
+    }
+
+    /**
+     * Load the built-in rules.
+     */
+    private void loadBuiltInRules() {
+        try {
+            RuleTemplateEntryLoader loader = new RuleTemplateEntryLoader(
+                    plugin.getRulesListManager(), config);
+
+            for (List<RuleEntry> entries : plugin.getBuiltInRules().listOf("", loader)) {
+                for (RuleEntry entry : entries) {
+                    learnRule(entry);
+                }
+            }
+        } catch (IOException e) {
+            logger.log(Level.SEVERE, "Failed to load the built-in rules", e);
+        } catch (ConfigurationException e) {
+            logger.log(Level.SEVERE, "Failed to load the built-in rules", e);
+        }
+    }
+
+    /**
+     * Load the user rules.
+     */
+    private void loadUserRules() {
+        File rulesFile = configMan.getRuleListFile(worldName);
+        RuleEntryLoader entryLoader = new RuleEntryLoader(plugin.getRulesListManager());
+        YamlConfigurationFile rulesConfig = new YamlConfigurationFile(rulesFile,
+                ConfigurationManager.YAML_STYLE, false);
+
+        try {
+            rulesConfig.load();
+
+            for (RuleEntry entry : rulesConfig.listOf(ConfigurationNode.ROOT, entryLoader)) {
+                learnRule(entry);
+            }
+        } catch (IOException e) {
+            logger.log(Level.SEVERE, "Failed to load " + rulesFile.getAbsolutePath(), e);
+        } catch (ConfigurationException e) {
+            logger.log(Level.SEVERE, "Failed to load " + rulesFile.getAbsolutePath(), e);
+        }
+    }
+
+    /**
+     * Load the blacklist.
+     */
+    private void loadBlacklist() {
         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);
+            File blacklistFile = configMan.getBlacklistFile(worldName);
 
-            // If the blacklist is empty, then set the field to null
-            // and save some resources
-            if (blist.isEmpty()) {
+            // Load blacklist settings
+            boolean useBlacklistAsWhitelist = config.getBoolean("blacklist.use-as-whitelist", false);
+            boolean logConsole = config.getBoolean("blacklist.logging.console.enable", true);
+            boolean logDatabase = config.getBoolean("blacklist.logging.database.enable", false);
+            String dsn = config.getString("blacklist.logging.database.dsn", "jdbc:mysql://localhost:3306/minecraft");
+            String user = config.getString("blacklist.logging.database.user", "root");
+            String pass = config.getString("blacklist.logging.database.pass", "");
+            String table = config.getString("blacklist.logging.database.table", "blacklist_events");
+            boolean logFile = config.getBoolean("blacklist.logging.file.enable", false);
+            String logFilePattern = config.getString("blacklist.logging.file.path", "worldguard/logs/%Y-%m-%d.log");
+            int logFileCacheSize = Math.max(1, config.getInt("blacklist.logging.file.open-files", 10));
+
+            Blacklist newBlacklist = new BukkitBlacklist(useBlacklistAsWhitelist, plugin);
+            newBlacklist.load(blacklistFile);
+
+            // If the blacklist is empty, then set the field to null and save some resources
+            if (newBlacklist.isEmpty()) {
                 this.blacklist = null;
             } else {
-                this.blacklist = blist;
-                logger.log(Level.INFO, "WorldGuard: Blacklist loaded.");
+                this.blacklist = newBlacklist;
+                logger.log(Level.INFO, "Blacklist loaded.");
 
-                BlacklistLogger blacklistLogger = blist.getLogger();
+                BlacklistLogger blacklistLogger = newBlacklist.getLogger();
 
-                if (logDatabase) {
-                    blacklistLogger.addHandler(new DatabaseLoggerHandler(dsn, user, pass, table, worldName));
-                }
+                if (logDatabase)
+                    blacklistLogger.addHandler(new DatabaseLoggerHandler(dsn, user,
+                            pass, table, worldName, logger));
 
-                if (logConsole) {
-                    blacklistLogger.addHandler(new ConsoleLoggerHandler(worldName));
-                }
+                if (logConsole)
+                    blacklistLogger.addHandler(new ConsoleLoggerHandler(worldName,
+                            logger));
 
                 if (logFile) {
-                    FileLoggerHandler handler =
-                            new FileLoggerHandler(logFilePattern, logFileCacheSize, worldName);
+                    FileLoggerHandler handler = new FileLoggerHandler(logFilePattern,
+                            logFileCacheSize, worldName, logger);
                     blacklistLogger.addHandler(handler);
                 }
             }
         } catch (FileNotFoundException e) {
-            logger.log(Level.WARNING, "WorldGuard blacklist does not exist.");
+            logger.log(Level.WARNING, "WorldGuard blacklist does not exist", e);
         } catch (IOException e) {
-            logger.log(Level.WARNING, "Could not load WorldGuard blacklist: "
-                    + e.getMessage());
+            logger.log(Level.WARNING, "Could not load blacklist", e);
         }
-
-        // 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, blockTNTExplosions
-                    ? "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;
+        return blacklist;
+    }
+
+    SpongeApplicator getSpongeApplicator() {
+        return spongeApplicator;
     }
 
     public String getWorldName() {
@@ -472,10 +316,8 @@ public class WorldConfiguration {
     }
 
     public boolean isChestProtected(Block block) {
-        if (!signChestProtection) {
-            return false;
-        }
-        return chestProtection.isProtected(block, null);
+
+        return signChestProtection && chestProtection.isProtected(block, null);
     }
 
     public boolean isChestProtectedPlacement(Block block, Player player) {
@@ -503,4 +345,38 @@ public class WorldConfiguration {
     public ChestProtection getChestProtection() {
         return chestProtection;
     }
+
+    public int getMaxRegionCount(Player player) {
+        int max = -1;
+        for (String group : plugin.getGroups(player)) {
+            if (maxRegionCounts.containsKey(group)) {
+                int groupMax = maxRegionCounts.get(group);
+                if (max < groupMax) max = groupMax;
+            }
+        }
+        if (max <= -1) {
+            max = maxRegionCountPerPlayer;
+        }
+        return max;
+    }
+
+    public KnownAttachmentRules getRuleList() {
+        return ruleList;
+    }
+
+    /**
+     * Register a rule with this rule list.
+     *
+     * @param entry entry
+     */
+    public void learnRule(RuleEntry entry) {
+        for (String name : entry.getAttachmentNames()) {
+            KnownAttachment attachment = KnownAttachment.fromId(name);
+            if (attachment != null) {
+                ruleList.get(attachment).learn(entry.getRule());
+            } else {
+                logger.warning("Don't know what the RuleList event '" + name + "' is");
+            }
+        }
+    }
 }

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

@@ -0,0 +1,75 @@
+/*
+ * WorldGuard
+ * Copyright (C) 2012 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.commandbook.InfoComponent;
+import com.sk89q.worldguard.LocalPlayer;
+import com.sk89q.worldguard.protection.ApplicableRegionSet;
+import com.sk89q.worldguard.protection.regions.ProtectedRegion;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+
+/**
+ * @author zml2008
+ */
+public class WorldGuardCommandBookListener implements Listener {
+    private final WorldGuardPlugin plugin;
+    
+    public WorldGuardCommandBookListener(WorldGuardPlugin plugin) {
+        this.plugin = plugin;
+    }
+    
+    @EventHandler
+    public void onPlayerWhois(InfoComponent.PlayerWhoisEvent event) {
+        if (event.getPlayer() instanceof Player) {
+            Player player = (Player) event.getPlayer();
+            LocalPlayer localPlayer = plugin.wrapPlayer(player);
+            if (plugin.getGlobalStateManager().get(player.getWorld()).useRegions) {
+                ApplicableRegionSet regions = plugin.getGlobalRegionManager()
+                        .get(player.getWorld()).getApplicableRegions(player.getLocation());
+                
+                // Current regions
+                StringBuilder regionStr = new StringBuilder();
+                boolean first = true;
+                
+                for (ProtectedRegion region : regions) {
+                    if (!first) {
+                        regionStr.append(", ");
+                    }
+                    
+                    if (region.isOwner(localPlayer)) {
+                        regionStr.append("+");
+                    } else if (region.isMemberOnly(localPlayer)) {
+                        regionStr.append("-");
+                    }
+                    
+                    regionStr.append(region.getId());
+                    
+                    first = false;
+                }
+                
+                if (regions.size() > 0) {
+                    event.addWhoisInformation("Current Regions", regionStr);
+                }
+                event.addWhoisInformation("Can build", regions.canBuild(localPlayer));
+            }
+        }
+    }
+}

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

@@ -0,0 +1,225 @@
+// $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.ChatColor;
+import org.bukkit.World;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Creeper;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Hanging;
+import org.bukkit.entity.ItemFrame;
+import org.bukkit.entity.Painting;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.hanging.HangingBreakByEntityEvent;
+import org.bukkit.event.hanging.HangingBreakEvent;
+import org.bukkit.event.hanging.HangingPlaceEvent;
+import org.bukkit.event.player.PlayerInteractEntityEvent;
+
+import com.sk89q.rulelists.KnownAttachment;
+import com.sk89q.rulelists.RuleSet;
+import com.sk89q.worldedit.blocks.ItemID;
+import com.sk89q.worldguard.blacklist.events.BlockBreakBlacklistEvent;
+import com.sk89q.worldguard.blacklist.events.ItemUseBlacklistEvent;
+import com.sk89q.worldguard.protection.flags.DefaultFlag;
+
+/**
+ * Listener for painting related events.
+ *
+ * @author BangL <henno.rickowski@gmail.com>
+ */
+public class WorldGuardHangingListener implements Listener {
+
+    private WorldGuardPlugin plugin;
+
+    /**
+     * Construct the object;
+     *
+     * @param plugin The plugin instance
+     */
+    public WorldGuardHangingListener(WorldGuardPlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    /**
+     * Register events.
+     */
+    public void registerEvents() {
+        plugin.getServer().getPluginManager().registerEvents(this, plugin);
+    }
+
+    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
+    public void onHangingingBreak(HangingBreakEvent breakEvent) {
+        if (!(breakEvent instanceof HangingBreakByEntityEvent)) {
+            return;
+        }
+
+        HangingBreakByEntityEvent event = (HangingBreakByEntityEvent) breakEvent;
+        Hanging hanging = event.getEntity();
+        World world = hanging.getWorld();
+        ConfigurationManager cfg = plugin.getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(world);
+
+        if (event.getRemover() instanceof Player) {
+            Player player = (Player) event.getRemover();
+
+            if (wcfg.getBlacklist() != null) {
+                if (hanging instanceof Painting
+                        && !wcfg.getBlacklist().check(
+                            new BlockBreakBlacklistEvent(plugin.wrapPlayer(player),
+                                    toVector(player.getLocation()), ItemID.PAINTING), false, false)) {
+                    event.setCancelled(true);
+                    return;
+                } else if (hanging instanceof ItemFrame
+                        && !wcfg.getBlacklist().check(
+                            new BlockBreakBlacklistEvent(plugin.wrapPlayer(player),
+                                    toVector(player.getLocation()), ItemID.ITEM_FRAME), false, false)) {
+                    event.setCancelled(true);
+                    return;
+                }
+            }
+
+            if (wcfg.useRegions) {
+                if (!plugin.getGlobalRegionManager().canBuild(player, hanging.getLocation())) {
+                    player.sendMessage(ChatColor.DARK_RED + "You don't have permission for this area.");
+                    event.setCancelled(true);
+                    return;
+                }
+            }
+        } else {
+            if (event.getRemover() instanceof Creeper) {
+                if (wcfg.useRegions && !plugin.getGlobalRegionManager().allows(DefaultFlag.CREEPER_EXPLOSION, hanging.getLocation())) {
+                    event.setCancelled(true);
+                    return;
+                }
+            }
+
+            if (hanging instanceof Painting
+                    && ((wcfg.useRegions && !plugin.getGlobalRegionManager().allows(
+                            DefaultFlag.ENTITY_PAINTING_DESTROY, hanging.getLocation())))) {
+                event.setCancelled(true);
+            } else if (hanging instanceof ItemFrame
+                    && ((wcfg.useRegions && !plugin.getGlobalRegionManager()
+                            .allows(DefaultFlag.ENTITY_ITEM_FRAME_DESTROY,
+                                    hanging.getLocation())))) {
+                event.setCancelled(true);
+            }
+        }
+
+        // RuleLists
+        RuleSet rules = wcfg.getRuleList().get(KnownAttachment.ENTITY_DAMAGE);
+        BukkitContext context = new BukkitContext(event);
+        context.setSourceEntity(event.getRemover());
+        context.setTargetEntity(event.getEntity());
+        if (rules.process(context)) {
+            event.setCancelled(true);
+            return;
+        }
+    }
+
+    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
+    public void onHangingPlace(HangingPlaceEvent 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 (event.getEntity() instanceof Painting
+                    && !wcfg.getBlacklist().check(
+                        new ItemUseBlacklistEvent(plugin.wrapPlayer(player),
+                                toVector(player.getLocation()), ItemID.PAINTING), false, false)) {
+                event.setCancelled(true);
+                return;
+            } else if (event.getEntity() instanceof ItemFrame
+                    && !wcfg.getBlacklist().check(
+                        new ItemUseBlacklistEvent(plugin.wrapPlayer(player),
+                                toVector(player.getLocation()), ItemID.ITEM_FRAME), 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;
+            }
+        }
+
+        // RuleLists
+        RuleSet rules = wcfg.getRuleList().get(KnownAttachment.ENTITY_SPAWN);
+        BukkitContext context = new BukkitContext(event);
+        context.setSourceEntity(event.getPlayer());
+        context.setTargetEntity(event.getEntity());
+        if (rules.process(context)) {
+            event.setCancelled(true);
+            return;
+        }
+    }
+
+    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
+    public void onEntityInteract(PlayerInteractEntityEvent event) {
+        Player player = event.getPlayer();
+        Entity entity = event.getRightClicked();
+
+        ConfigurationManager cfg = plugin.getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(entity.getWorld());
+
+        if (wcfg.useRegions && (entity instanceof ItemFrame || entity instanceof Painting)) {
+            if (!plugin.getGlobalRegionManager().canBuild(player, entity.getLocation())) {
+                player.sendMessage(ChatColor.DARK_RED + "You don't have permission for this area.");
+                event.setCancelled(true);
+                return;
+            }
+
+            if (entity instanceof ItemFrame
+                    && ((!plugin.getGlobalRegionManager().allows(
+                            DefaultFlag.ENTITY_ITEM_FRAME_DESTROY, entity.getLocation())))) {
+                event.setCancelled(true);
+                return;
+            } else if (entity instanceof Painting
+                    && ((!plugin.getGlobalRegionManager().allows(
+                            DefaultFlag.ENTITY_PAINTING_DESTROY, entity.getLocation())))) {
+                event.setCancelled(true);
+                return;
+            }
+        }
+
+        // RuleLists
+        RuleSet rules = wcfg.getRuleList().get(KnownAttachment.ENTITY_INTERACT);
+        BukkitContext context = new BukkitContext(event);
+        context.setSourceEntity(player);
+        context.setTargetEntity(entity);
+        if (rules.process(context)) {
+            event.setCancelled(true);
+            return;
+        }
+    }
+}

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

@@ -0,0 +1,199 @@
+// $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.ChatColor;
+import org.bukkit.Warning;
+import org.bukkit.World;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Creeper;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Painting;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.painting.PaintingBreakByEntityEvent;
+import org.bukkit.event.painting.PaintingBreakEvent;
+import org.bukkit.event.painting.PaintingPlaceEvent;
+import org.bukkit.event.player.PlayerInteractEntityEvent;
+
+import com.sk89q.rulelists.KnownAttachment;
+import com.sk89q.rulelists.RuleSet;
+import com.sk89q.worldedit.blocks.ItemID;
+import com.sk89q.worldguard.blacklist.events.BlockBreakBlacklistEvent;
+import com.sk89q.worldguard.blacklist.events.ItemUseBlacklistEvent;
+import com.sk89q.worldguard.protection.flags.DefaultFlag;
+
+/**
+ * Listener for painting related events.
+ *
+ * @author sk89q
+ * @deprecated Use {@link com.sk89q.worldguard.bukkit.WorldGuardHangingListener} instead.
+ */
+@Deprecated
+@Warning(reason="This listener has been replaced by WorldGuardHangingListener")
+public class WorldGuardPaintingListener implements Listener {
+
+    private WorldGuardPlugin plugin;
+
+    /**
+     * Construct the object;
+     *
+     * @param plugin The plugin instance
+     */
+    public WorldGuardPaintingListener(WorldGuardPlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    /**
+     * Register events.
+     */
+    public void registerEvents() {
+        plugin.getServer().getPluginManager().registerEvents(this, plugin);
+    }
+
+    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
+    public void onPaintingBreak(PaintingBreakEvent breakEvent) {
+        if (!(breakEvent instanceof PaintingBreakByEntityEvent)) {
+            return;
+        }
+
+        PaintingBreakByEntityEvent event = (PaintingBreakByEntityEvent) breakEvent;
+        Painting painting = event.getPainting();
+        World world = painting.getWorld();
+        ConfigurationManager cfg = plugin.getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(world);
+
+        if (event.getRemover() instanceof Player) {
+            Player player = (Player) event.getRemover();
+
+            if (wcfg.getBlacklist() != null) {
+                if (!wcfg.getBlacklist().check(
+                            new BlockBreakBlacklistEvent(plugin.wrapPlayer(player),
+                                    toVector(player.getLocation()), ItemID.PAINTING), 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;
+                }
+            }
+        } else {
+            if (event.getRemover() instanceof Creeper) {
+                if (wcfg.useRegions && !plugin.getGlobalRegionManager().allows(DefaultFlag.CREEPER_EXPLOSION, painting.getLocation())) {
+                    event.setCancelled(true);
+                    return;
+                }
+            }
+
+            if ((wcfg.useRegions && !plugin.getGlobalRegionManager().allows(
+                    DefaultFlag.ENTITY_PAINTING_DESTROY, painting.getLocation()))) {
+                event.setCancelled(true);
+            }
+        }
+
+        // RuleLists
+        RuleSet rules = wcfg.getRuleList().get(KnownAttachment.ENTITY_DAMAGE);
+        BukkitContext context = new BukkitContext(event);
+        context.setSourceEntity(event.getRemover());
+        context.setTargetEntity(event.getPainting());
+        rules.process(context);
+    }
+
+    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
+    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()), ItemID.PAINTING), 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;
+            }
+        }
+
+        // RuleLists
+        RuleSet rules = wcfg.getRuleList().get(KnownAttachment.ENTITY_SPAWN);
+        BukkitContext context = new BukkitContext(event);
+        context.setSourceEntity(event.getPlayer());
+        context.setTargetEntity(event.getPainting());
+        if (rules.process(context)) {
+            event.setCancelled(true);
+            return;
+        }
+    }
+
+    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
+    public void onEntityInteract(PlayerInteractEntityEvent event) {
+        Player player = event.getPlayer();
+        Entity entity = event.getRightClicked();
+
+        ConfigurationManager cfg = plugin.getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(entity.getWorld());
+
+        if (wcfg.useRegions && entity instanceof Painting) {
+            if (!plugin.getGlobalRegionManager().canBuild(player, entity.getLocation())) {
+                player.sendMessage(ChatColor.DARK_RED + "You don't have permission for this area.");
+                event.setCancelled(true);
+                return;
+            }
+
+            if (entity instanceof Painting
+                    && ((!plugin.getGlobalRegionManager().allows(
+                            DefaultFlag.ENTITY_PAINTING_DESTROY, entity.getLocation())))) {
+                event.setCancelled(true);
+                return;
+            }
+        }
+
+        // RuleLists
+        RuleSet rules = wcfg.getRuleList().get(KnownAttachment.ENTITY_INTERACT);
+        BukkitContext context = new BukkitContext(event);
+        context.setSourceEntity(player);
+        context.setTargetEntity(entity);
+        if (rules.process(context)) {
+            event.setCancelled(true);
+            return;
+        }
+    }
+}

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

@@ -0,0 +1,40 @@
+package com.sk89q.worldguard.bukkit;
+
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.server.PluginDisableEvent;
+import org.bukkit.event.server.PluginEnableEvent;
+import org.bukkit.plugin.PluginManager;
+
+/**
+ * Listener for server events.
+ */
+public class WorldGuardServerListener implements Listener {
+
+    private final WorldGuardPlugin plugin;
+
+    public WorldGuardServerListener(WorldGuardPlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    public void registerEvents() {
+        PluginManager pm = plugin.getServer().getPluginManager();
+        pm.registerEvents(this, plugin);
+    }
+
+    @EventHandler
+    public void onPluginEnable(PluginEnableEvent event) {
+        // Legacy god mode
+        if (event.getPlugin().getDescription().getName().equalsIgnoreCase("CommandBook")) {
+            plugin.getGlobalStateManager().updateCommandBookGodMode();
+        }
+    }
+
+    @EventHandler
+    public void onPluginDisable(PluginDisableEvent event) {
+        // Legacy god mode
+        if (event.getPlugin().getDescription().getName().equalsIgnoreCase("CommandBook")) {
+            plugin.getGlobalStateManager().updateCommandBookGodMode();
+        }
+    }
+}

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

@@ -7,19 +7,15 @@ package com.sk89q.worldguard.bukkit;
 
 import static com.sk89q.worldguard.bukkit.BukkitUtil.toVector;
 
-import java.util.logging.Logger;
-
 import org.bukkit.ChatColor;
-import org.bukkit.Location;
 import org.bukkit.World;
 import org.bukkit.entity.Entity;
 import org.bukkit.entity.Player;
 import org.bukkit.entity.Vehicle;
-import org.bukkit.event.Event;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
 import org.bukkit.event.vehicle.VehicleDestroyEvent;
-import org.bukkit.event.vehicle.VehicleListener;
 import org.bukkit.event.vehicle.VehicleMoveEvent;
-import org.bukkit.plugin.PluginManager;
 
 import com.sk89q.worldedit.Vector;
 import com.sk89q.worldguard.LocalPlayer;
@@ -29,63 +25,35 @@ import com.sk89q.worldguard.protection.flags.DefaultFlag;
 import com.sk89q.worldguard.protection.managers.RegionManager;
 import com.sk89q.worldguard.protection.regions.ProtectedRegion;
 
-public class WorldGuardVehicleListener extends VehicleListener {
-
-    /**
-     * Logger for messages.
-     */
-    private static final Logger logger = Logger.getLogger("Minecraft.WorldGuard");
+/**
+ * Listener for vehicle events.
+ */
+public class WorldGuardVehicleListener implements Listener {
 
     private WorldGuardPlugin plugin;
 
-    /**
-     * Construct the object;
-     *
-     * @param plugin
-     */
     public WorldGuardVehicleListener(WorldGuardPlugin plugin) {
         this.plugin = plugin;
     }
 
-    /**
-     * Register events.
-     */
     public void registerEvents() {
-        registerEvent("VEHICLE_MOVE", Event.Priority.Normal);
-        registerEvent("VEHICLE_DESTROY", Event.Priority.Normal);
+        plugin.getServer().getPluginManager().registerEvents(this, plugin);
     }
 
-    /**
-     * 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 vehicle is destroyed.
-     */
-    @Override
+    @EventHandler
     public void onVehicleDestroy(VehicleDestroyEvent event) {
         Vehicle vehicle = event.getVehicle();
         Entity destroyer = event.getAttacker();
 
         if (!(destroyer instanceof Player)) return; // don't care
+        
         Player player = (Player) destroyer;
         World world = vehicle.getWorld();
 
         ConfigurationManager cfg = plugin.getGlobalStateManager();
         WorldConfiguration wcfg = cfg.get(world);
 
+        // Regions
         if (wcfg.useRegions) {
             Vector pt = toVector(vehicle.getLocation());
             RegionManager mgr = plugin.getGlobalRegionManager().get(world);
@@ -94,7 +62,7 @@ public class WorldGuardVehicleListener extends VehicleListener {
 
             if (!plugin.getGlobalRegionManager().hasBypass(player, world)
                     && !set.canBuild(localPlayer)
-                    && !set.allows(DefaultFlag.DESTROY_VEHICLE)) {
+                    && !set.allows(DefaultFlag.DESTROY_VEHICLE, localPlayer)) {
                 player.sendMessage(ChatColor.DARK_RED + "You don't have permission to destroy vehicles here.");
                 event.setCancelled(true);
                 return;
@@ -102,10 +70,7 @@ public class WorldGuardVehicleListener extends VehicleListener {
         }
     }
 
-    /**
-     * Called when a vehicle moves.
-     */
-    @Override
+    @EventHandler
     public void onVehicleMove(VehicleMoveEvent event) {
         Vehicle vehicle = event.getVehicle();
         if (vehicle.getPassenger() == null
@@ -115,6 +80,7 @@ public class WorldGuardVehicleListener extends VehicleListener {
         ConfigurationManager cfg = plugin.getGlobalStateManager();
         WorldConfiguration wcfg = cfg.get(world);
 
+        // Regions
         // unfortunate code duplication
         if (wcfg.useRegions) {
             // Did we move a block?
@@ -152,44 +118,44 @@ public class WorldGuardVehicleListener extends VehicleListener {
                     return;
                 }
 
-                String greeting = set.getFlag(DefaultFlag.GREET_MESSAGE);
-                String farewell = set.getFlag(DefaultFlag.FAREWELL_MESSAGE);
-                Boolean notifyEnter = set.getFlag(DefaultFlag.NOTIFY_ENTER);
-                Boolean notifyLeave = set.getFlag(DefaultFlag.NOTIFY_LEAVE);
-                
-                if (state.lastFarewell != null && (farewell == null 
+                String greeting = set.getFlag(DefaultFlag.GREET_MESSAGE, localPlayer);
+                String farewell = set.getFlag(DefaultFlag.FAREWELL_MESSAGE, localPlayer);
+                Boolean notifyEnter = set.getFlag(DefaultFlag.NOTIFY_ENTER, localPlayer);
+                Boolean notifyLeave = set.getFlag(DefaultFlag.NOTIFY_LEAVE, localPlayer);
+
+                if (state.lastFarewell != null && (farewell == null
                         || !state.lastFarewell.equals(farewell))) {
                     String replacedFarewell = plugin.replaceMacros(
                             player, BukkitUtil.replaceColorMacros(state.lastFarewell));
                     player.sendMessage(ChatColor.AQUA + " ** " + replacedFarewell);
                 }
-                
+
                 if (greeting != null && (state.lastGreeting == null
                         || !state.lastGreeting.equals(greeting))) {
                     String replacedGreeting = plugin.replaceMacros(
                             player, BukkitUtil.replaceColorMacros(greeting));
                     player.sendMessage(ChatColor.AQUA + " ** " + replacedGreeting);
                 }
-                
+
                 if ((notifyLeave == null || !notifyLeave)
                         && state.notifiedForLeave != null && state.notifiedForLeave) {
-                    plugin.broadcastNotification(ChatColor.GRAY + "WG: " 
+                    plugin.broadcastNotification(ChatColor.GRAY + "WG: "
                             + ChatColor.LIGHT_PURPLE + player.getName()
                             + ChatColor.GOLD + " left NOTIFY region");
                 }
-                
+
                 if (notifyEnter != null && notifyEnter && (state.notifiedForEnter == null
                         || !state.notifiedForEnter)) {
                     StringBuilder regionList = new StringBuilder();
-                    
+
                     for (ProtectedRegion region : set) {
                         if (regionList.length() != 0) {
                             regionList.append(", ");
                         }
                         regionList.append(region.getId());
                     }
-                    
-                    plugin.broadcastNotification(ChatColor.GRAY + "WG: " 
+
+                    plugin.broadcastNotification(ChatColor.GRAY + "WG: "
                             + ChatColor.LIGHT_PURPLE + player.getName()
                             + ChatColor.GOLD + " entered NOTIFY region: "
                             + ChatColor.WHITE

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

@@ -20,123 +20,72 @@ package com.sk89q.worldguard.bukkit;
 
 import static com.sk89q.worldguard.bukkit.BukkitUtil.toVector;
 
-import java.util.logging.Logger;
-
 import org.bukkit.Location;
-import org.bukkit.event.Event;
-import org.bukkit.event.Event.Priority;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
 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.rulelists.KnownAttachment;
+import com.sk89q.rulelists.RuleSet;
 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;
 
-public class WorldGuardWeatherListener extends WeatherListener {
+/**
+ * Listener for weather events.
+ */
+public class WorldGuardWeatherListener implements Listener {
 
-    /**
-     * 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);
+        plugin.getServer().getPluginManager().registerEvents(this, plugin);
     }
 
-    /**
-     * 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
+    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     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);
-            }
+        // RuleLists
+        RuleSet rules = wcfg.getRuleList().get(KnownAttachment.WEATHER_TRANSITION);
+        BukkitContext context = new BukkitContext(event);
+        if (rules.process(context)) {
+            event.setCancelled(true);
+            return;
         }
     }
 
-    @Override
+    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     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);
-            }
+        // RuleLists
+        RuleSet rules = wcfg.getRuleList().get(KnownAttachment.WEATHER_TRANSITION);
+        BukkitContext context = new BukkitContext(event);
+        if (rules.process(context)) {
+            event.setCancelled(true);
+            return;
         }
     }
 
-    @Override
+    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onLightningStrike(LightningStrikeEvent event) {
-        if (event.isCancelled()) {
-           return;
-        }
+        Location loc = event.getLightning().getLocation();
 
         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();
+        // Regions
         if (wcfg.useRegions) {
             Vector pt = toVector(loc);
             RegionManager mgr = plugin.getGlobalRegionManager().get(loc.getWorld());
@@ -146,5 +95,14 @@ public class WorldGuardWeatherListener extends WeatherListener {
                 event.setCancelled(true);
             }
         }
+
+        // RuleLists
+        RuleSet rules = wcfg.getRuleList().get(KnownAttachment.WEATHER_PHENOMENON);
+        BukkitContext context = new BukkitContext(event);
+        context.setTargetBlock(loc.getBlock().getState());
+        if (rules.process(context)) {
+            event.setCancelled(true);
+            return;
+        }
     }
 }

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

@@ -5,102 +5,63 @@
 */
 package com.sk89q.worldguard.bukkit;
 
-import java.util.logging.Logger;
-
-import org.bukkit.World;
-import org.bukkit.entity.Entity;
-import org.bukkit.event.Event;
-import org.bukkit.event.world.ChunkLoadEvent;
-import org.bukkit.event.world.WorldListener;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
 import org.bukkit.event.world.WorldLoadEvent;
-import org.bukkit.plugin.PluginManager;
+import org.bukkit.event.world.WorldSaveEvent;
+import org.bukkit.event.world.WorldUnloadEvent;
 
-public class WorldGuardWorldListener extends WorldListener {
+import com.sk89q.rulelists.KnownAttachment;
+import com.sk89q.rulelists.RuleSet;
 
-    /**
-     * Logger for messages.
-     */
-    private static final Logger logger = Logger.getLogger("Minecraft.WorldGuard");
+/**
+ * Listener for world events.
+ */
+public class WorldGuardWorldListener implements Listener {
 
     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);
-        registerEvent("WORLD_LOAD", Event.Priority.Normal);
+        plugin.getServer().getPluginManager().registerEvents(this, plugin);
     }
 
-    /**
-     * 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 (BukkitUtil.isIntensiveEntity(entity)) {
-                    entity.remove();
-                    removed++;
-                }
-            }
-
-            if (removed > 50) {
-                logger.info("WG Halt-Act: " + removed + " entities (>50) auto-removed from "
-                        + event.getChunk().toString());
-            }
-        }
-    }
-
-    /**
-     * Called when a world is loaded.
-     */
+    @EventHandler
     public void onWorldLoad(WorldLoadEvent event) {
-        initWorld(event.getWorld());
+        ConfigurationManager cfg = plugin.getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(event.getWorld());
+
+        // RuleLists
+        RuleSet rules = wcfg.getRuleList().get(KnownAttachment.WORLD_LOAD);
+        BukkitContext context = new BukkitContext(event);
+        rules.process(context);
     }
 
-    public void initWorld(World world) {
+    @EventHandler
+    public void onWorldLoad(WorldUnloadEvent event) {
         ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(world);
-        if (wcfg.alwaysRaining && !wcfg.disableWeather) {
-            world.setStorm(true);
-        } else if (wcfg.disableWeather && !wcfg.alwaysRaining) {
-            world.setStorm(false);
-        }
-        if (wcfg.alwaysThundering && !wcfg.disableThunder) {
-            world.setThundering(true);
-        } else if (wcfg.disableThunder && !wcfg.alwaysThundering) {
-            world.setStorm(false);
+        WorldConfiguration wcfg = cfg.get(event.getWorld());
+
+        // RuleLists
+        RuleSet rules = wcfg.getRuleList().get(KnownAttachment.WORLD_UNLOAD);
+        BukkitContext context = new BukkitContext(event);
+        if (rules.process(context)) {
+            event.setCancelled(true);
+            return;
         }
     }
+
+    @EventHandler
+    public void onWorldSave(WorldSaveEvent event) {
+        ConfigurationManager cfg = plugin.getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(event.getWorld());
+
+        // RuleLists
+        RuleSet rules = wcfg.getRuleList().get(KnownAttachment.WORLD_SAVE);
+        BukkitContext context = new BukkitContext(event);
+        rules.process(context);
+    }
 }

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

@@ -33,13 +33,16 @@ import com.sk89q.worldguard.bukkit.ConfigurationManager;
 import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
 
 public class GeneralCommands {
+    private final WorldGuardPlugin plugin;
+
+    public GeneralCommands(WorldGuardPlugin plugin) {
+        this.plugin = plugin;
+    }
     
-    @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 {
+    @SuppressWarnings("deprecation")
+    @Command(aliases = {"god"}, usage = "[player]",
+            desc = "Enable godmode on a player", flags = "s", max = 1)
+    public void god(CommandContext args, CommandSender sender) throws CommandException {
         ConfigurationManager config = plugin.getGlobalStateManager();
         
         Iterable<Player> targets = null;
@@ -82,12 +85,10 @@ public class GeneralCommands {
         }
     }
     
-    @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 {
+    @SuppressWarnings("deprecation")
+    @Command(aliases = {"ungod"}, usage = "[player]",
+            desc = "Disable godmode on a player", flags = "s", max = 1)
+    public void ungod(CommandContext args, CommandSender sender) throws CommandException {
         ConfigurationManager config = plugin.getGlobalStateManager();
         
         Iterable<Player> targets = null;
@@ -129,12 +130,8 @@ public class GeneralCommands {
         }
     }
     
-    @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 {
+    @Command(aliases = {"heal"}, usage = "[player]", desc = "Heal a player", flags = "s", max = 1)
+    public void heal(CommandContext args,CommandSender sender) throws CommandException {
         
         Iterable<Player> targets = null;
         boolean included = false;
@@ -154,6 +151,7 @@ public class GeneralCommands {
 
         for (Player player : targets) {
             player.setHealth(20);
+            player.setFoodLevel(20);
             
             // Tell the user
             if (player.equals(sender)) {
@@ -175,12 +173,8 @@ public class GeneralCommands {
         }
     }
     
-    @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 {
+    @Command(aliases = {"slay"}, usage = "[player]", desc = "Slay a player", flags = "s", max = 1)
+    public void slay(CommandContext args, CommandSender sender) throws CommandException {
         
         Iterable<Player> targets = null;
         boolean included = false;
@@ -221,13 +215,9 @@ public class GeneralCommands {
         }
     }
     
-    @Command(aliases = {"locate"},
-            usage = "[player]",
-            desc = "Locate a player",
-            flags = "", min = 0, max = 1)
+    @Command(aliases = {"locate"}, usage = "[player]", desc = "Locate a player", max = 1)
     @CommandPermissions({"worldguard.locate"})
-    public static void locate(CommandContext args, WorldGuardPlugin plugin,
-            CommandSender sender) throws CommandException {
+    public void locate(CommandContext args, CommandSender sender) throws CommandException {
         
         Player player = plugin.checkPlayer(sender);
         
@@ -243,16 +233,13 @@ public class GeneralCommands {
         }
     }
     
-    @Command(aliases = {"stack", ";"},
-            usage = "",
-            desc = "Stack items",
-            flags = "", min = 0, max = 0)
+    @Command(aliases = {"stack", ";"}, usage = "", desc = "Stack items", max = 0)
     @CommandPermissions({"worldguard.stack"})
-    public static void stack(CommandContext args, WorldGuardPlugin plugin,
-            CommandSender sender) throws CommandException {
+    public void stack(CommandContext args, CommandSender sender) throws CommandException {
         
         Player player = plugin.checkPlayer(sender);
         boolean ignoreMax = plugin.hasPermission(player, "worldguard.stack.illegitimate");
+        boolean ignoreDamaged = plugin.hasPermission(player, "worldguard.stack.damaged");
         
         ItemStack[] items = player.getInventory().getContents();
         int len = items.length;
@@ -286,18 +273,19 @@ public class GeneralCommands {
                     // Same type?
                     // Blocks store their color in the damage value
                     if (item2.getTypeId() == item.getTypeId() &&
-                            (!ItemType.usesDamageValue(item.getTypeId())
-                                    || item.getDurability() == item2.getDurability())) {
+                            ((!ItemType.usesDamageValue(item.getTypeId()) && ignoreDamaged)
+                                    || item.getDurability() == item2.getDurability()) &&
+                            item.getEnchantments().equals(item2.getEnchantments())) {
                         // This stack won't fit in the parent stack
                         if (item2.getAmount() > needed) {
-                            item.setAmount(64);
+                            item.setAmount(max);
                             item2.setAmount(item2.getAmount() - needed);
                             break;
                         // This stack will
                         } else {
                             items[j] = null;
                             item.setAmount(item.getAmount() + item2.getAmount());
-                            needed = 64 - item.getAmount();
+                            needed = max - item.getAmount();
                         }
 
                         affected++;

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

@@ -23,22 +23,22 @@ import org.bukkit.command.CommandSender;
 
 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.NestedCommand;
 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 {
+    @SuppressWarnings("unused")
+    private final WorldGuardPlugin plugin;
+
+    public ProtectionCommands(WorldGuardPlugin plugin) {
+        this.plugin = plugin;
     }
 
-    @Command(aliases = {"worldguard"},
-            desc = "WorldGuard commands")
+    @Command(aliases = {"region", "regions", "rg"}, desc = "Region management commands")
+    @NestedCommand({RegionCommands.class, RegionMemberCommands.class})
+    public void region(CommandContext args, CommandSender sender) {}
+
+    @Command(aliases = {"worldguard", "wg"}, desc = "WorldGuard commands")
     @NestedCommand({WorldGuardCommands.class})
-    public static void worldGuard(CommandContext args, WorldGuardPlugin plugin,
-            CommandSender sender) throws CommandException {
-    }
+    public void worldGuard(CommandContext args, CommandSender sender) {}
 }

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

@@ -19,8 +19,6 @@
 
 package com.sk89q.worldguard.bukkit.commands;
 
-import java.io.IOException;
-
 import org.bukkit.ChatColor;
 import org.bukkit.World;
 import org.bukkit.command.CommandSender;
@@ -31,20 +29,25 @@ 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.domains.DefaultDomain;
+import com.sk89q.worldguard.protection.flags.DefaultFlag;
 import com.sk89q.worldguard.protection.managers.RegionManager;
 import com.sk89q.worldguard.protection.regions.ProtectedRegion;
-import com.sk89q.worldguard.util.RegionUtil;
+import com.sk89q.worldguard.protection.databases.ProtectionDatabaseException;
+import com.sk89q.worldguard.protection.databases.RegionDBUtil;
 
 // @TODO: A lot of code duplication here! Need to fix.
 
 public class RegionMemberCommands {
+    private final WorldGuardPlugin plugin;
+
+    public RegionMemberCommands(WorldGuardPlugin plugin) {
+        this.plugin = plugin;
+    }
     
-    @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 {
+    @Command(aliases = {"addmember", "addmember"}, usage = "<id> <members...>",
+            desc = "Add a member to a region", min = 2)
+    public void addMember(CommandContext args, CommandSender sender) throws CommandException {
         
         Player player = plugin.checkPlayer(sender);
         World world = player.getWorld();
@@ -58,7 +61,9 @@ public class RegionMemberCommands {
         if (region == null) {
             throw new CommandException("Could not find a region by that ID.");
         }
-        
+
+        id = region.getId();
+
         if (region.isOwner(localPlayer)) {
             plugin.checkPermission(sender, "worldguard.region.addmember.own." + id.toLowerCase());
         } else if (region.isMember(localPlayer)) {
@@ -67,25 +72,22 @@ public class RegionMemberCommands {
             plugin.checkPermission(sender, "worldguard.region.addmember." + id.toLowerCase());
         }
 
-        RegionUtil.addToDomain(region.getMembers(), args.getPaddedSlice(2, 0), 0);
+        RegionDBUtil.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: "
+        } catch (ProtectionDatabaseException e) {
+            throw new CommandException("Failed to write regions: "
                     + 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 {
+    @Command(aliases = {"addowner", "addowner"}, usage = "<id> <owners...>",
+            desc = "Add an owner to a region", min = 2)
+    public void addOwner(CommandContext args, CommandSender sender) throws CommandException {
         
         Player player = plugin.checkPlayer(sender);
         World world = player.getWorld();
@@ -99,34 +101,46 @@ public class RegionMemberCommands {
         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());
+
+        id = region.getId();
+
+        Boolean flag = region.getFlag(DefaultFlag.BUYABLE);
+        DefaultDomain owners = region.getOwners();
+        if (flag != null && flag && owners != null && owners.size() == 0) {
+            if (!plugin.hasPermission(player, "worldguard.region.unlimited")) {
+                int maxRegionCount = plugin.getGlobalStateManager().get(world).getMaxRegionCount(player);
+                if (maxRegionCount >= 0 && mgr.getRegionCountOfPlayer(localPlayer)
+                        >= maxRegionCount) {
+                    throw new CommandException("You already own the maximum allowed amount of regions.");
+                }
+            }
+            plugin.checkPermission(sender, "worldguard.region.addowner.unclaimed." + id.toLowerCase());
         } else {
-            plugin.checkPermission(sender, "worldguard.region.addowner." + id.toLowerCase());
+            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);
+        RegionDBUtil.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: "
+        } catch (ProtectionDatabaseException e) {
+            throw new CommandException("Failed to write regions: "
                     + 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 {
+    @Command(aliases = {"removemember", "remmember", "removemem", "remmem"}, usage = "<id> <owners...>",
+            desc = "Remove an owner to a region", min = 2)
+    public void removeMember(CommandContext args, CommandSender sender) throws CommandException {
         
         Player player = plugin.checkPlayer(sender);
         World world = player.getWorld();
@@ -140,7 +154,9 @@ public class RegionMemberCommands {
         if (region == null) {
             throw new CommandException("Could not find a region by that ID.");
         }
-        
+
+        id = region.getId();
+
         if (region.isOwner(localPlayer)) {
             plugin.checkPermission(sender, "worldguard.region.removemember.own." + id.toLowerCase());
         } else if (region.isMember(localPlayer)) {
@@ -149,24 +165,22 @@ public class RegionMemberCommands {
             plugin.checkPermission(sender, "worldguard.region.removemember." + id.toLowerCase());
         }
 
-        RegionUtil.removeFromDomain(region.getMembers(), args.getPaddedSlice(2, 0), 0);
+        RegionDBUtil.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: "
+        } catch (ProtectionDatabaseException e) {
+            throw new CommandException("Failed to write regions: "
                     + 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,
+    @Command(aliases = {"removeowner", "remowner"}, usage = "<id> <owners...>",
+            desc = "Remove an owner to a region", min = 2)
+    public void removeOwner(CommandContext args,
             CommandSender sender) throws CommandException {
         
         Player player = plugin.checkPlayer(sender);
@@ -181,7 +195,9 @@ public class RegionMemberCommands {
         if (region == null) {
             throw new CommandException("Could not find a region by that ID.");
         }
-        
+
+        id = region.getId();
+
         if (region.isOwner(localPlayer)) {
             plugin.checkPermission(sender, "worldguard.region.removeowner.own." + id.toLowerCase());
         } else if (region.isMember(localPlayer)) {
@@ -190,15 +206,15 @@ public class RegionMemberCommands {
             plugin.checkPermission(sender, "worldguard.region.removeowner." + id.toLowerCase());
         }
 
-        RegionUtil.removeFromDomain(region.getOwners(), args.getPaddedSlice(2, 0), 0);
+        RegionDBUtil.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: "
+        } catch (ProtectionDatabaseException e) {
+            throw new CommandException("Failed to write regions: "
                     + e.getMessage());
         }
     }

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

@@ -22,35 +22,34 @@ package com.sk89q.worldguard.bukkit.commands;
 import org.bukkit.ChatColor;
 import org.bukkit.World;
 import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Entity;
-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.BukkitUtil;
-import com.sk89q.worldguard.bukkit.ConfigurationManager;
+import com.sk89q.worldguard.bukkit.LagStopMode;
 import com.sk89q.worldguard.bukkit.WorldConfiguration;
 import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
 
 public class ToggleCommands {
+    private final WorldGuardPlugin plugin;
 
-    @Command(aliases = {"stopfire"},
-            usage = "[<world>]", desc = "Disables all fire spread temporarily",
-            flags = "", min = 0, max = 1)
+    public ToggleCommands(WorldGuardPlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    @Command(aliases = {"stopfire"}, usage = "[<world>]",
+            desc = "Disables all fire spread temporarily", max = 1)
     @CommandPermissions({"worldguard.fire-toggle.stop"})
-    public static void stopFire(CommandContext args, WorldGuardPlugin plugin,
-            CommandSender sender) throws CommandException {
-        
+    public void stopFire(CommandContext args, 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) {
@@ -67,21 +66,18 @@ public class ToggleCommands {
         wcfg.fireSpreadDisableToggle = true;
     }
 
-    @Command(aliases = {"allowfire"},
-            usage = "[<world>]", desc = "Allows all fire spread temporarily",
-            flags = "", min = 0, max = 1)
+    @Command(aliases = {"allowfire"}, usage = "[<world>]",
+            desc = "Allows all fire spread temporarily", max = 1)
     @CommandPermissions({"worldguard.fire-toggle.stop"})
-    public static void allowFire(CommandContext args, WorldGuardPlugin plugin,
-            CommandSender sender) throws CommandException {
-        
+    public void allowFire(CommandContext args, 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) {
@@ -96,51 +92,21 @@ public class ToggleCommands {
         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)
+    @Command(aliases = {"halt-activity", "stoplag", "haltactivity"},
+            desc = "Attempts to cease as much activity in order to stop lag", flags = "cag", max = 0)
     @CommandPermissions({"worldguard.halt-activity"})
-    public static void stopLag(CommandContext args, WorldGuardPlugin plugin,
-            CommandSender sender) throws CommandException {
+    public void stopLag(CommandContext args, CommandSender sender) throws CommandException {
+        LagStopMode lagStopper = plugin.getLagStopMode();
 
-        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 (BukkitUtil.isIntensiveEntity(entity)) {
-                        entity.remove();
-                        removed++;
-                    }
-                }
-
-                if (removed > 10) {
-                    sender.sendMessage("" + removed + " entities (>10) auto-removed from "
-                            + world.toString());
-                }
-            }
+        lagStopper.setRemoveAnimals(!args.hasFlag('c'));
 
+        if (!args.hasFlag('c')) {
+            sender.sendMessage(ChatColor.YELLOW + "Enabling lag stop mode...");
+            lagStopper.enable(!args.hasFlag('g'));
         } 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.");
+            sender.sendMessage(ChatColor.YELLOW + "Disabling lag stop mode...");
+            lagStopper.disable();
         }
+
     }
 }

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

@@ -32,6 +32,7 @@ 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.rebar.util.MaterialDatabase;
 import com.sk89q.worldguard.bukkit.LoggerToChatHandler;
 import com.sk89q.worldguard.bukkit.ReportWriter;
 import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
@@ -39,38 +40,36 @@ import com.sk89q.worldguard.util.PastebinPoster;
 import com.sk89q.worldguard.util.PastebinPoster.PasteCallback;
 
 public class WorldGuardCommands {
+    private final WorldGuardPlugin plugin;
 
-    @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 {
+    public WorldGuardCommands(WorldGuardPlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    @Command(aliases = {"version"}, desc = "Get the WorldGuard version", max = 0)
+    public void version(CommandContext args, 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)
+    @Command(aliases = {"reload"}, desc = "Reload WorldGuard configuration", max = 0)
     @CommandPermissions({"worldguard.reload"})
-    public static void relload(CommandContext args, WorldGuardPlugin plugin,
-            CommandSender sender) throws CommandException {
-        
+    public void reload(CommandContext args, 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 = Logger.getLogger("");
             minecraftLogger.addHandler(handler);
         }
 
         try {
+            MaterialDatabase.reload();
             plugin.getGlobalStateManager().unload();
             plugin.getGlobalRegionManager().unload();
             plugin.getGlobalStateManager().load();
@@ -84,19 +83,17 @@ public class WorldGuardCommands {
                 minecraftLogger.removeHandler(handler);
             }
         }
+
+        plugin.simulateWorldLoad();
     }
-    
-    @Command(aliases = {"report"},
-            usage = "",
-            desc = "Writes a report on WorldGuard",
-            flags = "p", min = 0, max = 0)
+
+    @Command(aliases = {"report"}, desc = "Writes a report on WorldGuard", flags = "p", max = 0)
     @CommandPermissions({"worldguard.report"})
-    public static void report(CommandContext args, WorldGuardPlugin plugin,
-            final CommandSender sender) throws CommandException {
-        
+    public void report(CommandContext args, 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 "
@@ -104,18 +101,20 @@ public class WorldGuardCommands {
         } 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() {
-                
+
+                @Override
                 public void handleSuccess(String url) {
                     // Hope we don't have a thread safety issue here
                     sender.sendMessage(ChatColor.YELLOW + "WorldGuard report (1 hour): " + url);
                 }
-                
+
+                @Override
                 public void handleError(String err) {
                     // Hope we don't have a thread safety issue here
                     sender.sendMessage(ChatColor.YELLOW + "WorldGuard report pastebin error: " + err);
@@ -126,12 +125,9 @@ public class WorldGuardCommands {
     }
 
     @Command(aliases = {"flushstates", "clearstates"},
-            usage = "[player]",
-            desc = "Flush the state manager",
-            flags = "", min = 0, max = 1)
+            usage = "[player]", desc = "Flush the state manager", max = 1)
     @CommandPermissions("worldguard.flushstates")
-    public static void flushStates(CommandContext args, WorldGuardPlugin plugin,
-            CommandSender sender) throws CommandException {
+    public void flushStates(CommandContext args, CommandSender sender) throws CommandException {
         if (args.argsLength() == 0) {
             plugin.getFlagStateManager().forgetAll();
             sender.sendMessage("Cleared all states.");

src/main/java/com/sk89q/worldguard/bukkit/definitions/BlockCriteria.java

@@ -0,0 +1,117 @@
+// $Id$
+/*
+ * This file is a part of WorldGuard.
+ * Copyright (c) sk89q <http://www.sk89q.com>
+ * Copyright (c) the WorldGuard team and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free Software 
+ * (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 
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package com.sk89q.worldguard.bukkit.definitions;
+
+import java.util.List;
+
+import org.bukkit.block.Block;
+import org.bukkit.block.BlockState;
+
+import com.sk89q.rebar.util.MaterialPattern;
+import com.sk89q.rulelists.Criteria;
+import com.sk89q.worldguard.bukkit.BukkitContext;
+import com.sk89q.worldguard.bukkit.resolvers.BlockResolver;
+
+public class BlockCriteria implements Criteria<BukkitContext> {
+    
+    public enum Direction {
+        AT,
+        ABOVE,
+        BELOW,
+        AROUND
+    }
+
+    private final BlockResolver resolver;
+    private Direction direction;
+    private MaterialPattern[] patterns = new MaterialPattern[0];
+
+    public BlockCriteria(BlockResolver resolver) {
+        this.resolver = resolver;
+    }
+
+    public MaterialPattern[] getPatterns() {
+        return patterns;
+    }
+
+    public void setPatterns(MaterialPattern[] patterns) {
+        this.patterns = patterns;
+    }
+
+    public void setPatterns(List<MaterialPattern> patterns) {
+        MaterialPattern[] arr = new MaterialPattern[patterns.size()];
+        patterns.toArray(arr);
+        this.patterns = arr;
+    }
+
+    public Direction getDirection() {
+        return direction;
+    }
+
+    public void setDirection(Direction direction) {
+        this.direction = direction;
+    }
+    
+    private boolean matches(BlockState block) {
+        for (MaterialPattern pattern : patterns) {
+            if (pattern.matches(block.getTypeId(), block.getRawData())) {
+                return true;
+            }
+        }
+        
+        return false;
+    }
+    
+    private boolean matches(Block block) {
+        for (MaterialPattern pattern : patterns) {
+            if (pattern.matches(block.getTypeId(), block.getData())) {
+                return true;
+            }
+        }
+        
+        return false;
+    }
+
+    @Override
+    public boolean matches(BukkitContext context) {
+        BlockState block = resolver.resolve(context);
+
+        if (block == null) {
+            return false;
+        }
+
+        switch (getDirection()) {
+        case AT:
+            return matches(block);
+        case ABOVE:
+            return matches(block.getBlock().getRelative(0, 1, 0));
+        case BELOW:
+            return matches(block.getBlock().getRelative(0, -1, 0));
+        case AROUND:
+            return matches(block.getBlock().getRelative(0, -1, 0)) ||
+                    matches(block.getBlock().getRelative(0, 1, 0)) ||
+                    matches(block.getBlock().getRelative(-1, 0, 0)) ||
+                    matches(block.getBlock().getRelative(1, 0, 0)) ||
+                    matches(block.getBlock().getRelative(0, 0, -1)) ||
+                    matches(block.getBlock().getRelative(0, 0, 1));
+        }
+
+        return false;
+    }
+
+}

src/main/java/com/sk89q/worldguard/bukkit/definitions/BlockCriteriaLoader.java

@@ -0,0 +1,74 @@
+// $Id$
+/*
+ * This file is a part of WorldGuard.
+ * Copyright (c) sk89q <http://www.sk89q.com>
+ * Copyright (c) the WorldGuard team and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free Software
+ * (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
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package com.sk89q.worldguard.bukkit.definitions;
+
+import static com.sk89q.rulelists.RuleEntryLoader.INLINE;
+
+import java.util.List;
+
+import com.sk89q.rebar.config.AbstractNodeLoader;
+import com.sk89q.rebar.config.ConfigurationNode;
+import com.sk89q.rebar.config.LoaderBuilderException;
+import com.sk89q.rebar.config.types.EnumLoaderBuilder;
+import com.sk89q.rebar.config.types.MaterialPatternLoaderBuilder;
+import com.sk89q.rebar.util.LoggerUtils;
+import com.sk89q.rebar.util.MaterialPattern;
+import com.sk89q.rulelists.DefinitionException;
+import com.sk89q.rulelists.RuleListUtils;
+import com.sk89q.rulelists.RuleListsManager;
+import com.sk89q.worldguard.bukkit.definitions.BlockCriteria.Direction;
+import com.sk89q.worldguard.bukkit.resolvers.BlockResolver;
+
+public class BlockCriteriaLoader extends AbstractNodeLoader<BlockCriteria> {
+
+    private final RuleListsManager manager;
+    private MaterialPatternLoaderBuilder materialLoader = new MaterialPatternLoaderBuilder();
+    private EnumLoaderBuilder<Direction> dirLoader = new EnumLoaderBuilder<Direction>(Direction.class);
+
+    public BlockCriteriaLoader(RuleListsManager manager) {
+        this.manager = manager;
+    }
+
+    @Override
+    public BlockCriteria read(ConfigurationNode node)
+            throws DefinitionException {
+        BlockResolver resolver = manager.getResolvers()
+                .get(BlockResolver.class, node.getString("block", BlockResolver.DEFAULT));
+
+        // Load patterns
+        List<MaterialPattern> patterns = node.contains(INLINE) ?
+                node.listOf(INLINE, materialLoader) : node.listOf("material", materialLoader);
+        if (patterns.size() == 0) {
+            throw new LoaderBuilderException("No block materials specified");
+        }
+
+        // Load direction
+        Direction direction = node.getOf("relative", dirLoader, Direction.AT);
+
+        BlockCriteria criteria = new BlockCriteria(resolver);
+        criteria.setPatterns(patterns);
+        criteria.setDirection(direction);
+
+        RuleListUtils.warnUnknown(node, LoggerUtils.getLogger(getClass()),
+                                  "block", "material", "relative");
+
+        return criteria;
+    }
+
+}

src/main/java/com/sk89q/worldguard/bukkit/definitions/CancelAction.java

@@ -0,0 +1,31 @@
+// $Id$
+/*
+ * This file is a part of WorldGuard.
+ * Copyright (c) sk89q <http://www.sk89q.com>
+ * Copyright (c) the WorldGuard team and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free Software 
+ * (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 
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package com.sk89q.worldguard.bukkit.definitions;
+
+import com.sk89q.rulelists.Action;
+import com.sk89q.rulelists.Context;
+
+public class CancelAction implements Action<Context> {
+
+    @Override
+    public void apply(Context context) {
+        context.cancel();
+    }
+
+}

src/main/java/com/sk89q/worldguard/bukkit/definitions/CancelActionLoader.java

@@ -0,0 +1,39 @@
+// $Id$
+/*
+ * This file is a part of WorldGuard.
+ * Copyright (c) sk89q <http://www.sk89q.com>
+ * Copyright (c) the WorldGuard team and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free Software
+ * (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
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package com.sk89q.worldguard.bukkit.definitions;
+
+import com.sk89q.rebar.config.AbstractNodeLoader;
+import com.sk89q.rebar.config.ConfigurationNode;
+import com.sk89q.rebar.util.LoggerUtils;
+import com.sk89q.rulelists.DefinitionException;
+import com.sk89q.rulelists.RuleListUtils;
+
+public class CancelActionLoader extends AbstractNodeLoader<CancelAction> {
+
+    private final CancelAction instance = new CancelAction();
+
+    @Override
+    public CancelAction read(ConfigurationNode node)
+            throws DefinitionException {
+        RuleListUtils.warnUnknown(node, LoggerUtils.getLogger(getClass()));
+
+        return instance;
+    }
+
+}

src/main/java/com/sk89q/worldguard/bukkit/definitions/DamageCriteria.java

@@ -0,0 +1,58 @@
+// $Id$
+/*
+ * This file is a part of WorldGuard.
+ * Copyright (c) sk89q <http://www.sk89q.com>
+ * Copyright (c) the WorldGuard team and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free Software 
+ * (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 
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package com.sk89q.worldguard.bukkit.definitions;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import org.bukkit.event.Event;
+import org.bukkit.event.entity.EntityDamageEvent;
+import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+
+import com.sk89q.rulelists.Criteria;
+import com.sk89q.worldguard.bukkit.BukkitContext;
+
+public class DamageCriteria implements Criteria<BukkitContext> {
+
+    private Set<DamageCause> causes = new HashSet<DamageCause>();
+
+    public DamageCriteria(Set<DamageCause> causes) {
+        this.causes = causes;
+    }
+
+    public Set<DamageCause> getCauses() {
+        return causes;
+    }
+
+    public void setCauses(Set<DamageCause> causes) {
+        this.causes = causes;
+    }
+
+    @Override
+    public boolean matches(BukkitContext context) {
+        Event event = context.getEvent();
+
+        if (event instanceof EntityDamageEvent) {
+            return causes.contains(((EntityDamageEvent) event).getCause());
+        } else {
+            return false;
+        }
+    }
+
+}

src/main/java/com/sk89q/worldguard/bukkit/definitions/DamageCriteriaLoader.java

@@ -0,0 +1,53 @@
+// $Id$
+/*
+ * This file is a part of WorldGuard.
+ * Copyright (c) sk89q <http://www.sk89q.com>
+ * Copyright (c) the WorldGuard team and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free Software
+ * (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
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package com.sk89q.worldguard.bukkit.definitions;
+
+import static com.sk89q.rulelists.RuleEntryLoader.INLINE;
+
+import java.util.Set;
+
+import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+
+import com.sk89q.rebar.config.AbstractNodeLoader;
+import com.sk89q.rebar.config.ConfigurationNode;
+import com.sk89q.rebar.config.types.EnumLoaderBuilder;
+import com.sk89q.rebar.util.LoggerUtils;
+import com.sk89q.rulelists.DefinitionException;
+import com.sk89q.rulelists.RuleListUtils;
+
+public class DamageCriteriaLoader extends AbstractNodeLoader<DamageCriteria> {
+
+    private EnumLoaderBuilder<DamageCause> typeLoader =
+            new EnumLoaderBuilder<DamageCause>(DamageCause.class);
+
+    @Override
+    public DamageCriteria read(ConfigurationNode node) throws DefinitionException {
+        Set<DamageCause> types = node.contains(INLINE) ?
+                node.setOf(INLINE, typeLoader) :
+                node.setOf("type", typeLoader);
+
+        DamageCriteria criteria = new DamageCriteria(types);
+
+        RuleListUtils.warnUnknown(node, LoggerUtils.getLogger(getClass()),
+                                  "type");
+
+        return criteria;
+    }
+
+}

src/main/java/com/sk89q/worldguard/bukkit/definitions/EntityCriteria.java

@@ -0,0 +1,137 @@
+// $Id$
+/*
+ * This file is a part of WorldGuard.
+ * Copyright (c) sk89q <http://www.sk89q.com>
+ * Copyright (c) the WorldGuard team and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free Software
+ * (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
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package com.sk89q.worldguard.bukkit.definitions;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Tameable;
+import org.bukkit.event.block.BlockIgniteEvent;
+import org.bukkit.event.block.BlockIgniteEvent.IgniteCause;
+
+import com.sk89q.rulelists.Criteria;
+import com.sk89q.worldguard.bukkit.BukkitContext;
+import com.sk89q.worldguard.bukkit.BukkitUtil;
+import com.sk89q.worldguard.bukkit.resolvers.EntityResolver;
+import com.sk89q.worldguard.bukkit.resolvers.SourceEntityResolver;
+
+public class EntityCriteria implements Criteria<BukkitContext> {
+
+    private final EntityResolver entityResolver;
+    private Set<EntityType> types = new HashSet<EntityType>();
+    private Class<?>[] ofTypes = new Class<?>[0];
+    private Boolean isTamed = null;
+
+    // Counteract 1.3->1.4 breaking change
+    private EntityType fireballType =
+            BukkitUtil.tryEnum(EntityType.class, "FIREBALL", "LARGE_FIREBALL");
+
+    public EntityCriteria(EntityResolver entityResolver) {
+        this.entityResolver = entityResolver;
+    }
+
+    public Class<?>[] getOfTypes() {
+        return ofTypes;
+    }
+
+    public void setOfTypes(Class<?>[] ofTypes) {
+        this.ofTypes = ofTypes;
+    }
+
+    public Set<EntityType> getTypes() {
+        return types;
+    }
+
+    public void setTypes(Set<EntityType> types) {
+        this.types = types;
+    }
+
+    public Boolean getIsTamed() {
+        return isTamed;
+    }
+
+    public void setIsTamed(Boolean isTamed) {
+        this.isTamed = isTamed;
+    }
+
+    @Override
+    public boolean matches(BukkitContext context) {
+        Entity entity = entityResolver.resolve(context);
+        boolean matched = false;
+
+        // Hack because BlockIgniteEvent doesn't give an entity
+        if (context.getEvent() instanceof BlockIgniteEvent && entityResolver instanceof SourceEntityResolver) {
+            BlockIgniteEvent igniteEvent = (BlockIgniteEvent) context.getEvent();
+
+            if (igniteEvent.getCause() == IgniteCause.FIREBALL) {
+                if (types.contains(fireballType)) {
+                    matched = true;
+                }
+            }
+
+            if (igniteEvent.getCause() == IgniteCause.LIGHTNING) {
+                if (types.contains(EntityType.LIGHTNING)) {
+                    matched = true;
+                }
+            }
+        }
+
+        if (entity == null) {
+            return matched;
+        }
+
+        if (ofTypes.length != 0) {
+            Class<?> cls = entity.getClass();
+
+            for (Class<?> type : ofTypes) {
+                if (type.isAssignableFrom(cls)) {
+                    matched = true;
+                    break;
+                }
+            }
+
+            if (!matched) {
+                return false;
+            }
+        }
+
+        if (isTamed != null) {
+            if (entity instanceof Tameable && ((Tameable) entity).isTamed() == isTamed) {
+                matched = true;
+            }
+
+            if (!matched) {
+                return false;
+            }
+        }
+
+        if (types.size() == 0) {
+            matched = types.contains(entity.getType());
+
+            if (!matched) {
+                return false;
+            }
+        }
+
+        return matched;
+    }
+
+}

src/main/java/com/sk89q/worldguard/bukkit/definitions/EntityCriteriaLoader.java

@@ -0,0 +1,91 @@
+// $Id$
+/*
+ * This file is a part of WorldGuard.
+ * Copyright (c) sk89q <http://www.sk89q.com>
+ * Copyright (c) the WorldGuard team and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free Software
+ * (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
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package com.sk89q.worldguard.bukkit.definitions;
+
+import static com.sk89q.rulelists.RuleEntryLoader.INLINE;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+
+import org.bukkit.entity.Animals;
+import org.bukkit.entity.Creature;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Monster;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Tameable;
+
+import com.sk89q.rebar.config.AbstractNodeLoader;
+import com.sk89q.rebar.config.ConfigurationNode;
+import com.sk89q.rebar.config.types.EnumLoaderBuilder;
+import com.sk89q.rebar.util.LoggerUtils;
+import com.sk89q.rulelists.DefinitionException;
+import com.sk89q.rulelists.RuleListUtils;
+import com.sk89q.rulelists.RuleListsManager;
+import com.sk89q.worldguard.bukkit.resolvers.EntityResolver;
+
+public class EntityCriteriaLoader extends AbstractNodeLoader<EntityCriteria> {
+
+    private final RuleListsManager manager;
+    private EnumLoaderBuilder<EntityType> typeLoader =
+            new EnumLoaderBuilder<EntityType>(EntityType.class);
+
+    public EntityCriteriaLoader(RuleListsManager manager) {
+        this.manager = manager;
+    }
+
+    @Override
+    public EntityCriteria read(ConfigurationNode node) throws DefinitionException {
+        EntityResolver entityResolver = manager.getResolvers()
+                .get(EntityResolver.class, node.getString("entity", EntityResolver.DEFAULT));
+
+        Set<EntityType> types = node.contains(INLINE) ?
+                node.setOf(INLINE, typeLoader) :
+                node.setOf("type", typeLoader);
+
+        EntityCriteria criteria = new EntityCriteria(entityResolver);
+
+        List<Class<?>> ofTypes = new ArrayList<Class<?>>();
+
+        if (node.getBoolean("is-animal", false))
+            ofTypes.add(Animals.class);
+        if (node.getBoolean("is-monster", false))
+            ofTypes.add(Monster.class);
+        if (node.getBoolean("is-creature", false))
+            ofTypes.add(Creature.class);
+        if (node.getBoolean("is-living", false))
+            ofTypes.add(LivingEntity.class);
+        if (node.getBoolean("is-player", false))
+            ofTypes.add(Player.class);
+        if (node.getBoolean("is-tameable", false))
+            ofTypes.add(Tameable.class);
+
+        criteria.setTypes(types);
+        criteria.setOfTypes(ofTypes.toArray(new Class<?>[ofTypes.size()]));
+        criteria.setIsTamed(node.getBoolean("is-tamed"));
+
+        RuleListUtils.warnUnknown(node, LoggerUtils.getLogger(getClass()),
+                                  "entity", "type", "is-animal", "is-monster", "is-creature",
+                                  "is-living", "is-player", "is-tameable", "is-tamed");
+
+        return criteria;
+    }
+
+}

src/main/java/com/sk89q/worldguard/bukkit/definitions/ItemCriteria.java

@@ -0,0 +1,131 @@
+// $Id$
+/*
+ * This file is a part of WorldGuard.
+ * Copyright (c) sk89q <http://www.sk89q.com>
+ * Copyright (c) the WorldGuard team and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free Software
+ * (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
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package com.sk89q.worldguard.bukkit.definitions;
+
+import java.util.List;
+import java.util.Set;
+
+import org.bukkit.Material;
+import org.bukkit.entity.Entity;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.potion.Potion;
+import org.bukkit.potion.PotionEffect;
+import org.bukkit.potion.PotionEffectType;
+
+import com.sk89q.rebar.util.MaterialPattern;
+import com.sk89q.rulelists.Criteria;
+import com.sk89q.worldguard.bukkit.BukkitContext;
+import com.sk89q.worldguard.bukkit.resolvers.EntityResolver;
+import com.sk89q.worldguard.bukkit.resolvers.ItemStackSlotResolver;
+
+public class ItemCriteria implements Criteria<BukkitContext> {
+
+    private final EntityResolver entityResolver;
+    private final ItemStackSlotResolver itemResolver;
+    private MaterialPattern[] patterns = new MaterialPattern[0];
+    private Set<PotionEffectType> potionEffects = null;
+    private Boolean hasData = false;
+
+    public ItemCriteria(EntityResolver entityResolver, ItemStackSlotResolver itemResolver) {
+        this.entityResolver = entityResolver;
+        this.itemResolver = itemResolver;
+    }
+
+    public Boolean hasDataCheck() {
+        return hasData;
+    }
+
+    public void setDataCheck(Boolean hasData) {
+        this.hasData = hasData;
+    }
+
+    public MaterialPattern[] getPatterns() {
+        return patterns;
+    }
+
+    public void setPatterns(MaterialPattern[] patterns) {
+        this.patterns = patterns;
+    }
+
+    public void setPatterns(List<MaterialPattern> patterns) {
+        MaterialPattern[] arr = new MaterialPattern[patterns.size()];
+        patterns.toArray(arr);
+        this.patterns = arr;
+    }
+
+    public Set<PotionEffectType> getPotionEffects() {
+        return potionEffects;
+    }
+
+    public void setPotionEffects(Set<PotionEffectType> effects) {
+        this.potionEffects = effects;
+    }
+
+    @Override
+    public boolean matches(BukkitContext context) {
+        ItemStack item;
+        boolean matched = false;
+
+        if (entityResolver == null) {
+            item = context.getItem();
+        } else {
+            Entity entity = entityResolver.resolve(context);
+
+            if (entity == null) {
+                return false;
+            }
+
+            item = itemResolver.resolve(entity).get();
+        }
+
+        if (item == null) {
+            return false;
+        }
+
+        if (hasData != null) {
+            matched = hasData == (item.getDurability() != 0);
+            if (!matched) {
+                return false;
+            }
+        }
+
+        if (item.getType() == Material.POTION && potionEffects.size() > 0) {
+            for (PotionEffect effect : Potion.fromItemStack(item).getEffects()) {
+                if (potionEffects.contains(effect.getType())) {
+                    matched = true;
+                    break;
+                }
+            }
+
+            if (!matched) {
+                return false;
+            }
+        }
+
+        for (MaterialPattern pattern : patterns) {
+            if (pattern.matches(item.getTypeId(), item.getDurability())) {
+                matched = true;
+                break;
+            }
+        }
+
+        return matched;
+    }
+
+}

src/main/java/com/sk89q/worldguard/bukkit/definitions/ItemCriteriaLoader.java

@@ -0,0 +1,92 @@
+// $Id$
+/*
+ * This file is a part of WorldGuard.
+ * Copyright (c) sk89q <http://www.sk89q.com>
+ * Copyright (c) the WorldGuard team and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free Software
+ * (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
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package com.sk89q.worldguard.bukkit.definitions;
+
+import static com.sk89q.rulelists.RuleEntryLoader.INLINE;
+
+import java.util.List;
+import java.util.Set;
+
+import org.bukkit.potion.PotionEffectType;
+
+import com.sk89q.rebar.config.AbstractNodeLoader;
+import com.sk89q.rebar.config.ConfigurationNode;
+import com.sk89q.rebar.config.LoaderBuilderException;
+import com.sk89q.rebar.config.types.MaterialPatternLoaderBuilder;
+import com.sk89q.rebar.config.types.StaticFieldLoaderBuilder;
+import com.sk89q.rebar.util.LoggerUtils;
+import com.sk89q.rebar.util.MaterialPattern;
+import com.sk89q.rulelists.DefinitionException;
+import com.sk89q.rulelists.RuleListUtils;
+import com.sk89q.rulelists.RuleListsManager;
+import com.sk89q.worldguard.bukkit.resolvers.EntityResolver;
+import com.sk89q.worldguard.bukkit.resolvers.ItemStackSlotResolver;
+
+public class ItemCriteriaLoader extends AbstractNodeLoader<ItemCriteria> {
+
+    private final RuleListsManager manager;
+    private MaterialPatternLoaderBuilder materialLoader = new MaterialPatternLoaderBuilder();
+    private StaticFieldLoaderBuilder<PotionEffectType> effectLoader =
+            new StaticFieldLoaderBuilder<PotionEffectType>(PotionEffectType.class);
+
+    public ItemCriteriaLoader(RuleListsManager manager) {
+        this.manager = manager;
+    }
+
+    @Override
+    public ItemCriteria read(ConfigurationNode node) throws DefinitionException {
+        String entity = node.getString("entity");
+        EntityResolver entityResolver = null;
+        ItemStackSlotResolver resolver = null;
+
+        if (entity != null) {
+            entityResolver = manager.getResolvers()
+                    .get(EntityResolver.class, entity);
+            resolver = manager.getResolvers()
+                    .get(ItemStackSlotResolver.class, node.getString("item", ItemStackSlotResolver.DEFAULT));
+        }
+
+        // has-data
+        Boolean hasData = null;
+        if (node.contains("has-data")) {
+            hasData = node.getBoolean("has-data", false);
+        }
+
+        // Patterns
+        List<MaterialPattern> patterns = node.contains(INLINE) ? node.listOf(INLINE,
+                materialLoader) : node.listOf("material", materialLoader);
+        if (patterns.size() == 0 && hasData == null) {
+            throw new LoaderBuilderException("No block materials specified");
+        }
+
+        // Potion effects
+        Set<PotionEffectType> effects = node.setOf("potion-effect", effectLoader);
+
+        ItemCriteria criteria = new ItemCriteria(entityResolver, resolver);
+        criteria.setPatterns(patterns);
+        criteria.setDataCheck(hasData);
+        criteria.setPotionEffects(effects);
+
+        RuleListUtils.warnUnknown(node, LoggerUtils.getLogger(getClass()),
+                                  "item", "entity", "has-data", "material", "potion-effect");
+
+        return criteria;
+    }
+
+}

src/main/java/com/sk89q/worldguard/bukkit/definitions/PermissionCriteria.java

@@ -0,0 +1,63 @@
+// $Id$
+/*
+ * This file is a part of WorldGuard.
+ * Copyright (c) sk89q <http://www.sk89q.com>
+ * Copyright (c) the WorldGuard team and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free Software 
+ * (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 
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package com.sk89q.worldguard.bukkit.definitions;
+
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+
+import com.sk89q.rulelists.Criteria;
+import com.sk89q.worldguard.bukkit.BukkitContext;
+import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
+import com.sk89q.worldguard.bukkit.resolvers.EntityResolver;
+
+public class PermissionCriteria implements Criteria<BukkitContext> {
+
+    private final WorldGuardPlugin wg;
+    private final EntityResolver entityResolver;
+    private String permission;
+
+    public PermissionCriteria(WorldGuardPlugin wg, EntityResolver entityResolver) {
+        this.wg = wg;
+        this.entityResolver = entityResolver;
+    }
+
+    public String getPermission() {
+        return permission;
+    }
+
+    public void setPermission(String permission) {
+        this.permission = permission;
+    }
+
+    @Override
+    public boolean matches(BukkitContext context) {
+        Entity entity = entityResolver.resolve(context);
+
+        if (entity == null) {
+            return false;
+        }
+        
+        if (entity instanceof Player) {
+            return wg.hasPermission((Player) entity, permission);
+        }
+        
+        return false;
+    }
+
+}

src/main/java/com/sk89q/worldguard/bukkit/definitions/PermissionCriteriaLoader.java

@@ -0,0 +1,60 @@
+// $Id$
+/*
+ * This file is a part of WorldGuard.
+ * Copyright (c) sk89q <http://www.sk89q.com>
+ * Copyright (c) the WorldGuard team and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free Software
+ * (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
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package com.sk89q.worldguard.bukkit.definitions;
+
+import static com.sk89q.rulelists.RuleEntryLoader.INLINE;
+
+import com.sk89q.rebar.config.AbstractNodeLoader;
+import com.sk89q.rebar.config.ConfigurationNode;
+import com.sk89q.rebar.util.LoggerUtils;
+import com.sk89q.rulelists.DefinitionException;
+import com.sk89q.rulelists.RuleListUtils;
+import com.sk89q.rulelists.RuleListsManager;
+import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
+import com.sk89q.worldguard.bukkit.resolvers.EntityResolver;
+
+public class PermissionCriteriaLoader extends AbstractNodeLoader<PermissionCriteria> {
+
+    private final WorldGuardPlugin wg;
+    private final RuleListsManager manager;
+
+    public PermissionCriteriaLoader(WorldGuardPlugin wg, RuleListsManager manager) {
+        this.wg = wg;
+        this.manager = manager;
+    }
+
+    @Override
+    public PermissionCriteria read(ConfigurationNode node) throws DefinitionException {
+        EntityResolver entityResolver = manager.getResolvers()
+                .get(EntityResolver.class, node.getString("entity", EntityResolver.DEFAULT));
+
+        String permission = node.contains(INLINE) ?
+                node.getString(INLINE, "") :
+                node.getString("permission", "");
+
+        PermissionCriteria criteria = new PermissionCriteria(wg, entityResolver);
+        criteria.setPermission(permission);
+
+        RuleListUtils.warnUnknown(node, LoggerUtils.getLogger(getClass()),
+                                  "entity", "permission");
+
+        return criteria;
+    }
+
+}

src/main/java/com/sk89q/worldguard/bukkit/definitions/PhenomenonCriteria.java

@@ -0,0 +1,53 @@
+// $Id$
+/*
+ * This file is a part of WorldGuard.
+ * Copyright (c) sk89q <http://www.sk89q.com>
+ * Copyright (c) the WorldGuard team and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free Software 
+ * (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 
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package com.sk89q.worldguard.bukkit.definitions;
+
+import org.bukkit.event.Event;
+import org.bukkit.event.weather.LightningStrikeEvent;
+
+import com.sk89q.rulelists.Criteria;
+import com.sk89q.worldguard.bukkit.BukkitContext;
+
+public class PhenomenonCriteria implements Criteria<BukkitContext> {
+    
+    private Boolean isLightning = null;
+
+    public PhenomenonCriteria(Boolean isLightning) {
+    }
+
+    public Boolean getIsLightning() {
+        return isLightning;
+    }
+
+    public void setIsLightning(Boolean isLightning) {
+        this.isLightning = isLightning;
+    }
+
+    @Override
+    public boolean matches(BukkitContext context) {
+        Event event = context.getEvent();
+
+        if (isLightning != null && isLightning && event instanceof LightningStrikeEvent) {
+            return true;
+        } else {
+            return isLightning == null;
+        }
+    }
+
+}

src/main/java/com/sk89q/worldguard/bukkit/definitions/PhenomenonCriteriaLoader.java

@@ -0,0 +1,55 @@
+// $Id$
+/*
+ * This file is a part of WorldGuard.
+ * Copyright (c) sk89q <http://www.sk89q.com>
+ * Copyright (c) the WorldGuard team and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free Software
+ * (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
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package com.sk89q.worldguard.bukkit.definitions;
+
+import static com.sk89q.rulelists.RuleEntryLoader.INLINE;
+
+import java.util.Set;
+
+import com.sk89q.rebar.config.AbstractNodeLoader;
+import com.sk89q.rebar.config.ConfigurationNode;
+import com.sk89q.rebar.config.types.EnumLoaderBuilder;
+import com.sk89q.rebar.util.LoggerUtils;
+import com.sk89q.rulelists.DefinitionException;
+import com.sk89q.rulelists.RuleListUtils;
+
+public class PhenomenonCriteriaLoader extends AbstractNodeLoader<PhenomenonCriteria> {
+
+    public enum Phenomenon {
+        LIGHTNING;
+    }
+
+    private EnumLoaderBuilder<Phenomenon> typeLoader =
+            new EnumLoaderBuilder<Phenomenon>(Phenomenon.class);
+
+    @Override
+    public PhenomenonCriteria read(ConfigurationNode node) throws DefinitionException {
+        Set<Phenomenon> types = node.contains(INLINE) ?
+                node.setOf(INLINE, typeLoader) :
+                node.setOf("type", typeLoader);
+
+        PhenomenonCriteria criteria = new PhenomenonCriteria(types.contains(Phenomenon.LIGHTNING));
+
+        RuleListUtils.warnUnknown(node, LoggerUtils.getLogger(getClass()),
+                                  "type");
+
+        return criteria;
+    }
+
+}

src/main/java/com/sk89q/worldguard/bukkit/definitions/SetBlockAction.java

@@ -0,0 +1,65 @@
+// $Id$
+/*
+ * This file is a part of WorldGuard.
+ * Copyright (c) sk89q <http://www.sk89q.com>
+ * Copyright (c) the WorldGuard team and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free Software 
+ * (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 
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package com.sk89q.worldguard.bukkit.definitions;
+
+import org.bukkit.block.BlockState;
+import org.bukkit.event.Event;
+import org.bukkit.event.block.BlockBreakEvent;
+import org.bukkit.event.block.BlockPlaceEvent;
+
+import com.sk89q.rebar.util.MaterialPattern;
+import com.sk89q.rulelists.Action;
+import com.sk89q.worldguard.bukkit.BukkitContext;
+import com.sk89q.worldguard.bukkit.resolvers.BlockResolver;
+
+public class SetBlockAction implements Action<BukkitContext> {
+
+    private final BlockResolver blockResolver;
+    private MaterialPattern material;
+
+    public SetBlockAction(BlockResolver blockResolver) {
+        this.blockResolver = blockResolver;
+    }
+
+    public MaterialPattern getMaterial() {
+        return material;
+    }
+
+    public void setMaterial(MaterialPattern material) {
+        this.material = material;
+    }
+
+    @Override
+    public void apply(BukkitContext context) {
+        BlockState state = blockResolver.resolve(context);
+        Event event = context.getEvent();
+        
+        if (state == null) {
+            return;
+        }
+
+        state.setTypeId(material.getMaterial());
+        state.setRawData((byte) material.getDefaultData());
+        
+        if (!(event instanceof BlockPlaceEvent || event instanceof BlockBreakEvent)) {
+            state.update();
+        }
+    }
+
+}

src/main/java/com/sk89q/worldguard/bukkit/definitions/SetBlockActionLoader.java

@@ -0,0 +1,64 @@
+// $Id$
+/*
+ * This file is a part of WorldGuard.
+ * Copyright (c) sk89q <http://www.sk89q.com>
+ * Copyright (c) the WorldGuard team and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free Software
+ * (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
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package com.sk89q.worldguard.bukkit.definitions;
+
+import static com.sk89q.rulelists.RuleEntryLoader.INLINE;
+
+import com.sk89q.rebar.config.AbstractNodeLoader;
+import com.sk89q.rebar.config.ConfigurationNode;
+import com.sk89q.rebar.config.LoaderBuilderException;
+import com.sk89q.rebar.config.types.MaterialPatternLoaderBuilder;
+import com.sk89q.rebar.util.LoggerUtils;
+import com.sk89q.rebar.util.MaterialPattern;
+import com.sk89q.rulelists.DefinitionException;
+import com.sk89q.rulelists.RuleListUtils;
+import com.sk89q.rulelists.RuleListsManager;
+import com.sk89q.worldguard.bukkit.resolvers.BlockResolver;
+
+public class SetBlockActionLoader extends AbstractNodeLoader<SetBlockAction> {
+
+    private final RuleListsManager manager;
+    private MaterialPatternLoaderBuilder materialLoader = new MaterialPatternLoaderBuilder();
+
+    public SetBlockActionLoader(RuleListsManager manager) {
+        this.manager = manager;
+    }
+
+    @Override
+    public SetBlockAction read(ConfigurationNode node) throws DefinitionException {
+        BlockResolver resolver = manager.getResolvers()
+                .get(BlockResolver.class, node.getString("block", BlockResolver.DEFAULT));
+
+        // Load patterns
+        MaterialPattern material = node.contains(INLINE) ?
+                node.getOf(INLINE, materialLoader) : node.getOf("material", materialLoader);
+        if (material == null) {
+            throw new LoaderBuilderException("One block material must be specified");
+        }
+
+        SetBlockAction criteria = new SetBlockAction(resolver);
+        criteria.setMaterial(material);
+
+        RuleListUtils.warnUnknown(node, LoggerUtils.getLogger(getClass()),
+                                  "block", "material");
+
+        return criteria;
+    }
+
+}