Updated for 1.7.

CHANGELOG.txt

@@ -1,3 +1,43 @@
+1.7
+- Updated for v0.2.6_02 and hMod b129.
+- Added option to prevent water from damaging particular blocks
+    (Redstone wire, Minecart tracks, etc.). See disable-water-damage-blocks.
+- /reload WorldGuard should now reload WorldGuard's configuration.
+- Added wg-invincible and wg-amphibious groups that let you give certain
+    players invincibility or underwater breathing.
+- Added the ability to disable fall, water, lava, and/or fire damage.
+- Water/lava bucket blocking should now be more reliable.
+- Added /stack (alias /;) commands to stack items in your inventory into
+    piles up to 64 items in size. Even unstackable items like signs can be
+    stacked.
+- /god mode should now let you gain health.
+- /god mode should now work more reliably.
+- Caught an error message for when the configuration file does not exist.
+
+1.6
+- Added spawn protection that prevents damage when a player spawns.
+- Added login protection that prevents damage when a player joins.
+- Added /god. /god can be used on others, provided that the /godother
+    permission is set for the command's user.
+
+1.5.1
+- Removed the 'java.lang.NoSuchMethodError: Item.setDamage(I)V' error
+    generated.
+
+1.5
+- Removed the block lag fix.
+- WorldGuard now conditionally loads features so you can use any up-to-date
+    build of hMod and the unsupported features won't break the entire
+    plugin. When WG loads, check the server console for a report of
+    features that are not supported by your version of hMod.
+- Changed some configuration defaults:
+    disable-lava-fire=true
+    simulate-sponge=true
+    item-durability=false
+
+1.4.1
+- Fixed issue with the block lag fix dropping item stacks of 0 quantity.
+
 1.4
 - New on-acquire hook. This does both a total inventory check on inventory
     change and item pick up denial. The item pick up denial is largely

README.txt

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

manifest.mf

@@ -1,2 +1,2 @@
 Manifest-Version: 1.0
-WorldGuard-Version: 1.4
+WorldGuard-Version: 1.7

src/LoggerToChatHandler.java

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

src/WorldGuard.java

@@ -21,8 +21,11 @@ import java.util.logging.Logger;
 import java.util.logging.Level;
 import java.util.jar.Manifest;
 import java.util.jar.Attributes;
+import java.util.List;
+import java.util.ArrayList;
 import java.net.URL;
 import java.io.*;
