Added a better and more complete implementation for attributes with sane class names.

The name of the class could be better.

pom.xml

@@ -43,6 +43,12 @@
       <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>
@@ -89,6 +95,24 @@
       <version>4.8.1</version>
       <scope>test</scope>
     </dependency>
+    <dependency>
+      <groupId>commons-lang</groupId>
+      <artifactId>commons-lang</artifactId>
+      <version>2.3</version>
+      <scope>compile</scope>
+    </dependency>
+    <dependency>
+      <groupId>com.jolbox</groupId>
+      <artifactId>bonecp</artifactId>
+      <version>0.7.1.RELEASE</version>
+      <scope>compile</scope>
+    </dependency>
+	<dependency>
+		<groupId>org.mockito</groupId>
+		<artifactId>mockito-all</artifactId>
+		<version>1.9.5</version>
+		<scope>test</scope>
+	</dependency>
   </dependencies>
   <distributionManagement>
     <site>
@@ -122,9 +146,18 @@
         <filtering>true</filtering>
         <directory>${basedir}/src/main/resources/</directory>
         <includes>
-          <include>config.yml</include>
-          <include>config_world.yml</include>
           <include>blacklist.txt</include>
+          <include>builtin_rules.yml</include>
+          <include>rulelist.yml</include>
+        </includes>
+      </resource>
+      <resource>
+        <targetPath></targetPath>
+        <filtering>false</filtering>
+        <directory>${basedir}/src/main/resources/</directory>
+        <includes>
+          <include>models/</include>
+          <include>sql/</include>
         </includes>
       </resource>
     </resources>
@@ -173,6 +206,7 @@
                 <includes>
                   <include>net.sf.opencsv:opencsv</include>
                   <include>org.khelekore:prtree</include>
+                  <include>com.sk89q:rebar</include>
                 </includes>
               </artifactSet>
             </configuration>

src/main/assembly/default.xml

@@ -3,6 +3,7 @@
   xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.2"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.2 http://maven.apache.org/xsd/assembly-1.1.2.xsd">
+  <id>default</id>
   <includeBaseDirectory>false</includeBaseDirectory>
   <formats>
     <format>tar.gz</format>

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,75 @@
+// $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 attachment is analogous to an event.
+ */
+public final class Attachment {
+
+    private static int NEXT_ID = 0;
+
+    private final int id;
+    private final String alias;
+
+    /**
+     * Create a new attachment with the given alias. The alias is used in rule list
+     * files.
+     *
+     * @param alias alias name
+     */
+    public Attachment(String alias) {
+        this.alias = alias;
+
+        // No internal ID
+        id = -1;
+    }
+
+    /**
+     * Create a new attachment with the given alias. The alias is used in rule list
+     * files.
+     *
+     * @param alias alias name
+     * @param isInternal true to assign this attachment a standard internal ID
+     */
+    Attachment(String alias, boolean isInternal) {
+        this.alias = alias;
+
+        id = isInternal ? NEXT_ID++ : -1;
+    }
+
+    /**
+     * Get the internal ID.
+     *
+     * @return ID number, possibly -1 for no internal ID
+     */
+    int getId() {
+        return id;
+    }
+
+    /**
+     * Get the alias used inside rule list files.
+     *
+     * @return alias
+     */
+    public String getAlias() {
+        return alias;
+    }
+
+}

src/main/java/com/sk89q/rulelists/AttachmentManager.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;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+import com.sk89q.rebar.config.Loader;
+import com.sk89q.rebar.config.LoaderBuilderException;
+
+/**
+ * A database of valid attachments.
+ */
+public final class AttachmentManager implements Loader<Attachment> {
+
+    private Set<Attachment> attachments = new HashSet<Attachment>();
+    private Map<String, Attachment> aliasMap = new HashMap<String, Attachment>();
+
+    public AttachmentManager() {
+    }
+
+    /**
+     * Register an attachment.
+     *
+     * @param attachment the attachment
+     */
+    public synchronized void register(Attachment attachment) {
+        if (attachments.contains(attachment)
+                || aliasMap.containsKey(attachment.getAlias().toLowerCase())) {
+            throw new IllegalArgumentException("Attachment '" + attachment + "' already registered.");
+        }
+
+        attachments.add(attachment);
+        aliasMap.put(attachment.getAlias().toLowerCase(), attachment);
+    }
+
+    /**
+     * Get an attachment by its alias.
+     *
+     * @param alias alias, case in-sensitive
+     * @return an attachment or null
+     */
+    public synchronized Attachment lookup(String alias) {
+        return aliasMap.get(alias.toLowerCase());
+    }
+
+    @Override
+    public Attachment read(Object value) throws LoaderBuilderException {
+        String id = String.valueOf(value);
+
+        Attachment attachment = lookup(id);
+        if (attachment == null) {
+            throw new LoaderBuilderException("Unknown RuleList attachment: " + id);
+        }
+
+        return attachment;
+    }
+
+}

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/DefaultAttachments.java

@@ -0,0 +1,80 @@
+// $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.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+
+/**
+ * Contains names of standard attachments.
+ */
+public final class DefaultAttachments {
+
+    public final static Attachment BLOCK_BREAK = new Attachment("block-break", true);
+    public final static Attachment BLOCK_PLACE = new Attachment("block-place", true);
+    public final static Attachment BLOCK_SPREAD = new Attachment("block-spread", true);
+    public final static Attachment BLOCK_PHYSICS = new Attachment("block-physics", true);
+    public final static Attachment BLOCK_INTERACT = new Attachment("block-interact", true);
+    public final static Attachment BLOCK_FADE = new Attachment("block-fade", true);
+    public final static Attachment BLOCK_FORM = new Attachment("block-form", true);
+    public final static Attachment PLAYER_JOIN = new Attachment("player-join", true);
+    public final static Attachment PLAYER_RESPAWN = new Attachment("player-respawn", true);
+    public final static Attachment PLAYER_QUIT = new Attachment("player-quit", true);
+    public final static Attachment ENTITY_EXPLODE = new Attachment("entity-explode", true);
+    public final static Attachment ENTITY_DAMAGE = new Attachment("entity-damage", true);
+    public final static Attachment ENTITY_DEATH = new Attachment("entity-death", true);
+    public final static Attachment ENTITY_IGNITE = new Attachment("entity-ignite", true);
+    public final static Attachment ENTITY_SPAWN = new Attachment("entity-spawn", true);
+    public final static Attachment ENTITY_STRIKE = new Attachment("entity-strike", true);
+    public final static Attachment ENTITY_INTERACT = new Attachment("entity-interact", true);
+    public final static Attachment CHAT = new Attachment("chat", true);
+    public final static Attachment ITEM_DROP = new Attachment("item-drop", true);
+    public final static Attachment ITEM_PICKUP = new Attachment("item-pickup", true);
+    public final static Attachment ITEM_USE = new Attachment("item-use", true);
+    public final static Attachment WEATHER_PHENOMENON = new Attachment("weather-phenomenon", true);
+    public final static Attachment WEATHER_TRANSITION = new Attachment("weather-transition", true);
+    public final static Attachment WORLD_LOAD = new Attachment("world-load", true);
+    public final static Attachment WORLD_UNLOAD = new Attachment("world-unload", true);
+    public final static Attachment WORLD_SAVE = new Attachment("world-save", true);
+
+    private DefaultAttachments() {
+
+    }
+
+    /**
+     * Register the attachments in this class with the given manager.
+     *
+     * @param manager the manager
+     */
+    public static void registerWith(AttachmentManager manager) {
+        for (Field field : DefaultAttachments.class.getFields()) {
+            if (Modifier.isStatic(field.getModifiers())
+                    && Attachment.class.isAssignableFrom(field.getType())) {
+                try {
+                    manager.register((Attachment) field.get(null));
+                } catch (IllegalArgumentException e) {
+                    throw new RuntimeException("Failed to register default attachment", e);
+                } catch (IllegalAccessException e) {
+                    throw new RuntimeException("Failed to register default attachment", e);
+                }
+            }
+        }
+    }
+
+}

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/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 attachments and a rule.
+ */
+public class RuleEntry {
+
+    private final List<Attachment> attachments;
+    private final Rule<?> rule;
+
+    /**
+     * Construct the rule entry with the list of attachments and rules.
+     *
+     * @param attachments attachment names
+     * @param rule rules
+     */
+    public RuleEntry(List<Attachment> attachments, Rule<?> rule) {
+        this.attachments = attachments;
+        this.rule = rule;
+    }
+
+    /**
+     * Get the list of attachments.
+     *
+     * @return attachment
+     */
+    public List<Attachment> getAttachments() {
+        return attachments;
+    }
+
+    /**
+     * Get the rule.
+     *
+     * @return rule
+     */
+    public Rule<?> getRule() {
+        return rule;
+    }
+
+}

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

@@ -0,0 +1,175 @@
+// $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.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 final Logger logger = LoggerUtils.getLogger(RuleEntryLoader.class);
+
+    private final AttachmentManager attachmentManager;
+    private final DefinitionLoader<Criteria<?>> criteriaLoader;
+    private final DefinitionLoader<Action<?>> actionLoader;
+
+    /**
+     * Construct the loader.
+     *
+     * @param ruleListsManager the action lists manager
+     */
+    public RuleEntryLoader(RuleListsManager ruleListsManager) {
+        attachmentManager = ruleListsManager.getAttachments();
+        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<Attachment> when = node.listOf("when", attachmentManager);
+
+        // 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("RuleList: Missing '?' parameter in definition " +
+                		"(to define what kind of criteria/action it is)");
+
+                return null;
+            } catch (DefinitionException e) {
+                logger.warning("RuleList: Invalid definition " +
+                        "identified by type '" + id + "': " + e.getMessage());
+
+                // Throw an exception in strict mode
+                if (strict) {
+                    throw new LoaderBuilderException("RuleList: Invalid definition " +
+                            "identified by type '" + id + "': " + e.getMessage());
+                }
+
+                return null;
+            }
+        }
+
+    }
+
+}

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