+import java.lang.reflect.*;
 
 /**
  * Entry point for the plugin for hey0's mod.
@@ -53,40 +56,86 @@ public class WorldGuard extends Plugin {
     public void initialize() {
         PluginLoader loader = etc.getLoader();
 
-        loader.addListener(PluginLoader.Hook.COMMAND, listener, this,
-                PluginListener.Priority.MEDIUM);
-        loader.addListener(PluginLoader.Hook.SERVERCOMMAND, listener, this,
-                PluginListener.Priority.MEDIUM);
-        loader.addListener(PluginLoader.Hook.EXPLODE, listener, this,
-                PluginListener.Priority.HIGH);
-        loader.addListener(PluginLoader.Hook.IGNITE, listener, this,
-                PluginListener.Priority.HIGH);
-        loader.addListener(PluginLoader.Hook.FLOW, listener, this,
-                PluginListener.Priority.HIGH);
-        loader.addListener(PluginLoader.Hook.LOGINCHECK, listener, this,
-                PluginListener.Priority.HIGH);
-        loader.addListener(PluginLoader.Hook.LOGIN, listener, this,
-                PluginListener.Priority.MEDIUM);
-        loader.addListener(PluginLoader.Hook.BLOCK_CREATED, listener, this,
-                PluginListener.Priority.HIGH);
-        loader.addListener(PluginLoader.Hook.BLOCK_DESTROYED, listener, this,
-                PluginListener.Priority.CRITICAL);
-        loader.addListener(PluginLoader.Hook.BLOCK_BROKEN, listener, this,
-                PluginListener.Priority.HIGH);
-        loader.addListener(PluginLoader.Hook.DISCONNECT, listener, this,
-                PluginListener.Priority.HIGH);
-        loader.addListener(PluginLoader.Hook.ITEM_DROP, listener, this,
-                PluginListener.Priority.HIGH);
-        loader.addListener(PluginLoader.Hook.ITEM_PICK_UP, listener, this,
-                PluginListener.Priority.HIGH);
-        loader.addListener(PluginLoader.Hook.COMPLEX_BLOCK_CHANGE, listener, this,
-                PluginListener.Priority.HIGH);
-        loader.addListener(PluginLoader.Hook.COMPLEX_BLOCK_SEND, listener, this,
-                PluginListener.Priority.HIGH);
-        loader.addListener(PluginLoader.Hook.INVENTORY_CHANGE, listener, this,
-                PluginListener.Priority.HIGH);
-        loader.addListener(PluginLoader.Hook.BLOCK_PHYSICS, listener, this,
-                PluginListener.Priority.MEDIUM);
+        List<String> missingFeatures = new ArrayList<String>();
+
+        registerHook("COMMAND", PluginListener.Priority.MEDIUM);
+        registerHook("SERVERCOMMAND", PluginListener.Priority.MEDIUM);
+        if (!registerHook("EXPLODE", PluginListener.Priority.HIGH)) {
+            missingFeatures.add("disabling TNT or creeper explosions");
+        }
+        if (!registerHook("IGNITE", PluginListener.Priority.HIGH)) {
+            missingFeatures.add("disabling fire or lava fire");
+        }
+        if (!registerHook("FLOW", PluginListener.Priority.HIGH)) {
+            missingFeatures.add("controlling lava flow");
+            missingFeatures.add("sponge simulation");
+        }
+        registerHook("LOGINCHECK", PluginListener.Priority.HIGH);
+        registerHook("LOGIN", PluginListener.Priority.MEDIUM);
+        registerHook("BLOCK_CREATED", PluginListener.Priority.HIGH);
+        registerHook("BLOCK_DESTROYED", PluginListener.Priority.CRITICAL);
+        registerHook("BLOCK_BROKEN", PluginListener.Priority.HIGH);
+        registerHook("BLOCK_PLACE", PluginListener.Priority.HIGH);
+        registerHook("DISCONNECT", PluginListener.Priority.HIGH);
+        registerHook("ITEM_DROP", PluginListener.Priority.HIGH);
+        if (!registerHook("ITEM_USE", PluginListener.Priority.HIGH)) {
+            missingFeatures.add("denying use of the lava or water buckets");
+        }
+        if (!registerHook("ITEM_PICK_UP", PluginListener.Priority.HIGH)) {
+            missingFeatures.add("denying item pickups");
+            missingFeatures.add("the item durability fix");
+        } else {
+            try {
+                Method method = 
+                        Item.class.getDeclaredMethod("setDamage", new Class[]{ Integer.class });
+                if (method == null) {
+                    missingFeatures.add("the item durability fix");
+                }
+            } catch (NoSuchMethodException e) {
+                missingFeatures.add("the item durability fix");
+            }
+        }
+        registerHook("COMPLEX_BLOCK_CHANGE", PluginListener.Priority.HIGH);
+        registerHook("COMPLEX_BLOCK_SEND", PluginListener.Priority.HIGH);
+        registerHook("INVENTORY_CHANGE", PluginListener.Priority.HIGH);
+        if (!registerHook("BLOCK_PHYSICS", PluginListener.Priority.MEDIUM)) {
+            missingFeatures.add("controlling the physics of gravel, sand, or portal blocks");
+        }
+        if (!registerHook("HEALTH_CHANGE", PluginListener.Priority.MEDIUM)) {
+            missingFeatures.add("god mode");
+        }
+        if (!registerHook("DAMAGE", PluginListener.Priority.MEDIUM)) {
+            missingFeatures.add("disabling fall, water, lava, and fire damage");
+        }
+        if (!registerHook("LIQUID_DESTROY", PluginListener.Priority.MEDIUM)) {
+            missingFeatures.add("disabling water damage");
+        }
+
+        if (missingFeatures.size() > 0) {
+            logger.log(Level.WARNING, "WorldGuard: Your version of hMod does not support "
+                    + concatMissingFeatures(missingFeatures) + ".");
+        } else {
+            logger.log(Level.INFO, "WorldGuard: Your version of hMod appears to"
+                    + " support all features.");
+        }
+    }
+
+    /**
+     * Conditionally registers a hook.
+     *
+     * @param name
+     * @param priority
+     * @return where the hook was registered correctly
+     */
+    public boolean registerHook(String name, PluginListener.Priority priority) {
+        try {
+            PluginLoader.Hook hook = PluginLoader.Hook.valueOf(name);
+            etc.getLoader().addListener(hook, listener, this, priority);
+            return true;
+        } catch (IllegalArgumentException e) {
+            //logger.log(Level.WARNING, "WorldGuard: Missing hook " + name + "!");
+            return false;
+        }
     }
 
     /**
@@ -134,4 +183,38 @@ public class WorldGuard extends Plugin {
             return "(unknown)";
         }
     }
+
+    /**
+     * Joins a string from an array of strings.
+     *
+     * @param str
+     * @param delimiter
+     * @return
+     */
+    private static String concatMissingFeatures(List<String> str) {
+        if (str.isEmpty()) {
+            return "";
+        }
+
+        int size = str.size();
+        StringBuilder buffer = new StringBuilder();
+        buffer.append("(1) ");
+        buffer.append(str.get(0));
+        for (int i = 1; i < size; i++) {
+            if (i == size - 1) {
+                buffer.append(" or ");
+                buffer.append("(");
+                buffer.append(i + 1);
+                buffer.append(") ");
+                buffer.append(str.get(i));
+            } else {
+                buffer.append(", ");
+                buffer.append("(");
+                buffer.append(i + 1);
+                buffer.append(") ");
+                buffer.append(str.get(i));
+            }
+        }
+        return buffer.toString();
+    }
 }

src/WorldGuardListener.java

@@ -21,15 +21,12 @@ import java.util.Timer;
 import java.util.TimerTask;
 import java.util.logging.Logger;
 import java.util.logging.Level;
-import java.util.logging.Handler;
-import java.util.logging.ConsoleHandler;
 import java.util.Set;
 import java.util.HashSet;
-import java.util.LinkedList;
+import java.util.Map;
+import java.util.HashMap;
 import java.util.Random;
 import java.io.*;
-import java.util.logging.FileHandler;
-import com.sk89q.worldguard.*;
 
 /**
  * Event listener for Hey0's server mod.
@@ -58,12 +55,24 @@ public class WorldGuardListener extends PluginListener {
      * Properties file for WorldGuard.
      */
     private PropertiesFile properties = new PropertiesFile("worldguard.properties");
-
     /**
-     * Stop fire spread mode.
+     * List of players with god mode on.
      */
+    private Set<String> invinciblePlayers = new HashSet<String>();
+    /**
+     * List of amphibious players.
+     */
+    private Set<String> amphibiousPlayers = new HashSet<String>();
+    /**
+     * Used to keep recent join times.
+     */
+    private Map<String,Long> recentLogins = new HashMap<String,Long>();
+    /**
+     * Used to keep recent spawn times.
+     */
+    private Map<String,Long> lastSpawn = new HashMap<String,Long>();
+
     private boolean stopFireSpread = false;
-    
     private boolean enforceOneSession;
     private boolean blockCreepers;
     private boolean blockTNT;