@@ -0,0 +1,83 @@
+// $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;
+
+/**
+ * Holds all the rules.
+ */
+public class RuleList {
+
+    private Map<Attachment, RuleSet> collections = new HashMap<Attachment, RuleSet>();
+
+    /**
+     * Build a new instance.
+     */
+    public RuleList() {
+    }
+
+    /**
+     * Get a rule set for a given attachment. A rule set is guaranteed to be
+     * returned for all given attachments.
+     *
+     * @param attachment the attachment
+     * @return the rule set
+     */
+    public synchronized RuleSet get(Attachment attachment) {
+        RuleSet collection = collections.get(attachment);
+        if (collection == null) {
+            collection = new RuleSet();
+            collections.put(attachment, collection);
+        }
+        return collection;
+    }
+
+    /**
+     * Register a rule with this rule list.
+     *
+     * @param entry entry
+     */
+    public void learn(RuleEntry entry) {
+        Rule<?> rule = entry.getRule();
+
+        for (Attachment attachment : entry.getAttachments()) {
+            learn(attachment, rule);
+        }
+    }
+
+    /**
+     * Register a rule with this rule list.
+     *
+     * @param attachment the attachment for the rule
+     * @param rule the rule itself
+     */
+    public void learn(Attachment attachment, Rule<?> rule) {
+        get(attachment).learn(rule);
+    }
+
+    /**
+     * Forget all rules.
+     */
+    public void clear() {
+        collections.clear();
+    }
+
+}

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 criterion 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,93 @@
+// $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.Collections;
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ * Holds a collection of rules that can be applied to a context.
+ *
+ * @see RuleList
+ */
+public class RuleSet {
+
+    private List<Rule<?>> rules = new LinkedList<Rule<?>>();
+
+    RuleSet() {
+    }
+
+    /**
+     * Add the given rule to this set.
+     *
+     * @param rule the rule
+     */
+    public synchronized void learn(Rule<?> rule) {
+        rules.add(rule);
+    }
+
+    /**
+     * Forget all rules.
+     */
+    public synchronized void clear() {
+        rules.clear();
+    }
+
+    /**
+     * Return whether this set has rules.
+     *
+     * @return true if there are rules
+     */
+    public synchronized boolean hasRules() {
+        return rules.size() > 0;
+    }
+
+    /**
+     * Get the list of rules. The returned list cannot be modified.
+     *
+     * @return rule list
+     */
+    public synchronized List<Rule<?>> getRules() {
+        return Collections.unmodifiableList(rules);
+    }
+
+    /**
+     * Apply this rule set onto the given context. Only one thread should call
+     * this method at a given time.
+     *
+     * @param context the context
+     * @return true if the event has been cancelled
+     */
+    @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/Classifier.java

@@ -0,0 +1,26 @@
+// $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
+ * PARTICULAR PURPOSE. See the GNU Lesser 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;
+
+/**
+ * A user, group, or other object that describes a set of users.
+ */
+public interface Classifier {
+
+}

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

@@ -0,0 +1,238 @@
+// $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;
+import com.sk89q.worldguard.region.ApplicableRegionSet;
+
+/**
+ * An implementation of a {@link Context} for Bukkit. This object is thread-safe, but
+ * the underlying objects returned by this class may not be.
+ *
+ * @see Context
+ */
+public class BukkitContext extends Context {
+
+    private final RegionQueryCache regionCache;
+    private final Event event;
+    private RegionQuery regionQuery;
+    private String message;
+    private Entity sourceEntity;
+    private Entity targetEntity;
+    private ItemStack item;
+    private BlockState sourceBlock;
+    private BlockState targetBlock;
+    private BlockState replacedTargetBlock;
+    private ApplicableRegionSet lastApplRegionSet;
+
+    /**
+     * Construct a context linked to the given event.
+     *
+     * @param plugin the WorldGuard plugin
+     * @param event the event
+     */
+    BukkitContext(WorldGuardPlugin plugin, Event event) {
+        this.regionCache = plugin.getRegionCache();
+        this.event = event;
+    }
+
+    /**
+     * Get the message attribute of this context.
+     *
+     * @return message or null
+     */
+    public String getMessage() {
+        return message;
+    }
+
+    /**
+     * Set the message attribute of this context.
+     *
+     * @param message or null
+     */
+    public void setMessage(String message) {
+        this.message = message;
+    }
+
+    /**
+     * Get the source entity for this context. The source entity is the 'cause' of
+     * this context, if it is available.
+     *
+     * @return entity or null
+     */
+    public Entity getSourceEntity() {
+        return sourceEntity;
+    }
+
+    /**
+     * Set the source entity for this context. The source entity is the 'cause' of
+     * this context, if it is available.
+     *
+     * @param sourceEntity entity or null
+     */
+    public void setSourceEntity(Entity sourceEntity) {
+        this.sourceEntity = sourceEntity;
+    }
+
+    /**
+     * Get the target entity for this context. The target entity is the 'subject'
+     * of this context, if it is available.
+     *
+     * @return entity or null
+     */
+    public Entity getTargetEntity() {
+        return targetEntity;
+    }
+
+    /**
+     * Set the target entity for this context. The target entity is the 'subject'
+     * of this context, if it is available.
+     *
+     * @param targetEntity entity or null
+     */
+    public void setTargetEntity(Entity targetEntity) {
+        this.targetEntity = targetEntity;
+    }
+
+    /**
+     * Get the primary item related to this context. Only events that are oriented
+     * around an item have this property set.
+     *
+     * @return item or null
+     */
+    public ItemStack getItem() {
+        return item;
+    }
+
+    /**
+     * Set the primary item related to this context. Only events that are oriented
+     * around an item have this property set.
+     *
+     * @param item  item or null
+     */
+    public void setItem(ItemStack item) {
+        this.item = item;
+    }
+
+    /**
+     * Get the source block for this context. The source block is the 'cause'
+     * of this context, if it is available.
+     *
+     * @return block or null
+     */
+    public BlockState getSourceBlock() {
+        return sourceBlock;
+    }
+
+    /**
+     * Set the source block for this context. The source block is the 'cause'
+     * of this context, if it is available.
+     *
+     * @param block block or null
+     */
+    public void setSourceBlock(BlockState block) {
+        this.sourceBlock = block;
+    }
+
+    /**
+     * Get a target block for this context. The target block is the 'subject' of
+     * this context, if it is available.
+     *
+     * @return block or null
+     */
+    public BlockState getTargetBlock() {
+        return targetBlock;
+    }
+
+    /**
+     * Set a target block for this context. The target block is the 'subject' of
+     * this context, if it is available.
+     *
+     * @param targetBlock block or null
+     */
+    public void setTargetBlock(BlockState targetBlock) {
+        this.targetBlock = targetBlock;
+    }
+
+    /**
+     * Get the placed block for this context. The placed block is the 'new' block
+     * that will replace the existing block in this context, if it is available.
+     *
+     * @return block or null
+     */
+    public BlockState getPlacedBlock() {
+        return replacedTargetBlock;
+    }
+
+    /**
+     * Set the placed block for this context. The placed block is the 'new' block
+     * that will replace the existing block in this context, if it is available.
+     *
+     * @param replacedTargetBlock block or null
+     */
+    public void setPlacedBlock(BlockState replacedTargetBlock) {
+        this.replacedTargetBlock = replacedTargetBlock;
+    }
+
+    /**
+     * Get the last {@link ApplicableRegionSet}. This can be set by a rule and used
+     * within one, but it cannot be guaranteed to exist across rules.
+     *
+     * @return an {@link ApplicableRegionSet} or null
+     */
+    public ApplicableRegionSet getApplicableRegionSet() {
+        return lastApplRegionSet;
+    }
+
+    /**
+     * Set the last {@link ApplicableRegionSet}.
+     *
+     * @param set an {@link ApplicableRegionSet} or null
+     */
+    public void setApplicableRegionSet(ApplicableRegionSet set) {
+        this.lastApplRegionSet = set;
+    }
+
+    /**
+     * Get the underlying event object.
+     *
+     * @return event object
+     */
+    public Event getEvent() {
+        return event;
+    }
+
+    /**
+     * Get the region query object.
+     *
+     * @return region query object
+     */
+    public synchronized RegionQuery getRegionQuery() {
+        if (regionQuery == null) {
+            regionQuery = regionCache.against(event);
+        }
+        return regionQuery;
+    }
+
+}

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

@@ -225,22 +225,6 @@ public class BukkitUtil {
         return str;
     }
 
-    /**
-     * Returns whether an entity should be removed for the halt activity mode.
-     *
-     * @param entity
-     * @return true if it's to be removed
-     */
-    public static boolean isIntensiveEntity(Entity entity) {
-        return entity instanceof Item
-                || entity instanceof TNTPrimed
-                || entity instanceof ExperienceOrb
-                || entity instanceof FallingSand
-                || (entity instanceof LivingEntity
-                    && !(entity instanceof Tameable)
-                    && !(entity instanceof Player));
-    }
-
     /**
      * Returns whether our running CraftBukkit already supports
      * the HangingEvent instead of the PaintingEvent
@@ -273,4 +257,19 @@ public class BukkitUtil {
 
         return null;
     }
+
+    static void checkAndDestroy(World world, int x, int y, int z, int required) {
+        if (world.getBlockTypeIdAt(x, y, z) == required) {
+            world.getBlockAt(x, y, z).setTypeId(BlockID.AIR);
+        }
+    }
+
+    static void checkAndDestroyAround(World world, int x, int y, int z, int required) {
+        checkAndDestroy(world, x, y, z + 1, required);
+        checkAndDestroy(world, x, y, z - 1, required);
+        checkAndDestroy(world, x, y + 1, z, required);
+        checkAndDestroy(world, x, y - 1, z, required);
+        checkAndDestroy(world, x + 1, y, z, required);
+        checkAndDestroy(world, x - 1, y, z, required);
+    }
 }

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

@@ -26,94 +26,70 @@ 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.yaml.snakeyaml.DumperOptions.FlowStyle;
 
 import com.sk89q.commandbook.CommandBook;
 import com.sk89q.commandbook.GodComponent;
-import com.sk89q.util.yaml.YAMLFormat;
-import com.sk89q.util.yaml.YAMLProcessor;
-import org.bukkit.World;
-import org.bukkit.entity.Player;
-
+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;
-
-    /**
-     * Holds configurations for different worlds.
-     */
     private ConcurrentMap<String, WorldConfiguration> worlds;
+    private YamlConfigurationFile config;
 
-    /**
-     * The global configuration for use when loading worlds
-     */
-    private YAMLProcessor config;
+    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>();
 
     private boolean hasCommandBookGodMode = false;
 
+    /* Configuration data start */
     public boolean useRegionsScheduler;
     public boolean useRegionsCreatureSpawnEvent;
-    public boolean activityHaltToggle = false;
-    public boolean autoGodMode;
     public boolean usePlayerMove;
     public Map<String, String> hostKeys = new HashMap<String, String>();
 
-    /**
-     * Region Storage Configuration method, and config values
-     */
     public boolean useSqlDatabase = false;
     public String sqlDsn;
     public String sqlUsername;
     public String sqlPassword;
+    /* Configuration data end */
 
     /**
      * Construct the object.
      *
-     * @param plugin The plugin instance
+     * @param plugin the plugin instance
      */
     public ConfigurationManager(WorldGuardPlugin plugin) {
         this.plugin = plugin;
@@ -123,60 +99,66 @@ public class ConfigurationManager {
     /**
      * Load the configuration.
      */
-    @SuppressWarnings("unchecked")
     public void load() {
-        // Create the default configuration file
-        plugin.createDefaultConfiguration(
-                new File(plugin.getDataFolder(), "config.yml"), "config.yml");
+        loadConfig();
 
-        config = new YAMLProcessor(new File(plugin.getDataFolder(), "config.yml"), true, YAMLFormat.EXTENDED);
-        try {
-            config.load();
-        } catch (IOException e) {
-            plugin.getLogger().severe("Error reading configuration for global config: ");
-            e.printStackTrace();
-        }
-
-        config.removeProperty("suppress-tick-sync-warnings");
-        useRegionsScheduler = config.getBoolean(
-                "regions.use-scheduler", true);
-        useRegionsCreatureSpawnEvent = config.getBoolean(
-                "regions.use-creature-spawn-event", true);
-        autoGodMode = config.getBoolean(
-                "auto-invincible", config.getBoolean("auto-invincible-permission", false));
-        config.removeProperty("auto-invincible-permission");
-        usePlayerMove = config.getBoolean(
-                "use-player-move-event", true);
-
-        hostKeys = new HashMap<String, String>();
-        Object hostKeysRaw = config.getProperty("host-keys");
-        if (hostKeysRaw == null || !(hostKeysRaw instanceof Map)) {
-            config.setProperty("host-keys", new HashMap<String, String>());
-        } else {
-            for (Map.Entry<Object, Object> entry : ((Map<Object, Object>) hostKeysRaw).entrySet()) {
-                String key = String.valueOf(entry.getKey());
-                String value = String.valueOf(entry.getValue());
-                hostKeys.put(key.toLowerCase(), value);
-            }
-        }
-
-        useSqlDatabase = config.getBoolean(
-                "regions.sql.use", false);
+        // Regions settings
+        useRegionsScheduler = config.getBoolean("regions.use-scheduler", true);
+        useRegionsCreatureSpawnEvent = config.getBoolean("regions.use-creature-spawn-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);
         }
 
-        config.setHeader(CONFIG_HEADER);
-
-        if (!config.save()) {
-            plugin.getLogger().severe("Error saving configuration!");
-        }
+        saveConfig();
     }
 
     /**
@@ -186,6 +168,41 @@ 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.
      *
@@ -199,7 +216,7 @@ public class ConfigurationManager {
 
         while (config == null) {
             if (newConfig == null) {
-                newConfig = new WorldConfiguration(plugin, worldName, this.config);
+                newConfig = new WorldConfiguration(plugin, worldName, this, this.config);
             }
             worlds.putIfAbsent(world.getName(), newConfig);
             config = worlds.get(world.getName());
@@ -208,12 +225,91 @@ public class ConfigurationManager {
         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 The player to forget about
      */
-    public void forgetPlayer(LocalPlayer player) {
+    void forgetPlayer(LocalPlayer player) {
         for (Map.Entry<String, WorldConfiguration> entry
                 : worlds.entrySet()) {
 
@@ -235,7 +331,6 @@ public class ConfigurationManager {
      */
     @Deprecated
     public void enableGodMode(Player player) {
-
         hasGodMode.add(player.getName());
     }
 
@@ -293,7 +388,10 @@ public class ConfigurationManager {
         return hasAmphibious.contains(player.getName());
     }
 
-    public void updateCommandBookGodMode() {
+    /**
+     * Check and store whether CommandBook is installed.
+     */
+    void updateCommandBookGodMode() {
         try {
             if (plugin.getServer().getPluginManager().isPluginEnabled("CommandBook")) {
                 Class.forName("com.sk89q.commandbook.GodComponent");
@@ -304,7 +402,12 @@ public class ConfigurationManager {
         hasCommandBookGodMode = false;
     }
 
-    public boolean hasCommandBookGodMode() {
+    /**
+     * 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/DisallowedPVPEvent.java

@@ -17,7 +17,7 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-package com.sk89q.worldguard.protection.events;
+package com.sk89q.worldguard.bukkit;
 
 import org.bukkit.entity.Player;
 import org.bukkit.event.Cancellable;

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

@@ -1,236 +0,0 @@
-// $Id$
-/*
- * WorldGuard
- * Copyright (C) 2010 sk89q <http://www.sk89q.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
-*/
-
-package com.sk89q.worldguard.bukkit;
-
-import static com.sk89q.worldguard.bukkit.BukkitUtil.toVector;
-
-import java.util.HashMap;
-import java.util.Map;
-
-import org.bukkit.GameMode;
-import org.bukkit.World;
-import org.bukkit.entity.Player;
-
-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;
-
-/**
- * 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 The plugin instance
-     */
-    public FlagStateManager(WorldGuardPlugin plugin) {
-        this.plugin = plugin;
-
-        states = new HashMap<String, PlayerFlagState>();
-    }
-
-    /**
-     * Run the task.
-     */
-    public void run() {
-        Player[] players = plugin.getServer().getOnlinePlayers();
-        ConfigurationManager config = plugin.getGlobalStateManager();
-
-        for (Player player : players) {
-            WorldConfiguration worldConfig = config.get(player.getWorld());
-
-            if (!worldConfig.useRegions) {
-                continue;
-            }
-
-            PlayerFlagState state;
-
-            synchronized (this) {
-                state = states.get(player.getName());
-
-                if (state == null) {
-                    state = new PlayerFlagState();
-                    states.put(player.getName(), state);
-                }
-            }
-
-            Vector playerLocation = toVector(player.getLocation());
-            RegionManager regionManager = plugin.getGlobalRegionManager()
-                    .get(player.getWorld());
-            ApplicableRegionSet applicable = regionManager
-                    .getApplicableRegions(playerLocation);
-
-            if (!RegionQueryUtil.isInvincible(plugin, player, applicable)
-                    && !plugin.getGlobalStateManager().hasGodMode(player)
-                    && !(player.getGameMode() == GameMode.CREATIVE)) {
-                processHeal(applicable, player, state);
-                processFeed(applicable, player, state);
-            }
-        }
-    }
-
-    /**
-     * Process healing for a player.
-     *
-     * @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;
-        }
-        if (minHealth == null) minHealth = 0;
-        if (maxHealth == null) maxHealth = 20;
-
-        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;
-        } else if (now - state.lastHeal > healDelay * 1000) {
-            // clamp health between minimum and maximum
-            player.setHealth(Math.min(maxHealth, Math.max(minHealth, player.getHealth() + healAmount)));
-            state.lastHeal = now;
-        }
-    }
-
-    /**
-     * Process restoring hunger for a player.
-     *
-     * @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;
-        }
-        if (minHunger == null) minHunger = 0;
-        if (maxHunger == null) maxHunger = 20;
-
-        if (player.getFoodLevel() >= maxHunger && feedAmount > 0) {
-            return;
-        }
-
-        if (feedDelay <= 0) {
-            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 The player to forget
-     */
-    public synchronized void forget(Player player) {
-        states.remove(player.getName());
-    }
-
-    /**
-     * Forget all managed players. Use with caution.
-     */
-    public synchronized void forgetAll() {
-        states.clear();
-    }
-
-    /**
-     * 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;
-        public int lastBlockZ;
-
-        /* Used to cache invincibility status */
-        public World lastInvincibleWorld;
-        public int lastInvincibleX;
-        public int lastInvincibleY;
-        public int lastInvincibleZ;
-        public boolean wasInvincible;
-    }
-}

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/LegacyWorldGuardMigration.java

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

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/RegionQuery.java

@@ -0,0 +1,96 @@
+// $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 com.sk89q.worldedit.Vector;
+import com.sk89q.worldguard.region.ApplicableRegionSet;
+import com.sk89q.worldguard.region.RegionManager;
+import com.sk89q.worldguard.region.RegionQueryCacheEntry;
+
+/**
+ * A class that will cache all region queries. Instances of this class are created
+ * via an instance of {@link RegionQueryCache} and represent a point in time.
+ */
+public final class RegionQuery {
+
+    private final WorldGuardPlugin plugin;
+    private final RegionQueryCacheEntry entry;
+
+    /**
+     * Construct the instance with the underlying cache entry.
+     *
+     * @param entry
+     */
+    RegionQuery(WorldGuardPlugin plugin, RegionQueryCacheEntry entry) {
+        this.plugin = plugin;
+        this.entry = entry;
+    }
+
+    /**
+     * 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 location the location to check
+     * @return the set, or null if region protection is disabled for the given location
+     */
+    public ApplicableRegionSet lookup(Location location) {
+        World world = location.getWorld();
+        Vector vector = BukkitUtil.toVector(location);
+
+        ConfigurationManager config = plugin.getGlobalStateManager();
+        WorldConfiguration worldConfig = config.get(world);
+        RegionManager regionManager = plugin.getGlobalRegionManager();
+
+        if (!worldConfig.useRegions) {
+            return null;
+        }
+
+        return entry.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 block the block to check
+     * @return the set, or null if region protection is disabled for the given block
+     */
+    public ApplicableRegionSet lookup(Block block) {
+        return lookup(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 entity the entity to check
+     * @return the set, or null if region protection is disabled for the given entity
+     */
+    public ApplicableRegionSet lookup(Entity entity) {
+        return lookup(entity.getLocation());
+    }
+
+}

src/main/java/com/sk89q/worldguard/bukkit/RegionQueryCache.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;
+
+import org.bukkit.event.Event;
+
+import com.sk89q.worldguard.region.AbstractRegionQueryCache;
+
+/**
+ * An implementation of {@link AbstractRegionQueryCache} for Bukkit. This implementation
+ * is thread-safe.
+ */
+public final class RegionQueryCache extends AbstractRegionQueryCache {
+
+    private final WorldGuardPlugin plugin;
+
+    /**
+     * Construct the cache with the given plugin instance.
+     *
+     * @param plugin plugin instance
+     */
+    public RegionQueryCache(WorldGuardPlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    /**
+     * Get a {@link RegionQuery} object that can cache region queries. The object
+     * returned by this method does not need to be cached. It is merely a proxy class.
+     *
+     * @param event the event to cache against
+     * @return an object to perform lookups against
+     */
+    public RegionQuery against(Event event) {
+        return new RegionQuery(plugin, get(event));
+    }
+
+}

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

@@ -1,83 +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 org.bukkit.Location;
-import org.bukkit.World;
-import org.bukkit.entity.Player;
-
-import com.sk89q.worldedit.Vector;
-import com.sk89q.worldguard.protection.ApplicableRegionSet;
-import com.sk89q.worldguard.protection.flags.DefaultFlag;
-import com.sk89q.worldguard.protection.flags.StateFlag;
-import com.sk89q.worldguard.protection.managers.RegionManager;
-
-public class RegionQueryUtil {
-
-    public static boolean isInvincible(WorldGuardPlugin plugin, Player player) {
-        return isInvincible(plugin, player, null);
-    }
-
-    public static boolean isInvincible(WorldGuardPlugin plugin, Player player,
-                                       ApplicableRegionSet set) {
-        Location loc = player.getLocation();
-        World world = player.getWorld();
-        
-        FlagStateManager.PlayerFlagState state = plugin.getFlagStateManager().getState(player);
-
-        if (state.lastInvincibleWorld == null ||
-                !state.lastInvincibleWorld.equals(world) ||
-                state.lastInvincibleX != loc.getBlockX() ||
-                state.lastInvincibleY != loc.getBlockY() ||
-                state.lastInvincibleZ != loc.getBlockZ()) {
-            state.lastInvincibleX = loc.getBlockX();
-            state.lastInvincibleY = loc.getBlockY();
-            state.lastInvincibleZ = loc.getBlockZ();
-            state.lastInvincibleWorld = world;
-
-            if (set == null) {
-                Vector vec = new Vector(state.lastInvincibleX,
-                        state.lastInvincibleY, state.lastInvincibleZ);
-                RegionManager mgr = plugin.getGlobalRegionManager().get(world);
-                set = mgr.getApplicableRegions(vec);
-            }
-
-            state.wasInvincible = set.allows(DefaultFlag.INVINCIBILITY, plugin.wrapPlayer(player));
-        }
-
-        return state.wasInvincible;
-    }
-
-    public static Boolean isAllowedInvinciblity(WorldGuardPlugin plugin, Player player) {
-        World world = player.getWorld();
-        FlagStateManager.PlayerFlagState state = plugin.getFlagStateManager().getState(player);
-        Vector vec = new Vector(state.lastInvincibleX, state.lastInvincibleY, state.lastInvincibleZ);
-
-        StateFlag.State regionState = plugin.getGlobalRegionManager().get(world).
-                getApplicableRegions(vec).getFlag(DefaultFlag.INVINCIBILITY, plugin.wrapPlayer(player));
-        if (regionState == StateFlag.State.ALLOW) {
-            return Boolean.TRUE;
-        } else if (regionState == StateFlag.State.DENY) {
-            return Boolean.FALSE;
-        } else {
-            return null;
-        }
-    }
-}

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

@@ -35,22 +35,17 @@ import org.bukkit.World;
 import org.bukkit.entity.Entity;
 import org.bukkit.plugin.Plugin;
 
-import com.sk89q.worldguard.protection.GlobalRegionManager;
-import com.sk89q.worldguard.protection.flags.DefaultFlag;
-import com.sk89q.worldguard.protection.flags.Flag;
-import com.sk89q.worldguard.protection.flags.StateFlag;
-import com.sk89q.worldguard.protection.managers.RegionManager;
-import com.sk89q.worldguard.protection.regions.ProtectedRegion;
+import com.sk89q.worldguard.region.RegionManager;
 import com.sk89q.worldguard.util.LogListBlock;
 
 public class ReportWriter {
 
     private static final SimpleDateFormat dateFmt =
         new SimpleDateFormat("yyyy-MM-dd kk:mm Z");
-    
+
     private Date date = new Date();
     private StringBuilder output = new StringBuilder();
-    
+
     public ReportWriter(WorldGuardPlugin plugin) {
         appendReportHeader(plugin);
         appendServerInformation(plugin.getServer());
@@ -63,38 +58,38 @@ public class ReportWriter {
         appendln("END OF REPORT");
         appendln();
     }
-    
+
     protected static String repeat(String str, int n) {
         if(str == null) {
             return null;
         }
-        
+
         StringBuilder sb = new StringBuilder();
         for (int i = 0; i < n; i++) {
             sb.append(str);
         }
-        
+
         return sb.toString();
     }
-    
+
     protected void appendln(String text) {
         output.append(text);
         output.append("\r\n");
     }
-    
+
     protected void appendln(String text, Object ... args) {
         output.append(String.format(text, args));
         output.append("\r\n");
     }
-    
+
     protected void append(LogListBlock log) {
         output.append(log.toString());
     }
-    
+
     protected void appendln() {
         output.append("\r\n");
     }
-    
+
     protected void appendHeader(String text) {
         String rule = repeat("-", text.length());
         output.append(rule);
@@ -104,7 +99,7 @@ public class ReportWriter {
         output.append("\r\n");
         appendln();
     }
-    
+
     private void appendReportHeader(WorldGuardPlugin plugin) {
         appendln("WorldGuard Configuration Report");
         appendln("Generated " + dateFmt.format(date));
@@ -112,13 +107,13 @@ public class ReportWriter {
         appendln("Version: " + plugin.getDescription().getVersion());
         appendln();
     }
-    
+
     private void appendGlobalConfiguration(ConfigurationManager config) {
         appendHeader("Global Configuration");
-        
+
         LogListBlock log = new LogListBlock();
         LogListBlock configLog = log.putChild("Configuration");
-        
+
         Class<? extends ConfigurationManager> cls = config.getClass();
         for (Field field : cls.getFields()) {
             try {
@@ -130,16 +125,16 @@ public class ReportWriter {
             } catch (IllegalAccessException ignore) {
             }
         }
-        
+
         append(log);
         appendln();
     }
-    
+
     private void appendServerInformation(Server server) {
         appendHeader("Server Information");
-        
+
         LogListBlock log = new LogListBlock();
-        
+
         Runtime runtime = Runtime.getRuntime();
 
         log.put("Java", "%s %s (%s)",
@@ -164,23 +159,23 @@ public class ReportWriter {
         append(log);
         appendln();
     }
-    
+
     private void appendPluginInformation(Plugin[] plugins) {
         appendHeader("Plugins (" + plugins.length + ")");
-        
+
         LogListBlock log = new LogListBlock();
-        
+
         for (Plugin plugin : plugins) {
             log.put(plugin.getDescription().getName(), plugin.getDescription().getVersion());
         }
 
         append(log);
         appendln();
-        
+
         /*appendHeader("Plugin Information");
-        
+
         log = new LogListBlock();
-        
+
         for (Plugin plugin : plugins) {
             log.putChild(plugin.getDescription().getName())
                 .put("Data folder", plugin.getDataFolder())
@@ -191,20 +186,20 @@ public class ReportWriter {
         append(log);
         appendln();*/
     }
-    
+
     private void appendWorldInformation(List<World> worlds) {
         appendHeader("Worlds");
-        
+
         LogListBlock log = new LogListBlock();
-        
+
         int i = 0;
         for (World world : worlds) {
             int loadedChunkCount = world.getLoadedChunks().length;
-            
+
             LogListBlock worldLog = log.putChild(world.getName() + " (" +  i + ")");
             LogListBlock infoLog = worldLog.putChild("Information");
             LogListBlock entitiesLog = worldLog.putChild("Entities");
-            
+
             infoLog.put("Seed", world.getSeed());
             infoLog.put("Environment", world.getEnvironment().toString());
             infoLog.put("Player count", world.getPlayers().size());
@@ -212,21 +207,21 @@ public class ReportWriter {
             infoLog.put("Loaded chunk count", loadedChunkCount);
             infoLog.put("Spawn location", world.getSpawnLocation());
             infoLog.put("Raw time", world.getFullTime());
-            
+
             Map<Class<? extends Entity>, Integer> entityCounts =
                     new HashMap<Class<? extends Entity>, Integer>();
-            
+
             // Collect entities
             for (Entity entity : world.getEntities()) {
                 Class<? extends Entity> cls = entity.getClass();
-                
+
                 if (entityCounts.containsKey(cls)) {
                     entityCounts.put(cls, entityCounts.get(cls) + 1);
                 } else {
                     entityCounts.put(cls, 1);
                 }
             }
-            
+
             // Print entities
             for (Map.Entry<Class<? extends Entity>, Integer> entry
                     : entityCounts.entrySet()) {
@@ -235,18 +230,18 @@ public class ReportWriter {
                         entry.getValue(),
                         (float) (entry.getValue() / (double) loadedChunkCount));
             }
-            
+
             i++;
         }
 
         append(log);
         appendln();
     }
-    
+
     private void appendWorldConfigurations(WorldGuardPlugin plugin, List<World> worlds,
-            GlobalRegionManager regionMgr, ConfigurationManager mgr) {
+            RegionManager regionMgr, ConfigurationManager mgr) {
         appendHeader("World Configurations");
-        
+
         LogListBlock log = new LogListBlock();
 
         int i = 0;
@@ -264,9 +259,9 @@ public class ReportWriter {
                     + world.getName() + "/blacklist.txt")).getAbsoluteFile());
             infoLog.put("Regions file", (new File(plugin.getDataFolder(), "worlds/"
                     + world.getName() + "/regions.yml")).getAbsoluteFile());
-            
+
             WorldConfiguration config = mgr.get(world);
-            
+
             Class<? extends WorldConfiguration> cls = config.getClass();
             for (Field field : cls.getFields()) {
                 try {
@@ -277,7 +272,7 @@ public class ReportWriter {
                 } catch (IllegalAccessException ignore) {
                 }
             }
-            
+
             if (config.getBlacklist() == null) {
                 blacklistLog.put("State", "DISABLED");
             } else {
@@ -288,13 +283,13 @@ public class ReportWriter {
                         config.getBlacklist().isWhitelist());
             }
 
-            RegionManager worldRegions = regionMgr.get(world);
+            /*RegionIndex worldRegions = regionMgr.get(world);
 
             regionsLog.put("Type", worldRegions.getClass().getCanonicalName());
             regionsLog.put("Number of regions", worldRegions.getRegions().size());
             LogListBlock globalRegionLog = regionsLog.putChild("Global region");
-            
-            ProtectedRegion globalRegion = worldRegions.getRegion("__global__");
+
+            Region globalRegion = worldRegions.getRegion("__global__");
             if (globalRegion == null) {
                 globalRegionLog.put("Status", "UNDEFINED");
             } else {
@@ -304,17 +299,17 @@ public class ReportWriter {
                                 globalRegion.getFlag(flag));
                     }
                 }
-            }
+            }*/
         }
 
         append(log);
         appendln();
     }
-    
+
     public void write(File file) throws IOException {
         FileWriter writer = null;
         BufferedWriter out;
-        
+
         try {
             writer = new FileWriter(file);
             out = new BufferedWriter(writer);
@@ -329,7 +324,7 @@ public class ReportWriter {
             }
         }
     }
-    
+
     @Override
     public String toString() {
         return output.toString();

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 The plugin instace
-     * @param world The world the sponge isin
-     * @param ox The x coordinate of the 'sponge' block
-     * @param oy The y coordinate of the 'sponge' block
-     * @param oz The z coordinate of the 'sponge' block
-     */
-    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 The plugin instance
-     * @param world The world the sponge is located in
-     * @param ox The x coordinate of the 'sponge' block
-     * @param oy The y coordinate of the 'sponge' block
-     * @param oz The z coordinate of the 'sponge' block
-     */
-    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

@@ -19,524 +19,353 @@
 
 package com.sk89q.worldguard.bukkit;
 
-import com.sk89q.util.yaml.YAMLFormat;
-import com.sk89q.util.yaml.YAMLProcessor;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import org.bukkit.entity.Player;
+
+import com.sk89q.rebar.config.ConfigurationException;
+import com.sk89q.rebar.config.ConfigurationNode;
+import com.sk89q.rebar.config.YamlConfiguration;
+import com.sk89q.rebar.config.YamlConfigurationFile;
+import com.sk89q.rebar.config.YamlConfigurationResource;
+import com.sk89q.rebar.config.YamlStyle;
+import com.sk89q.rebar.util.LoggerUtils;
+import com.sk89q.rulelists.RuleList;
+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;
 import com.sk89q.worldguard.blacklist.loggers.DatabaseLoggerHandler;
 import com.sk89q.worldguard.blacklist.loggers.FileLoggerHandler;
-import com.sk89q.worldguard.chest.ChestProtection;
-import com.sk89q.worldguard.chest.SignChestProtection;
-import org.bukkit.block.Block;
-import org.bukkit.entity.EntityType;
-import org.bukkit.entity.Player;
-
-import java.io.File;
-import java.io.FileNotFoundException;
-import java.io.IOException;
-import java.util.*;
-import java.util.logging.Level;
 
 /**
  * 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 WorldGuardPlugin plugin;
-
-    private String worldName;
-    private YAMLProcessor parentConfig;
-    private YAMLProcessor config;
-    private File blacklistFile;
+    private final WorldGuardPlugin plugin;
+    private final ConfigurationManager configMan;
+    private final YamlConfigurationFile config;
+    private final String worldName;
 
     private Blacklist blacklist;
-    private ChestProtection chestProtection = new SignChestProtection();
+    private RuleList ruleList = new RuleList();
+    private SpongeApplicator spongeApplicator = null;
 
     /* Configuration data start */
     public boolean opPermissions;
-    public boolean fireSpreadDisableToggle;
-    public boolean itemDurability;
-    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 blockWitherExplosions;
-    public boolean blockWitherBlockDamage;
-    public boolean blockWitherSkullExplosions;
-    public boolean blockWitherSkullBlockDamage;
-    public boolean blockEnderDragonBlockDamage;
-    public boolean blockFireballExplosions;
-    public boolean blockFireballBlockDamage;
-    public boolean blockEntityPaintingDestroy;
-    public boolean blockEntityItemFrameDestroy;
-    public boolean blockPluginSpawning;
-    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;
-    public Set<EntityType> blockCreatureSpawn;
+    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 disableSignChestProtectionCheck;
-    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;
-
     private Map<String, Integer> maxRegionCounts;
-
+    public boolean fireSpreadDisableToggle;
     /* Configuration data end */
 
     /**
      * Construct the object.
      *
-     * @param plugin The WorldGuardPlugin instance
-     * @param worldName The world name that this WorldConfiguration is for.
-     * @param parentConfig The parent configuration to read defaults from
+     * @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, YAMLProcessor parentConfig) {
-        File baseFolder = new File(plugin.getDataFolder(), "worlds/" + worldName);
-        File 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 = parentConfig;
+        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 YAMLProcessor(configFile, true, YAMLFormat.EXTENDED);
-        loadConfiguration();
-
-        plugin.getLogger().info("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;
-        }
-    }
-
-    @SuppressWarnings("unused")
-    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;
-    }
-
-    private List<String> getKeys(String node) {
-        List<String> res = parentConfig.getKeys(node);
-
-        if (res == null || res.size() == 0) {
-            res = config.getKeys(node);
-        }
-        if (res == null) {
-            res = new ArrayList<String>();
-        }
-
-        return res;
-    }
-
-    private Object getProperty(String node) {
-        Object res = parentConfig.getProperty(node);
-
-        if (config.getProperty(node) != null) {
-            res = config.getProperty(node);
-        }
-
-        return res;
+        load();
     }
 
     /**
      * Load the configuration.
      */
-    private void loadConfiguration() {
+    private void load() {
+        logger.info("Loading configuration for '" + worldName + "'...");
+
+        loadConfig();
+
+        // Load rule lists
+        ruleList.clear();
+        loadBuiltInRules();
+        loadUserRules();
+        loadBlacklist();
+        loadSettings();
+
+        saveConfig();
+    }
+
+    /**
+     * Load the configuration from file.
+     */
+    private void loadConfig() {
         try {
             config.load();
         } catch (IOException e) {
-            plugin.getLogger().severe("Error reading configuration for world " + worldName + ": ");
-            e.printStackTrace();
+            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) {
+                    ruleList.learn(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)) {
+                ruleList.learn(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 (blacklist != null) {
+                blacklist.getLogger().close();
+            }
+
+            File blacklistFile = configMan.getBlacklistFile(worldName);
+
+            // 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 = newBlacklist;
+                logger.log(Level.INFO, "Blacklist loaded.");
+
+                BlacklistLogger blacklistLogger = newBlacklist.getLogger();
+
+                if (logDatabase)
+                    blacklistLogger.addHandler(new DatabaseLoggerHandler(dsn, user,
+                            pass, table, worldName, logger));
+
+                if (logConsole)
+                    blacklistLogger.addHandler(new ConsoleLoggerHandler(worldName,
+                            logger));
+
+                if (logFile) {
+                    FileLoggerHandler handler = new FileLoggerHandler(logFilePattern,
+                            logFileCacheSize, worldName, logger);
+                    blacklistLogger.addHandler(handler);
+                }
+            }
+        } catch (FileNotFoundException e) {
+            logger.log(Level.WARNING, "WorldGuard blacklist does not exist", e);
+        } catch (IOException e) {
+            logger.log(Level.WARNING, "Could not load blacklist", e);
+        }
+    }
+
+    /**
+     * Load the settings.
+     */
+    private void loadSettings() {
+        opPermissions = config.getBoolean("op-permissions", true);
+
+        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);
         }
 
-        opPermissions = getBoolean("op-permissions", true);
+        signChestProtection = config.getBoolean("chest-protection.enable", false);
+        disableSignChestProtectionCheck = config.getBoolean("chest-protection.disable-off-check", false);
 
-        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);
+        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);
 
-        simulateSponge = getBoolean("simulation.sponge.enable", true);
-        spongeRadius = Math.max(1, getInt("simulation.sponge.radius", 3)) - 1;
-        redstoneSponges = getBoolean("simulation.sponge.redstone", false);
-
-        pumpkinScuba = getBoolean("default.pumpkin-scuba", false);
-        disableHealthRegain = getBoolean("default.disable-health-regain", false);
-
-        noPhysicsGravel = getBoolean("physics.no-physics-gravel", false);
-        noPhysicsSand = getBoolean("physics.no-physics-sand", false);
-        allowPortalAnywhere = getBoolean("physics.allow-portal-anywhere", false);
-        preventWaterDamage = new HashSet<Integer>(getIntList("physics.disable-water-damage-blocks", null));
-
-        blockTNTExplosions = getBoolean("ignition.block-tnt", false);
-        blockTNTBlockDamage = getBoolean("ignition.block-tnt-block-damage", false);
-        blockLighter = getBoolean("ignition.block-lighter", false);
-
-        preventLavaFire = getBoolean("fire.disable-lava-fire-spread", true);
-        disableFireSpread = getBoolean("fire.disable-all-fire-spread", false);
-        disableFireSpreadBlocks = new HashSet<Integer>(getIntList("fire.disable-fire-spread-blocks", null));
-        allowedLavaSpreadOver = new HashSet<Integer>(getIntList("fire.lava-spread-blocks", null));
-
-        blockCreeperExplosions = getBoolean("mobs.block-creeper-explosions", false);
-        blockCreeperBlockDamage = getBoolean("mobs.block-creeper-block-damage", false);
-        blockWitherExplosions = getBoolean("mobs.block-wither-explosions", false);
-        blockWitherBlockDamage = getBoolean("mobs.block-wither-block-damage", false);
-        blockWitherSkullExplosions = getBoolean("mobs.block-wither-skull-explosions", false);
-        blockWitherSkullBlockDamage = getBoolean("mobs.block-wither-skull-block-damage", false);
-        blockEnderDragonBlockDamage = getBoolean("mobs.block-enderdragon-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);
-        blockEntityPaintingDestroy = getBoolean("mobs.block-painting-destroy", false);
-        blockEntityItemFrameDestroy = getBoolean("mobs.block-item-frame-destroy", false);
-        blockPluginSpawning = getBoolean("mobs.block-plugin-spawning", true);
-
-        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);
-        disableSignChestProtectionCheck = getBoolean("chest-protection.disable-off-check", 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", 334);
-        maxClaimVolume = getInt("regions.max-claim-volume", 30000);
-        claimOnlyInsideExistingRegions = getBoolean("regions.claim-only-inside-existing-regions", false);
-
-        maxRegionCountPerPlayer = getInt("regions.max-region-count-per-player.default", 7);
+        maxRegionCountPerPlayer = config.getInt("regions.max-region-count-per-player.default", 7);
         maxRegionCounts = new HashMap<String, Integer>();
         maxRegionCounts.put(null, maxRegionCountPerPlayer);
 
-        for (String key : getKeys("regions.max-region-count-per-player")) {
+        for (String key : config.getKeys("regions.max-region-count-per-player")) {
             if (!key.equalsIgnoreCase("default")) {
-                Object val = getProperty("regions.max-region-count-per-player." + key);
+                Object val = config.get("regions.max-region-count-per-player." + key);
                 if (val != null && val instanceof Number) {
                     maxRegionCounts.put(key, ((Number) val).intValue());
                 }
             }
         }
 
+        // Very important part for protection!
+        if (useRegions) {
+            loadRegionModels();
+        }
+
         // useiConomy = getBoolean("iconomy.enable", false);
         // buyOnClaim = getBoolean("iconomy.buy-on-claim", false);
         // buyOnClaimPrice = getDouble("iconomy.buy-on-claim-price", 1.0);
-
-        blockCreatureSpawn = new HashSet<EntityType>();
-        for (String creatureName : getStringList("mobs.block-creature-spawn", null)) {
-            EntityType creature = EntityType.fromName(creatureName);
-
-            if (creature == null) {
-                plugin.getLogger().warning("Unknown mob type '" + creatureName + "'");
-            } else if (!creature.isAlive()) {
-                plugin.getLogger().warning("Entity type '" + creatureName + "' is not a creature");
-            } else {
-                blockCreatureSpawn.add(creature);
-            }
-        }
-
-        boolean useBlacklistAsWhitelist = getBoolean("blacklist.use-as-whitelist", false);
-
-        // Console log configuration
-        boolean logConsole = getBoolean("blacklist.logging.console.enable", true);
-
-        // Database log configuration
-        boolean logDatabase = getBoolean("blacklist.logging.database.enable", false);
-        String dsn = getString("blacklist.logging.database.dsn", "jdbc:mysql://localhost:3306/minecraft");
-        String user = getString("blacklist.logging.database.user", "root");
-        String pass = getString("blacklist.logging.database.pass", "");
-        String table = getString("blacklist.logging.database.table", "blacklist_events");
-
-        // File log configuration
-        boolean logFile = getBoolean("blacklist.logging.file.enable", false);
-        String logFilePattern = getString("blacklist.logging.file.path", "worldguard/logs/%Y-%m-%d.log");
-        int logFileCacheSize = Math.max(1, getInt("blacklist.logging.file.open-files", 10));
-
-        // Load the blacklist
-        try {
-            // If there was an existing blacklist, close loggers
-            if (blacklist != null) {
-                blacklist.getLogger().close();
-            }
-
-            // First load the blacklist data from worldguard-blacklist.txt
-            Blacklist blist = new BukkitBlacklist(useBlacklistAsWhitelist, plugin);
-            blist.load(blacklistFile);
-
-            // If the blacklist is empty, then set the field to null
-            // and save some resources
-            if (blist.isEmpty()) {
-                this.blacklist = null;
-            } else {
-                this.blacklist = blist;
-                plugin.getLogger().log(Level.INFO, "Blacklist loaded.");
-
-                BlacklistLogger blacklistLogger = blist.getLogger();
-
-                if (logDatabase) {
-                    blacklistLogger.addHandler(new DatabaseLoggerHandler(dsn, user, pass, table, worldName, plugin.getLogger()));
-                }
-
-                if (logConsole) {
-                    blacklistLogger.addHandler(new ConsoleLoggerHandler(worldName, plugin.getLogger()));
-                }
-
-                if (logFile) {
-                    FileLoggerHandler handler =
-                            new FileLoggerHandler(logFilePattern, logFileCacheSize, worldName, plugin.getLogger());
-                    blacklistLogger.addHandler(handler);
-                }
-            }
-        } catch (FileNotFoundException e) {
-            plugin.getLogger().log(Level.WARNING, "WorldGuard blacklist does not exist.");
-        } catch (IOException e) {
-            plugin.getLogger().log(Level.WARNING, "Could not load WorldGuard blacklist: "
-                    + e.getMessage());
-        }
-
-        // Print an overview of settings
-        if (getBoolean("summary-on-start", true)) {
-            plugin.getLogger().log(Level.INFO, blockTNTExplosions
-                    ? "(" + worldName + ") TNT ignition is blocked."
-                    : "(" + worldName + ") TNT ignition is PERMITTED.");
-            plugin.getLogger().log(Level.INFO, blockLighter
-                    ? "(" + worldName + ") Lighters are blocked."
-                    : "(" + worldName + ") Lighters are PERMITTED.");
-            plugin.getLogger().log(Level.INFO, preventLavaFire
-                    ? "(" + worldName + ") Lava fire is blocked."
-                    : "(" + worldName + ") Lava fire is PERMITTED.");
-
-            if (disableFireSpread) {
-                plugin.getLogger().log(Level.INFO, "(" + worldName + ") All fire spread is disabled.");
-            } else {
-                if (disableFireSpreadBlocks.size() > 0) {
-                    plugin.getLogger().log(Level.INFO, "(" + worldName
-                            + ") Fire spread is limited to "
-                            + disableFireSpreadBlocks.size() + " block types.");
-                } else {
-                    plugin.getLogger().log(Level.INFO, "(" + worldName
-                            + ") Fire spread is UNRESTRICTED.");
-                }
-            }
-        }
-
-        config.setHeader(CONFIG_HEADER);
-
-        config.save();
     }
 
-    public Blacklist getBlacklist() {
-        return this.blacklist;
+    /**
+     * Load region protection model.
+     */
+    private void loadRegionModels() {
+        List<String> filenames;
+        RuleEntryLoader entryLoader = new RuleEntryLoader(plugin.getRulesListManager());
+
+        // Make a default protection model list
+        List<String> defaultProtectionModels = new ArrayList<String>();
+        defaultProtectionModels.add("minimal");
+
+        // Load protection model
+        filenames = config.getStringList("regions.protection-models", defaultProtectionModels);
+        for (YamlConfiguration config : readFiles(filenames, "/models/protection/",
+                new File(plugin.getDataFolder(), "models/protection"))) {
+            for (RuleEntry entry : config.listOf(ConfigurationNode.ROOT, entryLoader)) {
+                ruleList.learn(entry);
+            }
+        }
     }
 
+    /**
+     * Get the blacklist.
+     *
+     * @return the blacklist
+     */
+    Blacklist getBlacklist() {
+        return blacklist;
+    }
+
+    /**
+     * Get the RuleList.
+     *
+     * @return the rule list
+     */
+    RuleList getRuleList() {
+        return ruleList;
+    }
+
+    /**
+     * Get the sponge applicator.
+     *
+     * @return sponge applicator
+     */
+    SpongeApplicator getSpongeApplicator() {
+        return spongeApplicator;
+    }
+
+    /**
+     * Get the world name of this configuration.
+     *
+     * @return the world name
+     */
     public String getWorldName() {
         return this.worldName;
     }
 
-    public boolean isChestProtected(Block block, Player player) {
-        if (!signChestProtection) {
-            return false;
-        }
-        if (plugin.hasPermission(player, "worldguard.chest-protection.override")
-                || plugin.hasPermission(player, "worldguard.override.chest-protection")) {
-            return false;
-        }
-        return chestProtection.isProtected(block, player);
-    }
-
-    public boolean isChestProtected(Block block) {
-
-        return signChestProtection && chestProtection.isProtected(block, null);
-    }
-
-    public boolean isChestProtectedPlacement(Block block, Player player) {
-        if (!signChestProtection) {
-            return false;
-        }
-        if (plugin.hasPermission(player, "worldguard.chest-protection.override")
-                || plugin.hasPermission(player, "worldguard.override.chest-protection")) {
-            return false;
-        }
-        return chestProtection.isProtectedPlacement(block, player);
-    }
-
-    public boolean isAdjacentChestProtected(Block block, Player player) {
-        if (!signChestProtection) {
-            return false;
-        }
-        if (plugin.hasPermission(player, "worldguard.chest-protection.override")
-                || plugin.hasPermission(player, "worldguard.override.chest-protection")) {
-            return false;
-        }
-        return chestProtection.isAdjacentChestProtected(block, player);
-    }
-
-    public ChestProtection getChestProtection() {
-        return chestProtection;
-    }
-
+    /**
+     * Get the maximum region count for a given player.
+     *
+     * @param player player
+     * @return number of regions
+     */
     public int getMaxRegionCount(Player player) {
         int max = -1;
         for (String group : plugin.getGroups(player)) {
@@ -550,4 +379,56 @@ public class WorldConfiguration {
         }
         return max;
     }
+
+    /**
+     * Read a list of files, either from the .jar (preferred) or from disk.
+     *
+     * @param filenames list of filenames
+     * @param internalDir the base path for the JAR files
+     * @param externalDir the base dir for the disk files
+     * @return a list of {@link YamlConfiguration}s
+     */
+    private static List<YamlConfiguration> readFiles(Collection<String> filenames,
+            String internalDir, File externalDir) {
+        List<YamlConfiguration> configs = new ArrayList<YamlConfiguration>();
+
+        for (String filename : filenames) {
+            YamlConfiguration config;
+
+            // External file path
+            File file = new File(externalDir, filename);
+            file.getParentFile().mkdirs();
+
+            // Try loading from the .jar first
+            String path = internalDir + filename + ".yml";
+            config = new YamlConfigurationResource(WorldGuardPlugin.class, path);
+            try {
+                config.load();
+                configs.add(config);
+                continue; // Found!
+            } catch (FileNotFoundException e) {
+                // Do nothing
+            } catch (IOException e) {
+                logger.log(Level.SEVERE, "Failed to internal path " + path, e);
+            } catch (ConfigurationException e) {
+                logger.log(Level.SEVERE, "Failed to internal path " + path, e);
+            }
+
+            // Try loading from disk
+            config = new YamlConfigurationFile(file, new YamlStyle(), false);
+            try {
+                config.load();
+                configs.add(config);
+                continue; // Found!
+            } catch (FileNotFoundException e) {
+                logger.log(Level.SEVERE, "Failed to load " + file.getAbsolutePath());
+            } catch (IOException e) {
+                logger.log(Level.SEVERE, "Failed to load " + file.getAbsolutePath(), e);
+            } catch (ConfigurationException e) {
+                logger.log(Level.SEVERE, "Failed to load " + file.getAbsolutePath(), e);
+            }
+        }
+
+        return configs;
+    }
 }

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

@@ -16,14 +16,14 @@
  * 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.Location;
+import org.bukkit.Material;
 import org.bukkit.World;
 import org.bukkit.block.Block;
+import org.bukkit.block.BlockState;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
@@ -31,548 +31,310 @@ import org.bukkit.event.Listener;
 import org.bukkit.event.block.BlockBreakEvent;
 import org.bukkit.event.block.BlockBurnEvent;
 import org.bukkit.event.block.BlockDamageEvent;
+import org.bukkit.event.block.BlockDispenseEvent;
 import org.bukkit.event.block.BlockFadeEvent;
 import org.bukkit.event.block.BlockFormEvent;
 import org.bukkit.event.block.BlockFromToEvent;
 import org.bukkit.event.block.BlockIgniteEvent;
+import org.bukkit.event.block.BlockIgniteEvent.IgniteCause;
 import org.bukkit.event.block.BlockPhysicsEvent;
-import org.bukkit.event.block.BlockPistonExtendEvent;
-import org.bukkit.event.block.BlockPistonRetractEvent;
 import org.bukkit.event.block.BlockPlaceEvent;
-import org.bukkit.event.block.BlockRedstoneEvent;
 import org.bukkit.event.block.BlockSpreadEvent;
 import org.bukkit.event.block.LeavesDecayEvent;
 import org.bukkit.event.block.SignChangeEvent;
-import org.bukkit.event.block.BlockIgniteEvent.IgniteCause;
-import org.bukkit.inventory.ItemStack;
-import com.sk89q.worldedit.Vector;
-import com.sk89q.worldedit.blocks.BlockType;
-import com.sk89q.worldedit.blocks.ItemType;
+
+import com.sk89q.rulelists.DefaultAttachments;
+import com.sk89q.rulelists.RuleSet;
 import com.sk89q.worldedit.blocks.BlockID;
-import com.sk89q.worldguard.LocalPlayer;
-import com.sk89q.worldguard.blacklist.events.BlockBreakBlacklistEvent;
-import com.sk89q.worldguard.blacklist.events.BlockPlaceBlacklistEvent;
-import com.sk89q.worldguard.blacklist.events.DestroyWithBlacklistEvent;
-import com.sk89q.worldguard.protection.ApplicableRegionSet;
-import com.sk89q.worldguard.protection.flags.DefaultFlag;
-import com.sk89q.worldguard.protection.managers.RegionManager;
 
 /**
  * The listener for block events.
- *
- * @author sk89q
  */
-public class WorldGuardBlockListener implements Listener {
+class WorldGuardBlockListener implements Listener {
 
     private WorldGuardPlugin plugin;
 
     /**
-     * Construct the object.
+     * Construct the listener.
      *
-     * @param plugin The plugin instance
+     * @param plugin WorldGuard plugin
      */
-    public WorldGuardBlockListener(WorldGuardPlugin plugin) {
+    WorldGuardBlockListener(WorldGuardPlugin plugin) {
         this.plugin = plugin;
     }
 
     /**
-     * Register events.
+     * Register the events.
      */
-    public void registerEvents() {
+    void registerEvents() {
         plugin.getServer().getPluginManager().registerEvents(this, plugin);
     }
 
-    /**
-     * Get the world configuration given a world.
-     *
-     * @param world The world to get the configuration for.
-     * @return The configuration for {@code world}
-     */
-    protected WorldConfiguration getWorldConfig(World world) {
-        return plugin.getGlobalStateManager().get(world);
-    }
-
-    /**
-     * Get the world configuration given a player.
-     *
-     * @param player The player to get the wold from
-     * @return The {@link WorldConfiguration} for the player's world
-     */
-    protected WorldConfiguration getWorldConfig(Player player) {
-        return getWorldConfig(player.getWorld());
-    }
-
-    /*
-     * Called when a block is damaged.
-     */
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onBlockDamage(BlockDamageEvent event) {
         Player player = event.getPlayer();
         Block blockDamaged = event.getBlock();
 
+        ConfigurationManager cfg = plugin.getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(event.getBlock().getWorld());
+
         // Cake are damaged and not broken when they are eaten, so we must
         // handle them a bit separately
         if (blockDamaged.getTypeId() == BlockID.CAKE_BLOCK) {
-            if (!plugin.getGlobalRegionManager().canBuild(player, blockDamaged)) {
-                player.sendMessage(ChatColor.DARK_RED + "You're not invited to this tea party!");
+            // RuleLists
+            RuleSet rules = wcfg.getRuleList().get(DefaultAttachments.BLOCK_INTERACT);
+            BukkitContext context = new BukkitContext(plugin, event);
+            context.setSourceEntity(player);
+            context.setTargetBlock(event.getBlock().getState());
+            if (rules.process(context)) {
                 event.setCancelled(true);
                 return;
             }
         }
     }
 
-    /*
-     * Called when a block is broken.
-     */
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onBlockBreak(BlockBreakEvent event) {
         Player player = event.getPlayer();
-        WorldConfiguration wcfg = getWorldConfig(player);
-
-        if (!wcfg.itemDurability) {
-            ItemStack held = player.getItemInHand();
-            if (held.getTypeId() > 0
-                    && !(ItemType.usesDamageValue(held.getTypeId())
-                    || BlockType.usesData(held.getTypeId()))) {
-                held.setDurability((short) -1);
-                player.setItemInHand(held);
-            }
-        }
-
-        if (!plugin.getGlobalRegionManager().canBuild(player, event.getBlock())
-         || !plugin.getGlobalRegionManager().canConstruct(player, event.getBlock())) {
-            player.sendMessage(ChatColor.DARK_RED + "You don't have permission for this area.");
-            event.setCancelled(true);
-            return;
-        }
-
-        if (wcfg.getBlacklist() != null) {
-            if (!wcfg.getBlacklist().check(
-                    new BlockBreakBlacklistEvent(plugin.wrapPlayer(player),
-                    toVector(event.getBlock()),
-                    event.getBlock().getTypeId()), false, false)) {
-                event.setCancelled(true);
-                return;
-            }
-
-            if (!wcfg.getBlacklist().check(
-                    new DestroyWithBlacklistEvent(plugin.wrapPlayer(player),
-                    toVector(event.getBlock()),
-                    player.getItemInHand().getTypeId()), false, false)) {
-                event.setCancelled(true);
-                return;
-            }
-        }
-
-        if (wcfg.isChestProtected(event.getBlock(), player)) {
-            player.sendMessage(ChatColor.DARK_RED + "The chest is protected.");
-            event.setCancelled(true);
-            return;
-        }
-    }
-
-    /*
-     * Called when fluids flow.
-     */
-    @EventHandler(ignoreCancelled = true)
-    public void onBlockFromTo(BlockFromToEvent event) {
-        World world = event.getBlock().getWorld();
-        Block blockFrom = event.getBlock();
-        Block blockTo = event.getToBlock();
-
-        boolean isWater = blockFrom.getTypeId() == 8 || blockFrom.getTypeId() == 9;
-        boolean isLava = blockFrom.getTypeId() == 10 || blockFrom.getTypeId() == 11;
-        boolean isAir = blockFrom.getTypeId() == 0;
+        Block block = event.getBlock();
 
         ConfigurationManager cfg = plugin.getGlobalStateManager();
         WorldConfiguration wcfg = cfg.get(event.getBlock().getWorld());
 
-        if (cfg.activityHaltToggle) {
+        // RuleLists
+        RuleSet rules = wcfg.getRuleList().get(DefaultAttachments.BLOCK_BREAK);
+        BukkitContext context = new BukkitContext(plugin, event);
+        context.setSourceEntity(player);
+        context.setTargetBlock(event.getBlock().getState());
+        if (rules.process(context)) {
             event.setCancelled(true);
             return;
         }
 
-        if (wcfg.simulateSponge && isWater) {
-            int ox = blockTo.getX();
-            int oy = blockTo.getY();
-            int oz = blockTo.getZ();
+        /* --- No short-circuit returns below this line --- */
 
-            for (int cx = -wcfg.spongeRadius; cx <= wcfg.spongeRadius; cx++) {
-                for (int cy = -wcfg.spongeRadius; cy <= wcfg.spongeRadius; cy++) {
-                    for (int cz = -wcfg.spongeRadius; cz <= wcfg.spongeRadius; cz++) {
-                        Block sponge = world.getBlockAt(ox + cx, oy + cy, oz + cz);
-                        if (sponge.getTypeId() == 19
-                                && (!wcfg.redstoneSponges || !sponge.isBlockIndirectlyPowered())) {
-                            event.setCancelled(true);
-                            return;
-                        }
-                    }
-                }
+        // Sponges
+        SpongeApplicator spongeAppl = wcfg.getSpongeApplicator();
+        if (spongeAppl != null && block.getType() == Material.SPONGE) {
+            if (spongeAppl.isActiveSponge(block)) {
+                spongeAppl.placeWater(block);
             }
         }
+    }
 
-        /*if (plugin.classicWater && isWater) {
-        int blockBelow = blockFrom.getRelative(0, -1, 0).getTypeId();
-        if (blockBelow != 0 && blockBelow != 8 && blockBelow != 9) {
-        blockFrom.setTypeId(9);
-        if (blockTo.getTypeId() == 0) {
-        blockTo.setTypeId(9);
-        }
-        return;
-        }
-        }*/
+    @EventHandler(ignoreCancelled = true)
+    public void onBlockFromTo(BlockFromToEvent event) {
+        Block blockFrom = event.getBlock();
+        Block blockTo = event.getToBlock();
 
-        // Check the fluid block (from) whether it is air.
-        // If so and the target block is protected, cancel the event
-        if (wcfg.preventWaterDamage.size() > 0) {
-            int targetId = blockTo.getTypeId();
+        boolean isWater = blockFrom.getTypeId() == 8 || blockFrom.getTypeId() == 9;
 
-            if ((isAir || isWater) &&
-                    wcfg.preventWaterDamage.contains(targetId)) {
+        ConfigurationManager cfg = plugin.getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(event.getBlock().getWorld());
+
+        // Sponges
+        SpongeApplicator spongeAppl = wcfg.getSpongeApplicator();
+        if (spongeAppl != null && isWater) {
+            if (spongeAppl.isNearSponge(blockTo)) {
                 event.setCancelled(true);
                 return;
             }
         }
 
-        if (wcfg.allowedLavaSpreadOver.size() > 0 && isLava) {
-            int targetId = blockTo.getRelative(0, -1, 0).getTypeId();
-
-            if (!wcfg.allowedLavaSpreadOver.contains(targetId)) {
-                event.setCancelled(true);
-                return;
-            }
-        }
-
-        if (wcfg.highFreqFlags && isWater
-                && !plugin.getGlobalRegionManager().allows(DefaultFlag.WATER_FLOW,
-                blockFrom.getLocation())) {
+        // RuleLists
+        RuleSet rules = wcfg.getRuleList().get(DefaultAttachments.BLOCK_SPREAD);
+        BukkitContext context = new BukkitContext(plugin, event);
+        context.setSourceBlock(event.getBlock().getState());
+        context.setTargetBlock(event.getToBlock().getState());
+        if (rules.process(context)) {
             event.setCancelled(true);
             return;
         }
-
-        if (wcfg.highFreqFlags && isLava
-                && !plugin.getGlobalRegionManager().allows(DefaultFlag.LAVA_FLOW,
-                blockFrom.getLocation())) {
-            event.setCancelled(true);
-            return;
-        }
-
-        if (wcfg.disableObsidianGenerators && (isAir || isLava)
-                && blockTo.getTypeId() == 55) {
-            blockTo.setTypeId(0);
-            return;
-        }
     }
 
-    /*
-     * Called when a block gets ignited.
-     */
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onBlockIgnite(BlockIgniteEvent event) {
         IgniteCause cause = event.getCause();
         Block block = event.getBlock();
         World world = block.getWorld();
+        boolean isFireSpread = cause == IgniteCause.SPREAD;
 
         ConfigurationManager cfg = plugin.getGlobalStateManager();
         WorldConfiguration wcfg = cfg.get(world);
 
-        if (cfg.activityHaltToggle) {
-            event.setCancelled(true);
-            return;
-        }
-        boolean isFireSpread = cause == IgniteCause.SPREAD;
-
-        if (wcfg.preventLightningFire && cause == IgniteCause.LIGHTNING) {
-            event.setCancelled(true);
-            return;
-        }
-
-        if (wcfg.preventLavaFire && cause == IgniteCause.LAVA) {
-            event.setCancelled(true);
-            return;
-        }
-
-        if (wcfg.disableFireSpread && isFireSpread) {
-            event.setCancelled(true);
-            return;
-        }
-
-        if (wcfg.blockLighter && (cause == IgniteCause.FLINT_AND_STEEL || cause == IgniteCause.FIREBALL)
-                && event.getPlayer() != null
-                && !plugin.hasPermission(event.getPlayer(), "worldguard.override.lighter")) {
-            event.setCancelled(true);
-            return;
-        }
-
+        // Fire stop toggle
         if (wcfg.fireSpreadDisableToggle && isFireSpread) {
             event.setCancelled(true);
             return;
         }
 
-        if (wcfg.disableFireSpreadBlocks.size() > 0 && isFireSpread) {
-            int x = block.getX();
-            int y = block.getY();
-            int z = block.getZ();
+        // RuleLists
+        RuleSet rules;
+        BukkitContext context;
+        BlockState placedState;
 
-            if (wcfg.disableFireSpreadBlocks.contains(world.getBlockTypeIdAt(x, y - 1, z))
-                    || wcfg.disableFireSpreadBlocks.contains(world.getBlockTypeIdAt(x + 1, y, z))
-                    || wcfg.disableFireSpreadBlocks.contains(world.getBlockTypeIdAt(x - 1, y, z))
-                    || wcfg.disableFireSpreadBlocks.contains(world.getBlockTypeIdAt(x, y, z - 1))
-                    || wcfg.disableFireSpreadBlocks.contains(world.getBlockTypeIdAt(x, y, z + 1))) {
+        switch (event.getCause()) {
+        case FLINT_AND_STEEL:
+            // Consider flint and steel as an item use
+            rules = wcfg.getRuleList().get(DefaultAttachments.ITEM_USE);
+            context = new BukkitContext(plugin, event);
+            context.setSourceEntity(event.getPlayer());
+            context.setTargetBlock(event.getBlock().getState());
+            context.setItem(event.getPlayer().getItemInHand()); // Should be flint and steel
+
+            // Make a virtual new state
+            placedState = event.getBlock().getState();
+            placedState.setType(Material.FIRE);
+            context.setPlacedBlock(placedState);
+
+            if (rules.process(context)) {
                 event.setCancelled(true);
                 return;
             }
-        }
+            break;
+        case LAVA:
+        case SPREAD:
+            // Consider everything else as a block spread
+            rules = wcfg.getRuleList().get(DefaultAttachments.BLOCK_SPREAD);
+            context = new BukkitContext(plugin, event);
+            context.setTargetBlock(event.getBlock().getState());
 
-        if (wcfg.useRegions) {
-            Vector pt = toVector(block);
-            Player player = event.getPlayer();
-            RegionManager mgr = plugin.getGlobalRegionManager().get(world);
-            ApplicableRegionSet set = mgr.getApplicableRegions(pt);
+            // Make a virtual source state
+            BlockState sourceState = event.getBlock().getState();
+            sourceState.setType(event.getCause() == IgniteCause.LAVA ? Material.LAVA : Material.FIRE);
+            context.setSourceBlock(sourceState);
 
-            if (player != null && !plugin.getGlobalRegionManager().hasBypass(player, world)) {
-                LocalPlayer localPlayer = plugin.wrapPlayer(player);
+            // Make a virtual new state
+            placedState = event.getBlock().getState();
+            placedState.setType(Material.FIRE);
+            context.setPlacedBlock(placedState);
 
-                if (cause == IgniteCause.FLINT_AND_STEEL || cause == IgniteCause.FIREBALL) {
-                    if (!set.canBuild(localPlayer)) {
-                        event.setCancelled(true);
-                        return;
-                    }
-                    if (!set.allows(DefaultFlag.LIGHTER, localPlayer)
-                            && !plugin.hasPermission(player, "worldguard.override.lighter")) {
-                        event.setCancelled(true);
-                        return;
-                    }
-                }
-            }
-
-            if (wcfg.highFreqFlags && isFireSpread
-                    && !set.allows(DefaultFlag.FIRE_SPREAD)) {
+            if (rules.process(context)) {
                 event.setCancelled(true);
                 return;
             }
+            break;
+        case FIREBALL:
+        case LIGHTNING:
+            // Consider everything else as a block spread
+            rules = wcfg.getRuleList().get(DefaultAttachments.BLOCK_PLACE);
+            context = new BukkitContext(plugin, event);
+            context.setTargetBlock(event.getBlock().getState());
 
-            if (wcfg.highFreqFlags && cause == IgniteCause.LAVA
-                    && !set.allows(DefaultFlag.LAVA_FIRE)) {
-                event.setCancelled(true);
-                return;
-            }
-
-            if (cause == IgniteCause.LIGHTNING && !set.allows(DefaultFlag.LIGHTNING)) {
+            // Make a virtual new state
+            placedState = event.getBlock().getState();
+            placedState.setType(Material.FIRE);
+            context.setPlacedBlock(placedState);
+
+            if (rules.process(context)) {
                 event.setCancelled(true);
                 return;
             }
+            break;
         }
     }
 
-    /*
-     * Called when a block is destroyed from burning.
-     */
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onBlockBurn(BlockBurnEvent event) {
         ConfigurationManager cfg = plugin.getGlobalStateManager();
         WorldConfiguration wcfg = cfg.get(event.getBlock().getWorld());
 
-        if (cfg.activityHaltToggle) {
-            event.setCancelled(true);
-            return;
-        }
-
-        if (wcfg.disableFireSpread) {
-            event.setCancelled(true);
-            return;
-        }
-
+        // Fire stop toggle
         if (wcfg.fireSpreadDisableToggle) {
             Block block = event.getBlock();
             event.setCancelled(true);
-            checkAndDestroyAround(block.getWorld(), block.getX(), block.getY(), block.getZ(), BlockID.FIRE);
+            BukkitUtil.checkAndDestroyAround(block.getWorld(), block.getX(),
+                    block.getY(), block.getZ(), BlockID.FIRE);
             return;
         }
 
-        if (wcfg.disableFireSpreadBlocks.size() > 0) {
-            Block block = event.getBlock();
-
-            if (wcfg.disableFireSpreadBlocks.contains(block.getTypeId())) {
-                event.setCancelled(true);
-                checkAndDestroyAround(block.getWorld(), block.getX(), block.getY(), block.getZ(), BlockID.FIRE);
-                return;
-            }
-        }
-
-        if (wcfg.isChestProtected(event.getBlock())) {
+        // RuleLists
+        RuleSet rules = wcfg.getRuleList().get(DefaultAttachments.BLOCK_BREAK);
+        BukkitContext context = new BukkitContext(plugin, event);
+        BlockState virtualFireState = event.getBlock().getState();
+        virtualFireState.setType(Material.FIRE);
+        context.setSourceBlock(virtualFireState);
+        context.setTargetBlock(event.getBlock().getState());
+        if (rules.process(context)) {
             event.setCancelled(true);
             return;
         }
-
-        if (wcfg.useRegions) {
-            Block block = event.getBlock();
-            int x = block.getX();
-            int y = block.getY();
-            int z = block.getZ();
-            Vector pt = toVector(block);
-            RegionManager mgr = plugin.getGlobalRegionManager().get(block.getWorld());
-            ApplicableRegionSet set = mgr.getApplicableRegions(pt);
-
-            if (!set.allows(DefaultFlag.FIRE_SPREAD)) {
-                checkAndDestroyAround(block.getWorld(), x, y, z, BlockID.FIRE);
-                event.setCancelled(true);
-                return;
-            }
-
-        }
     }
 
-    private void checkAndDestroyAround(World world, int x, int y, int z, int required) {
-        checkAndDestroy(world, x, y, z + 1, required);
-        checkAndDestroy(world, x, y, z - 1, required);
-        checkAndDestroy(world, x, y + 1, z, required);
-        checkAndDestroy(world, x, y - 1, z, required);
-        checkAndDestroy(world, x + 1, y, z, required);
-        checkAndDestroy(world, x - 1, y, z, required);
-    }
-
-    private void checkAndDestroy(World world, int x, int y, int z, int required) {
-        if (world.getBlockTypeIdAt(x, y, z) == required) {
-            world.getBlockAt(x, y, z).setTypeId(BlockID.AIR);
-        }
-    }
-
-    /*
-     * Called when block physics occurs.
-     */
     @EventHandler(ignoreCancelled = true)
     public void onBlockPhysics(BlockPhysicsEvent event) {
+        Block block = event.getBlock();
+
         ConfigurationManager cfg = plugin.getGlobalStateManager();
         WorldConfiguration wcfg = cfg.get(event.getBlock().getWorld());
 
-        if (cfg.activityHaltToggle) {
+        // RuleLists
+        RuleSet rules = wcfg.getRuleList().get(DefaultAttachments.BLOCK_PHYSICS);
+        BukkitContext context = new BukkitContext(plugin, event);
+        context.setTargetBlock(event.getBlock().getState());
+        if (rules.process(context)) {
             event.setCancelled(true);
             return;
         }
 
-        int id = event.getChangedTypeId();
+        /* --- No short-circuit returns below this line --- */
 
-        if (id == 13 && wcfg.noPhysicsGravel) {
-            event.setCancelled(true);
-            return;
-        }
-
-        if (id == 12 && wcfg.noPhysicsSand) {
-            event.setCancelled(true);
-            return;
-        }
-
-        if (id == 90 && wcfg.allowPortalAnywhere) {
-            event.setCancelled(true);
-            return;
+        // Sponges
+        SpongeApplicator spongeAppl = wcfg.getSpongeApplicator();
+        if (spongeAppl != null && block.getType() == Material.SPONGE) {
+            if (spongeAppl.isActiveSponge(block)) {
+                spongeAppl.placeWater(block);
+            } else {
+                spongeAppl.clearWater(block);
+            }
         }
     }
 
-    /*
-     * Called when a player places a block.
-     */
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onBlockPlace(BlockPlaceEvent event) {
         Block blockPlaced = event.getBlock();
-        Player player = event.getPlayer();
         World world = blockPlaced.getWorld();
 
         ConfigurationManager cfg = plugin.getGlobalStateManager();
         WorldConfiguration wcfg = cfg.get(world);
 
-        if (wcfg.useRegions) {
-            final Location location = blockPlaced.getLocation();
-            if (!plugin.getGlobalRegionManager().canBuild(player, location)
-             || !plugin.getGlobalRegionManager().canConstruct(player, location)) {
-                player.sendMessage(ChatColor.DARK_RED + "You don't have permission for this area.");
-                event.setCancelled(true);
-                return;
-            }
+        // Sponges
+        SpongeApplicator spongeAppl = wcfg.getSpongeApplicator();
+        if (spongeAppl != null && spongeAppl.isActiveSponge(blockPlaced)) {
+            spongeAppl.clearWater(blockPlaced);
         }
 
-        if (wcfg.getBlacklist() != null) {
-            if (!wcfg.getBlacklist().check(
-                    new BlockPlaceBlacklistEvent(plugin.wrapPlayer(player), toVector(blockPlaced),
-                    blockPlaced.getTypeId()), false, false)) {
-                event.setCancelled(true);
-                return;
-            }
-        }
-
-        if (wcfg.signChestProtection && wcfg.getChestProtection().isChest(blockPlaced.getTypeId())) {
-            if (wcfg.isAdjacentChestProtected(event.getBlock(), player)) {
-                player.sendMessage(ChatColor.DARK_RED + "This spot is for a chest that you don't have permission for.");
-                event.setCancelled(true);
-                return;
-            }
-        }
-
-        if (wcfg.simulateSponge && blockPlaced.getTypeId() == 19) {
-            if (wcfg.redstoneSponges && blockPlaced.isBlockIndirectlyPowered()) {
-                return;
-            }
-
-            int ox = blockPlaced.getX();
-            int oy = blockPlaced.getY();
-            int oz = blockPlaced.getZ();
-
-            SpongeUtil.clearSpongeWater(plugin, world, ox, oy, oz);
-        }
-    }
-
-    /*
-     * Called when redstone changes.
-     */
-    @EventHandler(priority = EventPriority.HIGH)
-    public void onBlockRedstoneChange(BlockRedstoneEvent event) {
-        Block blockTo = event.getBlock();
-        World world = blockTo.getWorld();
-
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(world);
-
-        if (wcfg.simulateSponge && wcfg.redstoneSponges) {
-            int ox = blockTo.getX();
-            int oy = blockTo.getY();
-            int oz = blockTo.getZ();
-
-            for (int cx = -1; cx <= 1; cx++) {
-                for (int cy = -1; cy <= 1; cy++) {
-                    for (int cz = -1; cz <= 1; cz++) {
-                        Block sponge = world.getBlockAt(ox + cx, oy + cy, oz + cz);
-                        if (sponge.getTypeId() == 19
-                                && sponge.isBlockIndirectlyPowered()) {
-                            SpongeUtil.clearSpongeWater(plugin, world, ox + cx, oy + cy, oz + cz);
-                        } else if (sponge.getTypeId() == 19
-                                && !sponge.isBlockIndirectlyPowered()) {
-                            SpongeUtil.addSpongeWater(plugin, world, ox + cx, oy + cy, oz + cz);
-                        }
-                    }
-                }
-            }
-
+        // RuleLists
+        RuleSet rules = wcfg.getRuleList().get(DefaultAttachments.BLOCK_PLACE);
+        BukkitContext context = new BukkitContext(plugin, event);
+        context.setSourceEntity(event.getPlayer());
+        context.setTargetBlock(event.getBlock().getState());
+        context.setPlacedBlock(event.getBlockReplacedState());
+        if (rules.process(context)) {
+            event.setCancelled(true);
             return;
         }
     }
 
-    /*
-     * Called when a sign is changed.
-     */
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onSignChange(SignChangeEvent event) {
         Player player = event.getPlayer();
-        WorldConfiguration wcfg = getWorldConfig(player);
 
+        ConfigurationManager cfg = plugin.getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(player.getWorld());
+
+        // RuleLists
+        RuleSet rules = wcfg.getRuleList().get(DefaultAttachments.BLOCK_INTERACT);
+        BukkitContext context = new BukkitContext(plugin, event);
+        context.setTargetBlock(event.getBlock().getState());
+        if (rules.process(context)) {
+            event.setCancelled(true);
+            return;
+        }
+
+        // Chest protection
         if (wcfg.signChestProtection) {
             if (event.getLine(0).equalsIgnoreCase("[Lock]")) {
-                if (wcfg.isChestProtectedPlacement(event.getBlock(), player)) {
-                    player.sendMessage(ChatColor.DARK_RED + "You do not own the adjacent chest.");
-                    event.getBlock().breakNaturally();
-                    event.setCancelled(true);
-                    return;
-                }
-
                 if (event.getBlock().getTypeId() != BlockID.SIGN_POST) {
                     player.sendMessage(ChatColor.RED
                             + "The [Lock] sign must be a sign post, not a wall sign.");
@@ -617,12 +379,6 @@ public class WorldGuardBlockListener implements Listener {
                 return;
             }
         }
-
-        if (!plugin.getGlobalRegionManager().canBuild(player, event.getBlock())) {
-            player.sendMessage(ChatColor.DARK_RED + "You don't have permission for this area.");
-            event.setCancelled(true);
-            return;
-        }
     }
 
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
@@ -630,176 +386,78 @@ public class WorldGuardBlockListener implements Listener {
         ConfigurationManager cfg = plugin.getGlobalStateManager();
         WorldConfiguration wcfg = cfg.get(event.getBlock().getWorld());
 
-        if (cfg.activityHaltToggle) {
+        // RuleLists
+        RuleSet rules = wcfg.getRuleList().get(DefaultAttachments.BLOCK_FADE);
+        BukkitContext context = new BukkitContext(plugin, event);
+        context.setTargetBlock(event.getBlock().getState());
+        if (rules.process(context)) {
             event.setCancelled(true);
             return;
         }
-
-        if (wcfg.disableLeafDecay) {
-            event.setCancelled(true);
-            return;
-        }
-
-        if (wcfg.useRegions) {
-            if (!plugin.getGlobalRegionManager().allows(DefaultFlag.LEAF_DECAY,
-                    event.getBlock().getLocation())) {
-                event.setCancelled(true);
-            }
-        }
     }
 
-    /*
-     * Called when a block is formed based on world conditions.
-     */
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onBlockForm(BlockFormEvent event) {
         ConfigurationManager cfg = plugin.getGlobalStateManager();
         WorldConfiguration wcfg = cfg.get(event.getBlock().getWorld());
 
-        if (cfg.activityHaltToggle) {
+        // RuleLists
+        RuleSet rules = wcfg.getRuleList().get(DefaultAttachments.BLOCK_FORM);
+        BukkitContext context = new BukkitContext(plugin, event);
+        context.setTargetBlock(event.getBlock().getState());
+        context.setPlacedBlock(event.getNewState());
+        if (rules.process(context)) {
             event.setCancelled(true);
             return;
         }
-
-        int type = event.getNewState().getTypeId();
-
-        if (type == BlockID.ICE) {
-            if (wcfg.disableIceFormation) {
-                event.setCancelled(true);
-                return;
-            }
-            if (wcfg.useRegions && !plugin.getGlobalRegionManager().allows(
-                    DefaultFlag.ICE_FORM, event.getBlock().getLocation())) {
-                event.setCancelled(true);
-                return;
-            }
-        }
-
-        if (type == BlockID.SNOW) {
-            if (wcfg.disableSnowFormation) {
-                event.setCancelled(true);
-                return;
-            }
-            if (wcfg.useRegions && !plugin.getGlobalRegionManager().allows(
-                    DefaultFlag.SNOW_FALL, event.getBlock().getLocation())) {
-                event.setCancelled(true);
-                return;
-            }
-        }
     }
 
-    /*
-     * Called when a block spreads based on world conditions.
-     */
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onBlockSpread(BlockSpreadEvent event) {
         ConfigurationManager cfg = plugin.getGlobalStateManager();
         WorldConfiguration wcfg = cfg.get(event.getBlock().getWorld());
 
-        if (cfg.activityHaltToggle) {
+        // RuleLists
+        RuleSet rules = wcfg.getRuleList().get(DefaultAttachments.BLOCK_SPREAD);
+        BukkitContext context = new BukkitContext(plugin, event);
+        context.setSourceBlock(event.getSource().getState());
+        context.setTargetBlock(event.getBlock().getState());
+        context.setPlacedBlock(event.getNewState());
+        if (rules.process(context)) {
             event.setCancelled(true);
             return;
         }
-
-        int fromType = event.getSource().getTypeId();
-
-        if (fromType == BlockID.RED_MUSHROOM || fromType == BlockID.BROWN_MUSHROOM) {
-            if (wcfg.disableMushroomSpread) {
-                event.setCancelled(true);
-                return;
-            }
-            if (wcfg.useRegions && !plugin.getGlobalRegionManager().allows(
-                    DefaultFlag.MUSHROOMS, event.getBlock().getLocation())) {
-                event.setCancelled(true);
-                return;
-            }
-        }
-
-        if (fromType == BlockID.GRASS) {
-            if (wcfg.disableGrassGrowth) {
-                event.setCancelled(true);
-                return;
-            }
-            if (wcfg.useRegions && !plugin.getGlobalRegionManager().allows(
-                    DefaultFlag.GRASS_SPREAD, event.getBlock().getLocation())) {
-                event.setCancelled(true);
-                return;
-            }
-        }
     }
 
-    /*
-     * Called when a block fades.
-     */
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onBlockFade(BlockFadeEvent event) {
-
         ConfigurationManager cfg = plugin.getGlobalStateManager();
         WorldConfiguration wcfg = cfg.get(event.getBlock().getWorld());
 
-        int type = event.getBlock().getTypeId();
-
-        if (type == BlockID.ICE) {
-            if (wcfg.disableIceMelting) {
-                event.setCancelled(true);
-                return;
-            }
-            if (wcfg.useRegions && !plugin.getGlobalRegionManager().allows(
-                    DefaultFlag.ICE_MELT, event.getBlock().getLocation())) {
-                event.setCancelled(true);
-                return;
-            }
-        }
-
-        if (type == BlockID.SNOW) {
-            if (wcfg.disableSnowMelting) {
-                event.setCancelled(true);
-                return;
-            }
-            if (wcfg.useRegions && !plugin.getGlobalRegionManager().allows(
-                    DefaultFlag.SNOW_MELT, event.getBlock().getLocation())) {
-                event.setCancelled(true);
-                return;
-            }
+        // RuleLists
+        RuleSet rules = wcfg.getRuleList().get(DefaultAttachments.BLOCK_FADE);
+        BukkitContext context = new BukkitContext(plugin, event);
+        context.setTargetBlock(event.getBlock().getState());
+        context.setPlacedBlock(event.getNewState());
+        if (rules.process(context)) {
+            event.setCancelled(true);
+            return;
         }
     }
 
-    /*
-     * Called when a piston extends
-     */
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
-    public void onBlockPistonExtend(BlockPistonExtendEvent event) {
+    public void onBlockDispense(BlockDispenseEvent event) {
         ConfigurationManager cfg = plugin.getGlobalStateManager();
         WorldConfiguration wcfg = cfg.get(event.getBlock().getWorld());
 
-        if (wcfg.useRegions) {
-            if (!plugin.getGlobalRegionManager().allows(DefaultFlag.PISTONS, event.getBlock().getLocation())) {
-                event.setCancelled(true);
-                return;
-            }
-            for (Block block : event.getBlocks()) {
-                if (!plugin.getGlobalRegionManager().allows(DefaultFlag.PISTONS, block.getLocation())) {
-                    event.setCancelled(true);
-                    return;
-                }
-            }
-        }
-    }
-
-    /*
-     * Called when a piston retracts
-     */
-    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
-    public void onBlockPistonRetract(BlockPistonRetractEvent event) {
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(event.getBlock().getWorld());
-
-        if (wcfg.useRegions && event.isSticky()) {
-            if (!(plugin.getGlobalRegionManager().allows(DefaultFlag.PISTONS, event.getRetractLocation()))
-                    || !(plugin.getGlobalRegionManager().allows(DefaultFlag.PISTONS, event.getBlock().getLocation()))) {
-                event.setCancelled(true);
-                return;
-            }
+        // RuleLists
+        RuleSet rules = wcfg.getRuleList().get(DefaultAttachments.ITEM_DROP);
+        BukkitContext context = new BukkitContext(plugin, event);
+        context.setSourceBlock(event.getBlock().getState());
+        context.setItem(event.getItem());
+        if (rules.process(context)) {
+            event.setCancelled(true);
+            return;
         }
     }
 }

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

@@ -1,75 +0,0 @@
-/*
- * 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/WorldGuardEntityListener.java

@@ -18,29 +18,15 @@
  */
 package com.sk89q.worldguard.bukkit;
 
-import static com.sk89q.worldguard.bukkit.BukkitUtil.toVector;
-
-import java.util.Set;
-
-import org.bukkit.ChatColor;
+import java.util.Iterator;
 import org.bukkit.Location;
 import org.bukkit.Material;
 import org.bukkit.World;
 import org.bukkit.block.Block;
-import org.bukkit.entity.Creature;
-import org.bukkit.entity.Creeper;
-import org.bukkit.entity.EnderDragon;
-import org.bukkit.entity.EnderPearl;
-import org.bukkit.entity.Enderman;
+import org.bukkit.block.BlockState;
 import org.bukkit.entity.Entity;
-import org.bukkit.entity.EntityType;
-import org.bukkit.entity.Fireball;
 import org.bukkit.entity.LivingEntity;
 import org.bukkit.entity.Player;
-import org.bukkit.entity.Projectile;
-import org.bukkit.entity.TNTPrimed;
-import org.bukkit.entity.Tameable;
-import org.bukkit.entity.Wolf;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
 import org.bukkit.event.Listener;
@@ -51,411 +37,121 @@ import org.bukkit.event.entity.EntityCombustEvent;
 import org.bukkit.event.entity.EntityDamageByBlockEvent;
 import org.bukkit.event.entity.EntityDamageByEntityEvent;
 import org.bukkit.event.entity.EntityDamageEvent;
-import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+import org.bukkit.event.entity.PlayerDeathEvent;
 import org.bukkit.event.entity.EntityDeathEvent;
 import org.bukkit.event.entity.EntityExplodeEvent;
 import org.bukkit.event.entity.EntityInteractEvent;
-import org.bukkit.event.entity.EntityRegainHealthEvent;
 import org.bukkit.event.entity.ExplosionPrimeEvent;
-import org.bukkit.event.entity.FoodLevelChangeEvent;
 import org.bukkit.event.entity.PigZapEvent;
-import org.bukkit.event.entity.PlayerDeathEvent;
 import org.bukkit.event.entity.PotionSplashEvent;
-import org.bukkit.inventory.ItemStack;
-
-import com.sk89q.worldedit.Vector;
-import com.sk89q.worldedit.blocks.BlockID;
-import com.sk89q.worldguard.LocalPlayer;
-import com.sk89q.worldguard.blacklist.events.ItemUseBlacklistEvent;
-import com.sk89q.worldguard.protection.ApplicableRegionSet;
-import com.sk89q.worldguard.protection.GlobalRegionManager;
-import com.sk89q.worldguard.protection.events.DisallowedPVPEvent;
-import com.sk89q.worldguard.protection.flags.DefaultFlag;
-import com.sk89q.worldguard.protection.managers.RegionManager;
+import com.sk89q.rulelists.DefaultAttachments;
+import com.sk89q.rulelists.RuleSet;
+import com.sk89q.worldguard.region.RegionManager;
+import com.sk89q.worldguard.region.flags.DefaultFlag;
 
 /**
- * Listener for entity related events.
- *
- * @author sk89q
+ * The listener for entity events.
  */
-public class WorldGuardEntityListener implements Listener {
+class WorldGuardEntityListener implements Listener {
 
     private WorldGuardPlugin plugin;
-    private EntityType fireballType;
-    private EntityType witherType;
-    private EntityType witherSkullType;
 
     /**
-     * Construct the object;
+     * Construct the listener.
      *
-     * @param plugin The plugin instance
+     * @param plugin WorldGuard plugin
      */
-    public WorldGuardEntityListener(WorldGuardPlugin plugin) {
+    WorldGuardEntityListener(WorldGuardPlugin plugin) {
         this.plugin = plugin;
-
-        fireballType = BukkitUtil.tryEnum(EntityType.class, "LARGE_FIREBALL", "FIREBALL");
-        witherType = BukkitUtil.tryEnum(EntityType.class, "WITHER");
-        witherSkullType = BukkitUtil.tryEnum(EntityType.class, "WITHER_SKULL");
     }
 
     /**
-     * Register events.
+     * Register the events.
      */
-    public void registerEvents() {
+    void registerEvents() {
         plugin.getServer().getPluginManager().registerEvents(this, plugin);
     }
 
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onEntityInteract(EntityInteractEvent event) {
-        Entity entity = event.getEntity();
-        Block block = event.getBlock();
-
         ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(entity.getWorld());
+        WorldConfiguration wcfg = cfg.get(event.getEntity().getWorld());
 
-        if (block.getTypeId() == BlockID.SOIL) {
-            if (entity instanceof Creature && wcfg.disableCreatureCropTrampling) {
-                event.setCancelled(true);
-            }
+        // RuleLists
+        RuleSet rules = wcfg.getRuleList().get(DefaultAttachments.BLOCK_INTERACT);
+        BukkitContext context = new BukkitContext(plugin, event);
+        context.setSourceEntity(event.getEntity());
+        context.setTargetBlock(event.getBlock().getState());
+        if (rules.process(context)) {
+            event.setCancelled(true);
+            return;
         }
     }
 
     @EventHandler(priority = EventPriority.HIGH)
     public void onEntityDeath(EntityDeathEvent event) {
-        WorldConfiguration wcfg = plugin.getGlobalStateManager().get(event.getEntity().getWorld());
-
-        if (wcfg.disableExpDrops || !plugin.getGlobalRegionManager().allows(DefaultFlag.EXP_DROPS,
-                event.getEntity().getLocation())) {
-            event.setDroppedExp(0);
-        }
-
-        if (event instanceof PlayerDeathEvent && wcfg.disableDeathMessages) {
-            ((PlayerDeathEvent) event).setDeathMessage("");
-        }
-    }
-
-    private void onEntityDamageByBlock(EntityDamageByBlockEvent event) {
-        Entity defender = event.getEntity();
-        DamageCause type = event.getCause();
-
         ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(defender.getWorld());
+        WorldConfiguration wcfg = cfg.get(event.getEntity().getWorld());
 
-        if (defender instanceof Wolf && ((Wolf) defender).isTamed()) {
-            if (wcfg.antiWolfDumbness && !(type == DamageCause.VOID)) {
-                event.setCancelled(true);
-                return;
-            }
-        } else if (defender instanceof Player) {
-            Player player = (Player) defender;
+        /* --- No short-circuit returns below this line --- */
 
-            if (isInvincible(player)) {
-                event.setCancelled(true);
-                return;
-            }
+        // RuleLists
+        RuleSet rules = wcfg.getRuleList().get(DefaultAttachments.ENTITY_DEATH);
+        BukkitContext context = new BukkitContext(plugin, event);
+        context.setTargetEntity(event.getEntity());
 
-            if (wcfg.disableLavaDamage && type == DamageCause.LAVA) {
-                event.setCancelled(true);
-                player.setFireTicks(0);
-                return;
-            }
-
-            if (wcfg.disableContactDamage && type == DamageCause.CONTACT) {
-                event.setCancelled(true);
-                return;
-            }
-
-            if (wcfg.teleportOnVoid && type == DamageCause.VOID) {
-                BukkitUtil.findFreePosition(player);
-                event.setCancelled(true);
-                return;
-            }
-
-            if (wcfg.disableVoidDamage && type == DamageCause.VOID) {
-                event.setCancelled(true);
-                return;
-            }
-
-            if (wcfg.disableExplosionDamage && type == DamageCause.BLOCK_EXPLOSION) {
-                event.setCancelled(true);
-                return;
-            }
-        }
-    }
-
-    private void onEntityDamageByEntity(EntityDamageByEntityEvent event) {
-
-        if (event.getDamager() instanceof Projectile) {
-            onEntityDamageByProjectile(event);
-            return;
+        // Set a message if it's a death from a player
+        if (event instanceof PlayerDeathEvent) {
+            context.setMessage(((PlayerDeathEvent) event).getDeathMessage());
         }
 
-        Entity attacker = event.getDamager();
-        Entity defender = event.getEntity();
+        rules.process(context);
 
-        if (attacker instanceof Player) {
-            Player player = (Player) attacker;
-
-            ConfigurationManager cfg = plugin.getGlobalStateManager();
-            WorldConfiguration wcfg = cfg.get(player.getWorld());
-
-            ItemStack held = player.getInventory().getItemInHand();
-
-            if (held != null) {
-                if (wcfg.getBlacklist() != null) {
-                    if (!wcfg.getBlacklist().check(
-                            new ItemUseBlacklistEvent(plugin.wrapPlayer(player),
-                                    toVector(player.getLocation()), held.getTypeId()), false, false)) {
-                        event.setCancelled(true);
-                        return;
-                    }
-                }
-            }
+        // Set the message back
+        if (event instanceof PlayerDeathEvent) {
+            ((PlayerDeathEvent) event).setDeathMessage(context.getMessage());
         }
-
-        if (defender instanceof Player) {
-            Player player = (Player) defender;
-            LocalPlayer localPlayer = plugin.wrapPlayer(player);
-
-            ConfigurationManager cfg = plugin.getGlobalStateManager();
-            WorldConfiguration wcfg = cfg.get(player.getWorld());
-
-            if (isInvincible(player)) {
-                if (wcfg.regionInvinciblityRemovesMobs
-                        && attacker instanceof LivingEntity && !(attacker instanceof Player)
-                        && !(attacker instanceof Tameable && ((Tameable) attacker).isTamed())) {
-                    attacker.remove();
-                }
-
-                event.setCancelled(true);
-                return;
-            }
-
-            if (wcfg.disableLightningDamage && event.getCause() == DamageCause.LIGHTNING) {
-                event.setCancelled(true);
-                return;
-            }
-
-            if (wcfg.disableExplosionDamage && event.getCause() == DamageCause.ENTITY_EXPLOSION) {
-                event.setCancelled(true);
-                return;
-            }
-
-            if (attacker != null && attacker instanceof Player) {
-                if (wcfg.useRegions) {
-                    Vector pt = toVector(defender.getLocation());
-                    Vector pt2 = toVector(attacker.getLocation());
-                    RegionManager mgr = plugin.getGlobalRegionManager().get(player.getWorld());
-
-                    if (!mgr.getApplicableRegions(pt2).allows(DefaultFlag.PVP, plugin.wrapPlayer((Player) attacker))) {
-                        tryCancelPVPEvent((Player) attacker, player, event, true);
-                    } else if (!mgr.getApplicableRegions(pt).allows(DefaultFlag.PVP ,localPlayer)) {
-                        tryCancelPVPEvent((Player) attacker, player, event, false);
-                    }
-                }
-            }
-
-            if (attacker != null && attacker instanceof TNTPrimed) {
-                if (wcfg.blockTNTExplosions) {
-                    event.setCancelled(true);
-                    return;
-                }
-                if (wcfg.useRegions) {
-                    Vector pt = toVector(defender.getLocation());
-                    RegionManager mgr = plugin.getGlobalRegionManager().get(player.getWorld());
-                    ApplicableRegionSet set = mgr.getApplicableRegions(pt);
-                    if (!set.allows(DefaultFlag.TNT, localPlayer)) {
-                        event.setCancelled(true);
-                        return;
-                    }
-                }
-            }
-
-            if (attacker != null && attacker instanceof Fireball) {
-                if (wcfg.blockFireballExplosions) {
-                    event.setCancelled(true);
-                    return;
-                }
-                if (wcfg.useRegions) {
-                    Fireball fireball = (Fireball) attacker;
-                    Vector pt = toVector(defender.getLocation());
-                    RegionManager mgr = plugin.getGlobalRegionManager().get(player.getWorld());
-                    ApplicableRegionSet set = mgr.getApplicableRegions(pt);
-                    if (fireball.getShooter() instanceof Player) {
-                        Vector pt2 = toVector(fireball.getShooter().getLocation());
-                        if (!mgr.getApplicableRegions(pt2).allows(DefaultFlag.PVP, plugin.wrapPlayer((Player) fireball.getShooter()))) {
-                            tryCancelPVPEvent((Player) fireball.getShooter(), player, event, true);
-                        } else if (!set.allows(DefaultFlag.PVP, localPlayer)) {
-                            tryCancelPVPEvent((Player) fireball.getShooter(), player, event, false);
-                        }
-                    } else {
-                        if (!set.allows(DefaultFlag.GHAST_FIREBALL, localPlayer)) {
-                            event.setCancelled(true);
-                            return;
-                        }
-                    }
-
-                }
-            }
-
-            if (attacker != null && attacker instanceof LivingEntity && !(attacker instanceof Player)) {
-                if (attacker instanceof Creeper && wcfg.blockCreeperExplosions) {
-                    event.setCancelled(true);
-                    return;
-                }
-
-                if (wcfg.disableMobDamage) {
-                    event.setCancelled(true);
-                    return;
-                }
-
-                if (wcfg.useRegions) {
-                    Vector pt = toVector(defender.getLocation());
-                    RegionManager mgr = plugin.getGlobalRegionManager().get(player.getWorld());
-                    ApplicableRegionSet set = mgr.getApplicableRegions(pt);
-
-                    if (!set.allows(DefaultFlag.MOB_DAMAGE, localPlayer)) {
-                        event.setCancelled(true);
-                        return;
-                    }
-
-                    if (attacker instanceof Creeper) {
-                        if (!set.allows(DefaultFlag.CREEPER_EXPLOSION, localPlayer)) {
-                            event.setCancelled(true);
-                            return;
-                        }
-                    }
-                }
-
-            }
-        }
-    }
-
-    private void onEntityDamageByProjectile(EntityDamageByEntityEvent event) {
-        Entity defender = event.getEntity();
-        Entity attacker = ((Projectile) event.getDamager()).getShooter();
-
-        if (defender instanceof Player) {
-            Player player = (Player) defender;
-            LocalPlayer localPlayer = plugin.wrapPlayer(player);
-
-            ConfigurationManager cfg = plugin.getGlobalStateManager();
-            WorldConfiguration wcfg = cfg.get(player.getWorld());
-
-            // Check Invincible
-            if (isInvincible(player)) {
-                event.setCancelled(true);
-                return;
-            }
-
-            // Check Mob
-            if (attacker != null && attacker instanceof LivingEntity && !(attacker instanceof Player)) {
-                if (wcfg.disableMobDamage) {
-                    event.setCancelled(true);
-                    return;
-                }
-                if (wcfg.useRegions) {
-                    Vector pt = toVector(defender.getLocation());
-                    RegionManager mgr = plugin.getGlobalRegionManager().get(player.getWorld());
-
-                    if (!mgr.getApplicableRegions(pt).allows(DefaultFlag.MOB_DAMAGE, localPlayer)) {
-                        event.setCancelled(true);
-                        return;
-                    }
-                }
-            }
-
-            // Check Player
-            if (event.getDamager() instanceof EnderPearl) return;
-            if (attacker != null && attacker instanceof Player) {
-                if (wcfg.useRegions) {
-                    Vector pt = toVector(defender.getLocation());
-                    Vector pt2 = toVector(attacker.getLocation());
-                    RegionManager mgr = plugin.getGlobalRegionManager().get(player.getWorld());
-
-                    if (!mgr.getApplicableRegions(pt2).allows(DefaultFlag.PVP, plugin.wrapPlayer((Player) attacker))) {
-                        tryCancelPVPEvent((Player) attacker, player, event, true);
-                    } else if (!mgr.getApplicableRegions(pt).allows(DefaultFlag.PVP, localPlayer)) {
-                        tryCancelPVPEvent((Player) attacker, player, event, false);
-                    }
-                }
-            }
-        }
-
     }
 
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onEntityDamage(EntityDamageEvent event) {
-
-        if (event instanceof EntityDamageByEntityEvent) {
-            this.onEntityDamageByEntity((EntityDamageByEntityEvent) event);
-            return;
-        } else if (event instanceof EntityDamageByBlockEvent) {
-            this.onEntityDamageByBlock((EntityDamageByBlockEvent) event);
-            return;
-        }
-
-        Entity defender = event.getEntity();
-        DamageCause type = event.getCause();
-
         ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(defender.getWorld());
+        WorldConfiguration wcfg = cfg.get(event.getEntity().getWorld());
 
-        if (defender instanceof Wolf && ((Wolf) defender).isTamed()) {
-            if (wcfg.antiWolfDumbness) {
-                event.setCancelled(true);
-                return;
-            }
-        } else if (defender instanceof Player) {
-            Player player = (Player) defender;
-
-            if (isInvincible(player)) {
-                event.setCancelled(true);
-                player.setFireTicks(0);
-                return;
-            }
-
-            if (type == DamageCause.DROWNING && cfg.hasAmphibiousMode(player)) {
-                player.setRemainingAir(player.getMaximumAir());
+        // Redirect damage done by an entity
+        if (event instanceof EntityDamageByEntityEvent) {
+            // RuleLists
+            RuleSet rules = wcfg.getRuleList().get(DefaultAttachments.ENTITY_DAMAGE);
+            BukkitContext context = new BukkitContext(plugin, event);
+            context.setSourceEntity(((EntityDamageByEntityEvent) event).getDamager());
+            context.setTargetEntity(event.getEntity());
+            if (rules.process(context)) {
                 event.setCancelled(true);
                 return;
             }
 
-            ItemStack helmet = player.getInventory().getHelmet();
-
-            if (type == DamageCause.DROWNING && wcfg.pumpkinScuba
-                    && helmet != null
-                    && (helmet.getTypeId() == BlockID.PUMPKIN
-                    || helmet.getTypeId() == BlockID.JACKOLANTERN)) {
-                player.setRemainingAir(player.getMaximumAir());
+        // Redirect damage done by blocks
+        } else if (event instanceof EntityDamageByBlockEvent) {
+            // RuleLists
+            RuleSet rules = wcfg.getRuleList().get(DefaultAttachments.ENTITY_DAMAGE);
+            BukkitContext context = new BukkitContext(plugin, event);
+            Block damager = ((EntityDamageByBlockEvent) event).getDamager();
+            if (damager != null) { // Should NOT be null!
+                context.setSourceBlock(damager.getState());
+            }
+            context.setTargetEntity(event.getEntity());
+            if (rules.process(context)) {
                 event.setCancelled(true);
                 return;
             }
 
-            if (wcfg.disableFallDamage && type == DamageCause.FALL) {
-                event.setCancelled(true);
-                return;
-            }
-
-            if (wcfg.disableFireDamage && (type == DamageCause.FIRE
-                    || type == DamageCause.FIRE_TICK)) {
-                event.setCancelled(true);
-                return;
-            }
-
-            if (wcfg.disableDrowningDamage && type == DamageCause.DROWNING) {
-                player.setRemainingAir(player.getMaximumAir());
-                event.setCancelled(true);
-                return;
-            }
-
-           if (wcfg.teleportOnSuffocation && type == DamageCause.SUFFOCATION) {
-                BukkitUtil.findFreePosition(player);
-                event.setCancelled(true);
-                return;
-            }
-
-            if (wcfg.disableSuffocationDamage && type == DamageCause.SUFFOCATION) {
+        // Other damage
+        } else {
+            // RuleLists
+            RuleSet rules = wcfg.getRuleList().get(DefaultAttachments.ENTITY_DAMAGE);
+            BukkitContext context = new BukkitContext(plugin, event);
+            context.setTargetEntity(event.getEntity());
+            if (rules.process(context)) {
                 event.setCancelled(true);
                 return;
             }
@@ -469,240 +165,78 @@ public class WorldGuardEntityListener implements Listener {
         ConfigurationManager cfg = plugin.getGlobalStateManager();
         WorldConfiguration wcfg = cfg.get(entity.getWorld());
 
-        if (entity instanceof Player) {
-            Player player = (Player) entity;
-
-            if (cfg.hasGodMode(player) || (wcfg.useRegions && RegionQueryUtil.isInvincible(plugin, player))) {
-                event.setCancelled(true);
-                return;
-            }
+        // RuleLists
+        RuleSet rules = wcfg.getRuleList().get(DefaultAttachments.ENTITY_IGNITE);
+        BukkitContext context = new BukkitContext(plugin, event);
+        context.setTargetEntity(entity);
+        if (rules.process(context)) {
+            event.setCancelled(true);
+            return;
         }
     }
 
-    /*
-     * Called on entity explode.
-     */
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onEntityExplode(EntityExplodeEvent event) {
         ConfigurationManager cfg = plugin.getGlobalStateManager();
         Location l = event.getLocation();
         World world = l.getWorld();
         WorldConfiguration wcfg = cfg.get(world);
-        Entity ent = event.getEntity();
 
-        if (cfg.activityHaltToggle) {
-            ent.remove();
+        // RuleLists
+        RuleSet rules = wcfg.getRuleList().get(DefaultAttachments.ENTITY_EXPLODE);
+        BukkitContext context = new BukkitContext(plugin, event);
+        context.setTargetEntity(event.getEntity());
+        if (rules.process(context)) {
             event.setCancelled(true);
             return;
         }
 
-        if (ent.getType() == witherType) {
-            if (wcfg.blockWitherBlockDamage) {
-                event.blockList().clear();
-                return;
-            }
+        /* --- No short-circuit returns below this line --- */
 
-            if (wcfg.blockWitherExplosions) {
-                event.setCancelled(true);
-                return;
+        // Now apply RuleLists for each block
+        Iterator<Block> iter = event.blockList().iterator();
+        while (iter.hasNext()) {
+            Block block = iter.next();
+
+            rules = wcfg.getRuleList().get(DefaultAttachments.BLOCK_BREAK);
+            context = new BukkitContext(plugin, event);
+            context.setSourceEntity(event.getEntity());
+            context.setTargetBlock(block.getState());
+            rules.process(context);
+            if (context.isCancelled()) {
+                iter.remove();
             }
         }
-
-        if (ent.getType() == witherSkullType) {
-            if (wcfg.blockWitherSkullBlockDamage) {
-                event.blockList().clear();
-                return;
-            }
-
-            if (wcfg.blockWitherSkullExplosions) {
-                event.setCancelled(true);
-                return;
-            }
-        }
-
-        if (ent instanceof Creeper) {
-            if (wcfg.blockCreeperBlockDamage) {
-                event.blockList().clear();
-                return;
-            }
-
-            if (wcfg.blockCreeperExplosions) {
-                event.setCancelled(true);
-                return;
-            }
-
-            if (wcfg.useRegions) {
-                if (wcfg.useRegions) {
-                    RegionManager mgr = plugin.getGlobalRegionManager().get(world);
-
-                    for (Block block : event.blockList()) {
-                        if (!mgr.getApplicableRegions(toVector(block)).allows(DefaultFlag.CREEPER_EXPLOSION)) {
-                            event.blockList().clear();
-                            return;
-                        }
-                    }
-                }
-            }
-        } else if (ent instanceof EnderDragon) {
-            if (wcfg.blockEnderDragonBlockDamage) {
-                event.blockList().clear();
-                return;
-            }
-
-            if (wcfg.useRegions) {
-                RegionManager mgr = plugin.getGlobalRegionManager().get(world);
-
-                for (Block block : event.blockList()) {
-                    if (!mgr.getApplicableRegions(toVector(block)).allows(DefaultFlag.ENDERDRAGON_BLOCK_DAMAGE)) {
-                        event.blockList().clear();
-                        return;
-                    }
-                }
-            }
-        } else if (ent instanceof TNTPrimed) {
-            if (wcfg.blockTNTBlockDamage) {
-                event.blockList().clear();
-                return;
-            }
-
-            if (wcfg.blockTNTExplosions) {
-                event.setCancelled(true);
-                return;
-            }
-
-            if (wcfg.useRegions) {
-                RegionManager mgr = plugin.getGlobalRegionManager().get(world);
-
-                for (Block block : event.blockList()) {
-                    if (!mgr.getApplicableRegions(toVector(block)).allows(DefaultFlag.TNT)) {
-                        event.blockList().clear();
-                        return;
-                    }
-                }
-            }
-        } else if (ent instanceof Fireball) {
-            if (wcfg.blockFireballBlockDamage) {
-                event.blockList().clear();
-                return;
-            }
-
-            if (wcfg.blockFireballExplosions) {
-                event.setCancelled(true);
-                return;
-            }
-
-            if (wcfg.useRegions) {
-                RegionManager mgr = plugin.getGlobalRegionManager().get(world);
-
-                for (Block block : event.blockList()) {
-                    if (!mgr.getApplicableRegions(toVector(block)).allows(DefaultFlag.GHAST_FIREBALL)) {
-                        event.blockList().clear();
-                        return;
-                    }
-                }
-            }
-        }
-
-        if (wcfg.signChestProtection) {
-            for (Block block : event.blockList()) {
-                if (wcfg.isChestProtected(block)) {
-                    event.blockList().clear();
-                    return;
-                }
-            }
-        }
-
     }
 
-    /*
-     * Called on explosion prime
-     */
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onExplosionPrime(ExplosionPrimeEvent event) {
         ConfigurationManager cfg = plugin.getGlobalStateManager();
         WorldConfiguration wcfg = cfg.get(event.getEntity().getWorld());
-        Entity ent = event.getEntity();
 
-        if (cfg.activityHaltToggle) {
-            ent.remove();
+        // RuleLists
+        RuleSet rules = wcfg.getRuleList().get(DefaultAttachments.ENTITY_EXPLODE);
+        BukkitContext context = new BukkitContext(plugin, event);
+        context.setTargetEntity(event.getEntity());
+        if (rules.process(context)) {
             event.setCancelled(true);
             return;
         }
-        
-        if (event.getEntityType() == witherType) {
-            if (wcfg.blockWitherExplosions) {
-                event.setCancelled(true);
-                return;
-            }
-        }
-        else if (event.getEntityType() == witherSkullType) {
-            if (wcfg.blockWitherSkullExplosions) {
-                event.setCancelled(true);
-                return;
-            }
-        }
-        else if (event.getEntityType() == fireballType) {
-            if (wcfg.blockFireballExplosions) {
-                event.setCancelled(true);
-                return;
-            }
-        }
-        else if (event.getEntityType() == EntityType.CREEPER) {
-            if (wcfg.blockCreeperExplosions) {
-                event.setCancelled(true);
-                return;
-            }
-        }
-        else if (event.getEntityType() == EntityType.PRIMED_TNT) {
-            if (wcfg.blockTNTExplosions) {
-                event.setCancelled(true);
-                return;
-            }
-        }
     }
 
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onCreatureSpawn(CreatureSpawnEvent event) {
         ConfigurationManager cfg = plugin.getGlobalStateManager();
-
-        if (cfg.activityHaltToggle) {
-            event.setCancelled(true);
-            return;
-        }
-
         WorldConfiguration wcfg = cfg.get(event.getEntity().getWorld());
 
-        // allow spawning of creatures from plugins
-        if (!wcfg.blockPluginSpawning && event.getSpawnReason() == CreatureSpawnEvent.SpawnReason.CUSTOM)
-            return;
-
-        EntityType entityType = event.getEntityType();
-
-        if (wcfg.blockCreatureSpawn.contains(entityType)) {
+        // RuleLists
+        RuleSet rules = wcfg.getRuleList().get(DefaultAttachments.ENTITY_SPAWN);
+        BukkitContext context = new BukkitContext(plugin, event);
+        context.setTargetEntity(event.getEntity());
+        if (rules.process(context)) {
             event.setCancelled(true);
             return;
         }
-
-        Location eventLoc = event.getLocation();
-
-        if (wcfg.useRegions && cfg.useRegionsCreatureSpawnEvent) {
-            Vector pt = toVector(eventLoc);
-            RegionManager mgr = plugin.getGlobalRegionManager().get(eventLoc.getWorld());
-            // @TODO get victims' stacktraces and find out why it's null anyway
-            if (mgr == null) return;
-            ApplicableRegionSet set = mgr.getApplicableRegions(pt);
-
-            if (!set.allows(DefaultFlag.MOB_SPAWNING)) {
-                event.setCancelled(true);
-                return;
-            }
-
-            Set<EntityType> entityTypes = set.getFlag(DefaultFlag.DENY_SPAWN);
-            if (entityTypes != null && entityTypes.contains(entityType)) {
-                event.setCancelled(true);
-                return;
-            }
-        }
     }
 
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
@@ -710,8 +244,13 @@ public class WorldGuardEntityListener implements Listener {
         ConfigurationManager cfg = plugin.getGlobalStateManager();
         WorldConfiguration wcfg = cfg.get(event.getEntity().getWorld());
 
-        if (wcfg.disablePigZap) {
+        // RuleLists
+        RuleSet rules = wcfg.getRuleList().get(DefaultAttachments.ENTITY_STRIKE);
+        BukkitContext context = new BukkitContext(plugin, event);
+        context.setTargetEntity(event.getEntity());
+        if (rules.process(context)) {
             event.setCancelled(true);
+            return;
         }
     }
 
@@ -720,153 +259,56 @@ public class WorldGuardEntityListener implements Listener {
         ConfigurationManager cfg = plugin.getGlobalStateManager();
         WorldConfiguration wcfg = cfg.get(event.getEntity().getWorld());
 
-        if (wcfg.disableCreeperPower) {
-            event.setCancelled(true);
-        }
-    }
-
-    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
-    public void onEntityRegainHealth(EntityRegainHealthEvent event) {
-
-        Entity ent = event.getEntity();
-        World world = ent.getWorld();
-
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(world);
-
-        if (wcfg.disableHealthRegain) {
+        // RuleLists
+        RuleSet rules = wcfg.getRuleList().get(DefaultAttachments.ENTITY_STRIKE);
+        BukkitContext context = new BukkitContext(plugin, event);
+        context.setTargetEntity(event.getEntity());
+        if (rules.process(context)) {
             event.setCancelled(true);
             return;
         }
     }
 
-    /**
-     * Called when an enderman picks up or puts down a block and some other cases.
-     *
-     * @param event Relevant event details
-     */
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
-    public void onEndermanPickup(EntityChangeBlockEvent event) {
-        Entity ent = event.getEntity();
-        Block block = event.getBlock();
-        Location location = block.getLocation();
+    public void onEntityChangeBlock(EntityChangeBlockEvent event) {
+        Entity entity = event.getEntity();
 
-        if (ent instanceof Enderman) {
-            if (event.getTo() == Material.AIR) {
-                // pickup
-                ConfigurationManager cfg = plugin.getGlobalStateManager();
-                WorldConfiguration wcfg = cfg.get(ent.getWorld());
+        ConfigurationManager cfg = plugin.getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(entity.getWorld());
 
-                if (wcfg.disableEndermanGriefing) {
-                    event.setCancelled(true);
-                    return;
-                }
-
-                if (wcfg.useRegions) {
-                    if (!plugin.getGlobalRegionManager().allows(DefaultFlag.ENDER_BUILD, location)) {
-                        event.setCancelled(true);
-                        return;
-                    }
-                }
-            } else {
-                // place
-                ConfigurationManager cfg = plugin.getGlobalStateManager();
-                WorldConfiguration wcfg = cfg.get(ent.getWorld());
-
-                if (wcfg.disableEndermanGriefing) {
-                    event.setCancelled(true);
-                    return;
-                }
-
-                if (wcfg.useRegions) {
-                    if (!plugin.getGlobalRegionManager().allows(DefaultFlag.ENDER_BUILD, location)) {
-                        event.setCancelled(true);
-                        return;
-                    }
-                }
-            }
-        } else if (ent.getType() == witherType) {
-            ConfigurationManager cfg = plugin.getGlobalStateManager();
-            WorldConfiguration wcfg = cfg.get(ent.getWorld());
-            
-            if (wcfg.blockWitherBlockDamage || wcfg.blockWitherExplosions) {
-                event.setCancelled(true);
-                return;
-            }
-        }
-    }
-
-    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
-    public void onFoodLevelChange(FoodLevelChangeEvent event) {
-        if (event.getEntity() instanceof Player) {
-            Player player = (Player) event.getEntity();
-            if (event.getFoodLevel() < player.getFoodLevel() && isInvincible(player)) {
-                event.setCancelled(true);
-            }
+        // RuleLists
+        RuleSet rules = wcfg.getRuleList().get(event.getTo() == Material.AIR ?
+                DefaultAttachments.BLOCK_BREAK : DefaultAttachments.BLOCK_PLACE);
+        BukkitContext context = new BukkitContext(plugin, event);
+        context.setSourceEntity(entity);
+        BlockState newState = event.getBlock().getState(); // This event is lame
+        newState.setType(event.getTo()); // Need to construct our own BlockState
+        context.setTargetBlock(event.getBlock().getState());
+        context.setPlacedBlock(newState);
+        if (rules.process(context)) {
+            event.setCancelled(true);
+            return;
         }
     }
 
     @EventHandler(ignoreCancelled = true)
     public void onPotionSplash(PotionSplashEvent event) {
-        GlobalRegionManager global = plugin.getGlobalRegionManager();
+        RegionManager global = plugin.getGlobalRegionManager();
+
+        /* --- No short-circuit returns below this line --- */
+
         int blockedEntities = 0;
+
         for (LivingEntity e : event.getAffectedEntities()) {
-            if (!global.allows(DefaultFlag.POTION_SPLASH, e.getLocation(), e instanceof Player ? plugin.wrapPlayer((Player) e) : null)) {
+            if (!global.allows(DefaultFlag.POTION_SPLASH, e.getLocation(),
+                    e instanceof Player ? plugin.wrapPlayer((Player) e) : null)) {
                 event.setIntensity(e, 0);
                 ++blockedEntities;
             }
         }
+
         if (blockedEntities == event.getAffectedEntities().size()) {
             event.setCancelled(true);
         }
     }
-
-    /**
-     * Check if a player is invincible, via either god mode or region flag. If
-     * the region denies invincibility, the player must have an extra permission
-     * to override it. (worldguard.god.override-regions)
-     *
-     * @param player The player to check
-     * @return Whether {@code player} is invincible
-     */
-    private boolean isInvincible(Player player) {
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(player.getWorld());
-
-        boolean god = cfg.hasGodMode(player);
-        if (wcfg.useRegions) {
-            Boolean flag = RegionQueryUtil.isAllowedInvinciblity(plugin, player);
-            boolean allowed = flag == null || flag;
-            boolean invincible = RegionQueryUtil.isInvincible(plugin, player);
-
-            if (allowed) {
-                return god || invincible;
-            } else {
-                return (god && plugin.hasPermission(player, "worldguard.god.override-regions"))
-                    || invincible;
-            }
-        } else {
-            return god;
-        }
-    }
-
-    /**
-     * Using a DisallowedPVPEvent, notifies other plugins that WorldGuard
-     * wants to cancel a PvP damage event.<br />
-     * If this event is not cancelled, the attacking player is notified that
-     * PvP is disabled and WorldGuard cancels the damage event.
-     *
-     * @param attackingPlayer The attacker
-     * @param defendingPlayer The defender
-     * @param event The event that caused WorldGuard to act
-     */
-    public void tryCancelPVPEvent(final Player attackingPlayer, final Player defendingPlayer, EntityDamageByEntityEvent event, boolean aggressorTriggered) {
-        final DisallowedPVPEvent disallowedPVPEvent = new DisallowedPVPEvent(attackingPlayer, defendingPlayer, event);
-        plugin.getServer().getPluginManager().callEvent(disallowedPVPEvent);
-        if (!disallowedPVPEvent.isCancelled()) {
-            if (aggressorTriggered) attackingPlayer.sendMessage(ChatColor.DARK_RED + "You are in a no-PvP area.");
-            else attackingPlayer.sendMessage(ChatColor.DARK_RED + "That player is in a no-PvP area.");
-            event.setCancelled(true);
-        }
-    }
 }

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

@@ -19,178 +19,78 @@
 
 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.worldedit.blocks.ItemID;
-import com.sk89q.worldguard.blacklist.events.BlockBreakBlacklistEvent;
-import com.sk89q.worldguard.blacklist.events.ItemUseBlacklistEvent;
-import com.sk89q.worldguard.protection.flags.DefaultFlag;
+import com.sk89q.rulelists.DefaultAttachments;
+import com.sk89q.rulelists.RuleSet;
 
 /**
- * Listener for painting related events.
- *
- * @author BangL <henno.rickowski@gmail.com>
+ * Listener for hanging entity events.
  */
-public class WorldGuardHangingListener implements Listener {
+class WorldGuardHangingListener implements Listener {
 
     private WorldGuardPlugin plugin;
 
     /**
-     * Construct the object;
+     * Construct the listener.
      *
-     * @param plugin The plugin instance
+     * @param plugin WorldGuard plugin
      */
-    public WorldGuardHangingListener(WorldGuardPlugin plugin) {
+    WorldGuardHangingListener(WorldGuardPlugin plugin) {
         this.plugin = plugin;
     }
 
     /**
      * Register events.
      */
-    public void registerEvents() {
+    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;
+    public void onHangingingBreak(HangingBreakEvent event) {
         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.blockCreeperBlockDamage || wcfg.blockCreeperExplosions) {
-                    event.setCancelled(true);
-                    return;
-                }
-                if (wcfg.useRegions && !plugin.getGlobalRegionManager().allows(DefaultFlag.CREEPER_EXPLOSION, hanging.getLocation())) {
-                    event.setCancelled(true);
-                    return;
-                }
-            }
-
-            if (hanging instanceof Painting
-                    && (wcfg.blockEntityPaintingDestroy
-                    || (wcfg.useRegions
-                    && !plugin.getGlobalRegionManager().allows(DefaultFlag.ENTITY_PAINTING_DESTROY, hanging.getLocation())))) {
-                event.setCancelled(true);
-            } else if (hanging instanceof ItemFrame
-                    && (wcfg.blockEntityItemFrameDestroy
-                    || (wcfg.useRegions
-                    && !plugin.getGlobalRegionManager().allows(DefaultFlag.ENTITY_ITEM_FRAME_DESTROY, hanging.getLocation())))) {
-                event.setCancelled(true);
-            }
+        // RuleLists
+        RuleSet rules = wcfg.getRuleList().get(DefaultAttachments.ENTITY_DAMAGE);
+        BukkitContext context = new BukkitContext(plugin, event);
+        if (event instanceof HangingBreakByEntityEvent) {
+            context.setSourceEntity(((HangingBreakByEntityEvent) 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;
-            }
-        }
-    }
-
-    @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);
-            } else if (entity instanceof Painting
-                    && ((!plugin.getGlobalRegionManager().allows(
-                            DefaultFlag.ENTITY_PAINTING_DESTROY, entity.getLocation())))) {
-                event.setCancelled(true);
-            }
+        // RuleLists
+        RuleSet rules = wcfg.getRuleList().get(DefaultAttachments.ENTITY_SPAWN);
+        BukkitContext context = new BukkitContext(plugin, event);
+        context.setSourceEntity(event.getPlayer());
+        context.setTargetEntity(event.getEntity());
+        if (rules.process(context)) {
+            event.setCancelled(true);
+            return;
         }
     }
 }

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

@@ -19,156 +19,80 @@
 
 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.worldedit.blocks.ItemID;
-import com.sk89q.worldguard.blacklist.events.BlockBreakBlacklistEvent;
-import com.sk89q.worldguard.blacklist.events.ItemUseBlacklistEvent;
-import com.sk89q.worldguard.protection.flags.DefaultFlag;
+import com.sk89q.rulelists.DefaultAttachments;
+import com.sk89q.rulelists.RuleSet;
 
 /**
- * Listener for painting related events.
- *
- * @author sk89q
- * @deprecated Use {@link com.sk89q.worldguard.bukkit.WorldGuardHangingListener} instead.
+ * Listener for painting related events. This event is deprecated and it is provided for
+ * compatibility with older versions of Bukkit.
  */
 @Deprecated
-@Warning(reason="This listener has been replaced by WorldGuardHangingListener")
 public class WorldGuardPaintingListener implements Listener {
 
     private WorldGuardPlugin plugin;
 
     /**
-     * Construct the object;
+     * Construct the listener.
      *
-     * @param plugin The plugin instance
+     * @param plugin WorldGuard plugin
      */
-    public WorldGuardPaintingListener(WorldGuardPlugin plugin) {
+    WorldGuardPaintingListener(WorldGuardPlugin plugin) {
         this.plugin = plugin;
     }
 
     /**
      * Register events.
      */
-    public void registerEvents() {
+    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;
+    public void onPaintingBreak(PaintingBreakEvent event) {
         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.blockCreeperBlockDamage || wcfg.blockCreeperExplosions) {
-                    event.setCancelled(true);
-                    return;
-                }
-                if (wcfg.useRegions && !plugin.getGlobalRegionManager().allows(DefaultFlag.CREEPER_EXPLOSION, painting.getLocation())) {
-                    event.setCancelled(true);
-                    return;
-                }
-            }
-
-            if (wcfg.blockEntityPaintingDestroy
-                    || (wcfg.useRegions
-                    && !plugin.getGlobalRegionManager().allows(DefaultFlag.ENTITY_PAINTING_DESTROY, painting.getLocation()))) {
-                event.setCancelled(true);
-            }
+        // RuleLists
+        RuleSet rules = wcfg.getRuleList().get(DefaultAttachments.ENTITY_DAMAGE);
+        BukkitContext context = new BukkitContext(plugin, event);
+        if (event instanceof PaintingBreakByEntityEvent) {
+            context.setSourceEntity(((PaintingBreakByEntityEvent) event).getRemover());
+        }
+        context.setTargetEntity(event.getPainting());
+        if (rules.process(context)) {
+            event.setCancelled(true);
+            return;
         }
     }
 
     @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;
-            }
-        }
-    }
-
-    @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);
-            }
+        // RuleLists
+        RuleSet rules = wcfg.getRuleList().get(DefaultAttachments.ENTITY_SPAWN);
+        BukkitContext context = new BukkitContext(plugin, event);
+        context.setSourceEntity(event.getPlayer());
+        context.setTargetEntity(event.getPainting());
+        if (rules.process(context)) {
+            event.setCancelled(true);
+            return;
         }
     }
 }

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

@@ -22,7 +22,6 @@ package com.sk89q.worldguard.bukkit;
 import static com.sk89q.worldguard.bukkit.BukkitUtil.hasHangingEvent;
 
 import java.io.File;
-import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
@@ -31,12 +30,6 @@ import java.util.Arrays;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Set;
-import java.util.jar.JarFile;
-import java.util.zip.ZipEntry;
-
-import com.sk89q.bukkit.util.CommandsManagerRegistration;
-import com.sk89q.minecraft.util.commands.*;
-import com.sk89q.wepif.PermissionsResolverManager;
 import org.bukkit.ChatColor;
 import org.bukkit.Location;
 import org.bukkit.World;
@@ -46,55 +39,88 @@ import org.bukkit.command.Command;
 import org.bukkit.command.CommandSender;
 import org.bukkit.command.ConsoleCommandSender;
 import org.bukkit.entity.Player;
+import org.bukkit.event.world.WorldLoadEvent;
 import org.bukkit.permissions.Permissible;
 import org.bukkit.plugin.Plugin;
 import org.bukkit.plugin.java.JavaPlugin;
 
+import com.sk89q.bukkit.util.CommandsManagerRegistration;
+import com.sk89q.minecraft.util.commands.CommandException;
+import com.sk89q.minecraft.util.commands.CommandPermissionsException;
+import com.sk89q.minecraft.util.commands.CommandUsageException;
+import com.sk89q.minecraft.util.commands.CommandsManager;
+import com.sk89q.minecraft.util.commands.MissingNestedCommandException;
+import com.sk89q.minecraft.util.commands.SimpleInjector;
+import com.sk89q.minecraft.util.commands.WrappedCommandException;
+import com.sk89q.rebar.bukkit.VirtualRebarPlugin;
+import com.sk89q.rebar.config.ConfigurationException;
+import com.sk89q.rebar.config.YamlConfiguration;
+import com.sk89q.rebar.config.YamlConfigurationResource;
+import com.sk89q.rulelists.Action;
+import com.sk89q.rulelists.Criteria;
+import com.sk89q.rulelists.DefaultAttachments;
+import com.sk89q.rulelists.DefinitionManager;
+import com.sk89q.rulelists.ResolverManager;
+import com.sk89q.rulelists.RuleListsManager;
+import com.sk89q.wepif.PermissionsResolverManager;
 import com.sk89q.worldedit.bukkit.WorldEditPlugin;
 import com.sk89q.worldguard.LocalPlayer;
 import com.sk89q.worldguard.bukkit.commands.GeneralCommands;
 import com.sk89q.worldguard.bukkit.commands.ProtectionCommands;
 import com.sk89q.worldguard.bukkit.commands.ToggleCommands;
-import com.sk89q.worldguard.protection.GlobalRegionManager;
-import com.sk89q.worldguard.protection.managers.RegionManager;
-import com.sk89q.worldguard.util.FatalConfigurationLoadingException;
+import com.sk89q.worldguard.bukkit.definitions.BlockCriteriaLoader;
+import com.sk89q.worldguard.bukkit.definitions.CancelActionLoader;
+import com.sk89q.worldguard.bukkit.definitions.DamageCriteriaLoader;
+import com.sk89q.worldguard.bukkit.definitions.EntityCriteriaLoader;
+import com.sk89q.worldguard.bukkit.definitions.FlagCriteriaLoader;
+import com.sk89q.worldguard.bukkit.definitions.ItemCriteriaLoader;
+import com.sk89q.worldguard.bukkit.definitions.PermissionCriteriaLoader;
+import com.sk89q.worldguard.bukkit.definitions.PhenomenonCriteriaLoader;
+import com.sk89q.worldguard.bukkit.definitions.RegionCriteriaLoader;
+import com.sk89q.worldguard.bukkit.definitions.SetBlockActionLoader;
+import com.sk89q.worldguard.bukkit.definitions.SetDropActionLoader;
+import com.sk89q.worldguard.bukkit.definitions.SpawnCriteriaLoader;
+import com.sk89q.worldguard.bukkit.definitions.TellActionLoader;
+import com.sk89q.worldguard.bukkit.definitions.UpdateEntityActionLoader;
+import com.sk89q.worldguard.bukkit.definitions.UpdateItemActionLoader;
+import com.sk89q.worldguard.bukkit.definitions.SetMessageActionLoader;
+import com.sk89q.worldguard.bukkit.definitions.UpdateWorldActionLoader;
+import com.sk89q.worldguard.bukkit.definitions.WeatherCriteriaLoader;
+import com.sk89q.worldguard.bukkit.resolvers.BlockResolver;
+import com.sk89q.worldguard.bukkit.resolvers.EntityResolver;
+import com.sk89q.worldguard.bukkit.resolvers.ItemStackSlotResolver;
+import com.sk89q.worldguard.bukkit.resolvers.PlacedBlockResolver;
+import com.sk89q.worldguard.bukkit.resolvers.PlayerItemStackSlotResolver;
+import com.sk89q.worldguard.bukkit.resolvers.PlayerItemStackSlotResolver.Slot;
+import com.sk89q.worldguard.bukkit.resolvers.SourceBlockResolver;
+import com.sk89q.worldguard.bukkit.resolvers.SourceEntityResolver;
+import com.sk89q.worldguard.bukkit.resolvers.TargetBlockResolver;
+import com.sk89q.worldguard.bukkit.resolvers.TargetEntityResolver;
+import com.sk89q.worldguard.region.RegionManager;
+import com.sk89q.worldguard.region.indices.RegionIndex;
 
 /**
  * The main class for WorldGuard as a Bukkit plugin.
- *
- * @author sk89q
  */
 public class WorldGuardPlugin extends JavaPlugin {
 
-    /**
-     * Manager for commands. This automatically handles nested commands,
-     * permissions checking, and a number of other fancy command things.
-     * We just set it up and register commands against it.
-     */
     private final CommandsManager<CommandSender> commands;
-
-    /**
-     * Handles the region databases for all worlds.
-     */
-    private final GlobalRegionManager globalRegionManager;
-
-    /**
-     * Handles all configuration.
-     */
+    private final RegionManager globalRegionManager;
     private final ConfigurationManager configuration;
+    private RuleListsManager ruleListsManager;
+    private RegionQueryCache regionCache;
+    private final LagStopMode lagStopper;
+
+    private WorldGuardWorldListener worldListener;
 
     /**
-     * Used for scheduling flags.
-     */
-    private FlagStateManager flagStateManager;
-
-    /**
-     * Construct objects. Actual loading occurs when the plugin is enabled, so
-     * this merely instantiates the objects.
+     * Do initial loading of WorldGuard. Only called once. {@link #onEnable()} will be
+     * called when WorldGuard is enabled.
      */
     public WorldGuardPlugin() {
         configuration = new ConfigurationManager(this);
-        globalRegionManager = new GlobalRegionManager(this);
+        globalRegionManager = new RegionManager(this);
+        lagStopper = new LagStopMode(this);
 
         final WorldGuardPlugin plugin = this;
         commands = new CommandsManager<CommandSender>() {
@@ -105,11 +131,18 @@ public class WorldGuardPlugin extends JavaPlugin {
         };
     }
 
-    /**
-     * Called on plugin enable.
-     */
     @SuppressWarnings("deprecation")
+    @Override
     public void onEnable() {
+        // We don't require Rebar yet
+        VirtualRebarPlugin.setup(this);
+
+        // Set up RuleLists
+        ruleListsManager = new RuleListsManager();
+        registerRuleList();
+
+        // Setup the cache
+        regionCache = new RegionQueryCache(this);
 
         // Set the proper command injector
         commands.setInjector(new SimpleInjector(this));
@@ -133,27 +166,9 @@ public class WorldGuardPlugin extends JavaPlugin {
 
         PermissionsResolverManager.initialize(this);
 
-        // This must be done before configuration is loaded
-        LegacyWorldGuardMigration.migrateBlacklist(this);
-
-        try {
-        	// Load the configuration
-        	configuration.load();
-        	globalRegionManager.preload();
-        } catch (FatalConfigurationLoadingException e) {
-        	e.printStackTrace();
-        	getServer().shutdown();
-        }
-
-        // Migrate regions after the regions were loaded because
-        // the migration code reuses the loaded region managers
-        LegacyWorldGuardMigration.migrateRegions(this);
-
-        flagStateManager = new FlagStateManager(this);
-
-        if (configuration.useRegionsScheduler) {
-            getServer().getScheduler().scheduleAsyncRepeatingTask(this, flagStateManager, FlagStateManager.RUN_DELAY, FlagStateManager.RUN_DELAY);
-        }
+    	// Load the configuration
+    	configuration.load();
+    	globalRegionManager.preload();
 
         // Register events
         (new WorldGuardPlayerListener(this)).registerEvents();
@@ -162,47 +177,27 @@ public class WorldGuardPlugin extends JavaPlugin {
         (new WorldGuardWeatherListener(this)).registerEvents();
         (new WorldGuardVehicleListener(this)).registerEvents();
         (new WorldGuardServerListener(this)).registerEvents();
+        (worldListener = new WorldGuardWorldListener(this)).registerEvents();
+        lagStopper.registerEvents();
+
+        // Initialization
+        simulateWorldLoad();
+
         if (hasHangingEvent()) {
             (new WorldGuardHangingListener(this)).registerEvents();
         } else {
             (new WorldGuardPaintingListener(this)).registerEvents();
         }
         configuration.updateCommandBookGodMode();
-
-        if (getServer().getPluginManager().isPluginEnabled("CommandBook")) {
-            getServer().getPluginManager().registerEvents(new WorldGuardCommandBookListener(this), this);
-        }
-
-        // handle worlds separately to initialize already loaded worlds
-        WorldGuardWorldListener worldListener = (new WorldGuardWorldListener(this));
-        for (World world : getServer().getWorlds()) {
-            worldListener.initWorld(world);
-        }
-        worldListener.registerEvents();
-
-        if (!configuration.hasCommandBookGodMode()) {
-            // Check god mode for existing players, if any
-            for (Player player : getServer().getOnlinePlayers()) {
-                if (inGroup(player, "wg-invincible") ||
-                        (configuration.autoGodMode && hasPermission(player, "worldguard.auto-invincible"))) {
-                    configuration.enableGodMode(player);
-                }
-            }
-        }
     }
 
-    /**
-     * Called on plugin disable.
-     */
+    @Override
     public void onDisable() {
         globalRegionManager.unload();
         configuration.unload();
         this.getServer().getScheduler().cancelTasks(this);
     }
 
-    /**
-     * Handle a command.
-     */
     @Override
     public boolean onCommand(CommandSender sender, Command cmd, String label,
             String[] args) {
@@ -229,12 +224,22 @@ public class WorldGuardPlugin extends JavaPlugin {
         return true;
     }
 
+    /**
+     * Dispatch {@link WorldLoadEvent}s to the world listener.
+     */
+    public void simulateWorldLoad() {
+        for (World world : getServer().getWorlds()) {
+            WorldLoadEvent event = new WorldLoadEvent(world);
+            worldListener.onWorldLoad(event);
+        }
+    }
+
     /**
      * Get the GlobalRegionManager.
      *
      * @return The plugin's global region manager
      */
-    public GlobalRegionManager getGlobalRegionManager() {
+    public RegionManager getGlobalRegionManager() {
         return globalRegionManager;
     }
 
@@ -249,15 +254,6 @@ public class WorldGuardPlugin extends JavaPlugin {
         return getGlobalStateManager();
     }
 
-    /**
-     * Gets the flag state manager.
-     *
-     * @return The flag state manager
-     */
-    public FlagStateManager getFlagStateManager() {
-        return flagStateManager;
-    }
-
     /**
      * Get the global ConfigurationManager.
      * USe this to access global configuration values and per-world configuration values.
@@ -267,6 +263,85 @@ public class WorldGuardPlugin extends JavaPlugin {
         return configuration;
     }
 
+    /**
+     * Get the rules list manager.
+     *
+     * @return rule lists manager
+     */
+    public RuleListsManager getRulesListManager() {
+        return ruleListsManager;
+    }
+
+    /**
+     * Get the region query cache.
+     *
+     * @return region query cache
+     */
+    public RegionQueryCache getRegionCache() {
+        return regionCache;
+    }
+
+    /**
+     * Get the built-in rules.
+     *
+     * @return built-in rules
+     * @throws ConfigurationException on config error
+     * @throws IOException on I/O exception
+     */
+    public YamlConfiguration getBuiltInRules() throws IOException, ConfigurationException {
+        YamlConfiguration rules = new YamlConfigurationResource(getClass(),
+                "/defaults/builtin_rules.yml");
+        rules.load();
+        return rules;
+    }
+
+    /**
+     * Register RuleList resolvers, criterion, and actions.
+     */
+    private void registerRuleList() {
+        DefaultAttachments.registerWith(ruleListsManager.getAttachments());
+
+        // Subject resolvers
+        ResolverManager resolvers = ruleListsManager.getResolvers();
+
+        resolvers.register(BlockResolver.class, "source", new SourceBlockResolver());
+        resolvers.register(BlockResolver.class, "target", new TargetBlockResolver());
+        resolvers.register(BlockResolver.class, "placed", new PlacedBlockResolver());
+
+        resolvers.register(EntityResolver.class, "source", new SourceEntityResolver());
+        resolvers.register(EntityResolver.class, "target", new TargetEntityResolver());
+
+        resolvers.register(ItemStackSlotResolver.class, "held", new PlayerItemStackSlotResolver(Slot.HELD));
+        resolvers.register(ItemStackSlotResolver.class, "helmet", new PlayerItemStackSlotResolver(Slot.HELMET));
+        resolvers.register(ItemStackSlotResolver.class, "chestplate", new PlayerItemStackSlotResolver(Slot.CHESTPLATE));
+        resolvers.register(ItemStackSlotResolver.class, "leggings", new PlayerItemStackSlotResolver(Slot.LEGGINGS));
+        resolvers.register(ItemStackSlotResolver.class, "boots", new PlayerItemStackSlotResolver(Slot.BOOTS));
+
+        // Criterion
+        DefinitionManager<Criteria<?>> criterion = ruleListsManager.getCriterion();
+        criterion.register("match-block", new BlockCriteriaLoader(ruleListsManager));
+        criterion.register("match-item", new ItemCriteriaLoader(ruleListsManager));
+        criterion.register("match-entity", new EntityCriteriaLoader(ruleListsManager));
+        criterion.register("match-damage", new DamageCriteriaLoader());
+        criterion.register("match-spawn", new SpawnCriteriaLoader());
+        criterion.register("match-phenomenon", new PhenomenonCriteriaLoader());
+        criterion.register("match-weather", new WeatherCriteriaLoader());
+        criterion.register("region-of", new RegionCriteriaLoader(ruleListsManager));
+        criterion.register("has-flag", new FlagCriteriaLoader(this, ruleListsManager));
+        criterion.register("has-permission", new PermissionCriteriaLoader(this, ruleListsManager));
+
+        // Actions
+        DefinitionManager<Action<?>> actions = ruleListsManager.getActions();
+        actions.register("cancel", new CancelActionLoader());
+        actions.register("tell", new TellActionLoader(ruleListsManager));
+        actions.register("update-item", new UpdateItemActionLoader(ruleListsManager));
+        actions.register("update-world", new UpdateWorldActionLoader());
+        actions.register("update-entity", new UpdateEntityActionLoader(this, ruleListsManager));
+        actions.register("set-message", new SetMessageActionLoader(ruleListsManager));
+        actions.register("set-drop", new SetDropActionLoader());
+        actions.register("set-block", new SetBlockActionLoader(ruleListsManager));
+    }
+
     /**
      * Check whether a player is in a group.
      * This calls the corresponding method in PermissionsResolverManager
@@ -698,9 +773,7 @@ public class WorldGuardPlugin extends JavaPlugin {
      * @param actual The destination file
      * @param defaultName The name of the file inside the jar's defaults folder
      */
-    public void createDefaultConfiguration(File actual,
-            String defaultName) {
-
+    public void createDefaultConfiguration(File actual, String defaultName) {
         // Make parent directories
         File parent = actual.getParentFile();
         if (!parent.exists()) {
@@ -711,16 +784,10 @@ public class WorldGuardPlugin extends JavaPlugin {
             return;
         }
 
-        InputStream input =
-                    null;
-            try {
-                JarFile file = new JarFile(getFile());
-                ZipEntry copy = file.getEntry("defaults/" + defaultName);
-                if (copy == null) throw new FileNotFoundException();
-                input = file.getInputStream(copy);
-            } catch (IOException e) {
-                getLogger().severe("Unable to read default configuration: " + defaultName);
-            }
+        InputStream input = WorldGuardPlugin.class.getResourceAsStream("/defaults/" + defaultName);
+        if (input == null) {
+            getLogger().severe("Unable to read default configuration: " + defaultName);
+        }
 
         if (input != null) {
             FileOutputStream output = null;
@@ -780,7 +847,6 @@ public class WorldGuardPlugin extends JavaPlugin {
      * @param player The player to remove state information for
      */
     public void forgetPlayer(Player player) {
-        flagStateManager.forget(player);
     }
 
     /**
@@ -789,7 +855,7 @@ public class WorldGuardPlugin extends JavaPlugin {
      *
      * @param player The player to check.
      * @param loc The location to check at.
-     * @see GlobalRegionManager#canBuild(org.bukkit.entity.Player, org.bukkit.Location)
+     * @see RegionManager#canBuild(org.bukkit.entity.Player, org.bukkit.Location)
      * @return whether {@code player} can build at {@code loc}
      */
     public boolean canBuild(Player player, Location loc) {
@@ -802,7 +868,7 @@ public class WorldGuardPlugin extends JavaPlugin {
      *
      * @param player The player to check
      * @param block The block to check at.
-     * @see GlobalRegionManager#canBuild(org.bukkit.entity.Player, org.bukkit.block.Block)
+     * @see RegionManager#canBuild(org.bukkit.entity.Player, org.bukkit.block.Block)
      * @return whether {@code player} can build at {@code block}'s location
      */
     public boolean canBuild(Player player, Block block) {
@@ -815,7 +881,7 @@ public class WorldGuardPlugin extends JavaPlugin {
      * @param world world to get the region manager for
      * @return the region manager or null if regions are not enabled
      */
-    public RegionManager getRegionManager(World world) {
+    public RegionIndex getRegionManager(World world) {
         if (!getGlobalStateManager().get(world).useRegions) {
             return null;
         }
@@ -823,6 +889,15 @@ public class WorldGuardPlugin extends JavaPlugin {
         return getGlobalRegionManager().get(world);
     }
 
+    /**
+     * Get the "lag stop mode" controller.
+     *
+     * @return the lag stop mode
+     */
+    public LagStopMode getLagStopMode() {
+        return lagStopper;
+    }
+
     /**
      * Replace macros in the text.
      *

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

@@ -7,23 +7,32 @@ import org.bukkit.event.server.PluginEnableEvent;
 import org.bukkit.plugin.PluginManager;
 
 /**
- * @author zml2008
+ * Listener for server events.
  */
-public class WorldGuardServerListener implements Listener {
+class WorldGuardServerListener implements Listener {
 
     private final WorldGuardPlugin plugin;
 
-    public WorldGuardServerListener(WorldGuardPlugin plugin) {
+    /**
+     * Construct the listener.
+     *
+     * @param plugin WorldGuard plugin
+     */
+    WorldGuardServerListener(WorldGuardPlugin plugin) {
         this.plugin = plugin;
     }
 
-    public void registerEvents() {
+    /**
+     * Register events.
+     */
+    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();
         }
@@ -31,6 +40,7 @@ public class WorldGuardServerListener implements Listener {
 
     @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

@@ -5,42 +5,34 @@
 */
 package com.sk89q.worldguard.bukkit;
 
-import static com.sk89q.worldguard.bukkit.BukkitUtil.toVector;
-
-import org.bukkit.ChatColor;
-import org.bukkit.World;
 import org.bukkit.entity.Entity;
-import org.bukkit.entity.Player;
 import org.bukkit.entity.Vehicle;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
 import org.bukkit.event.vehicle.VehicleDestroyEvent;
-import org.bukkit.event.vehicle.VehicleMoveEvent;
-import com.sk89q.worldedit.Vector;
-import com.sk89q.worldguard.LocalPlayer;
-import com.sk89q.worldguard.bukkit.FlagStateManager.PlayerFlagState;
-import com.sk89q.worldguard.protection.ApplicableRegionSet;
-import com.sk89q.worldguard.protection.flags.DefaultFlag;
-import com.sk89q.worldguard.protection.managers.RegionManager;
-import com.sk89q.worldguard.protection.regions.ProtectedRegion;
+import com.sk89q.rulelists.DefaultAttachments;
+import com.sk89q.rulelists.RuleSet;
 
-public class WorldGuardVehicleListener implements Listener {
+/**
+ * Listener for vehicle events.
+ */
+class WorldGuardVehicleListener implements Listener {
 
     private WorldGuardPlugin plugin;
 
     /**
-     * Construct the object;
+     * Construct the listener.
      *
-     * @param plugin
+     * @param plugin WorldGuard plugin
      */
-    public WorldGuardVehicleListener(WorldGuardPlugin plugin) {
+    WorldGuardVehicleListener(WorldGuardPlugin plugin) {
         this.plugin = plugin;
     }
 
     /**
-     * Register events.
+     * Register the events.
      */
-    public void registerEvents() {
+    void registerEvents() {
         plugin.getServer().getPluginManager().registerEvents(this, plugin);
     }
 
@@ -49,130 +41,17 @@ public class WorldGuardVehicleListener implements Listener {
         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);
+        WorldConfiguration wcfg = cfg.get(vehicle.getWorld());
 
-        if (wcfg.useRegions) {
-            Vector pt = toVector(vehicle.getLocation());
-            RegionManager mgr = plugin.getGlobalRegionManager().get(world);
-            ApplicableRegionSet set = mgr.getApplicableRegions(pt);
-            LocalPlayer localPlayer = plugin.wrapPlayer(player);
-
-            if (!plugin.getGlobalRegionManager().hasBypass(player, world)
-                    && !set.canBuild(localPlayer)
-                    && !set.allows(DefaultFlag.DESTROY_VEHICLE, localPlayer)) {
-                player.sendMessage(ChatColor.DARK_RED + "You don't have permission to destroy vehicles here.");
-                event.setCancelled(true);
-                return;
-            }
-        }
-    }
-
-    @EventHandler
-    public void onVehicleMove(VehicleMoveEvent event) {
-        Vehicle vehicle = event.getVehicle();
-        if (vehicle.getPassenger() == null
-                || !(vehicle.getPassenger() instanceof Player)) return;
-        Player player = (Player) vehicle.getPassenger();
-        World world = vehicle.getWorld();
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(world);
-
-        // unfortunate code duplication
-        if (wcfg.useRegions) {
-            // Did we move a block?
-            if (event.getFrom().getBlockX() != event.getTo().getBlockX()
-                    || event.getFrom().getBlockY() != event.getTo().getBlockY()
-                    || event.getFrom().getBlockZ() != event.getTo().getBlockZ()) {
-                PlayerFlagState state = plugin.getFlagStateManager().getState(player);
-                LocalPlayer localPlayer = plugin.wrapPlayer(player);
-                boolean hasBypass = plugin.getGlobalRegionManager().hasBypass(player, world);
-
-                RegionManager mgr = plugin.getGlobalRegionManager().get(world);
-                Vector pt = new Vector(event.getTo().getBlockX(), event.getTo().getBlockY(), event.getTo().getBlockZ());
-                ApplicableRegionSet set = mgr.getApplicableRegions(pt);
-
-                boolean entryAllowed = set.allows(DefaultFlag.ENTRY, localPlayer);
-                if (!hasBypass && !entryAllowed) {
-
-                    vehicle.setVelocity(new org.bukkit.util.Vector(0,0,0));
-                    vehicle.teleport(event.getFrom());
-                    return;
-                }
-
-                // Have to set this state
-                if (state.lastExitAllowed == null) {
-                    state.lastExitAllowed = mgr.getApplicableRegions(toVector(event.getFrom()))
-                            .allows(DefaultFlag.EXIT, localPlayer);
-                }
-
-                boolean exitAllowed = set.allows(DefaultFlag.EXIT, localPlayer);
-                if (!hasBypass && exitAllowed && !state.lastExitAllowed) {
-                    player.sendMessage(ChatColor.DARK_RED + "You are not permitted to leave this area.");
-
-                    vehicle.setVelocity(new org.bukkit.util.Vector(0,0,0));
-                    vehicle.teleport(event.getFrom());
-                    return;
-                }
-
-                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: "
-                            + 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: "
-                            + ChatColor.LIGHT_PURPLE + player.getName()
-                            + ChatColor.GOLD + " entered NOTIFY region: "
-                            + ChatColor.WHITE
-                            + regionList);
-                }
-
-                state.lastGreeting = greeting;
-                state.lastFarewell = farewell;
-                state.notifiedForEnter = notifyEnter;
-                state.notifiedForLeave = notifyLeave;
-                state.lastExitAllowed = exitAllowed;
-                state.lastWorld = event.getTo().getWorld();
-                state.lastBlockX = event.getTo().getBlockX();
-                state.lastBlockY = event.getTo().getBlockY();
-                state.lastBlockZ = event.getTo().getBlockZ();
-            }
+        // RuleLists
+        RuleSet rules = wcfg.getRuleList().get(DefaultAttachments.ENTITY_DAMAGE);
+        BukkitContext context = new BukkitContext(plugin, event);
+        context.setSourceEntity(destroyer);
+        context.setTargetEntity(vehicle);
+        if (rules.process(context)) {
+            event.setCancelled(true);
+            return;
         }
     }
 }

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

@@ -18,8 +18,6 @@
  */
 package com.sk89q.worldguard.bukkit;
 
-import static com.sk89q.worldguard.bukkit.BukkitUtil.toVector;
-
 import org.bukkit.Location;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
@@ -27,28 +25,30 @@ import org.bukkit.event.Listener;
 import org.bukkit.event.weather.LightningStrikeEvent;
 import org.bukkit.event.weather.ThunderChangeEvent;
 import org.bukkit.event.weather.WeatherChangeEvent;
-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 implements Listener {
+import com.sk89q.rulelists.DefaultAttachments;
+import com.sk89q.rulelists.RuleSet;
+
+/**
+ * Listener for weather events.
+ */
+class WorldGuardWeatherListener implements Listener {
 
-    /**
-     * Plugin.
-     */
     private WorldGuardPlugin plugin;
 
     /**
-     * Construct the object;
+     * Construct the listener.
      *
-     * @param plugin The plugin instance
+     * @param plugin WorldGuard plugin
      */
-    public WorldGuardWeatherListener(WorldGuardPlugin plugin) {
+    WorldGuardWeatherListener(WorldGuardPlugin plugin) {
         this.plugin = plugin;
     }
 
-    public void registerEvents() {
+    /**
+     * Register the events.
+     */
+    void registerEvents() {
         plugin.getServer().getPluginManager().registerEvents(this, plugin);
     }
 
@@ -57,14 +57,12 @@ public class WorldGuardWeatherListener implements Listener {
         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(DefaultAttachments.WEATHER_TRANSITION);
+        BukkitContext context = new BukkitContext(plugin, event);
+        if (rules.process(context)) {
+            event.setCancelled(true);
+            return;
         }
     }
 
@@ -73,38 +71,29 @@ public class WorldGuardWeatherListener implements Listener {
         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(DefaultAttachments.WEATHER_TRANSITION);
+        BukkitContext context = new BukkitContext(plugin, event);
+        if (rules.process(context)) {
+            event.setCancelled(true);
+            return;
         }
     }
 
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onLightningStrike(LightningStrikeEvent event) {
+        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();
-        if (wcfg.useRegions) {
-            Vector pt = toVector(loc);
-            RegionManager mgr = plugin.getGlobalRegionManager().get(loc.getWorld());
-            ApplicableRegionSet set = mgr.getApplicableRegions(pt);
-
-            if (!set.allows(DefaultFlag.LIGHTNING)) {
-                event.setCancelled(true);
-            }
+        // RuleLists
+        RuleSet rules = wcfg.getRuleList().get(DefaultAttachments.WEATHER_PHENOMENON);
+        BukkitContext context = new BukkitContext(plugin, event);
+        context.setTargetBlock(loc.getBlock().getState());
+        if (rules.process(context)) {
+            event.setCancelled(true);
+            return;
         }
     }
 }

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

@@ -5,79 +5,75 @@
 */
 package com.sk89q.worldguard.bukkit;
 
-import org.bukkit.World;
-import org.bukkit.entity.Entity;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
-import org.bukkit.event.world.ChunkLoadEvent;
 import org.bukkit.event.world.WorldLoadEvent;
+import org.bukkit.event.world.WorldSaveEvent;
+import org.bukkit.event.world.WorldUnloadEvent;
 
+import com.sk89q.rulelists.DefaultAttachments;
+import com.sk89q.rulelists.RuleSet;
+
+/**
+ * Listener for world events.
+ */
 public class WorldGuardWorldListener implements Listener {
 
     private WorldGuardPlugin plugin;
 
     /**
-     * Construct the object;
+     * Construct the listener.
      *
-     * @param plugin The plugin instance
+     * @param plugin WorldGuard plugin
      */
     public WorldGuardWorldListener(WorldGuardPlugin plugin) {
         this.plugin = plugin;
     }
 
     /**
-     * Register events.
+     * Register the events.
      */
     public void registerEvents() {
         plugin.getServer().getPluginManager().registerEvents(this, plugin);
     }
 
     @EventHandler
-    public void onChunkLoad(ChunkLoadEvent event) {
+    public void onWorldLoad(WorldLoadEvent event) {
         ConfigurationManager cfg = plugin.getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(event.getWorld());
 
-        if (cfg.activityHaltToggle) {
-            int removed = 0;
+        /* --- No short-circuit returns below this line --- */
 
-            for (Entity entity : event.getChunk().getEntities()) {
-                if (BukkitUtil.isIntensiveEntity(entity)) {
-                    entity.remove();
-                    removed++;
-                }
-            }
+        // RuleLists
+        RuleSet rules = wcfg.getRuleList().get(DefaultAttachments.WORLD_LOAD);
+        BukkitContext context = new BukkitContext(plugin, event);
+        rules.process(context);
+    }
 
-            if (removed > 50) {
-                plugin.getLogger().info("Halt-Act: " + removed + " entities (>50) auto-removed from "
-                        + event.getChunk().toString());
-            }
+    @EventHandler
+    public void onWorldLoad(WorldUnloadEvent event) {
+        ConfigurationManager cfg = plugin.getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(event.getWorld());
+
+        // RuleLists
+        RuleSet rules = wcfg.getRuleList().get(DefaultAttachments.WORLD_UNLOAD);
+        BukkitContext context = new BukkitContext(plugin, event);
+        if (rules.process(context)) {
+            event.setCancelled(true);
+            return;
         }
     }
 
     @EventHandler
-    public void onWorldLoad(WorldLoadEvent event) {
-        initWorld(event.getWorld());
-    }
-
-    /**
-     * Initialize the settings for the specified world
-     * @see WorldConfiguration#alwaysRaining
-     * @see WorldConfiguration#disableWeather
-     * @see WorldConfiguration#alwaysThundering
-     * @see WorldConfiguration#disableThunder
-     * @param world The specified world
-     */
-    public void initWorld(World world) {
+    public void onWorldSave(WorldSaveEvent 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());
+
+        /* --- No short-circuit returns below this line --- */
+
+        // RuleLists
+        RuleSet rules = wcfg.getRuleList().get(DefaultAttachments.WORLD_SAVE);
+        BukkitContext context = new BukkitContext(plugin, event);
+        rules.process(context);
     }
 }

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

@@ -31,20 +31,12 @@ import com.sk89q.worldedit.bukkit.selections.Selection;
 import com.sk89q.worldguard.LocalPlayer;
 import com.sk89q.worldguard.bukkit.WorldConfiguration;
 import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
-import com.sk89q.worldguard.domains.DefaultDomain;
-import com.sk89q.worldguard.protection.ApplicableRegionSet;
-import com.sk89q.worldguard.protection.databases.ProtectionDatabaseException;
-import com.sk89q.worldguard.protection.databases.RegionDBUtil;
-import com.sk89q.worldguard.protection.databases.migrators.AbstractDatabaseMigrator;
-import com.sk89q.worldguard.protection.databases.migrators.MigrationException;
-import com.sk89q.worldguard.protection.databases.migrators.MigratorKey;
-import com.sk89q.worldguard.protection.flags.*;
-import com.sk89q.worldguard.protection.managers.RegionManager;
-import com.sk89q.worldguard.protection.regions.GlobalProtectedRegion;
-import com.sk89q.worldguard.protection.regions.ProtectedCuboidRegion;
-import com.sk89q.worldguard.protection.regions.ProtectedPolygonalRegion;
-import com.sk89q.worldguard.protection.regions.ProtectedRegion;
-import com.sk89q.worldguard.protection.regions.ProtectedRegion.CircularInheritanceException;
+import com.sk89q.worldguard.region.ApplicableRegionSet;
+import com.sk89q.worldguard.region.Region;
+import com.sk89q.worldguard.region.flags.*;
+import com.sk89q.worldguard.region.indices.RegionIndex;
+import com.sk89q.worldguard.region.shapes.Cuboid;
+import com.sk89q.worldguard.region.shapes.ExtrudedPolygon;
 import org.bukkit.ChatColor;
 import org.bukkit.World;
 import org.bukkit.command.CommandSender;
@@ -58,52 +50,52 @@ public class RegionCommands {
 
     private MigratorKey migrateDBRequest;
     private Date migrateDBRequestDate;
-    
+
     public RegionCommands(WorldGuardPlugin plugin) {
         this.plugin = plugin;
     }
-    
+
     @Command(aliases = {"define", "def", "d"}, usage = "<id> [<owner1> [<owner2> [<owners...>]]]",
             desc = "Defines a region", min = 1)
     @CommandPermissions({"worldguard.region.define"})
     public void define(CommandContext args, CommandSender sender) throws CommandException {
-        
+
         Player player = plugin.checkPlayer(sender);
         WorldEditPlugin worldEdit = plugin.getWorldEdit();
         String id = args.getString(0);
-        
-        if (!ProtectedRegion.isValidId(id)) {
+
+        if (!Region.isValidId(id)) {
             throw new CommandException("Invalid region ID specified!");
         }
-        
+
         if (id.equalsIgnoreCase("__global__")) {
             throw new CommandException("A region cannot be named __global__");
         }
-        
+
         // Attempt to get the player's selection from WorldEdit
         Selection sel = worldEdit.getSelection(player);
-        
+
         if (sel == null) {
             throw new CommandException("Select a region with WorldEdit first.");
         }
-        
-        RegionManager mgr = plugin.getGlobalRegionManager().get(sel.getWorld());
+
+        RegionIndex mgr = plugin.getGlobalRegionManager().get(sel.getWorld());
         if (mgr.hasRegion(id)) {
             throw new CommandException("That region is already defined. Use redefine instead.");
         }
-        
-        ProtectedRegion region;
+
+        Region region;
 
         // Detect the type of region from WorldEdit
         if (sel instanceof Polygonal2DSelection) {
             Polygonal2DSelection polySel = (Polygonal2DSelection) sel;
             int minY = polySel.getNativeMinimumPoint().getBlockY();
             int maxY = polySel.getNativeMaximumPoint().getBlockY();
-            region = new ProtectedPolygonalRegion(id, polySel.getNativePoints(), minY, maxY);
+            region = new ExtrudedPolygon(id, polySel.getNativePoints(), minY, maxY);
         } else if (sel instanceof CuboidSelection) {
             BlockVector min = sel.getNativeMinimumPoint().toBlockVector();
             BlockVector max = sel.getNativeMaximumPoint().toBlockVector();
-            region = new ProtectedCuboidRegion(id, min, max);
+            region = new Cuboid(id, min, max);
         } else {
             throw new CommandException(
                     "The type of region selected in WorldEdit is unsupported in WorldGuard!");
@@ -113,9 +105,9 @@ public class RegionCommands {
         if (args.argsLength() > 1) {
             region.setOwners(RegionDBUtil.parseDomainString(args.getSlice(1), 1));
         }
-        
+
         mgr.addRegion(region);
-        
+
         try {
             mgr.save();
             sender.sendMessage(ChatColor.YELLOW + "Region saved as " + id + ".");
@@ -124,23 +116,23 @@ public class RegionCommands {
                     + e.getMessage());
         }
     }
-    
+
     @Command(aliases = {"redefine", "update", "move"}, usage = "<id>",
             desc = "Re-defines the shape of a region", min = 1, max = 1)
     public void redefine(CommandContext args, CommandSender sender) throws CommandException {
-        
+
         Player player = plugin.checkPlayer(sender);
         World world = player.getWorld();
         WorldEditPlugin worldEdit = plugin.getWorldEdit();
         LocalPlayer localPlayer = plugin.wrapPlayer(player);
         String id = args.getString(0);
-        
+
         if (id.equalsIgnoreCase("__global__")) {
             throw new CommandException("The region cannot be named __global__");
         }
 
-        RegionManager mgr = plugin.getGlobalRegionManager().get(world);
-        ProtectedRegion existing = mgr.getRegionExact(id);
+        RegionIndex mgr = plugin.getGlobalRegionManager().get(world);
+        Region existing = mgr.getRegionExact(id);
 
         if (existing == null) {
             throw new CommandException("Could not find a region by that ID.");
@@ -152,27 +144,27 @@ public class RegionCommands {
             plugin.checkPermission(sender, "worldguard.region.redefine.member");
         } else {
             plugin.checkPermission(sender, "worldguard.region.redefine");
-        } 
-        
+        }
+
         // Attempt to get the player's selection from WorldEdit
         Selection sel = worldEdit.getSelection(player);
-        
+
         if (sel == null) {
             throw new CommandException("Select a region with WorldEdit first.");
         }
-        
-        ProtectedRegion region;
-        
+
+        Region region;
+
         // Detect the type of region from WorldEdit
         if (sel instanceof Polygonal2DSelection) {
             Polygonal2DSelection polySel = (Polygonal2DSelection) sel;
             int minY = polySel.getNativeMinimumPoint().getBlockY();
             int maxY = polySel.getNativeMaximumPoint().getBlockY();
-            region = new ProtectedPolygonalRegion(id, polySel.getNativePoints(), minY, maxY);
+            region = new ExtrudedPolygon(id, polySel.getNativePoints(), minY, maxY);
         } else if (sel instanceof CuboidSelection) {
             BlockVector min = sel.getNativeMinimumPoint().toBlockVector();
             BlockVector max = sel.getNativeMaximumPoint().toBlockVector();
-            region = new ProtectedCuboidRegion(id, min, max);
+            region = new Cuboid(id, min, max);
         } else {
             throw new CommandException(
                     "The type of region selected in WorldEdit is unsupported in WorldGuard!");
@@ -186,11 +178,11 @@ public class RegionCommands {
             region.setParent(existing.getParent());
         } catch (CircularInheritanceException ignore) {
         }
-        
+
         mgr.addRegion(region);
-        
+
         sender.sendMessage(ChatColor.YELLOW + "Region updated with new area.");
-        
+
         try {
             mgr.save();
         } catch (ProtectionDatabaseException e) {
@@ -198,137 +190,6 @@ public class RegionCommands {
                     + e.getMessage());
         }
     }
-    
-    @Command(aliases = {"claim"}, usage = "<id> [<owner1> [<owner2> [<owners...>]]]",
-            desc = "Claim a region", min = 1)
-    @CommandPermissions({"worldguard.region.claim"})
-    public void claim(CommandContext args, CommandSender sender) throws CommandException {
-        
-        Player player = plugin.checkPlayer(sender);
-        LocalPlayer localPlayer = plugin.wrapPlayer(player);
-        WorldEditPlugin worldEdit = plugin.getWorldEdit();
-        String id = args.getString(0);
-        
-        if (!ProtectedRegion.isValidId(id)) {
-            throw new CommandException("Invalid region ID specified!");
-        }
-        
-        if (id.equalsIgnoreCase("__global__")) {
-            throw new CommandException("A region cannot be named __global__");
-        }
-        
-        // Attempt to get the player's selection from WorldEdit
-        Selection sel = worldEdit.getSelection(player);
-        
-        if (sel == null) {
-            throw new CommandException("Select a region with WorldEdit first.");
-        }
-        
-        RegionManager mgr = plugin.getGlobalRegionManager().get(sel.getWorld());
-
-        if (mgr.hasRegion(id)) {
-            throw new CommandException("That region already exists. Please choose a different name.");
-        }
-        
-        ProtectedRegion region;
-
-        // Detect the type of region from WorldEdit
-        if (sel instanceof Polygonal2DSelection) {
-            Polygonal2DSelection polySel = (Polygonal2DSelection) sel;
-            int minY = polySel.getNativeMinimumPoint().getBlockY();
-            int maxY = polySel.getNativeMaximumPoint().getBlockY();
-            region = new ProtectedPolygonalRegion(id, polySel.getNativePoints(), minY, maxY);
-        } else if (sel instanceof CuboidSelection) {
-            BlockVector min = sel.getNativeMinimumPoint().toBlockVector();
-            BlockVector max = sel.getNativeMaximumPoint().toBlockVector();
-            region = new ProtectedCuboidRegion(id, min, max);
-        } else {
-            throw new CommandException(
-                    "The type of region selected in WorldEdit is unsupported in WorldGuard!");
-        }
-
-        // Get the list of region owners
-        if (args.argsLength() > 1) {
-            region.setOwners(RegionDBUtil.parseDomainString(args.getSlice(1), 1));
-        }
-
-        WorldConfiguration wcfg = plugin.getGlobalStateManager().get(player.getWorld());
-        
-        if (!plugin.hasPermission(sender, "worldguard.region.unlimited")) {
-            // Check whether the player has created too many regions 
-            int maxRegionCount = wcfg.getMaxRegionCount(player);
-            if (maxRegionCount >= 0
-                    && mgr.getRegionCountOfPlayer(localPlayer) >= maxRegionCount) {
-                throw new CommandException("You own too many regions, delete one first to claim a new one.");
-            }
-        }
-
-        ProtectedRegion existing = mgr.getRegionExact(id);
-
-        // Check for an existing region
-        if (existing != null) {
-            if (!existing.getOwners().contains(localPlayer)) {
-                throw new CommandException("This region already exists and you don't own it.");
-            }
-        }
-        
-        ApplicableRegionSet regions = mgr.getApplicableRegions(region);
-        
-        // Check if this region overlaps any other region
-        if (regions.size() > 0) {
-            if (!regions.isOwnerOfAll(localPlayer)) {
-                throw new CommandException("This region overlaps with someone else's region.");
-            }
-        } else {
-            if (wcfg.claimOnlyInsideExistingRegions) {
-                throw new CommandException("You may only claim regions inside " +
-                        "existing regions that you or your group own.");
-            }
-        }
-
-        /*if (plugin.getGlobalConfiguration().getiConomy() != null && wcfg.useiConomy && wcfg.buyOnClaim) {
-            if (iConomy.getBank().hasAccount(player.getName())) {
-                Account account = iConomy.getBank().getAccount(player.getName());
-                double balance = account.getBalance();
-                double regionCosts = region.countBlocks() * wcfg.buyOnClaimPrice;
-                if (balance >= regionCosts) {
-                    account.subtract(regionCosts);
-                    player.sendMessage(ChatColor.YELLOW + "You have bought that region for "
-                            + iConomy.getBank().format(regionCosts));
-                    account.save();
-                } else {
-                    player.sendMessage(ChatColor.RED + "You have not enough money.");
-                    player.sendMessage(ChatColor.RED + "The region you want to claim costs "
-                            + iConomy.getBank().format(regionCosts));
-                    player.sendMessage(ChatColor.RED + "You have " + iConomy.getBank().format(balance));
-                    return;
-                }
-            } else {
-                player.sendMessage(ChatColor.YELLOW + "You have not enough money.");
-                return;
-            }
-        }*/
-
-        if (!plugin.hasPermission(sender, "worldguard.region.unlimited")) {
-            if (region.volume() > wcfg.maxClaimVolume) {
-                player.sendMessage(ChatColor.RED + "This region is too large to claim.");
-                player.sendMessage(ChatColor.RED +
-                        "Max. volume: " + wcfg.maxClaimVolume + ", your volume: " + region.volume());
-                return;
-            }
-        }
-
-        region.getOwners().addPlayer(player.getName());
-        mgr.addRegion(region);
-        
-        try {
-            mgr.save();
-            sender.sendMessage(ChatColor.YELLOW + "Region saved as " + id + ".");
-        } catch (ProtectionDatabaseException e) {
-            throw new CommandException("Failed to write regions: "
-                    + e.getMessage());
-        }
-    }
 
     @Command(aliases = {"select", "sel", "s"}, usage = "[id]",
             desc = "Load a region as a WorldEdit selection", min = 0, max = 1)
@@ -338,7 +199,7 @@ public class RegionCommands {
         final World world = player.getWorld();
         final LocalPlayer localPlayer = plugin.wrapPlayer(player);
 
-        final RegionManager mgr = plugin.getGlobalRegionManager().get(world);
+        final RegionIndex mgr = plugin.getGlobalRegionManager().get(world);
 
         final String id;
         if (args.argsLength() == 0) {
@@ -354,7 +215,7 @@ public class RegionCommands {
             id = args.getString(0);
         }
 
-        final ProtectedRegion region = mgr.getRegion(id);
+        final Region region = mgr.getRegion(id);
 
         if (region == null) {
             throw new CommandException("Could not find a region by that ID.");
@@ -363,7 +224,7 @@ public class RegionCommands {
         selectRegion(player, localPlayer, region);
     }
 
-    public void selectRegion(Player player, LocalPlayer localPlayer, ProtectedRegion region) throws CommandException, CommandPermissionsException {
+    public void selectRegion(Player player, LocalPlayer localPlayer, Region region) throws CommandException, CommandPermissionsException {
         final WorldEditPlugin worldEdit = plugin.getWorldEdit();
         final String id = region.getId();
 
@@ -376,19 +237,19 @@ public class RegionCommands {
         }
 
         final World world = player.getWorld();
-        if (region instanceof ProtectedCuboidRegion) {
-            final ProtectedCuboidRegion cuboid = (ProtectedCuboidRegion) region;
-            final Vector pt1 = cuboid.getMinimumPoint();
-            final Vector pt2 = cuboid.getMaximumPoint();
+        if (region instanceof Cuboid) {
+            final Cuboid cuboid = (Cuboid) region;
+            final Vector pt1 = cuboid.getAABBMin();
+            final Vector pt2 = cuboid.getAABBMax();
             final CuboidSelection selection = new CuboidSelection(world, pt1, pt2);
             worldEdit.setSelection(player, selection);
             player.sendMessage(ChatColor.YELLOW + "Region selected as a cuboid.");
-        } else if (region instanceof ProtectedPolygonalRegion) {
-            final ProtectedPolygonalRegion poly2d = (ProtectedPolygonalRegion) region;
+        } else if (region instanceof ExtrudedPolygon) {
+            final ExtrudedPolygon poly2d = (ExtrudedPolygon) region;
             final Polygonal2DSelection selection = new Polygonal2DSelection(
                     world, poly2d.getPoints(),
-                    poly2d.getMinimumPoint().getBlockY(),
-                    poly2d.getMaximumPoint().getBlockY()
+                    poly2d.getAABBMin().getBlockY(),
+                    poly2d.getAABBMax().getBlockY()
             );
             worldEdit.setSelection(player, selection);
             player.sendMessage(ChatColor.YELLOW + "Region selected as a polygon.");
@@ -416,7 +277,7 @@ public class RegionCommands {
             world = plugin.matchWorld(sender, args.getString(0));
         }
 
-        final RegionManager mgr = plugin.getGlobalRegionManager().get(world);
+        final RegionIndex mgr = plugin.getGlobalRegionManager().get(world);
 
         final String id;
 
@@ -444,10 +305,10 @@ public class RegionCommands {
             id = args.getString(1).toLowerCase();
         }
 
-        final ProtectedRegion region = mgr.getRegion(id);
+        final Region region = mgr.getRegion(id);
 
         if (region == null) {
-            if (!ProtectedRegion.isValidId(id)) {
+            if (!Region.isValidId(id)) {
                 throw new CommandException("Invalid region ID specified!");
             }
             throw new CommandException("A region with ID '" + id + "' doesn't exist.");
@@ -460,7 +321,7 @@ public class RegionCommands {
         }
     }
 
-    public void displayRegionInfo(CommandSender sender, final LocalPlayer localPlayer, ProtectedRegion region) throws CommandPermissionsException {
+    public void displayRegionInfo(CommandSender sender, final LocalPlayer localPlayer, Region region) throws CommandPermissionsException {
         if (localPlayer == null) {
             plugin.checkPermission(sender, "worldguard.region.info");
         } else if (region.isOwner(localPlayer)) {
@@ -519,8 +380,8 @@ public class RegionCommands {
             sender.sendMessage(ChatColor.LIGHT_PURPLE + "Members: " + members.toUserFriendlyString());
         }
 
-        final BlockVector min = region.getMinimumPoint();
-        final BlockVector max = region.getMaximumPoint();
+        final BlockVector min = region.getAABBMin();
+        final BlockVector max = region.getAABBMax();
         sender.sendMessage(ChatColor.LIGHT_PURPLE + "Bounds:"
                 + " (" + min.getBlockX() + "," + min.getBlockY() + "," + min.getBlockZ() + ")"
                 + " (" + max.getBlockX() + "," + max.getBlockY() + "," + max.getBlockZ() + ")"
@@ -604,8 +465,8 @@ public class RegionCommands {
             world = plugin.checkPlayer(sender).getWorld();
         }
 
-        final RegionManager mgr = plugin.getGlobalRegionManager().get(world);
-        final Map<String, ProtectedRegion> regions = mgr.getRegions();
+        final RegionIndex mgr = plugin.getGlobalRegionManager().get(world);
+        final Map<String, Region> regions = mgr.getRegions();
 
         List<RegionEntry> regionEntries = new ArrayList<RegionEntry>();
         int index = 0;
@@ -652,11 +513,11 @@ public class RegionCommands {
     @Command(aliases = {"flag", "f"}, usage = "<id> <flag> [-g group] [value]", flags = "g:",
             desc = "Set flags", min = 2)
     public void flag(CommandContext args, CommandSender sender) throws CommandException {
-        
+
         Player player = plugin.checkPlayer(sender);
         World world = player.getWorld();
         LocalPlayer localPlayer = plugin.wrapPlayer(player);
-        
+
         String id = args.getString(0);
         String flagName = args.getString(1);
         String value = null;
@@ -666,8 +527,8 @@ public class RegionCommands {
             value = args.getJoinedStrings(2);
         }
 
-        RegionManager mgr = plugin.getGlobalRegionManager().get(world);
-        ProtectedRegion region = mgr.getRegion(id);
+        RegionIndex mgr = plugin.getGlobalRegionManager().get(world);
+        Region region = mgr.getRegion(id);
 
         if (region == null) {
             if (id.equalsIgnoreCase("__global__")) {
@@ -691,9 +552,9 @@ public class RegionCommands {
             else if (plugin.hasPermission(sender, "worldguard.region.flag.regions." + id.toLowerCase())) hasPerm = true;
         }
         if (!hasPerm) throw new CommandPermissionsException();
-        
+
         Flag<?> foundFlag = null;
-        
+
         // Now time to find the flag!
         for (Flag<?> flag : DefaultFlag.getFlags()) {
             // Try to detect the flag
@@ -702,10 +563,10 @@ public class RegionCommands {
                 break;
             }
         }
-        
+
         if (foundFlag == null) {
             StringBuilder list = new StringBuilder();
-            
+
             // Need to build a list
             for (Flag<?> flag : DefaultFlag.getFlags()) {
                 if (list.length() > 0) {
@@ -730,8 +591,8 @@ public class RegionCommands {
                                 + flag.getName() + "." + id.toLowerCase())) {
                         continue;
                     }
-                } 
-                
+                }
+
                 list.append(flag.getName());
             }
 
@@ -817,29 +678,29 @@ public class RegionCommands {
                     + e.getMessage());
         }
     }
-    
-    public <V> void setFlag(ProtectedRegion region,
+
+    public <V> void setFlag(Region region,
             Flag<V> flag, CommandSender sender, String value)
                 throws InvalidFlagFormat {
         region.setFlag(flag, flag.parseInput(plugin, sender, value));
     }
-    
+
     @Command(aliases = {"setpriority", "priority", "pri"}, usage = "<id> <priority>",
             desc = "Set the priority of a region", min = 2, max = 2)
     public void setPriority(CommandContext args, CommandSender sender) throws CommandException {
         Player player = plugin.checkPlayer(sender);
         World world = player.getWorld();
         LocalPlayer localPlayer = plugin.wrapPlayer(player);
-        
+
         String id = args.getString(0);
         int priority = args.getInteger(1);
-        
+
         if (id.equalsIgnoreCase("__global__")) {
             throw new CommandException("The region cannot be named __global__");
         }
-        
-        RegionManager mgr = plugin.getGlobalRegionManager().get(world);
-        ProtectedRegion region = mgr.getRegion(id);
+
+        RegionIndex mgr = plugin.getGlobalRegionManager().get(world);
+        Region region = mgr.getRegion(id);
         if (region == null) {
             throw new CommandException("Could not find a region by that ID.");
         }
@@ -852,14 +713,14 @@ public class RegionCommands {
             plugin.checkPermission(sender, "worldguard.region.setpriority.member." + id.toLowerCase());
         } else {
             plugin.checkPermission(sender, "worldguard.region.setpriority." + id.toLowerCase());
-        } 
+        }
 
         region.setPriority(priority);
 
         sender.sendMessage(ChatColor.YELLOW
                 + "Priority of '" + region.getId() + "' set to "
                 + priority + ".");
-        
+
         try {
             mgr.save();
         } catch (ProtectionDatabaseException e) {
@@ -867,22 +728,22 @@ public class RegionCommands {
                     + e.getMessage());
         }
     }
-    
+
     @Command(aliases = {"setparent", "parent", "par"}, usage = "<id> [parent-id]",
             desc = "Set the parent of a region", min = 1, max = 2)
     public void setParent(CommandContext args, CommandSender sender) throws CommandException {
         Player player = plugin.checkPlayer(sender);
         World world = player.getWorld();
         LocalPlayer localPlayer = plugin.wrapPlayer(player);
-        
+
         String id = args.getString(0);
-        
+
         if (id.equalsIgnoreCase("__global__")) {
             throw new CommandException("The region cannot be named __global__");
         }
-        
-        RegionManager mgr = plugin.getGlobalRegionManager().get(world);
-        ProtectedRegion region = mgr.getRegion(id);
+
+        RegionIndex mgr = plugin.getGlobalRegionManager().get(world);
+        Region region = mgr.getRegion(id);
         if (region == null) {
             throw new CommandException("Could not find a target region by that ID.");
         }
@@ -894,25 +755,25 @@ public class RegionCommands {
                 region.setParent(null);
             } catch (CircularInheritanceException ignore) {
             }
-    
+
             sender.sendMessage(ChatColor.YELLOW
                     + "Parent of '" + region.getId() + "' cleared.");
         } else {
             String parentId = args.getString(1);
-            ProtectedRegion parent = mgr.getRegion(parentId);
-    
+            Region parent = mgr.getRegion(parentId);
+
             if (parent == null) {
                 throw new CommandException("Could not find the parent region by that ID.");
             }
-            
+
             if (region.isOwner(localPlayer)) {
                 plugin.checkPermission(sender, "worldguard.region.setparent.own." + id.toLowerCase());
             } else if (region.isMember(localPlayer)) {
                 plugin.checkPermission(sender, "worldguard.region.setparent.member." + id.toLowerCase());
             } else {
                 plugin.checkPermission(sender, "worldguard.region.setparent." + id.toLowerCase());
-            } 
-            
+            }
+
             if (parent.isOwner(localPlayer)) {
                 plugin.checkPermission(sender, "worldguard.region.setparent.own." + parentId.toLowerCase());
             } else if (parent.isMember(localPlayer)) {
@@ -920,18 +781,18 @@ public class RegionCommands {
             } else {
                 plugin.checkPermission(sender, "worldguard.region.setparent." + parentId.toLowerCase());
             }
-            
+
             try {
                 region.setParent(parent);
             } catch (CircularInheritanceException e) {
                 throw new CommandException("Circular inheritance detected!");
             }
-    
+
             sender.sendMessage(ChatColor.YELLOW
                     + "Parent of '" + region.getId() + "' set to '"
                     + parent.getId() + "'.");
         }
-        
+
         try {
             mgr.save();
         } catch (ProtectionDatabaseException e) {
@@ -939,24 +800,24 @@ public class RegionCommands {
                     + e.getMessage());
         }
     }
-    
+
     @Command(aliases = {"remove", "delete", "del", "rem"}, usage = "<id>",
             desc = "Remove a region", min = 1, max = 1)
     public void remove(CommandContext args, CommandSender sender) throws CommandException {
-        
+
         Player player = plugin.checkPlayer(sender);
         World world = player.getWorld();
         LocalPlayer localPlayer = plugin.wrapPlayer(player);
-        
+
         String id = args.getString(0);
 
-        RegionManager mgr = plugin.getGlobalRegionManager().get(world);
-        ProtectedRegion region = mgr.getRegionExact(id);
+        RegionIndex mgr = plugin.getGlobalRegionManager().get(world);
+        Region region = mgr.getRegionExact(id);
 
         if (region == null) {
             throw new CommandException("Could not find a region by that ID.");
         }
-        
+
         if (region.isOwner(localPlayer)) {
             plugin.checkPermission(sender, "worldguard.region.remove.own." + id.toLowerCase());
         } else if (region.isMember(localPlayer)) {
@@ -964,12 +825,12 @@ public class RegionCommands {
         } else {
             plugin.checkPermission(sender, "worldguard.region.remove." + id.toLowerCase());
         }
-        
+
         mgr.removeRegion(id);
-        
+
         sender.sendMessage(ChatColor.YELLOW
                 + "Region '" + id + "' removed.");
-        
+
         try {
             mgr.save();
         } catch (ProtectionDatabaseException e) {
@@ -977,21 +838,21 @@ public class RegionCommands {
                     + e.getMessage());
         }
     }
-    
+
     @Command(aliases = {"load", "reload"}, usage = "[world]",
             desc = "Reload regions from file", max = 1)
     @CommandPermissions({"worldguard.region.load"})
     public void load(CommandContext args, CommandSender sender) throws CommandException {
-        
+
         World world = null;
-        
+
         if (args.argsLength() > 0) {
             world = plugin.matchWorld(sender, args.getString(0));
         }
 
         if (world != null) {
-            RegionManager mgr = plugin.getGlobalRegionManager().get(world);
-            
+            RegionIndex mgr = plugin.getGlobalRegionManager().get(world);
+
             try {
                 mgr.load();
                 sender.sendMessage(ChatColor.YELLOW
@@ -1002,8 +863,8 @@ public class RegionCommands {
             }
         } else {
             for (World w : plugin.getServer().getWorlds()) {
-                RegionManager mgr = plugin.getGlobalRegionManager().get(w);
-                
+                RegionIndex mgr = plugin.getGlobalRegionManager().get(w);
+
                 try {
                     mgr.load();
                 } catch (ProtectionDatabaseException e) {
@@ -1011,26 +872,26 @@ public class RegionCommands {
                             + e.getMessage());
                 }
             }
-            
+
             sender.sendMessage(ChatColor.YELLOW
                     + "Region databases loaded.");
         }
     }
-    
+
     @Command(aliases = {"save", "write"}, usage = "[world]",
             desc = "Re-save regions to file", max = 1)
     @CommandPermissions({"worldguard.region.save"})
     public void save(CommandContext args, CommandSender sender) throws CommandException {
-        
+
         World world = null;
-        
+
         if (args.argsLength() > 0) {
             world = plugin.matchWorld(sender, args.getString(0));
         }
 
         if (world != null) {
-            RegionManager mgr = plugin.getGlobalRegionManager().get(world);
-            
+            RegionIndex mgr = plugin.getGlobalRegionManager().get(world);
+
             try {
                 mgr.save();
                 sender.sendMessage(ChatColor.YELLOW
@@ -1041,8 +902,8 @@ public class RegionCommands {
             }
         } else {
             for (World w : plugin.getServer().getWorlds()) {
-                RegionManager mgr = plugin.getGlobalRegionManager().get(w);
-                
+                RegionIndex mgr = plugin.getGlobalRegionManager().get(w);
+
                 try {
                     mgr.save();
                 } catch (ProtectionDatabaseException e) {
@@ -1050,74 +911,24 @@ public class RegionCommands {
                             + e.getMessage());
                 }
             }
-            
+
             sender.sendMessage(ChatColor.YELLOW
                     + "Region databases saved.");
         }
     }
 
-    @Command(aliases = {"migratedb"}, usage = "<from> <to>",
-            desc = "Migrate from one Protection Database to another.", min = 1)
-    @CommandPermissions({"worldguard.region.migratedb"})
-    public void migratedb(CommandContext args, CommandSender sender) throws CommandException {
-        String from = args.getString(0).toLowerCase().trim();
-        String to = args.getString(1).toLowerCase().trim();
-
-        if (from.equals(to)) {
-            throw new CommandException("Will not migrate with common source and target.");
-        }
-
-        Map<MigratorKey, Class<? extends AbstractDatabaseMigrator>> migrators = AbstractDatabaseMigrator.getMigrators();
-        MigratorKey key = new MigratorKey(from,to);
-
-        if (!migrators.containsKey(key)) {
-            throw new CommandException("No migrator found for that combination and direction.");
-        }
-
-        long lastRequest = 10000000;
-        if (this.migrateDBRequestDate != null) { 
-            lastRequest = new Date().getTime() - this.migrateDBRequestDate.getTime();
-        }
-        if (this.migrateDBRequest == null || lastRequest > 60000) {
-            this.migrateDBRequest = key;
-            this.migrateDBRequestDate = new Date();
-
-            throw new CommandException("This command is potentially dangerous.\n" + 
-                    "Please ensure you have made a backup of your data, and then re-enter the command exactly to procede.");
-        }
-
-        Class<? extends AbstractDatabaseMigrator> cls = migrators.get(key);
-
-        try {
-            AbstractDatabaseMigrator migrator = cls.getConstructor(WorldGuardPlugin.class).newInstance(plugin);
-
-            migrator.migrate();
-        } catch (IllegalArgumentException ignore) {
-        } catch (SecurityException ignore) {
-        } catch (InstantiationException ignore) {
-        } catch (IllegalAccessException ignore) {
-        } catch (InvocationTargetException ignore) {
-        } catch (NoSuchMethodException ignore) {
-        } catch (MigrationException e) {
-            throw new CommandException("Error migrating database: " + e.getMessage());
-        }
-
-        sender.sendMessage(ChatColor.YELLOW + "Regions have been migrated successfully.\n" +
-                "If you wish to use the destination format as your new backend, please update your config and reload WorldGuard.");
-    }
-
     @Command(aliases = {"teleport", "tp"}, usage = "<id>", flags = "s",
             desc = "Teleports you to the location associated with the region.", min = 1, max = 1)
     @CommandPermissions({"worldguard.region.teleport"})
     public void teleport(CommandContext args, CommandSender sender) throws CommandException {
         final Player player = plugin.checkPlayer(sender);
 
-        final RegionManager mgr = plugin.getGlobalRegionManager().get(player.getWorld());
+        final RegionIndex mgr = plugin.getGlobalRegionManager().get(player.getWorld());
         String id = args.getString(0);
 
-        final ProtectedRegion region = mgr.getRegion(id);
+        final Region region = mgr.getRegion(id);
         if (region == null) {
-            if (!ProtectedRegion.isValidId(id)) {
+            if (!Region.isValidId(id)) {
                 throw new CommandException("Invalid region ID specified!");
             }
             throw new CommandException("A region with ID '" + id + "' doesn't exist.");

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

@@ -30,11 +30,11 @@ 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.protection.databases.ProtectionDatabaseException;
-import com.sk89q.worldguard.protection.databases.RegionDBUtil;
+import com.sk89q.worldguard.region.Region;
+import com.sk89q.worldguard.region.flags.DefaultFlag;
+import com.sk89q.worldguard.region.indices.RegionIndex;
+import com.sk89q.worldguard.region.stores.ProtectionDatabaseException;
+import com.sk89q.worldguard.region.stores.RegionDBUtil;
 
 // @TODO: A lot of code duplication here! Need to fix.
 
@@ -55,8 +55,8 @@ public class RegionMemberCommands {
         
         String id = args.getString(0);
 
-        RegionManager mgr = plugin.getGlobalRegionManager().get(world);
-        ProtectedRegion region = mgr.getRegion(id);
+        RegionIndex mgr = plugin.getGlobalRegionManager().get(world);
+        Region region = mgr.getRegion(id);
 
         if (region == null) {
             throw new CommandException("Could not find a region by that ID.");
@@ -95,8 +95,8 @@ public class RegionMemberCommands {
         
         String id = args.getString(0);
 
-        RegionManager mgr = plugin.getGlobalRegionManager().get(world);
-        ProtectedRegion region = mgr.getRegion(id);
+        RegionIndex mgr = plugin.getGlobalRegionManager().get(world);
+        Region region = mgr.getRegion(id);
 
         if (region == null) {
             throw new CommandException("Could not find a region by that ID.");
@@ -148,8 +148,8 @@ public class RegionMemberCommands {
         
         String id = args.getString(0);
 
-        RegionManager mgr = plugin.getGlobalRegionManager().get(world);
-        ProtectedRegion region = mgr.getRegion(id);
+        RegionIndex mgr = plugin.getGlobalRegionManager().get(world);
+        Region region = mgr.getRegion(id);
 
         if (region == null) {
             throw new CommandException("Could not find a region by that ID.");
@@ -189,8 +189,8 @@ public class RegionMemberCommands {
         
         String id = args.getString(0);
 
-        RegionManager mgr = plugin.getGlobalRegionManager().get(world);
-        ProtectedRegion region = mgr.getRegion(id);
+        RegionIndex mgr = plugin.getGlobalRegionManager().get(world);
+        Region region = mgr.getRegion(id);
 
         if (region == null) {
             throw new CommandException("Could not find a region by that ID.");

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

@@ -22,15 +22,11 @@ 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;
 
@@ -45,15 +41,15 @@ public class ToggleCommands {
             desc = "Disables all fire spread temporarily", max = 1)
     @CommandPermissions({"worldguard.fire-toggle.stop"})
     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) {
@@ -74,15 +70,14 @@ public class ToggleCommands {
             desc = "Allows all fire spread temporarily", max = 1)
     @CommandPermissions({"worldguard.fire-toggle.stop"})
     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) {
@@ -98,48 +93,20 @@ public class ToggleCommands {
     }
 
     @Command(aliases = {"halt-activity", "stoplag", "haltactivity"},
-            desc = "Attempts to cease as much activity in order to stop lag", flags = "c", max = 0)
+            desc = "Attempts to cease as much activity in order to stop lag", flags = "cag", max = 0)
     @CommandPermissions({"worldguard.halt-activity"})
     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;
@@ -56,18 +57,19 @@ public class WorldGuardCommands {
     @Command(aliases = {"reload"}, desc = "Reload WorldGuard configuration", max = 0)
     @CommandPermissions({"worldguard.reload"})
     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();
@@ -81,15 +83,17 @@ public class WorldGuardCommands {
                 minecraftLogger.removeHandler(handler);
             }
         }
+
+        plugin.simulateWorldLoad();
     }
-    
+
     @Command(aliases = {"report"}, desc = "Writes a report on WorldGuard", flags = "p", max = 0)
     @CommandPermissions({"worldguard.report"})
     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 "
@@ -97,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);

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/FlagCriteria.java

@@ -0,0 +1,113 @@
+// $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.entity.Entity;
+import org.bukkit.entity.Player;
+
+import com.sk89q.rulelists.Criteria;
+import com.sk89q.worldguard.LocalPlayer;
+import com.sk89q.worldguard.bukkit.BukkitContext;
+import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
+import com.sk89q.worldguard.bukkit.resolvers.BlockResolver;
+import com.sk89q.worldguard.bukkit.resolvers.EntityResolver;
+import com.sk89q.worldguard.region.ApplicableRegionSet;
+import com.sk89q.worldguard.region.flags.DefaultFlag;
+import com.sk89q.worldguard.region.flags.StateFlag;
+
+public class FlagCriteria implements Criteria<BukkitContext> {
+
+    private final WorldGuardPlugin plugin;
+    private final StateFlag flag;
+    private BlockResolver blockResolver;
+    private EntityResolver entityResolver;
+
+    public FlagCriteria(WorldGuardPlugin plugin, StateFlag flag) {
+        this.plugin = plugin;
+        this.flag = flag;
+    }
+
+    public BlockResolver getBlockResolver() {
+        return blockResolver;
+    }
+
+    public void setBlockResolver(BlockResolver blockResolver) {
+        this.blockResolver = blockResolver;
+    }
+
+    public EntityResolver getEntityResolver() {
+        return entityResolver;
+    }
+
+    public void setEntityResolver(EntityResolver entityResolver) {
+        this.entityResolver = entityResolver;
+    }
+
+    @Override
+    public boolean matches(BukkitContext context) {
+        boolean matches = false;
+
+        ApplicableRegionSet set = context.getApplicableRegionSet();
+
+        if (set == null) {
+            return false;
+        }
+
+        if (blockResolver != null) {
+            BlockState block = blockResolver.resolve(context);
+
+            if (block == null) {
+                return false;
+            }
+
+            if (flag == DefaultFlag.BUILD) {
+                matches = false;
+            } else {
+                matches = set.allows(flag);
+            }
+
+            if (!matches) {
+                return false;
+            }
+        }
+
+        if (entityResolver != null) {
+            Entity entity = entityResolver.resolve(context);
+
+            if (entity == null) {
+                return false;
+            }
+
+            LocalPlayer localPlayer = null;
+            if (entity instanceof Player) {
+                localPlayer = plugin.wrapPlayer((Player) entity);
+            }
+
+            if (flag == DefaultFlag.BUILD) {
+                matches = localPlayer != null && set.canBuild(localPlayer);
+            } else {
+                matches = set.allows(flag, localPlayer);
+            }
+        }
+
+        return matches;
+    }
+
+}

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

@@ -0,0 +1,83 @@
+// $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.config.LoaderBuilderException;
+import com.sk89q.rebar.config.types.StaticFieldLoaderBuilder;
+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.BlockResolver;
+import com.sk89q.worldguard.bukkit.resolvers.EntityResolver;
+import com.sk89q.worldguard.region.flags.DefaultFlag;
+import com.sk89q.worldguard.region.flags.StateFlag;
+
+public class FlagCriteriaLoader extends AbstractNodeLoader<FlagCriteria> {
+
+    private final WorldGuardPlugin plugin;
+    private final RuleListsManager manager;
+    private final StaticFieldLoaderBuilder<StateFlag> stateFlagLoader =
+            new StaticFieldLoaderBuilder<StateFlag>(DefaultFlag.class, StateFlag.class);
+
+    public FlagCriteriaLoader(WorldGuardPlugin plugin, RuleListsManager manager) {
+        this.plugin = plugin;
+        this.manager = manager;
+    }
+
+    @Override
+    public FlagCriteria read(ConfigurationNode node)
+            throws DefinitionException {
+        BlockResolver blockResolver = null;
+        EntityResolver entityResolver = null;
+
+        String entity = node.getString("entity");
+        String block = node.getString("block");
+
+        if (block != null) {
+            blockResolver = manager.getResolvers().get(BlockResolver.class, block);
+        }
+
+        if (entity != null) {
+            entityResolver = manager.getResolvers().get(EntityResolver.class, entity);
+        }
+
+        if (block == null && entity == null) {
+            throw new LoaderBuilderException("Flag criteria needs either a block resolver or an entity resolver");
+        }
+
+        StateFlag flag = node.getOf("flag", stateFlagLoader);
+        if (flag == null) {
+            throw new LoaderBuilderException("A flag must be specified");
+        }
+
+        FlagCriteria criteria = new FlagCriteria(plugin, flag);
+        criteria.setBlockResolver(blockResolver);
+        criteria.setEntityResolver(entityResolver);
+
+        RuleListUtils.warnUnknown(node, LoggerUtils.getLogger(getClass()),
+                                  "flag", "block", "entity");
+
+        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/RegionCriteria.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 org.bukkit.block.BlockState;
+import org.bukkit.entity.Entity;
+
+import com.sk89q.rulelists.Criteria;
+import com.sk89q.worldguard.bukkit.BukkitContext;
+import com.sk89q.worldguard.bukkit.resolvers.BlockResolver;
+import com.sk89q.worldguard.bukkit.resolvers.EntityResolver;
+import com.sk89q.worldguard.region.ApplicableRegionSet;
+
+public class RegionCriteria implements Criteria<BukkitContext> {
+
+    private BlockResolver blockResolver;
+    private EntityResolver entityResolver;
+
+    public BlockResolver getBlockResolver() {
+        return blockResolver;
+    }
+
+    public void setBlockResolver(BlockResolver blockResolver) {
+        this.blockResolver = blockResolver;
+    }
+
+    public EntityResolver getEntityResolver() {
+        return entityResolver;
+    }
+
+    public void setEntityResolver(EntityResolver entityResolver) {
+        this.entityResolver = entityResolver;
+    }
+
+    @Override
+    public boolean matches(BukkitContext context) {
+        boolean matches = false;
+
+        if (blockResolver != null) {
+            BlockState block = blockResolver.resolve(context);
+
+            if (block == null) {
+                return false;
+            }
+
+            ApplicableRegionSet set = context.getRegionQuery().lookup(block.getBlock());
+
+            if (set == null) {
+                return false;
+            }
+
+            context.setApplicableRegionSet(set);
+            matches = true;
+        }
+
+        if (entityResolver != null) {
+            Entity entity = entityResolver.resolve(context);
+
+            if (entity == null) {
+                return false;
+            }
+
+            ApplicableRegionSet set = context.getRegionQuery().lookup(entity);
+
+            if (set == null) {
+                return false;
+            }
+
+            context.setApplicableRegionSet(set);
+            matches = true;
+        }
+
+        return matches;
+    }
+
+}

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

@@ -0,0 +1,70 @@
+// $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.config.LoaderBuilderException;
+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.BlockResolver;
+import com.sk89q.worldguard.bukkit.resolvers.EntityResolver;
+
+public class RegionCriteriaLoader extends AbstractNodeLoader<RegionCriteria> {
+
+    private final RuleListsManager manager;
+
+    public RegionCriteriaLoader(RuleListsManager manager) {
+        this.manager = manager;
+    }
+
+    @Override
+    public RegionCriteria read(ConfigurationNode node)
+            throws DefinitionException {
+        BlockResolver blockResolver = null;
+        EntityResolver entityResolver = null;
+
+        String entity = node.getString("entity");
+        String block = node.getString("block");
+
+        if (block != null) {
+            blockResolver = manager.getResolvers().get(BlockResolver.class, block);
+        }
+
+        if (entity != null) {
+            entityResolver = manager.getResolvers().get(EntityResolver.class, entity);
+        }
+
+        if (block == null && entity == null) {
+            throw new LoaderBuilderException("Region criteria needs either a block resolver or an entity resolver");
+        }
+
+        RegionCriteria criteria = new RegionCriteria();
+        criteria.setBlockResolver(blockResolver);
+        criteria.setEntityResolver(entityResolver);
+
+        RuleListUtils.warnUnknown(node, LoggerUtils.getLogger(getClass()),
+                                  "block", "entity");
+
+        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;
+    }
+
+}

src/main/java/com/sk89q/worldguard/bukkit/definitions/SetDropAction.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.entity.PlayerDeathEvent;
+
+import com.sk89q.rulelists.Action;
+import com.sk89q.worldguard.bukkit.BukkitContext;
+
+public class SetDropAction implements Action<BukkitContext> {
+
+    private Integer exp;
+
+    public Integer getExp() {
+        return exp;
+    }
+
+    public void setExp(Integer exp) {
+        this.exp = exp;
+    }
+
+    @Override
+    public void apply(BukkitContext context) {
+        Event event = context.getEvent();
+        
+        if (event instanceof PlayerDeathEvent) {
+            PlayerDeathEvent deathEvent = (PlayerDeathEvent) event;
+            
+            if (exp != null) {
+                deathEvent.setDroppedExp(exp);
+            }
+        }
+        
+    }
+
+}

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

@@ -0,0 +1,41 @@
+// $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 SetDropActionLoader extends AbstractNodeLoader<SetDropAction> {
+
+    @Override
+    public SetDropAction read(ConfigurationNode node) throws DefinitionException {
+        SetDropAction criteria = new SetDropAction();
+
+        criteria.setExp(node.getInt("set-xp"));
+
+        RuleListUtils.warnUnknown(node, LoggerUtils.getLogger(getClass()),
+                                  "set-xp");
+
+        return criteria;
+    }
+
+}

src/main/java/com/sk89q/worldguard/bukkit/definitions/SetMessageAction.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.worldguard.bukkit.definitions;
+
+import com.sk89q.rulelists.Action;
+import com.sk89q.rulelists.ExpressionParser;
+import com.sk89q.worldguard.bukkit.BukkitContext;
+
+public class SetMessageAction implements Action<BukkitContext> {
+
+    private ExpressionParser parser;
+    private String message;
+
+    public SetMessageAction(String message) {
+        this.message = message;
+    }
+
+    public ExpressionParser getParser() {
+        return parser;
+    }
+
+    public void setParser(ExpressionParser parser) {
+        this.parser = parser;
+    }
+
+    public String getMessage() {
+        return message;
+    }
+
+    public void setMessage(String message) {
+        this.message = message;
+    }
+
+    @Override
+    public void apply(BukkitContext context) {
+        String newMessage = message;
+
+        if (parser != null) {
+            newMessage = parser.format(context, newMessage);
+        }
+
+        context.setMessage(newMessage);
+    }
+
+}

src/main/java/com/sk89q/worldguard/bukkit/definitions/SetMessageActionLoader.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 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.util.LoggerUtils;
+import com.sk89q.rulelists.DefinitionException;
+import com.sk89q.rulelists.RuleListUtils;
+import com.sk89q.rulelists.RuleListsManager;
+
+public class SetMessageActionLoader extends AbstractNodeLoader<SetMessageAction> {
+
+    private final RuleListsManager manager;
+
+    public SetMessageActionLoader(RuleListsManager manager) {
+        this.manager = manager;
+    }
+
+    @Override
+    public SetMessageAction read(ConfigurationNode node) throws DefinitionException {
+        String message = node.contains(INLINE) ?
+                node.getString(INLINE) :
+                node.getString("message");
+
+        if (message == null) {
+            throw new LoaderBuilderException("No message specified");
+        }
+
+        SetMessageAction action = new SetMessageAction(message);
+        action.setParser(manager.getParser());
+
+        RuleListUtils.warnUnknown(node, LoggerUtils.getLogger(getClass()),
+                                  "message");
+
+        return action;
+    }
+
+}

src/main/java/com/sk89q/worldguard/bukkit/definitions/SpawnCriteria.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.CreatureSpawnEvent;
+import org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason;
+
+import com.sk89q.rulelists.Criteria;
+import com.sk89q.worldguard.bukkit.BukkitContext;
+
+public class SpawnCriteria implements Criteria<BukkitContext> {
+
+    private Set<SpawnReason> causes = new HashSet<SpawnReason>();
+
+    public SpawnCriteria(Set<SpawnReason> causes) {
+        this.causes = causes;
+    }
+
+    public Set<SpawnReason> getCauses() {
+        return causes;
+    }
+
+    public void setCauses(Set<SpawnReason> causes) {
+        this.causes = causes;
+    }
+
+    @Override
+    public boolean matches(BukkitContext context) {
+        Event event = context.getEvent();
+
+        if (event instanceof CreatureSpawnEvent) {
+            return causes.contains(((CreatureSpawnEvent) event).getSpawnReason());
+        } else {
+            return false;
+        }
+    }
+
+}

src/main/java/com/sk89q/worldguard/bukkit/definitions/SpawnCriteriaLoader.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.CreatureSpawnEvent.SpawnReason;
+
+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 SpawnCriteriaLoader extends AbstractNodeLoader<SpawnCriteria> {
+
+    private EnumLoaderBuilder<SpawnReason> typeLoader =
+            new EnumLoaderBuilder<SpawnReason>(SpawnReason.class);
+
+    @Override
+    public SpawnCriteria read(ConfigurationNode node) throws DefinitionException {
+        Set<SpawnReason> types = node.contains(INLINE) ?
+                node.setOf(INLINE, typeLoader) :
+                node.setOf("type", typeLoader);
+
+        SpawnCriteria criteria = new SpawnCriteria(types);
+
+        RuleListUtils.warnUnknown(node, LoggerUtils.getLogger(getClass()),
+                                  "type");
+
+        return criteria;
+    }
+
+}

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

@@ -0,0 +1,68 @@
+// $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.command.CommandSender;
+import org.bukkit.entity.Entity;
+
+import com.sk89q.rulelists.Action;
+import com.sk89q.rulelists.ExpressionParser;
+import com.sk89q.worldguard.bukkit.BukkitContext;
+import com.sk89q.worldguard.bukkit.resolvers.EntityResolver;
+
+public class TellAction implements Action<BukkitContext> {
+
+    private ExpressionParser parser;
+    private EntityResolver entityResolver;
+    private String message;
+
+    public TellAction(EntityResolver entityResolver, String message) {
+        this.entityResolver = entityResolver;
+        this.message = message;
+    }
+
+    public ExpressionParser getParser() {
+        return parser;
+    }
+
+    public void setParser(ExpressionParser parser) {
+        this.parser = parser;
+    }
+
+    public String getMessage() {
+        return message;
+    }
+
+    public void setMessage(String message) {
+        this.message = message;
+    }
+
+    @Override
+    public void apply(BukkitContext context) {
+        Entity sender = entityResolver.resolve(context);
+
+        if (sender != null && sender instanceof CommandSender) {
+            if (parser != null) {
+                message = parser.format(context, message);
+            }
+            ((CommandSender) sender).sendMessage(message);
+        }
+    }
+
+}

src/main/java/com/sk89q/worldguard/bukkit/definitions/TellActionLoader.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 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.resolvers.EntityResolver;
+
+public class TellActionLoader extends AbstractNodeLoader<TellAction> {
+
+    private final RuleListsManager manager;
+
+    public TellActionLoader(RuleListsManager manager) {
+        this.manager = manager;
+    }
+
+    @Override
+    public TellAction read(ConfigurationNode node) throws DefinitionException {
+        EntityResolver entityResolver = manager.getResolvers()
+                .get(EntityResolver.class, node.getString("entity", EntityResolver.DEFAULT));
+
+        String message = node.contains(INLINE) ? node.getString(INLINE) : node.getString("message");
+
+        TellAction action = new TellAction(entityResolver, message);
+        action.setParser(manager.getParser());
+
+        RuleListUtils.warnUnknown(node, LoggerUtils.getLogger(getClass()),
+                                  "entity", "message");
+
+        return action;
+    }
+
+}

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

@@ -0,0 +1,344 @@
+// $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.Location;
+import org.bukkit.Material;
+import org.bukkit.World;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+
+import com.sk89q.rulelists.Action;
+import com.sk89q.worldedit.blocks.BlockType;
+import com.sk89q.worldguard.bukkit.BukkitContext;
+import com.sk89q.worldguard.bukkit.ConfigurationManager;
+import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
+import com.sk89q.worldguard.bukkit.resolvers.EntityResolver;
+
+public class UpdateEntityAction implements Action<BukkitContext> {
+
+    private final WorldGuardPlugin wg;
+    private final EntityResolver entityResolver;
+
+    private Boolean explode;
+    private Float fallDistance;
+    private Integer fireTicks;
+
+    private Integer health;
+    private Integer damage;
+    private Integer remainingAir;
+
+    private Integer foodLevel;
+    private Float exhaustionLevel;
+    private Float saturationLevel;
+    private Float walkSpeed;
+    private Boolean allowFlight;
+    private Boolean flying;
+    private Float flySpeed;
+    private Boolean sneaking;
+    private Boolean sprinting;
+    private Boolean invincible;
+    private Boolean openWorkbench;
+    private String performCommand;
+
+    private Boolean teleportSafely;
+
+    public UpdateEntityAction(WorldGuardPlugin wg, EntityResolver entityResolver) {
+        this.wg = wg;
+        this.entityResolver = entityResolver;
+    }
+
+    public Boolean getExplode() {
+        return explode;
+    }
+
+    public void setExplode(Boolean explode) {
+        this.explode = explode;
+    }
+
+    public Float getFallDistance() {
+        return fallDistance;
+    }
+
+    public void setFallDistance(Float fallDistance) {
+        this.fallDistance = fallDistance;
+    }
+
+    public Integer getFireTicks() {
+        return fireTicks;
+    }
+
+    public void setFireTicks(Integer fireTicks) {
+        this.fireTicks = fireTicks;
+    }
+
+    public Integer getHealth() {
+        return health;
+    }
+
+    public void setHealth(Integer health) {
+        this.health = health;
+    }
+
+    public Integer getDamage() {
+        return damage;
+    }
+
+    public void setDamage(Integer damage) {
+        this.damage = damage;
+    }
+
+    public Integer getRemainingAir() {
+        return remainingAir;
+    }
+
+    public void setRemainingAir(Integer remainingAir) {
+        this.remainingAir = remainingAir;
+    }
+
+    public Integer getFoodLevel() {
+        return foodLevel;
+    }
+
+    public void setFoodLevel(Integer foodLevel) {
+        this.foodLevel = foodLevel;
+    }
+
+    public Float getExhaustionLevel() {
+        return exhaustionLevel;
+    }
+
+    public void setExhaustionLevel(Float exhaustionLevel) {
+        this.exhaustionLevel = exhaustionLevel;
+    }
+
+    public Float getSaturationLevel() {
+        return saturationLevel;
+    }
+
+    public void setSaturationLevel(Float saturationLevel) {
+        this.saturationLevel = saturationLevel;
+    }
+
+    public Float getWalkSpeed() {
+        return walkSpeed;
+    }
+
+    public void setWalkSpeed(Float walkSpeed) {
+        this.walkSpeed = walkSpeed;
+    }
+
+    public Boolean getAllowFlight() {
+        return allowFlight;
+    }
+
+    public void setAllowFlight(Boolean allowFlight) {
+        this.allowFlight = allowFlight;
+    }
+
+    public Boolean getFlying() {
+        return flying;
+    }
+
+    public void setFlying(Boolean flying) {
+        this.flying = flying;
+    }
+
+    public Float getFlySpeed() {
+        return flySpeed;
+    }
+
+    public void setFlySpeed(Float flySpeed) {
+        this.flySpeed = flySpeed;
+    }
+
+    public Boolean getSneaking() {
+        return sneaking;
+    }
+
+    public void setSneaking(Boolean sneaking) {
+        this.sneaking = sneaking;
+    }
+
+    public Boolean getSprinting() {
+        return sprinting;
+    }
+
+    public void setSprinting(Boolean sprinting) {
+        this.sprinting = sprinting;
+    }
+
+    public Boolean getInvincible() {
+        return invincible;
+    }
+
+    public void setInvincible(Boolean invincible) {
+        this.invincible = invincible;
+    }
+
+    public Boolean getOpenWorkbench() {
+        return openWorkbench;
+    }
+
+    public void setOpenWorkbench(Boolean openWorkbench) {
+        this.openWorkbench = openWorkbench;
+    }
+
+    public String getPerformCommand() {
+        return performCommand;
+    }
+
+    public void setPerformCommand(String performCommand) {
+        this.performCommand = performCommand;
+    }
+
+    public Boolean getTeleportSafely() {
+        return teleportSafely;
+    }
+
+    public void setTeleportSafely(Boolean teleportSafely) {
+        this.teleportSafely = teleportSafely;
+    }
+
+    @SuppressWarnings("deprecation")
+    @Override
+    public void apply(BukkitContext context) {
+        Entity entity = entityResolver.resolve(context);
+
+        if (explode != null)
+            entity.getWorld().createExplosion(null, 4);
+
+        if (fireTicks != null)
+            entity.setFireTicks(fireTicks);
+
+        if (fallDistance != null)
+            entity.setFallDistance(fallDistance);
+
+        if (entity instanceof LivingEntity) {
+            LivingEntity living = (LivingEntity) entity;
+
+            if (health != null)
+                living.setHealth(health);
+
+            if (damage != null)
+                living.damage(damage);
+
+            if (remainingAir != null)
+                living.setRemainingAir(remainingAir);
+        }
+
+        if (entity instanceof Player) {
+            Player player = (Player) entity;
+
+            if (foodLevel != null)
+                player.setFoodLevel(foodLevel);
+
+            if (saturationLevel != null)
+                player.setSaturation(saturationLevel);
+
+            if (exhaustionLevel != null)
+                player.setExhaustion(exhaustionLevel);
+
+            if (walkSpeed != null)
+                player.setWalkSpeed(walkSpeed);
+
+            if (allowFlight != null)
+                player.setAllowFlight(allowFlight);
+
+            if (flying != null)
+                player.setFlying(flying);
+
+            if (flySpeed != null)
+                player.setFlySpeed(flySpeed);
+
+            if (sneaking != null)
+                player.setSneaking(sneaking);
+
+            if (sprinting != null)
+                player.setSneaking(sprinting);
+
+            if (invincible != null) {
+                ConfigurationManager cfg = wg.getGlobalStateManager();
+
+                if (invincible) {
+                    cfg.enableGodMode(player);
+                } else {
+                    cfg.disableGodMode(player);
+                }
+            }
+
+            if (openWorkbench != null && openWorkbench)
+                player.openWorkbench(player.getLocation(), true);
+
+            if (performCommand != null)
+                player.performCommand(performCommand);
+        }
+
+        if (teleportSafely != null && teleportSafely) {
+            Location loc = entity.getLocation();
+            World world = loc.getWorld();
+
+            // In case we're in void!
+            if (loc.getY() < 1) {
+                loc.setY(1);
+            }
+
+            int maxY = world.getMaxHeight();
+            int x = loc.getBlockX();
+            int y = Math.max(0, loc.getBlockY());
+            int z = loc.getBlockZ();
+
+            byte free = 0;
+
+            loop:
+            while (y <= maxY + 2) {
+                if (BlockType.canPassThrough(new Location(world, x, y, z).getBlock().getTypeId())) {
+                    ++free;
+                } else {
+                    free = 0;
+                }
+
+                if (free == 2) {
+                    Block block = world.getBlockAt(x, y - 2, z);
+                    int id = block.getTypeId();
+                    int data = block.getData();
+                    Location newLoc = new Location(world, x + 0.5,
+                            y - 2 + BlockType.centralTopLimit(id, data), z + 0.5);
+
+                    // Don't want the player falling into void
+                    if (newLoc.getBlockY() <= 1) {
+                        Block bottomBlock = world.getBlockAt(x, 0, z);
+                        bottomBlock.setType(Material.GLASS);
+                        newLoc.add(0, 1, 0);
+                    }
+
+                    entity.teleport(newLoc);
+                    entity.setFallDistance(0);
+
+                    break loop;
+                }
+
+                ++y;
+            }
+        }
+    }
+
+}

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

@@ -0,0 +1,81 @@
+// $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;
+import com.sk89q.rulelists.RuleListsManager;
+import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
+import com.sk89q.worldguard.bukkit.resolvers.EntityResolver;
+
+public class UpdateEntityActionLoader extends AbstractNodeLoader<UpdateEntityAction> {
+
+    private final WorldGuardPlugin wg;
+    private final RuleListsManager manager;
+
+    public UpdateEntityActionLoader(WorldGuardPlugin wg, RuleListsManager manager) {
+        this.wg = wg;
+        this.manager = manager;
+    }
+
+    @Override
+    public UpdateEntityAction read(ConfigurationNode node) throws DefinitionException {
+        EntityResolver entityResolver = manager.getResolvers()
+                .get(EntityResolver.class, node.getString("entity", EntityResolver.DEFAULT));
+
+        UpdateEntityAction criteria = new UpdateEntityAction(wg, entityResolver);
+
+        criteria.setExplode(node.getBoolean("explode"));
+        criteria.setFallDistance(node.getFloat("set-fall-distance"));
+        criteria.setFireTicks(node.getInt("set-fire-ticks"));
+        criteria.setTeleportSafely(node.getBoolean("teleport-safely"));
+
+        criteria.setHealth(node.getInt("set-health"));
+        criteria.setDamage(node.getInt("damage"));
+        criteria.setRemainingAir(node.getInt("set-air"));
+
+        criteria.setFoodLevel(node.getInt("food-level"));
+        criteria.setSaturationLevel(node.getFloat("set-saturation"));
+        criteria.setExhaustionLevel(node.getFloat("set-exhaustion"));
+        criteria.setWalkSpeed(node.getFloat("set-walk-speed"));
+        criteria.setAllowFlight(node.getBoolean("set-allow-flight"));
+        criteria.setFlying(node.getBoolean("set-flying"));
+        criteria.setFlySpeed(node.getFloat("set-fly-speed"));
+        criteria.setSneaking(node.getBoolean("set-sneaking"));
+        criteria.setSprinting(node.getBoolean("set-sprinting"));
+        criteria.setInvincible(node.getBoolean("set-invincible"));
+        criteria.setOpenWorkbench(node.getBoolean("open-workbench"));
+        criteria.setPerformCommand(node.getString("perform-command"));
+
+        RuleListUtils.warnUnknown(node, LoggerUtils.getLogger(getClass()),
+                                  "entity", "explode", "set-fall-distance",
+                                  "set-fire-ticks", "set-health", "damage", "set-air",
+                                  "food-level", "set-saturation", "set-exhaustion",
+                                  "set-walk-speed", "set-allow-flight", "set-flying",
+                                  "set-fly-speed", "set-sneaking", "set-sprinting",
+                                  "set-invincible", "open-workbench", "perform-command",
+                                  "teleport-safely");
+
+        return criteria;
+    }
+
+}

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

@@ -0,0 +1,95 @@
+// $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.inventory.ItemStack;
+
+import com.sk89q.rulelists.Action;
+import com.sk89q.worldguard.bukkit.BukkitContext;
+import com.sk89q.worldguard.bukkit.resolvers.EntityResolver;
+import com.sk89q.worldguard.bukkit.resolvers.ItemStackSlot;
+import com.sk89q.worldguard.bukkit.resolvers.ItemStackSlotResolver;
+
+public class UpdateItemAction implements Action<BukkitContext> {
+
+    private final EntityResolver entityResolver;
+    private final ItemStackSlotResolver itemResolver;
+    private boolean destroy = false;
+    private short newData = -1;
+
+    public UpdateItemAction(EntityResolver entityResolver, ItemStackSlotResolver itemResolver) {
+        this.entityResolver = entityResolver;
+        this.itemResolver = itemResolver;
+    }
+
+    public boolean isDestroy() {
+        return destroy;
+    }
+
+    public void setDestroy(boolean destroy) {
+        this.destroy = destroy;
+    }
+
+    public short getNewData() {
+        return newData;
+    }
+
+    public void setNewData(short newData) {
+        this.newData = newData;
+    }
+
+    @Override
+    public void apply(BukkitContext context) {
+        ItemStackSlot slot = null;
+        ItemStack item;
+
+        if (entityResolver == null) {
+            item = context.getItem();
+        } else {
+            Entity entity = entityResolver.resolve(context);
+
+            if (entity == null) {
+                return;
+            }
+
+            slot = itemResolver.resolve(entity);
+            item = slot.get();
+        }
+
+        if (item == null) {
+            return;
+        }
+
+        boolean updated = false;
+
+        if (destroy) {
+            item = null;
+            updated = true;
+        } else if (newData >= 0) {
+            item.setDurability(newData);
+            updated = true;
+        }
+
+        if (updated && slot != null) {
+            slot.update(item);
+        }
+    }
+
+}

src/main/java/com/sk89q/worldguard/bukkit/definitions/UpdateItemActionLoader.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 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.resolvers.EntityResolver;
+import com.sk89q.worldguard.bukkit.resolvers.ItemStackSlotResolver;
+
+public class UpdateItemActionLoader extends AbstractNodeLoader<UpdateItemAction> {
+
+    private final RuleListsManager manager;
+
+    public UpdateItemActionLoader(RuleListsManager manager) {
+        this.manager = manager;
+    }
+
+    @Override
+    public UpdateItemAction 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));
+        }
+
+        boolean destroy = node.getBoolean("destroy", false);
+        short newData = (short) node.getInt("set-data", -1);
+
+        UpdateItemAction action = new UpdateItemAction(entityResolver, resolver);
+        action.setDestroy(destroy);
+        action.setNewData(newData);
+
+        RuleListUtils.warnUnknown(node, LoggerUtils.getLogger(getClass()),
+                                  "item", "entity", "destroy", "set-data");
+
+        return action;
+    }
+
+}

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

@@ -0,0 +1,75 @@
+// $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.World;
+import org.bukkit.event.Event;
+import org.bukkit.event.weather.WeatherChangeEvent;
+import org.bukkit.event.world.WorldEvent;
+
+import com.sk89q.rulelists.Action;
+import com.sk89q.worldguard.bukkit.BukkitContext;
+
+public class UpdateWorldAction implements Action<BukkitContext> {
+
+    private Boolean storm = null;
+    private Boolean thunderstorm = null;
+
+    public UpdateWorldAction() {
+    }
+
+    public Boolean getStorm() {
+        return storm;
+    }
+
+    public void setStorm(Boolean storm) {
+        this.storm = storm;
+    }
+
+    public Boolean getThunderstorm() {
+        return thunderstorm;
+    }
+
+    public void setThunderstorm(Boolean thunderstorm) {
+        this.thunderstorm = thunderstorm;
+    }
+
+    @Override
+    public void apply(BukkitContext context) {
+        Event event = context.getEvent();
+        World world = null;
+        
+        if (event instanceof WeatherChangeEvent) {
+            world = ((WeatherChangeEvent) event).getWorld();
+        } else if (event instanceof WorldEvent) {
+            world = ((WorldEvent) event).getWorld();
+        } 
+        
+        if (world != null) {
+            if (storm != null) {
+                world.setStorm(storm);
+            }
+            
+            if (thunderstorm != null) {
+                world.setThundering(thunderstorm);
+            }
+        }
+    }
+
+}

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

@@ -0,0 +1,44 @@
+// $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 UpdateWorldActionLoader extends AbstractNodeLoader<UpdateWorldAction> {
+
+    @Override
+    public UpdateWorldAction read(ConfigurationNode node) throws DefinitionException {
+        Boolean storm = node.getBoolean("set-storm");
+        Boolean thunderstorm = node.getBoolean("set-thunderstorm");
+
+        UpdateWorldAction action = new UpdateWorldAction();
+        action.setStorm(storm);
+        action.setThunderstorm(thunderstorm);
+
+        RuleListUtils.warnUnknown(node, LoggerUtils.getLogger(getClass()),
+                                  "set-storm", "set-thunderstorm");
+
+        return action;
+    }
+
+}

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

@@ -0,0 +1,80 @@
+// $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.weather.ThunderChangeEvent;
+import org.bukkit.event.weather.WeatherChangeEvent;
+
+import com.sk89q.rulelists.Criteria;
+import com.sk89q.worldguard.bukkit.BukkitContext;
+
+public class WeatherCriteria implements Criteria<BukkitContext> {
+    
+    public enum Type {
+        STORM,
+        THUNDERSTORM,
+    }
+
+    private Set<Type> causes = new HashSet<Type>();
+    private Boolean isStarting = null;
+
+    public WeatherCriteria(Set<Type> causes) {
+        this.causes = causes;
+    }
+
+    public Set<Type> getCauses() {
+        return causes;
+    }
+
+    public void setCauses(Set<Type> causes) {
+        this.causes = causes;
+    }
+
+    public Boolean getIsStarting() {
+        return isStarting;
+    }
+
+    public void setIsStarting(Boolean isStarting) {
+        this.isStarting = isStarting;
+    }
+
+    @Override
+    public boolean matches(BukkitContext context) {
+        Event event = context.getEvent();
+        boolean startVal = true;
+        
+        if (isStarting != null) {
+            startVal = event instanceof WeatherChangeEvent && 
+                    ((WeatherChangeEvent) event).toWeatherState() == isStarting;
+        }
+
+        if (event instanceof WeatherChangeEvent) {
+            return startVal && causes.contains(Type.STORM);
+        } else if (event instanceof ThunderChangeEvent) {
+            return startVal && causes.contains(Type.THUNDERSTORM);
+        } else {
+            return startVal;
+        }
+    }
+
+}

src/main/java/com/sk89q/worldguard/bukkit/definitions/WeatherCriteriaLoader.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.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 WeatherCriteriaLoader extends AbstractNodeLoader<WeatherCriteria> {
+
+    private EnumLoaderBuilder<WeatherCriteria.Type> typeLoader =
+            new EnumLoaderBuilder<WeatherCriteria.Type>(WeatherCriteria.Type.class);
+
+    @Override
+    public WeatherCriteria read(ConfigurationNode node) throws DefinitionException {
+        Set<WeatherCriteria.Type> types = node.contains(INLINE) ?
+                node.setOf(INLINE, typeLoader) :
+                node.setOf("type", typeLoader);
+
+        WeatherCriteria criteria = new WeatherCriteria(types);
+        criteria.setIsStarting(node.getBoolean("is-starting"));
+
+        RuleListUtils.warnUnknown(node, LoggerUtils.getLogger(getClass()),
+                                  "type", "is-starting");
+
+        return criteria;
+    }
+
+}

src/main/java/com/sk89q/worldguard/bukkit/resolvers/BlockResolver.java

@@ -0,0 +1,32 @@
+// $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.resolvers;
+
+import org.bukkit.block.BlockState;
+
+import com.sk89q.rulelists.Context;
+import com.sk89q.rulelists.Resolver;
+
+public interface BlockResolver extends Resolver {
+    
+    public static final String DEFAULT = "target";
+
+    public BlockState resolve(Context context);
+    
+}

src/main/java/com/sk89q/worldguard/bukkit/resolvers/EntityResolver.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.resolvers;
+
+import org.bukkit.entity.Entity;
+
+import com.sk89q.rulelists.Context;
+import com.sk89q.rulelists.Resolver;
+
+public interface EntityResolver extends Resolver {
+
+    public static final String DEFAULT = "target";
+
+    public Entity resolve(Context context);
+}

src/main/java/com/sk89q/worldguard/bukkit/resolvers/ItemStackSlot.java

@@ -0,0 +1,44 @@
+// $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.resolvers;
+
+import org.bukkit.inventory.ItemStack;
+
+/**
+ * Indicates an item stack slot that can be updated with a new stack.
+ *
+ * @author sk89q
+ */
+public interface ItemStackSlot {
+
+    /**
+     * Get the current item stack.
+     *
+     * @return item stack, or null
+     */
+    ItemStack get();
+
+    /**
+     * Update the slot with a new item stack.
+     *
+     * @param stack the new item stack
+     */
+    void update(ItemStack stack);
+
+}

src/main/java/com/sk89q/worldguard/bukkit/resolvers/ItemStackSlotResolver.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.worldguard.bukkit.resolvers;
+
+import org.bukkit.entity.Entity;
+
+import com.sk89q.rulelists.Resolver;
+
+public interface ItemStackSlotResolver extends Resolver {
+    
+    public static final String DEFAULT = "held";
+
+    public ItemStackSlot resolve(Entity entity);
+}

src/main/java/com/sk89q/worldguard/bukkit/resolvers/PlacedBlockResolver.java

@@ -0,0 +1,33 @@
+// $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.resolvers;
+
+import org.bukkit.block.BlockState;
+
+import com.sk89q.rulelists.Context;
+import com.sk89q.worldguard.bukkit.BukkitContext;
+
+public class PlacedBlockResolver implements BlockResolver {
+
+    @Override
+    public BlockState resolve(Context context) {
+        return ((BukkitContext) context).getPlacedBlock();
+    }
+
+}

src/main/java/com/sk89q/worldguard/bukkit/resolvers/PlayerItemStackSlotResolver.java

@@ -0,0 +1,127 @@
+// $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.resolvers;
+
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.HumanEntity;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.PlayerInventory;
+
+public class PlayerItemStackSlotResolver implements ItemStackSlotResolver {
+
+    public enum Slot {
+        HELD,
+        HELMET,
+        CHESTPLATE,
+        LEGGINGS,
+        BOOTS;
+    }
+
+    private final Slot slot;
+
+    public PlayerItemStackSlotResolver(Slot slot) {
+        this.slot = slot;
+    }
+
+    @Override
+    public ItemStackSlot resolve(Entity entity) {
+        if (entity != null && entity instanceof HumanEntity) {
+            final PlayerInventory inventory = ((HumanEntity) entity).getInventory();
+
+            switch (slot) {
+            case HELD:
+                final ItemStack item = nonNull(inventory.getItemInHand());
+                return new ItemStackSlot() {
+                    @Override
+                    public void update(ItemStack stack) {
+                        inventory.setItemInHand(stack);
+                    }
+
+                    @Override
+                    public ItemStack get() {
+                        return item;
+                    }
+                };
+
+            case HELMET:
+                final ItemStack helmet = nonNull(inventory.getHelmet());
+                return new ItemStackSlot() {
+                    @Override
+                    public void update(ItemStack stack) {
+                        inventory.setHelmet(stack);
+                    }
+
+                    @Override
+                    public ItemStack get() {
+                        return helmet;
+                    }
+                };
+
+            case CHESTPLATE:
+                final ItemStack chestPlate = nonNull(inventory.getChestplate());
+                return new ItemStackSlot() {
+                    @Override
+                    public void update(ItemStack stack) {
+                        inventory.setChestplate(stack);
+                    }
+
+                    @Override
+                    public ItemStack get() {
+                        return chestPlate;
+                    }
+                };
+
+            case LEGGINGS:
+                final ItemStack leggings = nonNull(inventory.getLeggings());
+                return new ItemStackSlot() {
+                    @Override
+                    public void update(ItemStack stack) {
+                        inventory.setLeggings(stack);
+                    }
+
+                    @Override
+                    public ItemStack get() {
+                        return leggings;
+                    }
+                };
+
+            case BOOTS:
+                final ItemStack boots = nonNull(inventory.getBoots());
+                return new ItemStackSlot() {
+                    @Override
+                    public void update(ItemStack stack) {
+                        inventory.setBoots(stack);
+                    }
+
+                    @Override
+                    public ItemStack get() {
+                        return boots;
+                    }
+                };
+            }
+        }
+
+        return null;
+    }
+
+    private static ItemStack nonNull(ItemStack item) {
+        return item == null ? new ItemStack(0) : item;
+    }
+
+}

src/main/java/com/sk89q/worldguard/bukkit/resolvers/SimpleMethodCaller.java

@@ -0,0 +1,23 @@
+// $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.resolvers;
+
+public class SimpleMethodCaller {
+
+}

src/main/java/com/sk89q/worldguard/bukkit/resolvers/SourceBlockResolver.java

@@ -0,0 +1,33 @@
+// $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.resolvers;
+
+import org.bukkit.block.BlockState;
+
+import com.sk89q.rulelists.Context;
+import com.sk89q.worldguard.bukkit.BukkitContext;
+
+public class SourceBlockResolver implements BlockResolver {
+
+    @Override
+    public BlockState resolve(Context context) {
+        return ((BukkitContext) context).getSourceBlock();
+    }
+
+}

src/main/java/com/sk89q/worldguard/bukkit/resolvers/SourceEntityResolver.java

@@ -0,0 +1,33 @@
+// $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.resolvers;
+
+import org.bukkit.entity.Entity;
+
+import com.sk89q.rulelists.Context;
+import com.sk89q.worldguard.bukkit.BukkitContext;
+
+public class SourceEntityResolver implements EntityResolver {
+
+    @Override
+    public Entity resolve(Context context) {
+        return ((BukkitContext) context).getSourceEntity();
+    }
+
+}