@@ -72,15 +81,22 @@ public class WorldGuardListener extends PluginListener {
     private boolean disableAllFire;
     private boolean simulateSponge;
     private int spongeRadius;
-    private boolean blockLagFix;
     private boolean itemDurability;
     private Set<Integer> fireNoSpreadBlocks;
     private Set<Integer> allowedLavaSpreadOver;
     private Set<Integer> itemDropBlacklist;
+    private Set<Integer> preventWaterDamage;
     private boolean classicWater;
     private boolean noPhysicsGravel;
     private boolean noPhysicsSand;
     private boolean allowPortalAnywhere;
+    private boolean disableFallDamage;
+    private boolean disableLavaDamage;
+    private boolean disableFireDamage;
+    private boolean disableWaterDamage;
+    private int loginProtection;
+    private int spawnProtection;
+    private boolean kickOnDeath;
     private Blacklist blacklist;
 
     /**
@@ -90,6 +106,7 @@ public class WorldGuardListener extends PluginListener {
      */
     public WorldGuardListener(WorldGuard plugin) {
         this.plugin = plugin;
+        postReload();
     }
 
     /**
@@ -123,30 +140,62 @@ public class WorldGuardListener extends PluginListener {
         return result;
     }
 
+    /**
+     * Populates various lists.
+     */
+    public void postReload() {
+        invinciblePlayers.clear();
+        amphibiousPlayers.clear();
+        
+        for (Player player : etc.getServer().getPlayerList()) {
+            if (player.isInGroup("wg-invincible")) {
+                invinciblePlayers.add(player.getName());
+            }
+
+            if (player.isInGroup("wg-amphibious")) {
+                amphibiousPlayers.add(player.getName());
+            }
+        }
+    }
+
     /**
      * Load the configuration
      */
     public void loadConfiguration() {
-        properties.load();
+        try {
+            properties.load();
+        } catch (IOException e) {
+            logger.log(Level.WARNING, "WorldGuard: Failed to load configuration: "
+                    + e.getMessage());
+        }
+
+        recentLogins.clear();
 
         // Load basic options
         enforceOneSession = properties.getBoolean("enforce-single-session", true);
         blockCreepers = properties.getBoolean("block-creepers", false);
         blockTNT = properties.getBoolean("block-tnt", false);
         blockLighter = properties.getBoolean("block-lighter", false);
-        preventLavaFire = properties.getBoolean("disable-lava-fire", false);
+        preventLavaFire = properties.getBoolean("disable-lava-fire", true);
         disableAllFire = properties.getBoolean("disable-all-fire-spread", false);
+        preventWaterDamage = toBlockIDSet(properties.getString("disable-water-damage-blocks", ""));
         itemDropBlacklist = toBlockIDSet(properties.getString("item-drop-blacklist", ""));
         fireNoSpreadBlocks = toBlockIDSet(properties.getString("disallowed-fire-spread-blocks", ""));
         allowedLavaSpreadOver = toBlockIDSet(properties.getString("allowed-lava-spread-blocks", ""));
         classicWater = properties.getBoolean("classic-water", false);
-        simulateSponge = properties.getBoolean("simulate-sponge", false);
+        simulateSponge = properties.getBoolean("simulate-sponge", true);
         spongeRadius = Math.max(1, properties.getInt("sponge-radius", 3)) - 1;
-        blockLagFix = properties.getBoolean("block-lag-fix", false);
-        itemDurability = properties.getBoolean("item-durability", true);
+        itemDurability = properties.getBoolean("item-durability", false);
         noPhysicsGravel = properties.getBoolean("no-physics-gravel", false);
         noPhysicsSand = properties.getBoolean("no-physics-sand", false);
         allowPortalAnywhere = properties.getBoolean("allow-portal-anywhere", false);
+        disableFallDamage = properties.getBoolean("disable-fall-damage", false);
+        disableLavaDamage = properties.getBoolean("disable-lava-damage", false);
+        disableFireDamage = properties.getBoolean("disable-fire-damage", false);
+        disableWaterDamage = properties.getBoolean("disable-water-damage", false);
+        loginProtection = properties.getInt("login-protection", 3);
+        spawnProtection = properties.getInt("spawn-protection", 0);
+        kickOnDeath = properties.getBoolean("kick-on-death", false);
 
         // Console log configuration
         boolean logConsole = properties.getBoolean("log-console", true);
@@ -171,18 +220,18 @@ public class WorldGuardListener extends PluginListener {
             }
 
             // First load the blacklist data from worldguard-blacklist.txt
-            Blacklist blacklist = new Blacklist();
-            blacklist.load(new File("worldguard-blacklist.txt"));
+            Blacklist blist = new Blacklist();
+            blist.load(new File("worldguard-blacklist.txt"));
 
             // If the blacklist is empty, then set the field to null
             // and save some resources
-            if (blacklist.isEmpty()) {
+            if (blist.isEmpty()) {
                 this.blacklist = null;
             } else {
-                this.blacklist = blacklist;
+                this.blacklist = blist;
                 logger.log(Level.INFO, "WorldGuard: Blacklist loaded.");
 
-                BlacklistLogger blacklistLogger = blacklist.getLogger();
+                BlacklistLogger blacklistLogger = blist.getLogger();
 
                 if (logDatabase) {
                     blacklistLogger.addHandler(new DatabaseLoggerHandler(dsn, user, pass, table));
@@ -235,6 +284,7 @@ public class WorldGuardListener extends PluginListener {
      * @param user
      * @return kick reason. null if you don't want to kick the player.
      */
+    @Override
     public String onLoginChecks(String user) {
         if (enforceOneSession) {
             for (Player player : etc.getServer().getPlayerList()) {
@@ -252,10 +302,23 @@ public class WorldGuardListener extends PluginListener {
      *
      * @param player
      */
+    @Override
     public void onLogin(Player player) {
         if (stopFireSpread) {
             player.sendMessage(Colors.Yellow + "Fire spread is currently globally disabled.");
         }
+
+        if (loginProtection > 0 || spawnProtection > 0 || kickOnDeath) {
+            recentLogins.put(player.getName(), System.currentTimeMillis());
+        }
+
+        if (player.isInGroup("wg-invincible")) {
+            invinciblePlayers.add(player.getName());
+        }
+
+        if (player.isInGroup("wg-amphibious")) {
+            amphibiousPlayers.add(player.getName());
+        }
     }
 
     /**
@@ -266,6 +329,7 @@ public class WorldGuardListener extends PluginListener {
      * @param split
      * @return false if you want the command to be parsed.
      */
+    @Override
     public boolean onCommand(Player player, String[] split) {
         if (split[0].equalsIgnoreCase("/stopfire") &&
                 player.canUseCommand("/stopfire")) {
@@ -287,6 +351,122 @@ public class WorldGuardListener extends PluginListener {
             }
             stopFireSpread = false;
             return true;
+        } else if (split[0].equalsIgnoreCase("/god")
+                    && player.canUseCommand("/god")) {
+            // Allow setting other people invincible
+            if (split.length > 1) {
+                if (!player.canUseCommand("/godother")) {
+                    player.sendMessage(Colors.Rose + "You don't have permission to make others invincible.");
+                    return true;
+                }
+
+                Player other = etc.getServer().matchPlayer(split[1]);
+                if (other == null) {
+                    player.sendMessage(Colors.Rose + "Player not found.");
+                } else {
+                    if (!invinciblePlayers.contains(other.getName())) {
+                        invinciblePlayers.add(other.getName());
+                        player.sendMessage(Colors.Yellow + other.getName() + " is now invincible!");
+                        other.sendMessage(Colors.Yellow + player.getName() + " has made you invincible!");
+                    } else {
+                        invinciblePlayers.remove(other.getName());
+                        player.sendMessage(Colors.Yellow + other.getName() + " is no longer invincible.");
+                        other.sendMessage(Colors.Yellow + player.getName() + " has taken away your invincibility.");
+                    }
+                }
+            // Invincibility for one's self
+            } else {
+                if (!invinciblePlayers.contains(player.getName())) {
+                    invinciblePlayers.add(player.getName());
+                    player.sendMessage(Colors.Yellow + "You are now invincible!");
+                } else {
+                    invinciblePlayers.remove(player.getName());
+                    player.sendMessage(Colors.Yellow + "You are no longer invincible.");
+                }
+            }
+            return true;
+        } else if ((split[0].equalsIgnoreCase("/stack")
+                || split[0].equalsIgnoreCase("/;"))
+                    && player.canUseCommand("/stack")) {
+            hm[] items = player.getInventory().getArray();
+            int len = items.length;
+
+            int affected = 0;
+            
+            for (int i = 0; i < len; i++) {
+                hm item = items[i];
+
+                // Avoid infinite stacks and stacks with durability
+                if (item == null || item.a <= 0 || item.d > 0) {
+                    continue;
+                }
+
+                // Ignore buckets
+                if (item.c >= 325 && item.c <= 327) {
+                    continue;
+                }
+
+                if (item.a < 64) {
+                    int needed = 64 - item.a; // Number of needed items until 64
+
+                    // Find another stack of the same type
+                    for (int j = i + 1; j < len; j++) {
+                        hm item2 = items[j];
+
+                        // Avoid infinite stacks and stacks with durability
+                        if (item2 == null || item2.a <= 0 || item2.d > 0) {
+                            continue;
+                        }
+
+                        // Same type?
+                        if (item2.c == item.c) {
+                            // This stack won't fit in the parent stack
+                            if (item2.a > needed) {
+                                item.a = 64;
+                                item2.a -= needed;
+                                break;
+                            // This stack will
+                            } else {
+                                items[j] = null;
+                                item.a += item2.a;
+                                needed = 64 - item.a;
+                            }
+
+                            affected++;
+                        }
+                    }
+                }
+            }
+
+            if (affected > 0) {
+                player.getInventory().updateInventory();
+            }
+
+            player.sendMessage(Colors.Yellow + "Items compacted into stacks!");
+            
+            return true;
+        } else if (split[0].equalsIgnoreCase("/reload")
+                && player.canUseCommand("/reload")
+                && split.length > 1) {
+            if (split[1].equalsIgnoreCase("WorldGuard")) {
+                LoggerToChatHandler handler = new LoggerToChatHandler(player);
+                handler.setLevel(Level.ALL);
+                Logger minecraftLogger = Logger.getLogger("Minecraft");
+                minecraftLogger.addHandler(handler);
+
+                try {
+                    loadConfiguration();
+                    postReload();
+                    player.sendMessage("WorldGuard configuration reloaded.");
+                } catch (Throwable t) {
+                    player.sendMessage("Error while reloading: "
+                            + t.getMessage());
+                } finally {
+                    minecraftLogger.removeHandler(handler);
+                }
+
+                return true;
+            }
         }
 
         return false;
@@ -299,6 +479,7 @@ public class WorldGuardListener extends PluginListener {
      * @param split
      * @return false if you want the command to be parsed.
      */
+    @Override
     public boolean onConsoleCommand(String[] split) {
         if (split[0].equalsIgnoreCase("fire-stop")) {
             if (!stopFireSpread) {
@@ -335,6 +516,7 @@ public class WorldGuardListener extends PluginListener {
      * @return true if you don't want the dropped item to be spawned in the
      *         world
      */
+    @Override
     public boolean onItemDrop(Player player, Item item) {
         if (itemDropBlacklist != null) {
             int n = item.getItemId();
@@ -350,9 +532,9 @@ public class WorldGuardListener extends PluginListener {
             }
         }
 
-        if (!itemDurability) {
+        /*if (!itemDurability) {
             item.setDamage(0);
-        }
+        }*/
 
         return false;
     }
@@ -366,6 +548,7 @@ public class WorldGuardListener extends PluginListener {
      *            item that was picked up
      * @return true if you want to leave the item where it was
      */
+    @Override
     public boolean onItemPickUp(Player player, Item item) {
         if (blacklist != null && blacklist.hasOnAcquire()) {
             if (!blacklist.onSilentAcquire(item.getItemId(), player)) {
@@ -383,9 +566,10 @@ public class WorldGuardListener extends PluginListener {
      *            player who's inventory was modified
      * @return true if you want any changes to be reverted
      */
+    @Override
     public boolean onInventoryChange(Player player) {
         if (blacklist != null && blacklist.hasOnAcquire()) {
-            hj[] items = player.getInventory().getArray();
+            hm[] items = player.getInventory().getArray();
             boolean needUpdate = false;
 
             for (int i = 0; i < items.length; i++) {
@@ -406,38 +590,46 @@ public class WorldGuardListener extends PluginListener {
     }
 
     /**
-     * Called when someone presses right click. If they right clicked with a
-     * block you can return true to cancel that. You can intercept this to add
-     * your own right click actions to different item types (see itemInHand)
+     * Called when a player uses an item (rightclick with item in hand)
+     * @param player the player
+     * @param item the item being used (in hand)
+     * @return true to prevent using the item.
+     */
+    @Override
+    public boolean onItemUse(Player player, Item item) {
+        if (blacklist != null) {
+            int itemId = item.getItemId();
+
+            if (itemId >= 325 && itemId <= 327) {
+                if (!blacklist.onCreate(itemId, player)) {
+                    return true;
+                }
+            }
+        }
+        
+        return false;
+    }
+
+    /**
+     * Called when someone places a block. Return true to prevent the placement.
      *
      * @param player
      * @param blockPlaced
      * @param blockClicked
      * @param itemInHand
-     * @return false if you want the action to go through
+     * @return true if you want to undo the block placement
      */
-    public boolean onBlockCreate(Player player, Block blockPlaced, Block blockClicked,
-            int itemInHand) {
-        if (blacklist != null) {
-            if (!blacklist.onCreate(itemInHand, player)) {
-                // Water/lava bucket fix
-                if (itemInHand == 326 || itemInHand == 327) {
-                    final int x = blockPlaced.getX();
-                    final int y = blockPlaced.getY();
-                    final int z = blockPlaced.getZ();
-                    final int existingID = etc.getServer().getBlockIdAt(x, y, z);
+    @Override
+    public boolean onBlockPlace(Player player, Block blockPlaced,
+            Block blockClicked, Item itemInHand) {
+        
+        int itemId = itemInHand.getItemId();
 
-                    // This is REALLY BAD, but there's no other choice
-                    // at the moment that is as reliable
-                    timer.schedule(new TimerTask() {
-                        public void run() {
-                            try {
-                                etc.getServer().setBlockAt(existingID, x, y, z);
-                            } catch (Throwable t) {}
-                        }
-                    }, 200); // Just in case
+        if (blacklist != null) {
+            if (itemId < 325 || itemId > 327) {
+                if (!blacklist.onCreate(itemId, player)) {
+                    return true;
                 }
-                return true;
             }
 
             if (!blacklist.onUse(blockClicked, player)) {
@@ -474,6 +666,7 @@ public class WorldGuardListener extends PluginListener {
      * @param block
      * @return
      */
+    @Override
     public boolean onBlockDestroy(Player player, Block block) {
         int type = block.getType();
         
@@ -486,88 +679,6 @@ public class WorldGuardListener extends PluginListener {
                 return true;
             }
         }
-
-        if (blockLagFix
-                && type != 7 // Bedrock
-                && type != 46 // TNT
-                && type != 50 // Torch
-                && type != 51 // Fire
-                && type != 59 // Crops
-                && type != 62 // Burning furnace
-                && type != 64 // Wooden door
-                && type != 69 // Lever
-                && type != 71 // Iron door
-                && type != 75 // Redstone torch
-                && type != 76 // Redstone torch
-                && type != 77 // Stone button
-                ) {
-
-            // Check other plugins first to see if this block can be
-            // destroyed. Since this causes the hook to eventually call
-            // twice, we try to nullify it below
-            if (canDestroyBlock(player, block)) {
-                if (block.getStatus() == 3 && canBreakBlock(player, block)) {
-                    int dropItem = type;
-                    int count = 1;
-
-                    if (type == 1) { dropItem = 4; } // Stone
-                    else if (type == 2) { dropItem = 3; } // Grass
-                    else if (type == 16) { dropItem = 263; } // Coal ore
-                    else if (type == 18) { // Leaves
-                        if (rand.nextDouble() > 0.95) {
-                            dropItem = 6;
-                        } else {
-                            dropItem = 0;
-                        }
-                    }
-                    else if (type == 20) { dropItem = 0; } // Glass
-                    else if (type == 43) { dropItem = 44; } // Double step
-                    else if (type == 47) { dropItem = 0; } // Bookshelves
-                    else if (type == 52) { dropItem = 0; } // Mob spawner
-                    else if (type == 53) { dropItem = 5; } // Wooden stairs
-                    else if (type == 55) { dropItem = 331; } // Redstone wire
-                    else if (type == 56) { dropItem = 264; } // Diamond ore
-                    else if (type == 60) { dropItem = 3; } // Soil
-                    else if (type == 63) { dropItem = 323; } // Sign post
-                    else if (type == 67) { dropItem = 4; } // Cobblestone stairs
-                    else if (type == 68) { dropItem = 323; } // Wall sign
-                    else if (type == 73) { dropItem = 331; count = 4; } // Redstone ore
-                    else if (type == 74) { dropItem = 331; count = 4; } // Glowing redstone ore
-                    else if (type == 78) { dropItem = 0; } // Snow
-                    else if (type == 79) { dropItem = 0; } // Ice
-                    else if (type == 82) { dropItem = 337; count = 4; } // Clay
-                    else if (type == 83) { dropItem = 338; } // Reed
-                    else if (type == 89) { dropItem = 348; } // Lightstone
-
-                    etc.getServer().setBlockAt(0, block.getX(), block.getY(), block.getZ());
-
-                    if (dropItem > 0) {
-                        for (int i = 0; i < count; i++) {
-                            etc.getServer().dropItem(block.getX(), block.getY(), block.getZ(),
-                                    dropItem, i);
-                        }
-
-                        // Drop flint with gravel
-                        if (type == 13) {
-                            if (rand.nextDouble() >= 0.9) {
-                                etc.getServer().dropItem(block.getX(), block.getY(), block.getZ(),
-                                        318, 1);
-                            }
-                        }
-                    }
-
-                    // Now loop this hook back through!
-                    simulateBlockDestroy(player, block);
-                }
-
-                return true;
-            }
-
-            // So we don't have double hook calls caused by the
-            // plugin/protection check
-            block.setType(0);
-            block.setStatus(2);
-        }
         
         return false;
     }
@@ -579,6 +690,7 @@ public class WorldGuardListener extends PluginListener {
      * @param block
      * @return
      */
+    @Override
     public boolean onBlockBreak(Player player, Block block) {
         if (blacklist != null) {
             if (!blacklist.onBreak(block, player)) {
@@ -598,6 +710,7 @@ public class WorldGuardListener extends PluginListener {
      *            complex block that changed
      * @return true if you want any changes to be reverted
      */
+    @Override
     public boolean onComplexBlockChange(Player player, ComplexBlock complexBlock) {
         if (blacklist != null) {
             if (complexBlock instanceof Chest) {
@@ -640,6 +753,7 @@ public class WorldGuardListener extends PluginListener {
      *            complex block that's being sent
      * @return true if you want the chest, furnace or sign to be empty
      */
+    @Override
     public boolean onSendComplexBlock(Player player, ComplexBlock complexBlock) {
         if (blacklist != null) {
             if (complexBlock instanceof Chest) {
@@ -675,6 +789,7 @@ public class WorldGuardListener extends PluginListener {
      *
      * @return true if you dont want the fire to ignite.
      */
+    @Override
     public boolean onIgnite(Block block, Player player) {
         if (preventLavaFire && block.getStatus() == 1) {
             return true;
@@ -719,6 +834,7 @@ public class WorldGuardListener extends PluginListener {
      *
      * @return true if you dont the block to explode.
      */
+    @Override
     public boolean onExplode(Block block) {
         if (blockCreepers && block.getStatus() == 2) {
             return true;
@@ -744,6 +860,7 @@ public class WorldGuardListener extends PluginListener {
      *
      * @return true if you dont want the substance to flow.
      */
+    @Override
     public boolean onFlow(Block blockFrom, Block blockTo) {
         int x = blockFrom.getX();
         int y = blockFrom.getY();
@@ -817,70 +934,155 @@ public class WorldGuardListener extends PluginListener {
     	return false;
     }
 
+    /**
+     * Called when a players health changes.
+     * @param player
+     *              the player which health is changed.
+     * @param oldValue
+     *              old lives value
+     * @param newValue
+     *              new lives value
+     * @return
+     *      return true to stop the change.
+     */
+    @Override
+    public boolean onHealthChange(Player player, int oldValue, int newValue) {
+        String playerName = player.getName();
+
+        if (invinciblePlayers.contains(playerName)) {
+            return oldValue > newValue;
+        }
+
+        if (loginProtection > 0 || spawnProtection > 0 || kickOnDeath) {
+            long now = System.currentTimeMillis();
+            boolean recentLogin = false;
+
+            if (recentLogins.containsKey(playerName)) {
+                long time = recentLogins.get(playerName);
+                long elapsed = now - time;
+
+                if (loginProtection > 0 && elapsed <= loginProtection * 1000
+                        && newValue < oldValue) {
+                    return true;
+                }
+
+                recentLogin = elapsed <= 2000;
+
+                if (elapsed > 2000 && elapsed > loginProtection * 1000) {
+                    recentLogins.remove(playerName);
+                }
+            }
+
+            if (kickOnDeath && oldValue == -1 && newValue == 20 && !recentLogin) {
+                player.kick("You died! Rejoin please.");
+                return false;
+            }
+
+            if (spawnProtection > 0) {
+                if (oldValue == -1 && newValue == 20 && !recentLogin) { // Player was just respawned
+                    lastSpawn.put(player.getName(), now);
+                } else if (lastSpawn.containsKey(playerName)) {
+                    long time = lastSpawn.get(playerName);
+                    long elapsed = now - time;
+
+                    if (elapsed < spawnProtection * 1000) {
+                        return newValue < oldValue;
+                    } else {
+                        lastSpawn.remove(playerName);
+                    }
+                }
+            }
+        }
+        
+        return false;
+    }
+
+    /**
+     * Called when a living object is attacked.
+     * tip:
+     * Use isMob() and isPlayer() and getPlayer().
+     *
+     * @param type
+     *          type of damage dealt.
+     * @param attacker
+     *          object that is attacking.
+     * @param defender
+     *          object that is defending.
+     * @param amount
+     *          amount of damage dealt.
+     *
+     * @return
+     */
+    @Override
+    public boolean onDamage(PluginLoader.DamageType type, BaseEntity attacker,
+            BaseEntity defender, int amount) {
+        
+        if (defender.isPlayer()) {
+            Player player = defender.getPlayer();
+
+            if (invinciblePlayers.contains(player.getName())) {
+                return true;
+            }
+            
+            if (disableFallDamage && type == PluginLoader.DamageType.FALL) {
+                return true;
+            }
+
+            if (disableLavaDamage && type == PluginLoader.DamageType.LAVA) {
+                return true;
+            }
+
+            if (disableFireDamage && (type == PluginLoader.DamageType.FIRE
+                    || type == PluginLoader.DamageType.FIRE_TICK)) {
+                return true;
+            }
+
+            if (disableWaterDamage && type == PluginLoader.DamageType.WATER) {
+                return true;
+            }
+
+            if (type == PluginLoader.DamageType.WATER
+                    && amphibiousPlayers.contains(player.getName())) {
+                return true;
+            }
+        }
+        
+        return false;
+    }
+
+    /**
+     * Called when water or lava tries to populate a block, you can prevent
+     * crushing of torches, railways, flowers etc. You can alternatively allow
+     * to let normally solid blocks be crushed.
+     *
+     * @param currentState the current tristate, once it's set to a non DEFAULT_ACTION it is final.
+     * @param liquidBlock the type of the attacking block
+     * @param targetBlock the block to be destroyed
+     * @return final after a non DEFAULT_ACTION
+     */
+    @Override
+    public PluginLoader.HookResult onLiquidDestroy(PluginLoader.HookResult currentState,
+            int liquidBlockId, Block targetBlock) {
+        if (preventWaterDamage != null && liquidBlockId <= 9) {
+            if (preventWaterDamage.contains(targetBlock.getType())) {
+                return PluginLoader.HookResult.PREVENT_ACTION;
+            }
+        }
+
+        return PluginLoader.HookResult.DEFAULT_ACTION;
+    }
+
     /**
      * Called on player disconnect
      *
      * @param player
      */
+    @Override
     public void onDisconnect(Player player) {
         BlacklistEntry.forgetPlayer(player);
-    }
-
-    /**
-     * Simulate the block destroy hook.
-     *
-     * @param player
-     * @param block
-     * @return
-     */
-    private boolean simulateBlockDestroy(Player player, Block block) {
-        plugin.toggleEnabled(); // Prevent infinite loop
-        try {
-            block.setStatus(3);;
-            return !(Boolean)etc.getLoader().callHook(PluginLoader.Hook.BLOCK_DESTROYED,
-                    new Object[]{ player.getUser(), block });
-        } catch (Throwable t) {
-            return true;
-        } finally {
-            plugin.toggleEnabled();
-        }
-    }
-
-    /**
-     * Checks if a block can be broken.
-     *
-     * @param player
-     * @param block
-     * @return
-     */
-    private boolean canBreakBlock(Player player, Block orig) {
-        try {
-            Block block = etc.getServer().getBlockAt(
-                    orig.getX(), orig.getY(), orig.getZ());
-            return !(Boolean)etc.getLoader().callHook(PluginLoader.Hook.BLOCK_BROKEN,
-                    new Object[]{ player.getUser(), block });
-        } catch (Throwable t) {
-            return true;
-        }
-    }
-
-    /**
-     * Checks if a block can be destroyed.
-     * 
-     * @param player
-     * @param block
-     * @return
-     */
-    private boolean canDestroyBlock(Player player, Block block) {
-        plugin.toggleEnabled(); // Prevent infinite loop
-        try {
-            return !(Boolean)etc.getLoader().callHook(PluginLoader.Hook.BLOCK_DESTROYED,
-                    new Object[]{ player.getUser(), block });
-        } catch (Throwable t) {
-            return true;
-        } finally {
-            plugin.toggleEnabled();
-        }
+        invinciblePlayers.remove(player.getName());
+        amphibiousPlayers.remove(player.getName());
+        recentLogins.remove(player.getName());
     }
 
     /**

src/com/sk89q/worldguard/ConsoleLogFormat.java

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

worldguard.properties

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