Set version to 6.1.

Fixes WORLDGUARD-3494.

.gitattributes

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

.gitignore

@@ -0,0 +1,13 @@
+/.classpath
+/.project
+/.settings
+/target
+
+.DS_Store
+/*.iml
+/.idea
+
+/bin
+/dependency-reduced-pom.xml
+*-private.sh
+

.travis.yml

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

CHANGELOG.md

@@ -0,0 +1,818 @@
+# Changelog
+
+## 6.1
+
+* Added `exit-via-teleport` flag (default allow) to control exiting an exit=deny region via teleportation.
+* Added a `fall-damage` flag to control player damage caused by falling.
+* Added a `time-lock` flag to lock players' time of day. Valid values are from 0 to 24000 for absolute time, or +- any number for relative time.
+* Added a `weather-lock` flag to lock players' weather. Valid values are "clear" or "downfall". Unset to restore to normal world weather.
+* Added `-s` to the event debugging commands to show a stack trace rather than attempt to detect the causing plugin.
+* Added support for using the `-e` argument (sets an empty value for the flag) in the flag set command when the type of flag is of the 'set' type.
+* Added NPCs from the Citizens plugin to a whitelist so they are not protected.
+* Added support for Spigot's BlockExplodeEvent.
+* Changed tripwire to fall under the `use` flag.
+* Changed enderchests to fall under the `use` flag.
+* Changed vehicles and animals so they are not included in the `interact` flag.
+* Changed the display of custom blacklist messages to no longer include a period at the end.
+* Changed protection logic to consider connected chests.
+* Changed the heal and feed flags to increase values for players who are invincible (or in creative mode) but not decrease them.
+* Changed PvP protection to consider both attacker and defender locations.
+* Fixed missing protection data for some 1.8-added blocks.
+* Fixed compatibility issues with MC 1.7.
+* Fixed inverted daylight detectors not being protected.
+* Fixed spawn eggs not being included in protection.
+* Fixed piston blocking not working due to a bug in Spigot.
+* Fixed the blocking of certain invalid entity damage events.
+* Fixed creeper explosions not being blocked in certain situations with explosion related flags set.
+* Fixed "stickiness" with some position-related flags, sometimes resulting in rubber banding in the exit flags.
+* Fixed armor stands so that they are treated more like item frames than mobs.
+* Fixed blocks (e.g. sugar canes) adjacent to physics blocks (e.g. sand) not updating.
+* Fixed a NullPointerException that occurred sometimes when generating the scheduler section of the report function (`/wg report`).
+* Fixed the "no XP drops" configuration not functioning following a previous release.
+* Fixed changes to region ownership sometimes not triggering a region database save.
+* Fixed bucket protection displaying the "deny effect" even if bucket use was not prevented.
+* Fixed CommandFilter matching emoticons and other unwanted characters.
+* Fixed an exception occurring sometimes during game mode changes.
+* Fixed primed TNT being checked twice for TNT flags.
+
+## 6.0 beta 5
+
+MC 1.7.9, 1.7.10 and 1.8 (Spigot only) are supported.
+
+* Added a feature to detect when another plugin (incorrectly) includes WorldGuard's files, causing errors.
+* Added a new `exit-override` flag that can be used on an entry=allow region that players can walk into from an entry=deny region.
+* Added a new `entry-deny-message` to change the "entry denied" message.
+* Added a new `exit-deny-message` to change the "exit denied" message.
+* Changed entry/exit blocking to disembark players from their vehicles.
+* Changed the PvP flag to no longer apply to self-attack.
+* Fixed [#3220](http://youtrack.sk89q.com/issue/WORLDGUARD-3220): Polygon regions sharing points
+* Fixed [#3216](http://youtrack.sk89q.com/issue/WORLDGUARD-3216): Polygon regions 'disappearing' or not working correctly
+* Fixed [#3315](http://youtrack.sk89q.com/issue/WORLDGUARD-3315): Invincibility flag and mode not blocking knockback from snowballs, etc.
+* Fixed [#3314](http://youtrack.sk89q.com/issue/WORLDGUARD-3314): Protection bypassable by getting a skeleton or creeper to target a player
+* Fixed [#3326](http://youtrack.sk89q.com/issue/WORLDGUARD-3326): Enderchests cannot be protected with the use flag
+* Fixed [#3327](http://youtrack.sk89q.com/issue/WORLDGUARD-3327): Fake players from some Forge mods are not being detected properly
+* Fixed [#3328](http://youtrack.sk89q.com/issue/WORLDGUARD-3328): TypeToken error with CraftBukkit 1.7 in `/wg report`
+* Fixed [#3086](http://youtrack.sk89q.com/issue/WORLDGUARD-3086): Region entry / exit messages overlap between seprate worlds
+* Fixed [#2542](http://youtrack.sk89q.com/issue/WORLDGUARD-2542): Exit deny regions don't handle respawn / logout consistently
+* Fixed [#2731](http://youtrack.sk89q.com/issue/WORLDGUARD-2731): Greeting / farewell messages don't understand region inheritance
+* Fixed [#3308](http://youtrack.sk89q.com/issue/WORLDGUARD-3308): Enderchest interaction block not functioning with blacklist.txt
+* Fixed [#3312](http://youtrack.sk89q.com/issue/WORLDGUARD-3312): PVP flag blocking enderpearl teleport fall damage
+* Fixed [#3309](http://youtrack.sk89q.com/issue/WORLDGUARD-3309): Inventory view commands being blocked in protected regions
+* Fixed [#3310](http://youtrack.sk89q.com/issue/WORLDGUARD-3310): USE flag is not allowing workbench usage
+* Fixed [#3330](http://youtrack.sk89q.com/issue/WORLDGUARD-3330): Build permissions preventing block placement
+* API: Added `BukkitUtil.toRegion(Chunk)`
+
+## 6.0 beta 4
+
+MC 1.7.9, 1.7.10 and 1.8 (Spigot only) are supported.
+
+* Added better support for MC 1.8 blocks (regarding the use flag, etc.).
+* Added an an experimental "lite" version of WarmRoast to CPU profile your server (try it: `/wg profile -p`)
+* Added permissions for individual flag values (i.e. `worldguard.region.flag.flags.use.allow`).
+* Added support for slightly older versions of Bukkit 1.7.9.
+* Improved `/wg report`'s output (try it: `/wg report -p`)
+* Fixed armor stands not being protected properly.
+* Fixed lack of wood plate support with the `USE` flag.
+* Fixed left click also being blocked when only right click needed to be blocked.
+* Fixed items and paintings/item frames not decaying under some versions of Spigot.
+* Fixed parent-child inheritance so the child will always inherit the parent.
+* Fixed inheritance issues with a flag is set with a region group on a parent region.
+* Fixed high CPU usage when Citizens is also installed.
+* Fixed `on-acquire` in the blacklist so it also handles item transfers between inventories.
+* Fixed the blacklist not supporting color codes.
+* Changed the PvP flag so it applies to self-attack like in WG 5 (this change *may* be reverted).
+
+## 6.0 beta 3
+
+MC 1.7.10 and 1.8 (Spigot only) are supported.
+
+* Support both MC 1.7.10 and 1.8.
+* Don't apply the region override permission to PvP.
+* Fix incorrect detection of hostile and ambient creatures when protecting against PvE.
+* Fix the splash potion flag not working with the other flags.
+* Fix potion blocking.
+* Fix inability to blacklist the enchantment table and the workbench.
+* Make PASSTHROUGH=DENY useful on ``__global__``.
+* Fix issues (pistons broken, etc.) caused by adding members to ``__global__``.
+* Make the EXP_DROPS flag a build-compat flag and set its deny message.
+* Give the player back his/her XP bottle if it was blocked.
+* Expand the interaction whitelist configuration to "physical" events.
+* Catch command prefixes in the command flags.
+* Add a RIDE flag for vehicles.
+* Check for names in addition to UUIDs with /rg list.
+* Whitelist hoppers and let them cross regions regardless of region protection.
+* Revert USE flag's functionality to 5.x, add new INTERACT flag.
+* Fix spawn egg blocking.
+* Fix failed detection of incorrect blacklist block and item names.
+* Fix command prefix bypass with the op command blocking configuration.
+* Rewrite and update report generation (wg report).
+* Add event cancellation debug commands.
+* Fix location flags causing NullPointerExceptions.
+* Show more details in error log which world the error belongs to.
+* Add missing color codes when parsing input.
+* Let players use NPCs always.
+* Fix [WorldGuard] in log messages stacking on reloads.
+* Better handle empty group / player names due to bad region data.
+* Fix players being invincible with BUILD=deny.
+* Fix certain entities not being damaged in protected regions.
+* Improve entity detection in Entities utility class, add Entities.isNonPlayerCreature().
+* Add missing SQL table prefix in statement selecting world names.
+
+## 6.0 beta 2
+
+* Added an `-e` parameter to `/rg flag` that sets the flag to an empty value. You can use this to, for example, make it so the `deny-message` flag is empty, meaning that players won't get a message at all.
+* Added a visual smoke effect when an action on a block has been denied.
+* Added `event-handling.interaction-whitelist`, a list of items or blocks that should never be protected. For example, adding `wooden_door` to the list would make it so that doors could be used by anyone regardless if they have permission or not. You may still protect the blocks via other means.
+* Added `event-handling.emit-block-use-at-feet`, a list of items that, when used, will also be considered as the player using that item on the block at the player's feet. The purpose of this setting is, for example, to allow you to (sort of) prevent the use of a mod-added item that does not emit events.
+* Added `-s` to silently turn toggle `/stoplag` and `-i` to show the current state of the setting. (Thanks, [stuntguy3000](https://github.com/stuntguy3000)).
+* Added support for Bukkit [Material](http://jd.bukkit.org/rb/apidocs/org/bukkit/Material.html) names in the blacklist.
+* Fixed [#3167](http://youtrack.sk89q.com/issue/WORLDGUARD-3167): Saplings can be used without permission although it won't place blocks inside the region
+* Fixed [#3168](http://youtrack.sk89q.com/issue/WORLDGUARD-3168): Grown saplings that are partially prevented from placing all of its leaves may not remove the sapling
+* Fixed [#3169](http://youtrack.sk89q.com/issue/WORLDGUARD-3169): Bonemeal usage falls under the USE flag when it should really fall under building
+* Fixed [#3174](http://youtrack.sk89q.com/issue/WORLDGUARD-3174): Boat placement is not properly prevented in a protected region
+* Fixed [#3130](http://youtrack.sk89q.com/issue/WORLDGUARD-3130): Polygonal selections allow unlimited claim volumes with /rg claim
+* Fixed [#3137](http://youtrack.sk89q.com/issue/WORLDGUARD-3137): Claiming infinite regions is possible due to integer overflow
+* Fixed [#3171](http://youtrack.sk89q.com/issue/WORLDGUARD-3171): Can't pickup XP in protected regions without permission
+* Fixed [#3170](http://youtrack.sk89q.com/issue/WORLDGUARD-3170): Boats without a driver can be used to break lily pads
+* Fixed [#3172](http://youtrack.sk89q.com/issue/WORLDGUARD-3172): Players cannot be damaged by mobs in protected regions unless they have permission
+* Fixed [#3152](http://youtrack.sk89q.com/issue/WORLDGUARD-3152): BUILD overrides all other flags, unlike in WG 5
+* Fixed [#3154](http://youtrack.sk89q.com/issue/WORLDGUARD-3154): notify-enterflag doesn't work with horses and other vehicles
+* Fixed [#3166](http://youtrack.sk89q.com/issue/WORLDGUARD-3166): Trees do not grow naturally within protected regions
+
+## 6.0 beta 1
+
+### UUID support
+
+Regions now fully support the use of UUIDs rather than names for storing the owners and members of a region. Commands still accept names, but they are translated into UUIDs in the background. For users who already have existing region data, names will be automatically converted to UUIDs on the first run of WorldGuard.
+
+It is still possible to specify names rather than a UUID by using the `-n` flag with the region membership commands.
+
+### 'Deny by default'
+
+Previously, a pre-determined list of blocks and entities was used to determine whether an action by the player should be blocked. However, this has been reversed so that every action on a block or entity is denied (in a protected region) unless it has been deemed safe (such as, for example, right clicking with steak). Mods are now supported as a result.
+
+The `USE` flag has been repurposed as a general "interaction" flag and covers every left click or right click of a block or entity. It also covers interaction that falls outside clicking.
+
+### Exhaustive protection
+
+More events are now handled in the protection code. For example,
+
+* It is no longer possible to drop sand or gravel into a protected region from outside.
+* It is no longer possible to grief a region by growing a tree into it.
+* The entry and exit flags now handle players sitting on vehicles properly.
+* Piston-moved blocks cannot be pushed into a different protected region.
+* Owners of tamable animals are now considered in protection code.
+
+Even water and lava flow can also be checked, although this requires that it be explicitly enabled in the configuration (flow events are very frequent, so they incur extra CPU cost).
+
+The goal is to provide extremely exhaustive protection.
+
+### Large performance boost for spatial queries
+
+The performance of spatial queries for regions has been substantially increased at least an order of magnitude. Spatial queries are a necessity for the region code to query the list of regions that apply to a location in the world. There should be a negligible difference between 4, 40, and 4000 regions as long as too many regions are not overlapping.
+
+### Background region operations
+
+Region commands are now executed in the background. Notably, saves and loads will not lock up your server while they complete. Additionally, changes to regions are now saved periodically rather than immediately after every change.
+
+### Updated MySQL region support
+
+MySQL support has been completely overhauled. It should now be faster, no longer crash on foreign key index errors, use transactions, and support automatic creation and migration of tables (including support for table prefixes).
+
+### Partial region data saving
+
+For users of MySQL, WorldGuard now only saves changed and deleted regions when saving region data. No longer does WorldGuard have to rewrite the entire region database on each save.
+
+### Improved handling of related flags
+
+Multiple flags that apply to an event are now evaluated together if they are similar. For example, if a player right clicks a bed to sleep in it, both the `USE` and `SLEEP` flag are checked since they are both interaction-related. If one of them is `DENY`, then sleeping is denied (remember, `DENY` overrides `ALLOW`). If one of them is `ALLOW` and the other is not `DENY`, then sleeping is permitted.
+
+Only one "category" of flags needs to evaluate to true to permit an action. `DENY` will not cross categories. For example, if `BUILD` is deny, it will not override `SLEEP`, so if `SLEEP` is set to `ALLOW`, sleeping will be permitted. This is fairly similar to how it worked on WorldGuard 5.
+
+### Flag groups now work properly
+
+While you could always set a group to a flag's value, the functionality was incomplete and did not work most of the time.
+
+Now that groups are supported, you can change a flag so it only applies to a certain group of players. For example, `/rg flag example sleep deny -g members` would deny sleeping for only members of the `example` region.
+
+### Inheritance now works as expected
+
+Previously, a region only inherited flags and other details from its parents if the parent and the child overlapped at the location queried. This is no longer the case and inheritance is now always applied. 
+
+In addition, a new `-g` flag for `/rg define` lets you create a region with no physical area so that you can assign flags and use this region as a "template region."
+
+### Settable deny message
+
+It is now possible to change the message that users get when they are prevented from interacting with blocks or entities. This message is defined as a region flag, so you can set it on the `__global__` region or override it in a specific region. In addition, the tone and color of the default message has been softened, but you are free to change it entirely.
+
+### Blacklist support for data values (and later, variants)
+
+The blacklist was rewritten to support more than just block and item IDs. The immediate result is that you can now use data values, but as those are in the process of being deprecated by Mojang, it also allows support for Minecraft's new block variants in the future.
+
+### Debounced events
+
+Events that tend to reoccur very frequently (such as the ones that occur when you stand on a pressure plate continuously) have been "debounced" to reduce the number of checks that WorldGuard has to perform, reducing the amount of wasted CPU. In addition, the "you don't have permission" message is rate limited so players are not flooded with the message.
+
+### New block place and break flags
+
+A long requested feature was the availability of block place and break flags. These newly added flags work in tandem with the `BUILD` flag but can override `BUILD`. At the moment, it is not possible to allow explicit types of blocks to be placed or broken yet.
+
+### Build permission nodes
+
+A new optional (disabled by default in the configuration) feature is the checking of build permission nodes. For every block, entity, and item, the following permission nodes are checked:
+
+* Block place: `worldguard.build.block.place.<material>`
+* Block break: `worldguard.build.block.remove.<material>`
+* Block interact: `worldguard.build.block.interact.<material>`
+* Entity spawn: `worldguard.build.entity.place.<type>`
+* Entity destroy: `worldguard.build.entity.remove.<type>`
+* Entity interact: `worldguard.build.entity.interact.<type>`
+* Entity damage: `worldguard.build.entity.damage.<type>`
+* Item use: `worldguard.build.item.use.<material>`
+
+In addition, the permissions are also checked in the style of `worldguard.build.block.<material>.<action>`, so `worldguard.build.block.<material>.place` would work too.
+
+The list of usable material names comes from the [Material enumeration in Bukkit](http://jd.bukkit.org/rb/apidocs/org/bukkit/Material.html). For example, the permission for placing the bed block would be `worldguard.build.build.place.bed_block`. Be aware that _Material_ contains both item and block names.
+
+For entity names, see [EntityType](http://jd.bukkit.org/rb/apidocs/org/bukkit/entity/EntityType.html).
+
+### Other changes
+
+* Added a setting to permit "fake players" to bypass protection. Fake players are used by some servers and some mods to allow events to be thrown for mod blocks. WorldGuard considers a player to be a fake player if the name starts with `[` and ends with `]`.
+* Added a check so players can no longer disembark in a region from their tamed animal if they don't have permission to get back on.
+* Added an item pickup flag to go along with the item drop flag.
+* Added a new `//running` command was added to show currently running background tasks.
+* Added a blacklist `on-dispense` event.
+* Added more detailed error messages when parsing the YAML regions file.
+* Added the `-Dworldguard.debug.listener=true` option that can be set on your server's command line to see how WorldGuard processes events, although this will result in a lot of log messages.
+* Added log messages that occur on player join when a player had auto-god mode or auto-amphibious mode.
+* Fixed the heal command so that it now sets a player's health to the maximum rather than 20.
+* Fixed `ProtectedCuboidRegion.getPoints()` returning points in wrong order.
+* Fixed the obsidian generator disable option to also apply to tripwire.
+* Fixed an error with the blocked commands flag.
+* Fixed a connection leak with the MySQL region code.
+* Fixed `/wg reload` sometimes not applying new changes right away.
+* Changed the region removal command so that child regions are no longer removed without warning when removing the parent region.
+* Changed the YAML region data save code to first write the data to a temporary file before replacing the final file.
+* Changed how region data is handled when region support is disabled: it is no longer loaded.
+* Changed sponges to now be disabled by default. However, if you had previously installed WorldGuard, sponges will still be enabled. Sponges are being added in Minecraft and they work differently than in Minecraft Classic (which WorldGuard emulates). In addition, enabling sponge support in WorldGuard incurs extra CPU cost even if no sponges exist in the world.
+* Changed how region data is loaded and saved so failures are now more graceful. If the region data fails to load for a world, then the entire world will be protected by default. In addition, periodic attempts will be made to load the region data in the background.
+* Changed the `FEED` flag to maximize the player's saturation level if the hunger level is raised.
+* Changed the `wg-invincible` and `wg-amphibious` groups feature so that it now must be enabled in the configuration.
+* Removed the ability for WorldGuard to upgrade from a version for Minecraft Alpha.
+
+### API changes
+
+* You can use a new `WorldGuardPlugin.createProtectionQuery()` method to easily check build permissions.
+* The listener classes were moved. Consider them internal -- if you want to make use of the listener somehow, please put in a ticket in our issue tracker.
+* Much of the protection-related handling was previously scattered throughout the code. Now WorldGuard funnels events into an internal event system and then processes protection queries in a more consistent matter. These events are for internal use so it is strongly recommended that you do not use them (they may change without notice drastically). A lot of the protection-related flag handling was moved there.
+* A significant portion of classes under the package of `com.sk89q.worldguard.protection` were changed or removed. However, the basic calls (testing the value of a flag, etc.) should still work, but they may be deprecated. Some of the utility `Domain`-related classes were removed.
+* The old region database (load/save) API was removed and replaced with a new one. The new one no longer needs to pointless store a collection of regions on itself -- it has `collection = load()` and `save(collection)` methods.
+* Previously, there were subclasses of `RegionManager` that implemented different spatial indices. However, now `RegionManager` is a final class and the spatial indices are separate (see the `RegionIndex` interface).
+* A hash table was implemented that caches a list of regions within each loaded chunk. This increases performance of spatial queries substantially.
+* A cache of recent spatial queries now exists (a cache of `ApplicableRegionSets`), but you need to make use of `RegionQuery` to make use of this cache. However, if you need to do a spatial query to modify region data, then the old method is better (get a `RegionManager`, etc.).
+* `ApplicableRegionSet` was converted into an interface. In addition, there are now "virtual" `ApplicableRegionSet` instances that are returned by `RegionQuery` for certain special cases (such as, for example, region support being disabled by the user or region data being unavailable for a world due to an error). A new `isVirtual()` method is available. This is not an issue if you are getting `ApplicableRegionSet` instances from a `RegionManager`.
+* `ApplicableRegionSet` now can accept a pre-sorted collection and its use of a `TreeSet` was removed for performance reasons.
+* `FileNotFoundException` is now properly handled in the YAML region file class. It creates the new file and continues on.
+* Player names are deprecated by Mojang and so they need to be converted into UUIDs. As this will take some time, you should do this conversion in a background task. To check whether a region contains a player, it recommended that `contains(LocalPlayer)` be used because it's possible that the user may be still using names. A new `WorldGuardPlugin.wrapOfflinePlayer()` method was added for this specific purposes.
+* All flags now use `RegionGroup.ALL` as the default region group.
+* `StateFlag.getDefault()` now returns a `State` rather than a `boolean`.
+* The priority R-tree index now uses the R-tree for region intersection queries. Previously, it was only used for single point containment queries.
+* Regions now keep a "dirty" flag and changes it whenever data within the region is changed. When WorldGuard decides to periodically save region data, it may only save changed regions. Calling `save()` on the `RegionManager` is no longer needed as periodical saves happen automatically.
+* The old region data migration API was removed in favor of region store drivers. There is no longer a need to have an implementation for every possible conversion (i.e. YAML -> MySQL, MySQL -> YAML, etc.).
+* `ProtectedRegion.copyFrom()` was added to copy region settings from another region.
+* `@Nullable` annotations were added throughout the code. If you use IntelliJ IDEA, you may notice that it now warns you when a return value may be `null`.
+
+## 5.9
+
+* Added a config option to allow explosion flags to only prevent block damage
+* Added allow-tamed-spawns setting, on by default. This will stop WorldGuard from culling tamed animals.
+* Added config option and flag to prevent soil from drying naturally.
+* Added formatting codes, &k/l/m/n/o and &x (reset).
+* Added snow-fall-blocks option to config to restrict snow fall to certain blocks
+* Allow players to add newlines (\n) via command, not just manually in yml.
+* Allow the console to load/save all region managers with one command.
+* Changed entity report format slightly.
+* Check bypass perms for item-drop flag.
+* Check for entities and projectiles removing items from frames too.
+* Fix being able to use bonemeal to turn tall grass into double plants.
+* Fix number of arguments for migratedb command.
+* Fixed addowner/addmember commands adding command artifacts. Specifically,  "-w <world>" will no longer be added when using it.
+* Fixed milking cows in protected areas due to changes in Bukkit.
+* Fixed ProtectedCuboidRegion::getPoints() returning points in wrong order.
+* Fixed snowman trails being treated as snow fall.
+* Make /rg list default to own regions if the player doesn't have permission otherwise.
+* Protected items in item frames in protected regions.
+* Resolved an issue where explosions of type OTHER_EXPLOSION were ignoring the world  configuration settings.
+* Send item-use blacklist event when right-clicking entities.
+* Transformed the BlockFadeEvent handler into a switch.
+
+## 5.8
+
+* BREAKING CHANGE: This version has been built for versions of Bukkit for MC 1.6.1 and newer. Do not try to use this version of WG on an older Bukkit version.
+* Added support for Minecraft 1.6+. Actual support of new 1.6 additions is dependant on Bukkit. Please use a newer build of Bukkit if, for example, you seem to be unable to add "Horses" to your lists of entities.
+* Added mobs.disable-snowman-trails to disable the trails left by walking snowmen.
+* Added -a flag to /region removeowner and /region removemember to remove all objects.
+* Teleporting is now handled by entry/exit flags. If this is causing people to get entirely stuck inside entry/exit deny regions, set the new setting 'use-player-teleports' to 'false' in your configuration.
+* Updated formatting for region commands, especially /region info.
+* Changed permissions checking for /region commands to be more consistent, checking for region IDs as a sub-node. This means that if some permissions for some region commands no longer work, add '.*' to the end of permission lines for WG in your permission plugin.
+
+## 5.7.5
+
+* Refixed a few issues from 5.7.4.
+
+## 5.7.4
+
+* BREAKING CHANGE: Removed the cyan "**" in front of greeting and farewell messages to allow more customizability. You can re-add them by adding "&c**" to the flag.
+* Fixed an issue enderpearling inside exit/entry deny regions.
+* Added checks to players teleporting in and out of exit/entry regions. 
+* Fix bad matching in blocked and allowed command flags.
+* Fixed heal flag bugs when player max health was increased. 
+* Add fishing to xp blocker.
+* Applied other-explosion flag to entity damage as well.
+* Fixed an issue with interaction that should allow blacklisting item use actions with no block involved (eg fishing rods, potions) 
+* Fix witherskull/fireball settings not being differentiated in one case 
+* Allow cow milking in no-build areas
+* Fix infinite durability breaking items instantly.
+
+## 5.7.3
+
+* Fixed the error caused by Bukkit's change of the TNT minecart API.
+
+## 5.7.2
+
+* Updated to MineCraft 1.5.
+* Added TNT Minecart support. They are handled with the same flags/settings as TNT.
+* Added mining and smelting xp handling to the xp drops flag and setting.
+* Fixed a few edge cases for placing items on region borders.
+* Legacy: Fixed issue with //stack not respecting item metadata.
+
+## 5.7.1
+
+* Added a vine growth config option and flag.
+* Added support for many commands to be used from console. Usage is with -w flag and a world name e.g. /rg addmem <id> <player> -w <worldname> /rg flag <id> <flag> -w <worldname> <flagvalue>
+* Fixed bug that blocks placing plants in flower pots.
+* Fixed permissions check for /rg tp
+* Fixed enderchests not being accessible (they are now part of the USE flag)
+* Fixed an issue with slabs being placable in protected regions. This was also fixed in CraftBukkit but has been left in for users running other versions.
+* Fixed wither skulls being handled with other fireballs, despite having their own settings.
+* Fixed item frames being placable on region borders.
+* Fixed a bug that made explosions more ineffective than they should have been.
+* Fixed bonemeal usage in protected regions.
+* Fixed special minecarts being placable in protected regions.
+* Fixed bugs being placable on region borders.
+* Fixed wolves bypassing pvp flags.
+
+## 5.7
+
+* Fixed thread sync issue with FlagStateManager.
+* Fixed dragon egg region protection not working in certain cases.
+* Added beacon and anvil usage protection in regions.
+* Add mobs.block-enderdragon-portal-creation to stop enderdragons from making portals on death.
+* Fix TNT being lethal in some case when damage was disabled.
+* Fix snowballs and enderpearls being able to knock players back in pvp deny regions.
+* Add subcommand support for allowed and blocked command flags.
+* Add max-players-allowed and max-players-reject-message flags to limit the numbers of players in a region.
+* Fix players being able to plant cocoa beans in protected areas.
+* Add an enderpearl flag to prevent players from teleporting to and from regions.
+* Added mobs.block-other-explosions config setting and other-explosion flag to block explosions caused by uncovered things, such as other plugins. (It doesn't actually have to be a mob)
+* Fix mob damage setting and flag not blocking the DoT wither effect.
+* Ghast fireball flag will not block blaze fireballs from lighting things on fire.
+* Fixed players without region permissions being able to trigger tripwires, use enderchests, use wooden buttons, and put plants in flower pots.
+* Added mobs.block-zombie-door-destruction setting to stop zombies from breaking down doors while difficulty is set to hard.
+
+Thank you to thvortex, Dilandau, tophathacker, and Dark_arc for their contributions this release.
+
+## 5.6.5
+
+* Fixed a regression that caused paintings and item frames to no longer be properly protected.
+
+## 5.6.4
+
+* Added mobs.block-above-ground-slimes to block slimes spawning naturally above ground.
+* Added security.deop-everyone-on-join to de-op all players when they join.
+* Added security.block-in-game-op-command to prevent usage of /op from in-game.
+* Fixed a NullPointerException in PlayerInteract involving water potions and potion blocking.
+* Fixed an issue with snowballs being blocked in regions.
+* Changed dragon eggs to be checked like it is a broken block in regions.
+* Moved developer's WGBukkit class to package com.sk89q.worldguard.bukkit.
+
+## 5.6.3
+
+* Added helper WGBukkit class to get references to WorldGuard from other plugins.
+* Added physics.vine-like-rope-ladders to make ladders work like vines. As long as the top ladder block is present, ladder blocks will hold even if they have no block behind them, like a rope ladder.
+* Fixed NullPointerException in PlayerInteractEvent caused by potion blocking.
+* Fixed mobs.block-{item-frame,painting}-destroy not working.
+
+Thank you to def for testing the above fixes and features.
+
+## 5.6.2
+
+* Fixed potion blocking not working well for splash potions.
+
+## 5.6.1
+
+* Added a mycelium-spread region flag.
+* Added a dynamics.disable-mycelium-spread configuration setting.
+* Added new gameplay.block-potions option. For example: gameplay: block-potions: [invisibility, speed]
+* Fixed a bug in the entity explosion event handler that caused a NullPointerException.
+
+Thank you for gabizou for his contribution in this release.
+
+## 5.6
+
+* Added official support for Minecraft 1.4. Support for 1.3.2 (and below) is still provided in this release.
+* Added support for new and existing explosion types.
+* Added support for blocking withers with the following settings: mobs: block-wither-explosions: false block-wither-block-damage: false block-wither-skull-explosions: false block-wither-skull-block-damage: true
+* Added support for blocking item frames (and their use) in protected regions.
+* Added item frame destruction region flags (if you wish to disable item frame  destruction completely).
+* (Re-)added support for priority R-tree region indexes. This means quicker region lookup, and better support for servers with thousands of regions.
+* Improved /region info output for -g group flags.
+* Allowed removing of -g group flags with /region flag.
+* Allowed /region flag to set group and value at once.
+* Deleting a region flag now also deletes group flag.
+* Fixed detection of attack by projectiles to be more accurate.
+* Fixed support for saving non-string flags in the MySQL region support.
+* Fixed spurious comma in "Flags:" /region info output.
+* Fixed players who are not in god mode not receiving damage in PVP areas from enderpearls.
+* Players will now be told that they are in a no-PvP area if they are in one and attempting to attack someone, or that the player they are attacking is in a no-PvP area, if that is the case instead.
+* Fixed an issue where region.getId() was lowercase'd each pass of a for loop in MySQLDatabase.updatePoly2dPoints().
+* Fixed mob damage from projectiles not being properly blocked in regions where applicable.
+* Changed default region wand to leather (#334).
+
+Thank you to the following individuals for their contribution:
+thvortex, Rutr, Glitchfinder, and DarthAndroid.
+
+## 5.5.4
+
+* Minecraft 1.3 support.
+* Fixed /stack dupe bugs.
+* Added regions.use-creature-spawn-event.
+* Update for Async chat issue.
+* Add use flag to cakes.
+* Report number of plugins loaded in report writer.
+* Updated fireblal item blocking.
+* Fixed permissions for /region reload.
+
+## 5.5.3
+
+* Added game mode flag.
+* Added item drop pickup flag to regions.
+* Added support for fireball item blocking (385).
+* Added configuration option to allow creature spawns from plugins.
+* Added host key check.
+* Added a new line split feature to region greetings.
+* Prevented commands in the allow commands list from being blocked and vice versa.
+
+## 5.5.2
+
+* Added potion-splash flag to block splash potions
+* Add entity-painting-destroy which can be used to prevent entities from destroying paintings (skeletons firing arrows)
+* Added send-chat and receive-chat flags
+* Fixed having regions in multiple worlds with the same name not working with MySQL
+* A cancellable event is now fired if WorldGuard disallows PvP. (for developers!)
+* Made /region setparent check worldguard.region.setparent.own/member.<parent> instead of worldguard.region.setparent.own/member.<child>.
+* Allowed passing #<index> in place of a region ID, where <index> is the index as displayed by /region list.
+* Fixed an error that occured when clearing a non-existant region's parent.
+* Added a -s flag to /region teleport, which sends you to the spawn point instead of the teleport point of a region.
+* Added region/role-based permissions to /region teleport.
+* BREAKING CHANGE: Added a LocationFlag class and made the teleport and spawn flags use it.
+* /region info -s now selects the region being queried.
+* Added /region teleport <id>.
+* Vector flags can now be set to the current location with the value "here" and to a specific position with x,y,z.
+* Made /region info show the region you're in if you don't specify an id explicitly.
+* Prevent block ignition from lightning strikes if lightning is blocked in region. Fixes #1175
+* Correctly check both WEPIF and superperms in WorldGurdPlugin.broadcastNotification()
+* Destroy fire blocks when fire-spread is disallowed
+* Added a construct flag that can be used to restrict block placing/destroying in zones to certain roles.
+* Added FallingSand to list of intensive entities to be removed with /halt-activiy.
+* Replaced all usage of CreatureType by EntityType.
+* Updated to support Bukkit 1.2-R0.3 and newer
+* Made auto-god-mode disabled by default again.
+* Added sign protection check disable.
+* Cleaned up javadoc, deprecated duplicate methods, other cleanup
+* Added a RegionGroupFlag to evey region flag Using the /region flag command with -g, the region group that the region flag applies to can be set.
+
+## 5.5.1
+
+* Fixed attacking with arrows from non-PVP to PVP areas
+* Compatibility with Bukkit 1.1-R5
+* Removed broken suppress-tick-sync-warnings config option. See bukkit.yml's setings.warn-on-overload option instead.
+* Add region and 'can build' information to CommandBook's /whois
+
+Contributions thanks to: NolanSyKinsley
+
+## 5.5
+
+* Removed WorldEdit.jar from the classpath to stop conflicts with Bukkit's plugin loader
+* Now using Bukkit's tagged logging
+* Updated to new event system
+* Flush player flag state cache on world change
+* Improved compatibility with versions of CommandBook without GodComponent and updated pom dep for 2.0
+* Added MySQL region storage method.
+* Made explosions display their animations even when the event was blocked.
+* Added fallback support for those who don't have a version of CommandBook with GodComponent
+* Added LIGHTNING flag to DefaultFlag's flagsList Fixes #1026
+* Removed /god, /heal, /locate, and /stack from WorldGuard to CommandBook. CommandBook is now checked to see whether a player is godded.
+* Removed remaining usages of org.bukkit.util.config.Configuration
+* Removed some unused configuration options
+* Added permission worldguard.region.wand to the region wand
+* Fixed ProtectedRegion.compareTo.
+* Fixed FlatRegionManager.getApplicableRegions to return parent regions as well.
+* Added exp-drops flag to disable experience drops per-region.
+* Fixed some warnings.
+* Updated dependency version for WorldGuard from 5.0 to 5.1-SNAPSHOT.
+* Added support for fireballs shot by players being blocked by the PVP flag.
+* Now using dynamic command registration
+* Split off ender dragon block damage from creeper block damage.
+
+Contributions thanks to: narthollis, DarkArc, Wolvereness, and skeight
+
+## 5.4
+
+* Fixed configuration generation on Windows
+* Fixed intersection calculation for regions
+* Fixed timer and feeding delay for food flags
+* Fixed region managers not being created properly (This caused errors related to CREATURE_SPAWN)
+* Added support for Minecraft 1.0.1 blocks
+* Added support for enchantments and tool damage (worldguard.stack.damaged is the node) with /stack
+* Made being in the wg-invincible group respect the configuration's auto-invincible setting
+* Added per-group region claim limit maximum
+* Added worldguard.region.addowner.unclaimed.* permission for non-economy region 'buying'
+* Checking allowed/blocked commands now occurs earlier to override more plugins
+* Made PVP flag check whether either player is in a pvp deny region for blocking
+
+Contributions thanks to: epuidokas, wizjany, Turtle9598, and DerFlash
+
+## 5.3
+
+* Added new config options and flags to better handle explosions of all types
+* Added config options and flags for snow, ice, mushroom spread, grass spread, and leaf decay
+* Added min and max health flags to clamp the values for the existing healing flags
+* Added hunger flags similar to the existing healing flags
+* Added an option to disable the use of the move event. This can boost performance on large servers but will disable the greeting/farewell and entry/exit flags
+* Added flag to prevent pistons (including those that are outside the region, but would affect blocks inside the region)
+* Added a /wg flushstates [player] command to free players stuck in a region that was exit-deny but no longer exists or the flag was removed
+* Added a config option to disable xp orb dropping
+* Added config option to disable redstone wire obsidian generators
+* Added a vehicle-destroy flag
+* Added enderman protection config and flag
+* Allowed and blocked command flags will now fall back to the global region
+* The worldguard.region.flag.own/member permissions are now worldguard.region.flag.regions.own/member! Please change your permissions accordingly.
+* Made //stack respect max stack sizes unless the player has the worldguard.stack.illegitimate permission
+* Setting invincibility flag to deny will override god mode unless the player has worldguard.god.override-regions
+* The sleep flag will now prevent beds in the nether from exploding if set to deny
+* Existing regions can no longer be accidentally overwritten. Use /region redefine to move an existing region.
+* The info command will now sort players alphabetically
+* Priming TNT by punching it with flint and steal should throw a blacklist event (consistent with old Minecraft versions)
+* The /stoplag command will now remove xp orbs
+* Permissions system will use per-world permissions if the provider supports it
+* Players in vehicles are now subject to entry/exit and greeting/farewell flags
+* Fixed interact blacklist event not logging correctly
+* Fixed heal flag taking effect half a block northeast of the region
+* Fixed a infinite sign dropping bug
+* Fixed players being able to douse fire by punching it in regions they couldn't build it
+* Fixed players being able to eat protected cake
+* Fence gate usage can be blocked with the use flag
+* Fixed chests being unprotected when they should be in 1.8
+* Fixed weather config settings not applying when a world was loaded
+* Fixed explosion handling in certain cases
+* Fixed arrows working in non-pvp zones
+* Fixed buckets working on the border of protected regions in certain cases
+Contributions thanks to:
+wizjany, zml2008, imjake9, Droolio, epuidokas,
+EduardBaer, TomyLobo, and halvors
+
+## 5.2.2
+
+* Changed configuration saving so empty lists will be added to the configuration files.
+
+## 5.2.1
+
+* Add region bounds to /region info
+* Added the ability to add owners/members to the global region for handling guest groups. Now if there's owners or members on the global region, then those  that are not on the list cannot build.
+* Fixed some flag algorithm issues.
+* API: Fixed DefaultDomain.size() not counting players.
+* API: Undeprecated ApplicableRegionSet.allows(StateFlag).
+
+## 5.2
+
+* Gave the ability to use color colors and macros in greeting and farewell messages.
+* Added disable-ice-melting, disable-snow-formation, disable-mushroom-spread, disable-snow-melting, disable-ice-formation.
+* Added paintings to blacklist support.
+* Added default.disable-health-regain.
+* Added auto-invincible-permission setting, which lets you use the permission 'worldguard.auto-invincible' to become invincible on join automatically.
+* Flames won't appear if you are /god'ed now. 
+* Added blocked-cmds region flag to block commands.
+* Added allowed-cmds region flag to whitelist commands.
+* Added entry region flag to block entry. Use entry-group to determine who this affects.
+* Added exit region flag to block exit. Use exit-group to determine who this affects.
+* Made negative healing possible via the healing flag.
+* Changed the configuration header messages to be more helpful to new users.
+* Added a warning about modifying region files by hand.
+* Improved the API for plugin developers.
+
+## 5.1
+
+* A lot of changes.
+
+## 4.0-alpha1
+
+* This release is only to fix WorldGuard for Bukkit. Ignore the 4.0 label. Just move along. Nothing to see.
+
+## 3.2.2
+
+* Changed disable-water-damage to disable-drowning-damage.
+* Fixed suffocation disable option.
+* Fixed fire spread blocking.
+* stopfire and allowfire now work in server console, just like in hMod.
+
+## 3.2.1
+
+* Updated for recent Bukkit ItemStack change.
+
+## 3.2
+
+* Added regions.default.pvp to control default PvP setting.
+* Updated WorldGuard for the newer builds of Bukkit.
+* Fixed creeper explosion blocking.
+* Added redstone support to sponges, removed classic water.
+* Fixed item durability disable for hoes.
+
+
+## 3.1.2
+
+* Increased the priority of WorldGuard's event handling.
+
+## 3.1.1
+
+* Fixed creeper and chest flag conflicting.
+
+## 3.1
+
+* Added ability to disable chest protection. New configuration setting (regions.build.chest-access) and new chest flag.
+* Possibly fixed projectile blocking in no-PvP zones.
+* Added /regionmembership permission that lets people only change the owners and members of regions they own.
+
+## 3.0b2
+
+* Fixed issue where built-in permissions were not (re)loaded.
+* Fixed /god not working for others.
+
+## 3.0b1
+
+* Added parent-child relationships to regions.
+* Added global build flag.
+* Improved flag support.
+* Fixed no-PvP zone messages being sent to the wrong person.
+* Fixed commands so that they work in a recent version of Bukkit.
+* Fixed NullPointerException in explode hook.
+
+## 2.3.1
+
+* Fixed various cast exceptions with the blacklist loggers.
+* Added checks for unchecked exceptions when resolving permissions.
+* Fixed the item durability disable setting changing the damage value on an empty hand.
+
+## 2.3
+
+* /god now works very well.
+* Item (TNT, flint and steel, etc.) blocking should now work.
+* The TNT blocking configuration variable should now work.
+* Re-added /heal (not sure where that went), added /slay.
+* Implemented contact damage disable toggle.
+* Made all player damage disabling configuration parameters work.
+* Fixed teleport-on-suffocation setting.
+* Added /locate <name>, /locate <x> <y> <z>, and /locate that lets you program/change your compass bearing to point to a player's position (not yet live), a position, or back to spawn.
+* Fixed CSVDatabase spitting an error if the owners list was empty.
+
+## 2.2
+
+* Now supports GroupUsers.
+* Added support for blocking creeper explosions.
+* Fixed a bug where a player's groups were not being loaded correctly, causing the blacklist group ignore option to not work.
+
+## 2.1.1
+
+* Fixed fire spread disable preventing flint and steel too.
+* Fixed NullPointerException related to the player item event.
+* Made setup simpler.
+
+## 2.1
+
+* Improved Bukkit support.
+
+## 2.0beta3
+
+* Fixed NullPointerException inside the ignite hook.
+
+## 2.0beta2
+
+* Fixed a NullPointerException in the damage hook.
+
+## 2.0beta1
+
+* Added area protection. Use /region or /rg to define regions.
+
+## 1.8.1
+
+* Fixed NullPointerException.
+
+## 1.8
+
+* Updated for Minecraft beta.
+* Blacklist hooks have CHANGED. The new hooks are work better. on-create has been replaced with on-place (for block placement) and on-use (for item usage, light buckets and lighters). The old on-use is now on-right-click although it currently does nothing.
+* Added coordinates to blacklist file logger.
+* Added suffocation damage prevention.
+
+## 1.7.1
+
+* Updated for v0.2.8.
+
+## 1.7
+
+* Updated for v0.2.6_02 and hMod b129.
+* Added option to prevent water from damaging particular blocks (Redstone wire, Minecart tracks, etc.). See disable-water-damage-blocks.
+* /reload WorldGuard should now reload WorldGuard's configuration.
+* Added wg-invincible and wg-amphibious groups that let you give certain players invincibility or underwater breathing.
+* Added the ability to disable fall, water, lava, and/or fire damage.
+* Water/lava bucket blocking should now be more reliable.
+* Added /stack (alias /;) commands to stack items in your inventory into piles up to 64 items in size. Even unstackable items like signs can be stacked.
+* /god mode should now let you gain health.
+* /god mode should now work more reliably.
+* Caught an error message for when the configuration file does not exist.
+
+## 1.6
+
+* Added spawn protection that prevents damage when a player spawns.
+* Added login protection that prevents damage when a player joins.
+* Added /god. /god can be used on others, provided that the /godother permission is set for the command's user.
+
+## 1.5.1
+
+* Removed the 'java.lang.NoSuchMethodError: Item.setDamage(I)V' error generated.
+
+## 1.5
+
+* Removed the block lag fix.
+* WorldGuard now conditionally loads features so you can use any up-to-date build of hMod and the unsupported features won't break the entire plugin. When WG loads, check the server console for a report of features that are not supported by your version of hMod.
+* Changed some configuration defaults: disable-lava-fire=true simulate-sponge=true item-durability=false
+
+## 1.4.1
+
+* Fixed issue with the block lag fix dropping item stacks of 0 quantity.
+
+## 1.4
+
+* New on-acquire hook. This does both a total inventory check on inventory change and item pick up denial. The item pick up denial is largely thanks to Dinnerbone for fulfilling my request to add a particular hook.
+* Item durability can now be toggled with item-durability. Thanks to Dinnerbone for figuring this out while filfilling my request. The default setting is to fix item durability.
+* New no-physics-gravel and no-physics-sand options allow you to prevent gravel and sand from falling.
+* New allow-portal-anywhere option allows you to create portal blocks anywhere. 
+
+## 1.3
+
+* UPGRADE WARNING: If you are using database logging, you must add a NULL 'comment' VARCHAR field to the table. The line of SQL that you can run for MySQL can be found in blacklist_table.sql.
+* Improved plugin compatibility with the block lag fix. For maximum compatibility, you must now list WorldGuard as the first plugin in server.properties and you cannot reload or enable the plugin while the server is up. This is for bad plugins that unnecessarily use the "critical" priority for its hooks like the LWC. Most plugins don't do that though, so this won't apply for most people.
+* Fixed signs being blank if they were denied via the blacklist.
+* Added on-break event to the blacklist.
+* Added comments and messages. Comments are only for your own use and they are printed with the log and notify actions of the blacklist. The message replaces the message that is shown the user and it is optional.
+* The blacklist notification messages are now more compact and are light grey instead of light purple.
+* The notify, log, and tell actions will now trigger every time for the on-break, on-create, on-drop events rather than wait 3 seconds between events for the same item or block for a player.
+
+## 1.2
+
+* /stopfire and /allowfire disable and enable fire spreading globally.
+* Block lag fix slightly improved in accuracy for item drops.
+* Sponge updated to remove water when the sponge block is set. Sponge radius can now be controlled using the 'sponge-radius' parameter and the default is now set to simulate Classic.
+* Updated for a newer build of "b126," meaning that lava spread control now works well!
+* A new summary of the status of some core protections is now printed on start. Disable this with 'summary-on-start'.
+* Blacklist system has been overhauled. Check README.txt for changed configuration settings!
+* The blacklist's method of preventing notification repeats is now better, instead waiting 3 seconds before notifying again (before it didn't notify again at all unless the user started using another blocked action).
+* To give users the ability to receive notifications, the command to give permission to has been changed to /worldguardnotify, although the old one (that was never mentioned anywhere) still works.
+* Water and lava buckets are now psuedo-blocked using an unreliable method that risks the stability of your server (no other plugin does it better though). Use it as your own risk.
+* Added on item drop and on item use (i.e. chest) events.
+* Chests, signs, and furnaces can now be blocked better with the blacklist system.
+* The event names in the blacklist configuration have changed but the old event names should still work. The new names should make "more sense."
+* A new "ban" action has been added to the blacklist.
+* Action messages have been improved, now longer saying "destroyed" for everything.
+* Logging to file has been completely changed, allowing you to use the date and time and the player's username in the log filename. It no longer rotates log files based on size, however.
+* Logging to database is now supported.
+* Tools can now be destroyed on drop to alleviate the durability cheat. You can do this with either with the blacklist or with the 'item-drop-blacklist' configuration option. The configuration option prints more friendly messages than the 'tell' action of blacklists.
+
+## 1.1.2
+
+* Block lag fix: Snow and glass should no longer drop items.
+* Block lag fix: Block object now reset after hook call.
+
+## 1.1.1
+
+* Fixed redstone wire dropping wood blocks with the block lag fix.
+* The block lag fix now consults other plugins so that ALL protection mechanisms and plugins should work.
+
+## 1.1
+
+* Added block lag fix.
+
+## 1.0
+
+* Initial release.

CHANGELOG.txt

@@ -1,164 +0,0 @@
-2.2:
-- Now supports GroupUsers.
-- Added support for blocking creeper explosions.
-- Fixed a bug where a player's groups were not being loaded correctly,
-    causing the blacklist group ignore option to not work.
-
-2.1.1:
-- Fixed fire spread disable preventing flint and steel too.
-- Fixed NullPointerException related to the player item event.
-- Made setup simpler.
-
-2.1:
-- Improved Bukkit support.
-
-2.0beta3:
-- Fixed NullPointerException inside the ignite hook.
-
-2.0beta2:
-- Fixed a NullPointerException in the damage hook.
-
-2.0beta1:
-- Added area protection. Use /region or /rg to define regions.
-
-1.8.1
-- Fixed NullPointerException.
-
-1.8
-- Updated for Minecraft beta.
-- Blacklist hooks have CHANGED. The new hooks are work better. on-create has
-    been replaced with on-place (for block placement) and on-use
-    (for item usage, light buckets and lighters). The old on-use is now
-    on-right-click although it currently does nothing.
-- Added coordinates to blacklist file logger.
-- Added suffocation damage prevention.
-
-1.7.1
-- Updated for v0.2.8.
-
-1.7
-- Updated for v0.2.6_02 and hMod b129.
-- Added option to prevent water from damaging particular blocks
-    (Redstone wire, Minecart tracks, etc.). See disable-water-damage-blocks.
-- /reload WorldGuard should now reload WorldGuard's configuration.
-- Added wg-invincible and wg-amphibious groups that let you give certain
-    players invincibility or underwater breathing.
-- Added the ability to disable fall, water, lava, and/or fire damage.
-- Water/lava bucket blocking should now be more reliable.
-- Added /stack (alias /;) commands to stack items in your inventory into
-    piles up to 64 items in size. Even unstackable items like signs can be
-    stacked.
-- /god mode should now let you gain health.
-- /god mode should now work more reliably.
-- Caught an error message for when the configuration file does not exist.
-
-1.6
-- Added spawn protection that prevents damage when a player spawns.
-- Added login protection that prevents damage when a player joins.
-- Added /god. /god can be used on others, provided that the /godother
-    permission is set for the command's user.
-
-1.5.1
-- Removed the 'java.lang.NoSuchMethodError: Item.setDamage(I)V' error
-    generated.
-
-1.5
-- Removed the block lag fix.
-- WorldGuard now conditionally loads features so you can use any up-to-date
-    build of hMod and the unsupported features won't break the entire
-    plugin. When WG loads, check the server console for a report of
-    features that are not supported by your version of hMod.
-- Changed some configuration defaults:
-    disable-lava-fire=true
-    simulate-sponge=true
-    item-durability=false
-
-1.4.1
-- Fixed issue with the block lag fix dropping item stacks of 0 quantity.
-
-1.4
-- New on-acquire hook. This does both a total inventory check on inventory
-    change and item pick up denial. The item pick up denial is largely
-    thanks to Dinnerbone for fulfilling my request to add a particular hook.
-- Item durability can now be toggled with item-durability. Thanks to
-    Dinnerbone for figuring this out while filfilling my request. The
-    default setting is to fix item durability.
-- New no-physics-gravel and no-physics-sand options allow you to
-    prevent gravel and sand from falling.
-- New allow-portal-anywhere option allows you to create portal blocks
-    anywhere.
-    
-1.3
-- UPGRADE WARNING: If you are using database logging, you must add a
-    NULL 'comment' VARCHAR field to the table. The line of SQL that you
-    can run for MySQL can be found in blacklist_table.sql.
-- Improved plugin compatibility with the block lag fix. For maximum
-    compatibility, you must now list WorldGuard as the first plugin in
-    server.properties and you cannot reload or enable the plugin
-    while the server is up. This is for bad plugins that unnecessarily
-    use the "critical" priority for its hooks like the LWC. Most plugins
-    don't do that though, so this won't apply for most people.
-- Fixed signs being blank if they were denied via the blacklist.
-- Added on-break event to the blacklist.
-- Added comments and messages. Comments are only for your own use and they
-    are printed with the log and notify actions of the blacklist. The
-    message replaces the message that is shown the user and it is optional.
-- The blacklist notification messages are now more compact and are
-    light grey instead of light purple.
-- The notify, log, and tell actions will now trigger every time for the
-    on-break, on-create, on-drop events rather than wait 3 seconds between
-    events for the same item or block for a player.
-
-1.2
-- /stopfire and /allowfire disable and enable fire spreading globally.
-- Block lag fix slightly improved in accuracy for item drops.
-- Sponge updated to remove water when the sponge block is set. Sponge radius
-    can now be controlled using the 'sponge-radius' parameter and the
-    default is now set to simulate Classic.
-- Updated for a newer build of "b126," meaning that lava spread control
-    now works well!
-- A new summary of the status of some core protections is now printed
-    on start. Disable this with 'summary-on-start'.
-- Blacklist system has been overhauled. Check README.txt for changed
-    configuration settings!
-- The blacklist's method of preventing notification repeats is now better,
-    instead waiting 3 seconds before notifying again (before it didn't
-    notify again at all unless the user started using another blocked
-    action).
-- To give users the ability to receive notifications, the command to give
-    permission to has been changed to /worldguardnotify, although the
-    old one (that was never mentioned anywhere) still works.
-- Water and lava buckets are now psuedo-blocked using an unreliable
-    method that risks the stability of your server (no other plugin
-    does it better though). Use it as your own risk.
-- Added on item drop and on item use (i.e. chest) events.
-- Chests, signs, and furnaces can now be blocked better with the
-    blacklist system.
-- The event names in the blacklist configuration have changed but the old
-    event names should still work. The new names should make "more sense."
-- A new "ban" action has been added to the blacklist.
-- Action messages have been improved, now longer saying "destroyed"
-    for everything.
-- Logging to file has been completely changed, allowing you to use
-    the date and time and the player's username in the log filename. It
-    no longer rotates log files based on size, however.
-- Logging to database is now supported.
-- Tools can now be destroyed on drop to alleviate the durability cheat.
-    You can do this with either with the blacklist or with the
-    'item-drop-blacklist' configuration option. The configuration option
-    prints more friendly messages than the 'tell' action of blacklists.
-
-1.1.2
-- Block lag fix: Snow and glass should no longer drop items.
-- Block lag fix: Block object now reset after hook call.
-
-1.1.1
-- Fixed redstone wire dropping wood blocks with the block lag fix.
-- The block lag fix now consults other plugins so that ALL protection
-    mechanisms and plugins should work.
-
-1.1
-- Added block lag fix.
-
-1.0
-- Initial release.

CONTRIBUTING.md

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

INSTALL.md

@@ -0,0 +1,52 @@
+# New User Guide
+
+Thank you for installing WorldGuard! By default, when you first install WorldGuard, most features will be disabled until you enable the ones that you want to use.
+
+## Requirements
+
+You will need to be using [Bukkit](http://dl.bukkit.org/) for your server or one of its derivatives (such as Spigot or Cauldron). If you are using Minecraft Forge, you will have to use Cauldron in order to use WorldGuard.
+
+It is not possible to use WorldGuard with the plain vanilla server from Mojang.
+
+## Installation
+
+Installation is simple!
+
+1. Extract the `WorldGuard.jar` file and put it into your server's `plugins` folder. If the folder does not exist yet, you can create it yourself.
+2. Run the Bukkit server.
+3. Look inside `plugins/WorldGuard` and configure the plugin as necessary. There are also in-game commands.
+
+By default, only "ops" can use WorldGuard commands. If you install a permissions plugin, then you can assign fine grained permissions to your server's trusted users.
+
+## Documentation
+
+To learn how to use WorldGuard, check out [the wiki](http://wiki.sk89q.com/wiki/WorldGuard).
+
+## Frequently Asked Questions
+
+### How do I protect my spawn?
+
+Check out the [region protection tutorial](http://wiki.sk89q.com/wiki/$%7Bproject.name%7D/Regions/Tutorial) on the wiki.
+
+### Players can't do anything!
+
+WorldGuard will typically not block something without also telling the user that he or she does not have permission. Please make sure that it's not another plugin that is preventing players from interacting with the world.
+
+Also, be aware that spawn protection is a feature of vanilla Minecraft and you must disable that in `bukkit.yml`. It only allows ops to do anything in a specified radius around the world's spawn point.
+
+### I made a region but anyone can build in it!
+
+1. If players get a "you can't do that here" message but they are still able to build, it's because another plugin is likely undoing the protection offered by WorldGuard.
+2. If no message is being sent, make sure that there is a region where you think one is. 
+
+### Where can I ask questions?
+
+You can [ask questions on our forum](http://forum.sk89q.com) or visit us on IRC (irc.esper.net #sk89q).
+
+### Where can I file a bug report or request a feature?
+
+Visit our [issue tracker](http://youtrack.sk89q.com/dashboard). It's also used for WorldEdit and our other projects.
+
+### Is WorldGuard open source?
+
+Yes! [View the source code on GitHub](https://github.com/sk89q/worldguard).

LICENSE.txt

@@ -1,3 +1,4 @@
+
                    GNU LESSER GENERAL PUBLIC LICENSE
                        Version 3, 29 June 2007
 
@@ -162,4 +163,39 @@ General Public License ever published by the Free Software Foundation.
 whether future versions of the GNU Lesser General Public License shall
 apply, that proxy's public statement of acceptance of any version is
 permanent authorization for you to choose that version for the
-Library.
+Library.
+
+----------------------------------------------------------------------------
+
+This work includes Robert Olofsson's Priority R-Tree implementation, for which
+its license is reproduced below.
+
+Copyright (c) 2008-2010 Robert Olofsson.
+All rights reserved. 
+
+Redistribution and use in source and binary forms, with or without 
+modification, are permitted provided that the following conditions 
+are met: 
+
+1. Redistributions of source code must retain the above copyright 
+   notice, this list of conditions and the following disclaimer. 
+
+2. Redistributions in binary form must reproduce the above copyright 
+   notice, this list of conditions and the following disclaimer in the 
+   documentation and/or other materials provided with the distribution. 
+
+3. Neither the name of the authors nor the names of its contributors 
+   may be used to endorse or promote products derived from this software 
+   without specific prior written permission. 
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND 
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
+ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE 
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 
+SUCH DAMAGE.

README.md

@@ -0,0 +1,46 @@
+# ![WorldGuard](http://static.sk89q.com/readme/worldguard-new.png)
+
+WorldGuard lets you and players guard areas of land against griefers and undesirables, as well as tweak and disable various gameplay features of Minecraft.
+
+* Block creeper and wither block damage, falling damage, etc.;
+* Disable fire spread, lava fire spread, ice formation, Endermen picking up blocks, etc.;
+* Blacklist certain items and blocks so they can't be used;
+* Warn moderators when certain items and blocks are used;
+* Protect areas of your world so only certain people can build in them;
+* Set areas where PVP, TNT, mob damage, and other features are disabled;
+* Protect your server from various 'exploits' like magical obsidian creation machines;
+* Disable, or enable, various Minecraft features, like sponges from classic;
+* Add useful commands like an immediate "STOP ALL FIRE SPREAD" command.
+* Enable only features you want! Everything is off by default.
+
+WorldGuard is open source and is available under the GNU Lesser
+General Public License v3.
+
+Currently, Bukkit is required to use WorldGuard. You can get a release copy of WorldGuard from the [BukkitDev site](http://dev.bukkit.org/bukkit-plugins/worldguard/).
+
+Compiling
+---------
+
+The project is written for Java 6 and our build process makes use of
+[Maven](http://maven.apache.org). Detailed compilation information
+[can be found on the wiki](http://wiki.sk89q.com/wiki/WorldGuard/Development#Compiling).
+
+Dependencies are automatically handled by Maven.
+
+Contributing
+------------
+
+We happily accept contributions, especially through pull requests on GitHub.
+
+Please read CONTRIBUTING.md for important guidelines to follow.
+
+Submissions must be licensed under the GNU Lesser General Public License v3.
+
+Links
+-----
+
+* [Homepage](http://enginehub.org/worldguard)
+* [IRC channel](http://skq.me/irc/irc.esper.net/sk89q/) (#sk89q on irc.esper.net)
+* [Issue tracker](http://youtrack.sk89q.com/issues/WORLDGUARD)
+* [Continuous integration](http://builds.enginehub.org)
+* [End-user documentation](http://wiki.sk89q.com/wiki/WorldGuard)

README.txt

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

UPGRADE.md

@@ -0,0 +1,55 @@
+# Upgrading to WorldGuard 6
+
+This is a **major upgrade**. However, it is relatively well-tested because many people have *accidentally* updated to version 6 when the Spigot team updated WorldGuard for 1.8 but did not update v5.9.
+
+The version that you downloaded supports Minecraft 1.7.10 and 1.8.
+
+**NEW DOCUMENTATION:** There is [new work-in-progress documentation](http://docs.enginehub.org/manual/worldguard/latest/). However, refer to the [older wiki](http://wiki.sk89q.com/wiki/WorldGuard) for missing pages.
+
+## Downgrading to 5.9
+
+When updating to v6, your region data will be updated to use player UUIDs rather than their names. That means that you **cannot downgrade** to WG 5.9 because it does not understand UUIDs and will remove all ownership data. However, you can use [Six2Five](https://github.com/sk89q/Six2Five/releases/tag/release-1.0) to downgrade region data stored as YAML.
+
+Remember to make backups.
+
+If you do not use region protection, then downgrading requires no extra steps.
+
+## What's Changed?
+
+There have been many changes, but the most important (and breaking ones) are listed below.
+
+### Region Protection
+
+The region protection has been optimized and aggressive caching has been added. That means that the impact of region protection when hundreds or thousands of regions exist has been minimized. 
+
+* UUID support was added. On first server start, your region data will be converted to use UUIDs. Names that lack a UUID (i.e. they refer to accounts that don't exist) will remain, but can be removed by re-running the conversion (see the config) after changing the configuration to remove unconverted names. 
+* Build protection for regions is now much more complete, and WorldGuard protects against entities and blocks making changes as if they were players. For example, TNT cannot be flung into a protected region and piston machines cannot push into a protected region. Liquid flow (lava and water) can also be checked, although this is disabled by default.
+* Setting the `build` flag to `deny` will break pistons and Redstone. When you set the `build` flag to `deny`, you are essentially saying that *no one* can build at all. Now that blocks and entities are considered the same as players, they get blocked in that case. What's the solution? First of all, you probably do **not** want to set the build flag: remember, when you create a region, only members can build in it, so there's no need to change the `build` flag.
+* If you want to deny building "in the wilderness," use `/rg flag __global__ passthrough deny`. Unset the `build` flag if you had set it to `deny`. As you may know, when you create a region, protection is automatically turned on (only members can build). If you don't want that, you can set a region's `passthrough` flag to `allow`. In the case of the global region, it *defaults* to `allow`, so you have to set it to `deny` to turn that off.
+* Earlier versions of WorldGuard 6 changed the ``use`` flag to be much more encompassing, but this is **no longer the case**. The ``use`` flag now works like it did before in 5.x, only applying to things like doors, pressure plates, and levers. A new ``interact`` flag was added instead that controls all right clicks of blocks and entities.
+* By default, the ``use`` flag is now set so only members of a region can use levers and doors within a region. If you want to disable this type of protection in all protected regions, use `/rg flag __global__ use allow`.
+* Region groups for flags now work properly. You can set a certain flag to apply to only a certain group (owners, members, nonmembers, nonowners, all). Before, it only worked correctly for some flags. Region groups can be set like this: `/rg flag spawn pvp -g nonmembers deny`.
+* In WG 5.9, some flags had a default region group of "non-members." That means that if you did `/rg flag spawn chest-access deny`, only non-members would be unable to open chests. In WG 6, you have to explicitly specify this: `/rg flag spawn chest-access -g nonmembers deny`.
+* It is now possible to change the message that users get when they are prevented from interacting with blocks or entities. This message is defined as a region flag, so you can set it on the `__global__` region or override it in a specific region. In addition, the tone and color of the default message has been softened, but you are free to change it entirely.
+* The MySQL code was substantially rewritten to be faster and more efficient. Some changes are needed to the table structure, but WorldGuard is now capable of performing those automatically. However, those who use table prefixes *may* run into trouble.
+
+### Blacklist
+
+* If you want to blacklist only water and lava blocks and not buckets, you can no longer apply `on-place` to water or lava blocks because it will also deny the use of buckets. If you wish to deny the use of just the liquid blocks, use `on-use`. This is because WorldGuard now considers the use of a bucket also the placement of a liquid block.
+
+### Miscellaneous
+
+* In the rare situation that you are user of the "auto-invincibility" and "auto-no-drowning" groups (`wg-invincible` and `wg-amphibious`), you now have to enable these features in the config (`auto-invincible-group: true` and `auto-no-drowning-group: true`). This is because some permission plugins have been causing severe hang ups whenever it is queried for a player's groups, which, in this case, happens to include when the player joins.
+
+## Known Incompatibilities
+
+Plugins that utilize WorldGuard's API may not work anymore. They may crash with errors. The API has changed somewhat.
+
+* Spigot:
+    * `settings.global-api-cache`, if enabled, will crash WG UUID lookups (fixed in Spigot build #1625)
+
+## Other Changes
+
+The rest of the changes can be found in the CHANGELOG file.
+
+In addition, there is [new work-in-progress documentation](http://docs.enginehub.org/manual/worldguard/latest/) that describes some of the new features.

blacklist.txt

@@ -1,84 +0,0 @@
-#
-# This is the blacklist for WorldGuard. The blacklist allows you to perform
-# actions depending on an item or block ID. Comments start with # and they
-# are ignored so you can put your own notes.
-#
-# --------------------------------------------------------------------------
-#
-# WARNING:
-# Remember to check the compatibility spreadsheet for WorldGuard to see
-# if any events or actions are currently broken in your version of Bukkit.
-#
-# --------------------------------------------------------------------------
-#
-# Format:
-# [item1,item2]
-# option1=options
-# event1=whatToDo1,whatToDo2,whatToDo3
-# event2=whatToDo1,whatToDo2
-#
-# Example to block some ore mining and placement:
-# [coalore,goldore,ironore]
-# on-break=deny,log,kick
-# on-place=deny,tell
-#
-# Options:
-# - ignore-groups (comma-separated list of groups to not affect)
-# - comment (message for yourself that is printed with 'log' and 'notify')
-# - message (optional message to show the user instead; %s is the item name)
-#
-# Events:
-# - on-break (when a block of this type is about to be broken)
-# - on-destroy-with (the item/block held by the user while destroying)
-# - on-place (a block is being placed)
-# - on-use (an item like flint and steel or a bucket is being used)
-# - on-interact (when a block in used (doors, chests, etc.))
-# - on-drop (an item is being dropped from the player's inventory)
-# - on-acquire (an item enters a player's inventory via some method)
-#
-# Actions (for events):
-# - deny (deny completely)
-# - notify (notify admins)
-# - log (log to console/file/database)
-# - tell (tell a player that that's not allowed)
-# - kick (kick player)
-# - ban (ban player)
-#
-# Users with the /worldguardnotify permission will receive notifications.
-#
-# -------------
-#
-# You can have the same block or item used in two different sections and
-# they will both apply:
-#
-# [goldblock]
-# ignore-groups=vip
-# on-break=deny
-# [goldblock]
-# ignore-groups=admins
-# on-break=tell
-#
-# However, some events override others. For example, if you disable both
-# usage of the diamond pickaxe (with the on-destroy-with event) and
-# destruction of gold blocks (with the on-break event) and a player tries
-# to destroy a gold block with a diamond pickaxe, because the
-# on-destroy-with event comes first, the rules for the gold block
-# will not be applied (but the player will be denied nevertheless).
-#
-# --------------------------------------------------------------------------
-#
-# Some examples follow.
-#
-# REMEMBER: If a line has # in front, it will be ignored.
-#
-# --------------------------------------------------------------------------
-
-# Deny lava buckets
-#[lavabucket]
-#ignore-groups=admins,mods
-#on-use=deny,tell
-
-# Deny some ore
-#[coalore,goldore,ironore]
-#ignore-groups=admins,mods
-#on-break=notify,deny,log

build.xml

@@ -1,91 +0,0 @@
-<project name="WorldGuard" default="dist" basedir=".">
-  <description>WorldGuard fixes bugs with Minecraft SMP and provides for
-    protection.</description>
-  
-  <property name="src.dir" location="src"/>
-  <property name="build.dir" location="build"/>
-  <property name="dist.dir" location="dist"/>
-  <property name="release.dir" location="release"/>
-  <property name="lib.dir" location="lib"/>
-
-  <target name="init">
-    <mkdir dir="${build.dir}"/>
-  </target>
-
-  <!-- Compile the source files -->
-  <target name="compile" depends="init">
-    <javac srcdir="${src.dir}" deprecation="true" includeantruntime="true" destdir="${build.dir}" debug="true">
-      <classpath>
-        <fileset dir="${lib.dir}">
-          <include name="*.jar"/>
-        </fileset>
-      </classpath>
-    </javac>
-  </target>
-
-  <!-- Build the .jar -->
-  <target name="jar" depends="compile">
-    <mkdir dir="${dist.dir}"/>
-    <manifest file="manifest.mf" mode="replace">
-      <attribute name="Implementation-Title" value="WorldGuard"/>
-      <attribute name="Implementation-Version" value="${version}"/>
-      <attribute name="WorldGuard-Version" value="${version}"/>
-      <attribute name="Class-Path" value="WorldEdit.jar WorldGuard/WorldEdit.jar"/>
-    </manifest>
-    <delete file="${build.dir}/plugin.yml"/>
-    <copy tofile="${build.dir}/plugin.yml" file="plugin.yml"/>
-    <replace file="${build.dir}/plugin.yml" token="WGVERSIONMACRO" value="${version}"/>
-    <mkdir dir="${build.dir}/defaults"/>
-    <copy tofile="${build.dir}/defaults/config.yml" file="config.yml"/>
-    <copy tofile="${build.dir}/defaults/blacklist.txt" file="blacklist.txt"/>
-    <jar jarfile="${dist.dir}/WorldGuard.jar" basedir="${build.dir}" manifest="manifest.mf"/>
-  </target>
-
-  <!-- Create the .jar -->
-  <target name="dist">
-    <property name="version" value="nightly"/>
-    <antcall target="jar"/>
-  </target>
-
-  <!-- Build a release -->
-  <target name="release">
-    <input message="Enter version:" addproperty="version"/>
-    <antcall target="jar"/>
-    <delete dir="${release.dir}"/>
-    <mkdir dir="${release.dir}"/>
-    <copy tofile="${release.dir}/README.txt" file="README.txt"/>
-    <copy tofile="${release.dir}/LICENSE.txt" file="LICENSE.txt"/>
-    <copy tofile="${release.dir}/CHANGELOG.txt" file="CHANGELOG.txt"/>
-    <copy tofile="${release.dir}/blacklist_table.sql" file="blacklist_table.sql"/>
-    <copy tofile="${release.dir}/WorldGuard.jar" file="${dist.dir}/WorldGuard.jar"/>
-    <zip destfile="${release.dir}/worldguard-${version}.zip" basedir="${release.dir}" excludes="*.zip plugin.yml"/>
-    <mkdir dir="${release.dir}/src"/>
-    <copy todir="${release.dir}/src">
-      <fileset dir="${src.dir}"/>
-    </copy>
-    <zip destfile="${release.dir}/worldguard-${version}-src.zip" basedir="${release.dir}" excludes="*.zip plugin.yml"/>
-  </target>
-
-  <!-- Clean the output -->
-  <target name="clean">
-    <delete dir="${build.dir}"/>
-    <delete dir="${dist.dir}"/>
-    <delete dir="${release.dir}"/>
-  </target>
-  
-  <!--<target name="-get-version-git" if="git-revision">
-    <sequential>
-      <exec executable="git" failifexecutionfails="false" outputproperty="git-revision">
-        <arg value="rev-parse"/>
-        <arg value="HEAD"/>
-      </exec>
-      <exec executable="git" outputproperty="git-revision-dirty">
-        <arg value="diff"/>
-        <arg value="- -shortstat"/>
-      </exec>
-      <condition else="dev-${git-revision}-modified" property="version" value="dev-${git-revision}">
-        <equals arg1="" arg2="${git-revision-dirty}"/>
-      </condition>
-    </sequential>
-  </target>-->
-</project>

config.yml

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

config/assembly/default.xml

@@ -0,0 +1,63 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  ~ WorldGuard, a suite of tools for Minecraft
+  ~ Copyright (C) sk89q <http://www.sk89q.com>
+  ~ Copyright (C) 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 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 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/>.
+  -->
+
+<assembly
+  xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.2"
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.2 http://maven.apache.org/xsd/assembly-1.1.2.xsd">
+  <includeBaseDirectory>false</includeBaseDirectory>
+  <formats>
+    <format>tar.gz</format>
+    <format>tar.bz2</format>
+    <format>zip</format>
+  </formats>
+  <files>
+    <file>
+      <source>${project.build.directory}/${artifactId}-${project.version}.jar</source>
+      <outputDirectory>/</outputDirectory>
+      <filtered>false</filtered>
+    </file>
+    <file>
+      <source>${project.build.directory}/CHANGELOG.html</source>
+      <outputDirectory>/</outputDirectory>
+      <filtered>true</filtered>
+    </file>
+    <file>
+      <source>${project.build.directory}/INSTALL.html</source>
+      <destName>README.html</destName>
+      <outputDirectory>/</outputDirectory>
+      <filtered>true</filtered>
+    </file>
+    <file>
+      <source>${project.build.directory}/UPGRADE.html</source>
+      <destName>READ_BEFORE_UPGRADING_FROM_V5.html</destName>
+      <outputDirectory>/</outputDirectory>
+      <filtered>true</filtered>
+    </file>
+  </files>
+  <fileSets>
+    <fileSet>
+      <includes>
+        <include>contrib/blacklist_table.sql</include>
+        <include>contrib/region_manual_update_20110325.sql</include>
+      </includes>
+    </fileSet>
+  </fileSets>
+</assembly>

config/checkstyle/header.txt

@@ -0,0 +1,18 @@
+/*
+ * WorldGuard, a suite of tools for Minecraft
+ * Copyright (C) sk89q <http://www.sk89q.com>
+ * Copyright (C) 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 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 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/>.
+ */

config/checkstyle/import-control.xml

@@ -0,0 +1,41 @@
+<!--
+  ~ WorldGuard, a suite of tools for Minecraft
+  ~ Copyright (C) sk89q <http://www.sk89q.com>
+  ~ Copyright (C) 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 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 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/>.
+  -->
+
+<!DOCTYPE import-control PUBLIC
+    "-//Puppy Crawl//DTD Import Control 1.1//EN"
+    "http://www.puppycrawl.com/dtds/import_control_1_1.dtd">
+
+<import-control pkg="com.sk89q">
+  <allow pkg="java"/>
+  <allow pkg="javax"/>
+  <allow pkg="org.junit"/>
+  <allow pkg="junit"/>
+  <allow pkg="org.mockito"/>
+  <allow pkg="org.hamcrest"/>
+  <allow pkg="com.sk89q"/>
+  <allow pkg="org.enginehub"/>
+  <allow pkg="org.bukkit"/>
+  <allow pkg="org.yaml.snakeyaml"/>
+  <allow pkg="au.com.bytecode.opencsv"/>
+  <allow pkg="org.khelekore.prtree"/>
+  <allow pkg="com.google.common"/>
+  <allow pkg="com.jolbox.bonecp"/>
+  <allow pkg="org.flywaydb.core"/>
+  <allow pkg="org.json.simple"/>
+</import-control>

config/markdown/footer.html

@@ -0,0 +1,3 @@
+</div>
+</body>
+</html>

config/markdown/header.html

@@ -0,0 +1,368 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>WorldGuard - titleToken</title>
+<style>
+body {
+  margin: 0;
+  padding: 2em 2em 3em 2em;
+  color: #333;
+  font-family: "Helvetica Neue", Helvetica, "Segoe UI", Arial, freesans, sans-serif;
+  font-size: 15px;
+  line-height: 1.5;
+  word-wrap: break-word;
+}
+
+.wrapper {
+  margin: auto;
+  max-width: 750px;
+}
+
+a {
+  background: transparent;
+}
+
+a:active,
+a:hover {
+  outline: 0;
+}
+
+strong {
+  font-weight: bold;
+}
+
+h1 {
+  font-size: 2em;
+  margin: 0 0 0.67em 0;
+}
+
+img {
+  border: 0;
+}
+
+hr {
+  -moz-box-sizing: content-box;
+  box-sizing: content-box;
+  height: 0;
+}
+
+pre {
+  overflow: auto;
+}
+
+code,
+pre {
+  font-family: monospace, monospace;
+  font-size: 1em;
+}
+
+table {
+  border-collapse: collapse;
+  border-spacing: 0;
+}
+
+td,
+th {
+  padding: 0;
+}
+
+* {
+  -moz-box-sizing: border-box;
+  box-sizing: border-box;
+}
+
+a {
+  color: #4183c4;
+  text-decoration: none;
+}
+
+a:hover,
+a:focus,
+a:active {
+  text-decoration: underline;
+}
+
+hr {
+  height: 0;
+  margin: 15px 0;
+  overflow: hidden;
+  background: transparent;
+  border: 0;
+  border-bottom: 1px solid #ddd;
+}
+
+hr:before,
+hr:after {
+  display: table;
+  content: " ";
+}
+
+hr:after {
+  clear: both;
+}
+
+blockquote {
+  margin: 0;
+}
+
+ul,
+ol {
+  padding: 0;
+  margin-top: 0;
+  margin-bottom: 0;
+}
+
+ol ol {
+  list-style-type: lower-roman;
+}
+
+dd {
+  margin-left: 0;
+}
+
+code,
+pre {
+  font-family: Consolas, "Liberation Mono", Menlo, Courier, monospace;
+  font-size: 12px;
+}
+
+pre {
+  margin-top: 0;
+  margin-bottom: 0;
+}
+
+*:first-child {
+  margin-top: 0 !important;
+}
+
+*:last-child {
+  margin-bottom: 0 !important;
+}
+
+.anchor {
+  position: absolute;
+  top: 0;
+  bottom: 0;
+  left: 0;
+  display: block;
+  padding-right: 6px;
+  padding-left: 30px;
+  margin-left: -30px;
+}
+
+.anchor:focus {
+  outline: none;
+}
+
+h1,
+h2,
+h3,
+h4,
+h5,
+h6 {
+  position: relative;
+  margin-top: 1.5em;
+  margin-bottom: 16px;
+  font-weight: bold;
+  line-height: 1.4;
+}
+
+h1 {
+  padding-bottom: 0.3em;
+  font-size: 2.1em;
+  line-height: 1.2;
+  border-bottom: 1px solid #eee;
+}
+
+h2 {
+  padding-bottom: 0.3em;
+  font-size: 1.65em;
+  line-height: 1.225;
+  border-bottom: 1px solid #eee;
+}
+
+h3 {
+  font-size: 1.2em;
+  line-height: 1.43;
+}
+
+h4 {
+  font-size: 1.1em;
+}
+
+h5 {
+  font-size: 1em;
+}
+
+h6 {
+  font-size: 1em;
+  color: #777;
+}
+
+p,
+blockquote,
+ul,
+ol,
+dl,
+table,
+pre {
+  margin-top: 0;
+  margin-bottom: 16px;
+}
+
+hr {
+  height: 4px;
+  padding: 0;
+  margin: 16px 0;
+  background-color: #e7e7e7;
+  border: 0 none;
+}
+
+ul,
+ol {
+  padding-left: 2em;
+}
+
+ol ol,
+ol ul {
+  margin-top: 0;
+  margin-bottom: 0;
+}
+
+li>p {
+  margin-top: 16px;
+}
+
+dl {
+  padding: 0;
+}
+
+dl dt {
+  padding: 0;
+  margin-top: 16px;
+  font-size: 1em;
+  font-style: italic;
+  font-weight: bold;
+}
+
+dl dd {
+  padding: 0 16px;
+  margin-bottom: 16px;
+}
+
+blockquote {
+  padding: 0 15px;
+  color: #777;
+  border-left: 4px solid #ddd;
+}
+
+blockquote>:first-child {
+  margin-top: 0;
+}
+
+blockquote>:last-child {
+  margin-bottom: 0;
+}
+
+table {
+  display: block;
+  width: 100%;
+  overflow: auto;
+  word-break: normal;
+  word-break: keep-all;
+}
+
+table th {
+  font-weight: bold;
+}
+
+table th,
+table td {
+  padding: 6px 13px;
+  border: 1px solid #ddd;
+}
+
+table tr {
+  background-color: #fff;
+  border-top: 1px solid #ccc;
+}
+
+table tr:nth-child(2n) {
+  background-color: #f8f8f8;
+}
+
+img {
+  max-width: 100%;
+  -moz-box-sizing: border-box;
+  box-sizing: border-box;
+}
+
+code {
+  padding: 0;
+  padding-top: 0.2em;
+  padding-bottom: 0.2em;
+  margin: 0;
+  font-size: 85%;
+  background-color: rgba(0,0,0,0.04);
+  border-radius: 3px;
+}
+
+code:before,
+code:after {
+  letter-spacing: -0.2em;
+  content: "\00a0";
+}
+
+pre>code {
+  padding: 0;
+  margin: 0;
+  font-size: 100%;
+  word-break: normal;
+  white-space: pre;
+  background: transparent;
+  border: 0;
+}
+
+.highlight {
+  margin-bottom: 16px;
+}
+
+.highlight pre,
+pre {
+  padding: 16px;
+  overflow: auto;
+  font-size: 85%;
+  line-height: 1.45;
+  background-color: #f7f7f7;
+  border-radius: 3px;
+}
+
+.highlight pre {
+  margin-bottom: 0;
+  word-break: normal;
+}
+
+pre {
+  word-wrap: normal;
+}
+
+pre code {
+  display: inline;
+  max-width: initial;
+  padding: 0;
+  margin: 0;
+  overflow: initial;
+  line-height: inherit;
+  word-wrap: normal;
+  background-color: transparent;
+  border: 0;
+}
+
+pre code:before,
+pre code:after {
+  content: normal;
+}
+</style>
+</head>
+<body>
+<div class="wrapper">

contrib/blacklist_table.sql

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

contrib/region_manual_update_20110325.sql

@@ -0,0 +1,114 @@
+--
+-- This file only needs to be run if you are using a very old version
+-- of the region database (before 2011/03/25).
+--
+-- Otherwise, WG knows how to update your tables automatically, as well
+-- as set them up initially.
+--
+
+SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0;
+SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0;
+SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='TRADITIONAL';
+
+ALTER TABLE `region_cuboid` DROP FOREIGN KEY `fk_region_cuboid_region` ;
+
+ALTER TABLE `region_flag` DROP FOREIGN KEY `fk_flags_region1` ;
+
+ALTER TABLE `region_groups` DROP FOREIGN KEY `fk_region_groups_region` ;
+
+ALTER TABLE `region_players` DROP FOREIGN KEY `fk_region_players_user` , DROP FOREIGN KEY `fk_region_players_region` ;
+
+ALTER TABLE `region_poly2d` DROP FOREIGN KEY `fk_region_poly2d_region` ;
+
+ALTER TABLE `region_poly2d_point` DROP FOREIGN KEY `fk_region_poly2d_point_region_poly2d` ;
+
+ALTER TABLE `group` COLLATE = utf8_bin ;
+
+ALTER TABLE `region_cuboid` COLLATE = utf8_bin , ADD COLUMN `world_id` INT(10) UNSIGNED NOT NULL  AFTER `region_id` , CHANGE COLUMN `min_x` `min_x` BIGINT(20) NOT NULL  AFTER `world_id` , CHANGE COLUMN `min_y` `min_y` BIGINT(20) NOT NULL  AFTER `min_x` , CHANGE COLUMN `max_x` `max_x` BIGINT(20) NOT NULL  AFTER `min_z` , CHANGE COLUMN `max_y` `max_y` BIGINT(20) NOT NULL  AFTER `max_x` , 
+  ADD CONSTRAINT `fk_region_cuboid_region`
+  FOREIGN KEY (`region_id` , `world_id` )
+  REFERENCES `region` (`id` , `world_id` )
+  ON DELETE CASCADE
+  ON UPDATE CASCADE
+, DROP PRIMARY KEY 
+, ADD PRIMARY KEY (`region_id`, `world_id`) ;
+
+ALTER TABLE `region_flag` COLLATE = utf8_bin , ADD COLUMN `world_id` INT(10) UNSIGNED NOT NULL  AFTER `region_id` , CHANGE COLUMN `flag` `flag` VARCHAR(45) CHARACTER SET 'utf8' COLLATE 'utf8_bin' NOT NULL  , 
+  ADD CONSTRAINT `fk_flags_region`
+  FOREIGN KEY (`region_id` , `world_id` )
+  REFERENCES `region` (`id` , `world_id` )
+  ON DELETE CASCADE
+  ON UPDATE CASCADE
+, DROP INDEX `fk_flags_region` 
+, ADD INDEX `fk_flags_region` (`region_id` ASC, `world_id` ASC) ;
+
+ALTER TABLE `region_groups` COLLATE = utf8_bin , ADD COLUMN `world_id` INT(10) UNSIGNED NOT NULL  AFTER `region_id` , DROP FOREIGN KEY `fk_region_groups_group` ;
+
+ALTER TABLE `region_groups` 
+  ADD CONSTRAINT `fk_region_groups_group`
+  FOREIGN KEY (`group_id` )
+  REFERENCES `group` (`id` )
+  ON DELETE CASCADE
+  ON UPDATE CASCADE, 
+  ADD CONSTRAINT `fk_region_groups_region`
+  FOREIGN KEY (`region_id` , `world_id` )
+  REFERENCES `region` (`id` , `world_id` )
+  ON DELETE CASCADE
+  ON UPDATE CASCADE
+, DROP PRIMARY KEY 
+, ADD PRIMARY KEY (`region_id`, `world_id`, `group_id`) ;
+
+ALTER TABLE `region_players` COLLATE = utf8_bin , ADD COLUMN `world_id` INT(10) UNSIGNED NOT NULL  AFTER `region_id` , 
+  ADD CONSTRAINT `fk_region_users_region`
+  FOREIGN KEY (`region_id` , `world_id` )
+  REFERENCES `region` (`id` , `world_id` )
+  ON DELETE CASCADE
+  ON UPDATE CASCADE, 
+  ADD CONSTRAINT `fk_region_users_user`
+  FOREIGN KEY (`user_id` )
+  REFERENCES `user` (`id` )
+  ON DELETE CASCADE
+  ON UPDATE CASCADE
+, DROP PRIMARY KEY 
+, ADD PRIMARY KEY (`region_id`, `world_id`, `user_id`) 
+, ADD INDEX `fk_region_users_user` (`user_id` ASC) 
+, DROP INDEX `fk_region_players_user` ;
+
+ALTER TABLE `region_poly2d` COLLATE = utf8_bin , ADD COLUMN `world_id` INT(10) UNSIGNED NOT NULL  AFTER `region_id` , CHANGE COLUMN `min_y` `min_y` INT(11) NOT NULL  AFTER `world_id` , 
+  ADD CONSTRAINT `fk_region_poly2d_region`
+  FOREIGN KEY (`region_id` , `world_id` )
+  REFERENCES `region` (`id` , `world_id` )
+  ON DELETE CASCADE
+  ON UPDATE CASCADE
+, DROP PRIMARY KEY 
+, ADD PRIMARY KEY (`region_id`, `world_id`) ;
+
+ALTER TABLE `region_poly2d_point` COLLATE = utf8_bin , ADD COLUMN `world_id` INT(10) UNSIGNED NOT NULL  AFTER `region_id` , CHANGE COLUMN `x` `x` BIGINT(20) NOT NULL  AFTER `world_id` , 
+  ADD CONSTRAINT `fk_region_poly2d_point_region_poly2d`
+  FOREIGN KEY (`region_id` , `world_id` )
+  REFERENCES `region_poly2d` (`region_id` , `world_id` )
+  ON DELETE CASCADE
+  ON UPDATE CASCADE
+, DROP INDEX `fk_region_poly2d_point_region_poly2d` 
+, ADD INDEX `fk_region_poly2d_point_region_poly2d` (`region_id` ASC, `world_id` ASC) ;
+
+ALTER TABLE `user` COLLATE = utf8_bin ;
+
+ALTER TABLE `world` COLLATE = utf8_bin ;
+
+
+UPDATE `region_cuboid` AS c SET c.`world_id` = (SELECT p.`world_id` FROM `region` AS p WHERE p.`id` = c.`region_id`);
+
+UPDATE `region_flag` AS c SET c.`world_id` = (SELECT p.`world_id` FROM `region` AS p WHERE p.`id` = c.`region_id`);
+
+UPDATE `region_groups` AS c SET c.`world_id` = (SELECT p.`world_id` FROM `region` AS p WHERE p.`id` = c.`region_id`);
+
+UPDATE `region_players` AS c SET c.`world_id` = (SELECT p.`world_id` FROM `region` AS p WHERE p.`id` = c.`region_id`);
+
+UPDATE `region_poly2d` AS c SET c.`world_id` = (SELECT p.`world_id` FROM `region` AS p WHERE p.`id` = c.`region_id`);
+
+UPDATE `region_poly2d_point` AS c SET c.`world_id` = (SELECT p.`world_id` FROM `region` AS p WHERE p.`id` = c.`region_id`);
+
+SET SQL_MODE=@OLD_SQL_MODE;
+SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS;
+SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS;

plugin.yml

@@ -1,3 +0,0 @@
-name: WorldGuard
-main: com.sk89q.worldguard.bukkit.WorldGuardPlugin
-version: WGVERSIONMACRO

pom.xml

@@ -0,0 +1,525 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>com.sk89q</groupId>
+  <artifactId>worldguard</artifactId>
+  <version>6.1</version>
+  <packaging>jar</packaging>
+  
+  <!-- Project information -->
+  <name>WorldGuard</name>
+  <description>WorldGuard protects your Minecraft servers.</description>
+  <licenses>
+    <license>
+      <name>GNU General Public License 2.0</name>
+      <url>LICENSE.txt</url>
+      <distribution>repo</distribution>
+      <comments>License on all contributions</comments>
+    </license>
+  </licenses>
+  
+  <issueManagement>
+    <system>YouTrack</system>
+    <url>http://youtrack.sk89q.com</url>
+  </issueManagement>
+  
+  <ciManagement>
+    <system>Jenkins</system>
+    <url>http://build.sk89q.com</url>
+  </ciManagement>
+  
+  <scm>
+    <connection>scm:git:git://github.com/sk89q/worldguard.git</connection>
+    <developerConnection>scm:git:git@github.com:sk89q/worldguard.git</developerConnection>
+    <url>https://github.com/sk89q/worldguard</url>
+    <tag>master</tag>
+  </scm>
+  
+  <mailingLists>
+    <mailingList>
+      <name>Developer Discussion</name>
+      <archive>https://groups.google.com/d/forum/sk-dev-discuss</archive>
+    </mailingList>
+  </mailingLists>
+  
+  <distributionManagement>
+    <site>
+      <id>sk89q-docs-upload</id>
+      <url>ftp://sk89q-maven-deploy/worldguard/</url>
+    </site>
+    <repository>
+      <id>maven.sk89q.com</id>
+      <url>http://maven.sk89q.com/artifactory/libs-release-local</url>
+    </repository>
+    <snapshotRepository>
+      <id>maven.sk89q.com-snapshot</id>
+      <url>http://maven.sk89q.com/artifactory/libs-snapshot-local</url>
+    </snapshotRepository>
+  </distributionManagement>
+  
+  <properties> <!-- Fix encoding warnings -->
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+  </properties>
+  
+  <repositories>
+    <repository>
+      <id>sk89q-repo</id>
+      <url>http://maven.sk89q.com/repo/</url>
+    </repository>
+    <repository>
+      <id>spigot-repo</id>
+      <url>https://hub.spigotmc.org/nexus/content/groups/public/</url>
+    </repository>
+  </repositories>
+  
+  <dependencies>
+    <dependency>
+      <groupId>com.sk89q</groupId>
+      <artifactId>worldedit</artifactId>
+      <version>5.5.8</version>
+      <scope>compile</scope>
+      <type>jar</type>
+      <exclusions>
+        <exclusion>
+          <groupId>com.zachsthings.libcomponents</groupId>
+          <artifactId>libcomponents-bukkit</artifactId>
+        </exclusion>
+        <exclusion>
+          <groupId>org.bukkit</groupId>
+          <artifactId>bukkit</artifactId>
+        </exclusion>
+      </exclusions>
+    </dependency>
+
+    <dependency>
+      <groupId>com.sk89q.spigot</groupId>
+      <artifactId>bukkit-classloader-check</artifactId>
+      <version>1.8-R0.1-SNAPSHOT</version>
+      <scope>runtime</scope>
+    </dependency>
+
+    <dependency>
+      <groupId>org.bukkit</groupId>
+      <artifactId>bukkit</artifactId>
+      <version>1.8.6-R0.1-SNAPSHOT</version>
+      <scope>compile</scope>
+      <type>jar</type>
+    </dependency>
+    
+    <dependency>
+      <groupId>com.sk89q</groupId>
+      <artifactId>commandbook</artifactId>
+      <version>2.3</version>
+      <scope>compile</scope>
+      <type>jar</type>
+      <exclusions>
+        <exclusion>
+          <groupId>com.zachsthings.libcomponents</groupId>
+          <artifactId>libcomponents-bukkit</artifactId>
+        </exclusion>
+        <exclusion>
+          <groupId>org.spout</groupId>
+          <artifactId>spoutapi</artifactId>
+        </exclusion>
+        <exclusion>
+          <groupId>org.bukkit</groupId>
+          <artifactId>bukkit</artifactId>
+        </exclusion>
+      </exclusions>
+    </dependency>
+    
+    <dependency>
+      <groupId>com.nijikokun</groupId>
+      <artifactId>iconomy</artifactId>
+      <version>5.0</version>
+      <scope>compile</scope>
+      <type>jar</type>
+      <optional>true</optional>
+    </dependency>
+
+    <dependency>
+      <!-- Contains parts of Guava that are not compatible
+           between Bukkit 10.0.1 and 17+ -->
+      <groupId>com.sk89q</groupId>
+      <artifactId>guavabackport</artifactId>
+      <version>1.1</version>
+      <scope>compile</scope>
+      <type>jar</type>
+    </dependency>
+
+    <dependency>
+      <groupId>com.google.code.findbugs</groupId>
+      <artifactId>jsr305</artifactId>
+      <version>1.3.9</version>
+      <scope>compile</scope>
+      <type>jar</type>
+    </dependency>
+
+    <dependency>
+      <groupId>com.googlecode.json-simple</groupId>
+      <artifactId>json-simple</artifactId>
+      <version>1.1.1</version>
+    </dependency>
+    
+    <dependency>
+      <groupId>org.khelekore</groupId>
+      <artifactId>prtree</artifactId>
+      <version>1.5.0</version>
+      <scope>compile</scope>
+      <type>jar</type>
+    </dependency>
+    
+    <dependency>
+      <groupId>net.sf.opencsv</groupId>
+      <artifactId>opencsv</artifactId>
+      <version>2.0</version>
+      <scope>compile</scope>
+      <type>jar</type>
+      <optional>true</optional>
+    </dependency>
+
+    <dependency>
+      <groupId>org.flywaydb</groupId>
+      <artifactId>flyway-core</artifactId>
+      <version>3.0</version>
+      <scope>compile</scope>
+      <type>jar</type>
+      <optional>true</optional>
+    </dependency>
+
+    <dependency>
+      <groupId>com.sk89q</groupId>
+      <artifactId>squirrelid</artifactId>
+      <version>0.1.0</version>
+      <scope>compile</scope>
+      <type>jar</type>
+      <optional>true</optional>
+    </dependency>
+
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <version>4.11</version>
+      <scope>test</scope>
+      <type>jar</type>
+      <exclusions>
+        <exclusion>
+          <groupId>org.hamcrest</groupId>
+          <artifactId>hamcrest-core</artifactId>
+        </exclusion>
+      </exclusions>
+    </dependency>
+
+    <dependency>
+      <groupId>org.hamcrest</groupId>
+      <artifactId>hamcrest-library</artifactId>
+      <version>1.2.1</version>
+      <scope>test</scope>
+      <optional>true</optional>
+    </dependency>
+  </dependencies>
+  
+  <build>
+    <defaultGoal>install</defaultGoal>
+    <sourceDirectory>${basedir}/src/main/java</sourceDirectory>
+    
+    <extensions> <!-- Used for uploading the docs -->
+      <extension>
+        <groupId>org.apache.maven.wagon</groupId>
+         <artifactId>wagon-ftp</artifactId>
+         <version>1.0-beta-6</version>
+      </extension>
+    </extensions>
+
+    <resources>
+      <resource>
+        <targetPath>.</targetPath>
+        <filtering>true</filtering>
+        <directory>${basedir}/src/main/resources/</directory>
+        <includes>
+          <include>plugin.yml</include>
+        </includes>
+      </resource>
+      <resource>
+        <targetPath>defaults/</targetPath>
+        <filtering>true</filtering>
+        <directory>${basedir}/src/main/resources/</directory>
+        <includes>
+          <include>config.yml</include>
+          <include>config_world.yml</include>
+          <include>blacklist.txt</include>
+        </includes>
+      </resource>
+      <resource>
+        <targetPath>migrations/</targetPath>
+        <filtering>false</filtering>
+        <directory>${basedir}/src/main/resources/migrations/</directory>
+      </resource>
+    </resources>
+
+    <plugins>
+      <!-- Check style -->
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-checkstyle-plugin</artifactId>
+        <version>2.12</version>
+        <executions>
+          <execution>
+            <id>verify-style</id>
+            <phase>validate</phase>
+            <goals>
+              <goal>check</goal>
+            </goals>
+          </execution>
+        </executions>
+        <configuration>
+          <sourceDirectory>${basedir}/src</sourceDirectory>
+          <consoleOutput>true</consoleOutput>
+          <failsOnError>true</failsOnError>
+          <logViolationsToConsole>true</logViolationsToConsole>
+          <checkstyleRules>
+            <module name="Checker">
+              <!-- Tabs are strictly banned -->
+              <module name="FileTabCharacter"/>
+
+              <module name="TreeWalker">
+                <!-- Important basics -->
+                <!-- <module name="PackageDeclaration"/> Unlikely that we would miss this in a PR -->
+                <module name="OuterTypeFilename"/> <!-- TypeName -> TypeName.java -->
+
+                <!--
+                Control package usage, so people don't insert Bukkit into WE where it shouldn't belong, etc.
+                It is a bit draconian, so update as necessary!
+                -->
+                <module name="ImportControl">
+                  <property name="file" value="${basedir}/config/checkstyle/import-control.xml"/>
+                </module>
+
+                <!-- Code -->
+                <module name="HideUtilityClassConstructor"/> <!-- Utility classes should not have a constructor -->
+                <module name="CovariantEquals"/>
+                <module name="EqualsHashCode"/> <!-- equals() and hashCode() go together -->
+                <module name="NestedTryDepth"> <!-- SHOULD not need to adjust this -->
+                  <property name="max" value="2"/>
+                </module>
+                <module name="SuperFinalize"/> <!-- We don't actually use this -->
+                <module name="JUnitTestCase"/> <!-- Checks tearDown(), setUp() etc. -->
+
+                <!-- Style -->
+                <module name="LeftCurly"> <!-- Left brace never goes on another line -->
+                  <property name="option" value="eol"/>
+                </module> <!-- We don't check right brance -->
+                <module name="DefaultComesLast"/> <!-- default case in switch should be last -->
+                <module name="GenericWhitespace"/>
+
+                <!-- Naming -->
+                <module name="ClassTypeParameterName">
+                  <property name="format" value="^[A-Z][a-zA-Z0-9]*$"/>
+                </module>
+                <module name="LocalFinalVariableName"/>
+                <module name="LocalVariableName">
+                  <property name="format" value="^[a-z_][a-zA-Z0-9]*$"/>
+                </module>
+                <module name="MemberName">
+                  <property name="format" value="^[a-z_][a-zA-Z0-9]*$"/>
+                </module>
+                <module name="MethodName">
+                  <property name="format" value="^[a-z][a-zA-Z0-9]*$"/>
+                </module>
+                <!-- <module name="PackageName"/> Unlikely that we would miss this in a PR -->
+                <module name="ParameterName"/>
+                <!-- <module name="TypeName"/> Unlikely that we would miss this in a PR -->
+              </module>
+
+              <!-- Require the header, something that many people forget and we hate to fix -->
+              <!-- You should configure the header in your IDE -->
+              <module name="Header">
+                <property name="headerFile" value="${basedir}/config/checkstyle/header.txt"/>
+                <property name="fileExtensions" value="java"/>
+              </module>
+            </module>
+          </checkstyleRules>
+        </configuration>
+      </plugin>
+
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-compiler-plugin</artifactId>
+        <version>2.3.2</version>
+        <configuration>
+          <source>1.6</source>
+          <target>1.6</target>
+        </configuration>
+      </plugin>
+      
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-jar-plugin</artifactId>
+        <version>2.3.1</version>
+        <configuration>
+          <archive>
+            <addMavenDescriptor>true</addMavenDescriptor>
+            <manifest>
+              <addDefaultSpecificationEntries>true</addDefaultSpecificationEntries>
+              <addDefaultImplementationEntries>true</addDefaultImplementationEntries>
+            </manifest>
+            <manifestEntries>
+              <Class-Path>WorldGuard/WorldEdit.jar lib/WorldEdit.jar ../lib/WorldEdit.jar ../WorldEdit.jar</Class-Path>
+            </manifestEntries>
+          </archive>
+        </configuration>
+      </plugin>
+      
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-shade-plugin</artifactId>
+        <version>1.4</version>
+        <executions>
+          <execution>
+            <phase>package</phase>
+            <goals>
+              <goal>shade</goal>
+            </goals>
+            <configuration>
+              <artifactSet>
+                <includes>
+                  <include>net.sf.opencsv:opencsv</include>
+                  <include>org.khelekore:prtree</include>
+                  <include>org.flywaydb:flyway-core</include>
+                  <include>com.sk89q:squirrelid</include>
+                  <include>com.sk89q:guavabackport</include>
+                  <include>com.googlecode.json-simple:json-simple</include>
+                </includes>
+              </artifactSet>
+              <relocations>
+                <relocation>
+                  <pattern>com.sk89q.guavabackport</pattern>
+                  <shadedPattern>com.sk89q.worldguard.internal.guava</shadedPattern>
+                </relocation>
+                <relocation>
+                  <pattern>org.flywaydb</pattern>
+                  <shadedPattern>com.sk89q.worldguard.internal.flywaydb</shadedPattern>
+                </relocation>
+                <relocation>
+                  <pattern>com.sk89q.squirrelid</pattern>
+                  <shadedPattern>com.sk89q.worldguard.util.profile</shadedPattern>
+                </relocation>
+                <relocation>
+                  <pattern>org.json.simple</pattern>
+                  <shadedPattern>com.sk89q.worldguard.util.jsonsimple</shadedPattern>
+                </relocation>
+              </relocations>
+            </configuration>
+          </execution>
+        </executions>
+      </plugin>
+
+      <plugin>
+        <groupId>com.ruleoftech</groupId>
+        <artifactId>markdown-page-generator-plugin</artifactId>
+        <version>0.4</version>
+        <executions>
+          <execution>
+            <phase>package</phase>
+            <goals>
+              <goal>generate</goal>
+            </goals>
+          </execution>
+        </executions>
+        <configuration>
+          <inputDirectory>${basedir}</inputDirectory>
+          <outputDirectory>${project.build.directory}</outputDirectory>
+          <headerHtmlFile>${project.basedir}/config/markdown/header.html</headerHtmlFile>
+          <footerHtmlFile>${project.basedir}/config/markdown/footer.html</footerHtmlFile>
+        </configuration>
+      </plugin>
+      
+      <plugin>
+        <artifactId>maven-assembly-plugin</artifactId>
+        <version>2.2-beta-2</version>
+        <configuration>
+          <descriptor>${basedir}/config/assembly/default.xml</descriptor>
+        </configuration>
+        <executions>
+          <execution>
+            <id>release</id>
+            <phase>package</phase>
+            <goals>
+              <goal>single</goal>
+            </goals>
+          </execution>
+        </executions>
+      </plugin>
+      
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-release-plugin</artifactId>
+        <version>2.4.1</version>
+        <configuration>
+          <preparationGoals>assembly:assembly</preparationGoals>
+          <goals>assembly:assembly</goals>
+          <tagNameFormat>@{project.version}</tagNameFormat>
+        </configuration>
+      </plugin>
+      
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-source-plugin</artifactId>
+        <version>2.2.1</version>
+        <executions>
+          <execution>
+            <id>attach-sources</id>
+            <goals>
+              <goal>jar</goal>
+            </goals>
+          </execution>
+        </executions>
+      </plugin>
+      
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-javadoc-plugin</artifactId>
+        <version>2.8.1</version>
+        <configuration>
+          <additionalparam>-Xdoclint:none</additionalparam>
+        </configuration>
+        <executions>
+          <execution>
+            <id>attach-javadocs</id>
+            <goals>
+              <goal>jar</goal>
+            </goals>
+          </execution>
+        </executions>
+      </plugin>
+
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-site-plugin</artifactId>
+        <version>3.1</version>
+        <configuration>
+          <reportPlugins>
+            <plugin>
+              <groupId>org.apache.maven.plugins</groupId>
+              <artifactId>maven-project-info-reports-plugin</artifactId>
+              <version>2.5</version>
+              <reportSets>
+                <reportSet>
+                  <reports>
+                    <report>license</report>
+                    <report>index</report>
+                  </reports>
+                </reportSet>
+              </reportSets>
+            </plugin>
+            
+            <plugin>
+              <groupId>org.apache.maven.plugins</groupId>
+              <artifactId>maven-javadoc-plugin</artifactId>
+              <version>2.8.1</version>
+            </plugin>
+          </reportPlugins>
+        </configuration>
+      </plugin>
+    </plugins>
+  </build>
+</project>

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

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

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

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

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

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

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

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

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

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

src/com/sk89q/worldguard/LocalPlayer.java

@@ -1,89 +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.List;
-import com.sk89q.worldedit.Vector;
-
-public abstract class LocalPlayer {
-    /**
-     * Get a player's name.
-     * 
-     * @return
-     */
-    public abstract String getName();
-    
-    /**
-     * Returns true if the player is inside a group.
-     * 
-     * @param group
-     * @return
-     */
-    public abstract boolean hasGroup(String group);
-    
-    /**
-     * Get the player's position.
-     * 
-     * @return
-     */
-    public abstract Vector getPosition();
-    
-    /**
-     * Kick the player.
-     * 
-     * @param msg
-     */
-    public abstract void kick(String msg);
-    
-    /**
-     * Ban the player.
-     * 
-     * @param msg
-     */
-    public abstract void ban(String msg);
-    
-    /**
-     * Send the player a message;
-     * 
-     * @param msg
-     */
-    public abstract void printRaw(String msg);
-    
-    /**
-     * Get the player's list of groups.
-     * 
-     * @return
-     */
-    public abstract String[] getGroups();
-    
-    @Override
-    public boolean equals(Object obj) {
-        if (!(obj instanceof LocalPlayer)) {
-            return false;
-        }
-        
-        return ((LocalPlayer)obj).getName().equals(getName());
-    }
-    
-    @Override
-    public int hashCode() {
-        return getName().hashCode();
-    }
-}

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

@@ -1,301 +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.blacklist;
-
-import java.util.Map;
-import java.util.HashMap;
-import java.util.List;
-import java.util.ArrayList;
-import java.util.logging.Logger;
-import java.util.logging.Level;
-import java.io.*;
-import org.bukkit.ChatColor;
-import com.sk89q.worldedit.blocks.ItemType;
-import com.sk89q.worldguard.LocalPlayer;
-import com.sk89q.worldguard.blacklist.events.BlacklistEvent;
-
-/**
- *
- * @author sk89q
- */
-public abstract class Blacklist {
-    /**
-     * Logger.
-     */
-    private static final Logger logger = Logger.getLogger("Minecraft.WorldGuard");
-    
-    /**
-     * List of entries by block ID.
-     */
-    private Map<Integer,List<BlacklistEntry>> blacklist
-            = new HashMap<Integer,List<BlacklistEntry>>();
-    /**
-     * Logger.
-     */
-    private BlacklistLogger blacklistLogger = new BlacklistLogger();
-    /**
-     * Last event.
-     */
-    private BlacklistEvent lastEvent;
-    /**
-     * Used to prevent flooding.
-     */
-    Map<String,BlacklistTrackedEvent> lastAffected =
-            new HashMap<String,BlacklistTrackedEvent>();
-
-    /**
-     * Returns whether the list is empty.
-     * 
-     * @return
-     */
-    public boolean isEmpty() {
-        return blacklist.isEmpty();
-    }
-
-    /**
-     * Get the entries for an item or list.
-     */
-    public List<BlacklistEntry> getEntries(int id) {
-        return blacklist.get(id);
-    }
-    
-    /**
-     * Get the logger.
-     * 
-     * @return
-     */
-    public BlacklistLogger getLogger() {
-        return blacklistLogger;
-    }
-
-    /**
-     * Method to handle the event.
-     * 
-     * @param event
-     * @param forceRepeat
-     * @param silent
-     * @return
-     */
-    public boolean check(BlacklistEvent event, boolean forceRepeat, boolean silent) {
-        List<BlacklistEntry> entries = getEntries(event.getType());
-        if (entries == null) {
-            return true;
-        }
-        boolean ret = true;
-        for (BlacklistEntry entry : entries) {
-            if (!entry.check(event, forceRepeat, silent)) {
-                ret = false;
-            }
-        }
-        return ret;
-    }
-
-    /**
-     * Load the blacklist.
-     *
-     * @param file
-     * @return
-     * @throws IOException
-     */
-    public void load(File file) throws IOException {
-        FileReader input = null;
-        Map<Integer,List<BlacklistEntry>> blacklist =
-                new HashMap<Integer,List<BlacklistEntry>>();
-
-        try {
-            input = new FileReader(file);
-            BufferedReader buff = new BufferedReader(input);
-
-            String line;
-            List<BlacklistEntry> currentEntries = null;
-            while ((line = buff.readLine()) != null) {
-                line = line.trim();
-
-                // Blank line
-                if (line.length() == 0) {
-                    continue;
-                } else if (line.charAt(0) == ';' || line.charAt(0) == '#') {
-                    continue;
-                }
-
-                if (line.matches("^\\[.*\\]$")) {
-                    String[] items = line.substring(1, line.length() - 1).split(",");
-                    currentEntries = new ArrayList<BlacklistEntry>();
-
-                    for (String item : items) {
-                        int id = 0;
-
-                        try {
-                            id = Integer.parseInt(item.trim());
-                        } catch (NumberFormatException e) {
-                            id = getItemID(item.trim());
-                            if (id == 0) {
-                                logger.log(Level.WARNING, "WorldGuard: Unknown block name: "
-                                        + item);
-                                break;
-                            }
-                        }
-
-                        BlacklistEntry entry = new BlacklistEntry(this);
-                        if (blacklist.containsKey(id)) {
-                            blacklist.get(id).add(entry);
-                        } else {
-                            List<BlacklistEntry> entries = new ArrayList<BlacklistEntry>();
-                            entries.add(entry);
-                            blacklist.put(id, entries);
-                        }
-                        currentEntries.add(entry);
-                    }
-                } else if (currentEntries != null) {
-                    String[] parts = line.split("=");
-
-                    if (parts.length == 1) {
-                        logger.log(Level.WARNING, "Found option with no value "
-                                + file.getName() + " for '" + line + "'");
-                        continue;
-                    }
-
-                    boolean unknownOption = false;
-
-                    for (BlacklistEntry entry : currentEntries) {
-                        if (parts[0].equalsIgnoreCase("ignore-groups")) {
-                            entry.setIgnoreGroups(parts[1].split(","));
-                        } else if (parts[0].equalsIgnoreCase("on-break")) {
-                            entry.setBreakActions(parts[1].split(","));
-                        } else if (parts[0].equalsIgnoreCase("on-destroy-with")) {
-                            entry.setDestroyWithActions(parts[1].split(","));
-                        } else if (parts[0].equalsIgnoreCase("on-place")) {
-                            entry.setPlaceActions(parts[1].split(","));
-                        } else if (parts[0].equalsIgnoreCase("on-interact")) {
-                            entry.setInteractActions(parts[1].split(","));
-                        } else if (parts[0].equalsIgnoreCase("on-use")) {
-                            entry.setUseActions(parts[1].split(","));
-                        } else if (parts[0].equalsIgnoreCase("on-drop")) {
-                            entry.setDropActions(parts[1].split(","));
-                        } else if (parts[0].equalsIgnoreCase("on-acquire")) {
-                            entry.setAcquireActions(parts[1].split(","));
-                        } else if (parts[0].equalsIgnoreCase("message")) {
-                            entry.setMessage(parts[1].trim());
-                        } else if (parts[0].equalsIgnoreCase("comment")) {
-                            entry.setComment(parts[1].trim());
-                        } else {
-                            unknownOption = true;
-                        }
-                    }
-
-                    if (unknownOption) {
-                        logger.log(Level.WARNING, "Unknown option '" + parts[0]
-                                + "' in " + file.getName() + " for '" + line + "'");
-                    }
-                } else {
-                    logger.log(Level.WARNING, "Found option with no heading "
-                            + file.getName() + " for '" + line + "'");
-                }
-            }
-
-            this.blacklist = blacklist;
-        } finally {
-            try {
-                if (input != null) {
-                    input.close();
-                }
-            } catch (IOException e2) {
-            }
-        }
-    }
-    
-    /**
-     * Get the last event.
-     * 
-     * @return
-     */
-    public BlacklistEvent getLastEvent() {
-        return lastEvent;
-    }
-    
-    /**
-     * Notify administrators.
-     * 
-     * @param event
-     */
-    public void notify(BlacklistEvent event, String comment) {
-        lastEvent = event;
-        
-        broadcastNotification(ChatColor.GRAY + "WG: " 
-                + ChatColor.LIGHT_PURPLE + event.getPlayer().getName()
-                + ChatColor.GOLD + " (" + event.getDescription() + ") "
-                + ChatColor.WHITE
-                + getFriendlyItemName(event.getType())
-                + (comment != null ? " (" + comment + ")" : "") + ".");
-    }
-    
-    /**
-     * Sends a notification to all subscribing users.
-     * 
-     * @param msg
-     */
-    public abstract void broadcastNotification(String msg);
-
-    /**
-     * Forget a player.
-     *
-     * @param player
-     */
-    public void forgetPlayer(LocalPlayer player) {
-        lastAffected.remove(player.getName());
-    }
-
-    /**
-     * Forget all players.
-     *
-     * @param player
-     */
-    public void forgetAllPlayers() {
-        lastAffected.clear();
-    }
-
-    /**
-     * Get an item's ID from its name.
-     * 
-     * @param name
-     */
-    private static int getItemID(String name) {
-        ItemType type = ItemType.lookup(name);
-        if (type != null) {
-            return type.getID();
-        } else {
-            return -1;
-        }
-    }
-
-    /**
-     * Get an item's friendly name with its ID.
-     * 
-     * @param id
-     */
-    private static String getFriendlyItemName(int id) {
-        ItemType type = ItemType.fromID(id);
-        if (type != null) {
-            return type.getName() + " (#" + id + ")";
-        } else {
-            return "#" + id + "";
-        }
-    }
-}

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

@@ -1,381 +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.blacklist;
-
-import java.util.Set;
-import java.util.HashSet;
-import org.bukkit.ChatColor;
-import com.sk89q.worldedit.blocks.ItemType;
-import com.sk89q.worldguard.LocalPlayer;
-import com.sk89q.worldguard.blacklist.events.BlacklistEvent;
-import com.sk89q.worldguard.blacklist.events.BlockBreakBlacklistEvent;
-import com.sk89q.worldguard.blacklist.events.BlockInteractBlacklistEvent;
-import com.sk89q.worldguard.blacklist.events.BlockPlaceBlacklistEvent;
-import com.sk89q.worldguard.blacklist.events.DestroyWithBlacklistEvent;
-import com.sk89q.worldguard.blacklist.events.ItemAcquireBlacklistEvent;
-import com.sk89q.worldguard.blacklist.events.ItemDropBlacklistEvent;
-import com.sk89q.worldguard.blacklist.events.ItemUseBlacklistEvent;
-
-/**
- *
- * @author sk89q
- */
-public class BlacklistEntry {
-    /**
-     * Parent blacklist entry.
-     */
-    private Blacklist blacklist;
-    /**
-     * List of groups to not affect.
-     */
-    private Set<String> ignoreGroups;
-    
-    private String[] breakActions;
-    private String[] destroyWithActions;
-    private String[] placeActions;
-    private String[] interactActions;
-    private String[] useActions;
-    private String[] dropActions;
-    private String[] acquireActions;
-    
-    private String message;
-    private String comment;
-
-    /**
-     * Construct the object.
-     * 
-     * @param blacklist
-     */
-    public BlacklistEntry(Blacklist blacklist) {
-        this.blacklist = blacklist;
-    }
-
-    /**
-     * @return the ignoreGroups
-     */
-    public String[] getIgnoreGroups() {
-        return ignoreGroups.toArray(new String[ignoreGroups.size()]);
-    }
-
-    /**
-     * @param ignoreGroups the ignoreGroups to set
-     */
-    public void setIgnoreGroups(String[] ignoreGroups) {
-        Set<String> ignoreGroupsSet = new HashSet<String>();
-        for (String group : ignoreGroups) {
-            ignoreGroupsSet.add(group.toLowerCase());
-        }
-        this.ignoreGroups = ignoreGroupsSet;
-    }
-
-    /**
-     * @return
-     */
-    public String[] getBreakActions() {
-        return breakActions;
-    }
-
-    /**
-     * @param actions
-     */
-    public void setBreakActions(String[] actions) {
-        this.breakActions = actions;
-    }
-
-    /**
-     * @return
-     */
-    public String[] getDestroyWithActions() {
-        return destroyWithActions;
-    }
-
-    /**
-     * @param action
-     */
-    public void setDestroyWithActions(String[] actions) {
-        this.destroyWithActions = actions;
-    }
-
-    /**
-     * @return
-     */
-    public String[] getPlaceActions() {
-        return placeActions;
-    }
-
-    /**
-     * @param actions
-     */
-    public void setPlaceActions(String[] actions) {
-        this.placeActions = actions;
-    }
-
-    /**
-     * @return
-     */
-    public String[] getInteractActions() {
-        return interactActions;
-    }
-
-    /**
-     * @param actions
-     */
-    public void setInteractActions(String[] actions) {
-        this.interactActions = actions;
-    }
-
-    /**
-     * @return
-     */
-    public String[] getUseActions() {
-        return useActions;
-    }
-
-    /**
-     * @param actions
-     */
-    public void setUseActions(String[] actions) {
-        this.useActions = actions;
-    }
-
-    /**
-     * @return
-     */
-    public String[] getDropActions() {
-        return dropActions;
-    }
-
-    /**
-     * @param actions
-     */
-    public void setDropActions(String[] actions) {
-        this.dropActions = actions;
-    }
-
-    /**
-     * @return
-     */
-    public String[] getAcquireActions() {
-        return acquireActions;
-    }
-
-    /**
-     * @param actions
-     */
-    public void setAcquireActions(String[] actions) {
-        this.acquireActions = actions;
-    }
-
-    /**
-     * @return the message
-     */
-    public String getMessage() {
-        return message;
-    }
-
-    /**
-     * @param message the message to set
-     */
-    public void setMessage(String message) {
-        this.message = message;
-    }
-
-    /**
-     * @return the comment
-     */
-    public String getComment() {
-        return comment;
-    }
-
-    /**
-     * @param comment the comment to set
-     */
-    public void setComment(String comment) {
-        this.comment = comment;
-    }
-
-    /**
-     * Returns true if this player should be ignored.
-     *
-     * @param player
-     * @return
-     */
-    public boolean shouldIgnore(LocalPlayer player) {
-        if (ignoreGroups == null) {
-            return false;
-        }
-        for (String group : player.getGroups()) {
-            if (ignoreGroups.contains(group.toLowerCase())) {
-                return true;
-            }
-        }
-
-        return false;
-    }
-    
-    /**
-     * Get the associated actions with an event.
-     * 
-     * @param event
-     * @return
-     */
-    private String[] getActions(BlacklistEvent event) {
-        if (event instanceof BlockBreakBlacklistEvent) {
-            return breakActions;
-            
-        } else if (event instanceof BlockPlaceBlacklistEvent) {
-            return placeActions;
-            
-        } else if (event instanceof BlockInteractBlacklistEvent) {
-            return interactActions;
-            
-        } else if (event instanceof DestroyWithBlacklistEvent) {
-            return destroyWithActions;
-            
-        } else if (event instanceof ItemAcquireBlacklistEvent) {
-            return acquireActions;
-            
-        } else if (event instanceof ItemDropBlacklistEvent) {
-            return dropActions;
-            
-        } else if (event instanceof ItemUseBlacklistEvent) {
-            return useActions;
-            
-        } else {
-            return null;
-        }
-    }
-
-    /**
-     * Method to handle the event.
-     * 
-     * @param event
-     * @param forceRepeat
-     * @param silent
-     * @return
-     */
-    public boolean check(BlacklistEvent event, boolean forceRepeat, boolean silent) {
-        LocalPlayer player = event.getPlayer();
-        
-        if (shouldIgnore(player)) {
-            return true;
-        }
-
-        String name = player.getName();
-        long now = System.currentTimeMillis();
-        boolean repeating = false;
-
-        // Check to see whether this event is being repeated
-        BlacklistTrackedEvent tracked = blacklist.lastAffected.get(name);
-        if (tracked != null) {
-            if (tracked.matches(event, now)) {
-                repeating = true;
-            }
-        } else {
-            blacklist.lastAffected.put(name, new BlacklistTrackedEvent(event, now));
-        }
-
-        String actions[] = getActions(event);
-        boolean ret = true;
-        
-        // Nothing to do
-        if (actions == null) {
-            return true;
-        }
-        
-        for (String action : actions) {
-            // Deny
-            if (action.equalsIgnoreCase("deny")) {
-                if (silent) {
-                    return false;
-                }
-                
-                ret = false;
-
-            // Kick
-            } else if (action.equalsIgnoreCase("kick")) {
-                if (silent) {
-                    continue;
-                }
-                
-                if (this.message != null) {
-                    player.kick(String.format(this.message,
-                            getFriendlyItemName(event.getType())));
-                } else {
-                    player.kick("You can't " + event.getDescription() + " "
-                            + getFriendlyItemName(event.getType()));
-                }
-
-            // Ban
-            } else if (action.equalsIgnoreCase("ban")) {
-                if (silent) {
-                    continue;
-                }
-                
-                if (this.message != null) {
-                    player.ban("Banned: " + String.format(this.message,
-                            getFriendlyItemName(event.getType())));
-                } else {
-                    player.ban("Banned: You can't "
-                            + event.getDescription() + " "
-                            + getFriendlyItemName(event.getType()));
-                }
-            
-            } else if (!silent && (!repeating || forceRepeat)) {
-                // Notify
-                if (action.equalsIgnoreCase("notify")) {
-                    blacklist.notify(event, comment);
-                
-                // Log
-                } else if (action.equalsIgnoreCase("log")) {
-                    blacklist.getLogger().logEvent(event, comment);
-
-                // Tell
-                } else if (action.equalsIgnoreCase("tell")) {
-                    if (this.message != null) {
-                        player.printRaw(ChatColor.YELLOW +
-                                String.format(message, getFriendlyItemName(event.getType()))
-                                + ".");
-                    } else {
-                        player.printRaw(ChatColor.YELLOW + "You're not allowed to "
-                                + event.getDescription() + " "
-                                + getFriendlyItemName(event.getType()) + ".");
-                    }
-                }
-            }
-        }
-
-        return ret;
-    }
-
-    /**
-     * Get an item's friendly name with its ID.
-     * 
-     * @param id
-     */
-    private static String getFriendlyItemName(int id) {
-        ItemType type = ItemType.fromID(id);
-        if (type != null) {
-            return type.getName() + " (#" + id + ")";
-        } else {
-            return "#" + id + "";
-        }
-    }
-}

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

@@ -1,85 +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.blacklist;
-
-import java.util.Set;
-import java.util.HashSet;
-import com.sk89q.worldguard.blacklist.events.BlacklistEvent;
-import com.sk89q.worldguard.blacklist.loggers.BlacklistLoggerHandler;
-
-/**
- *
- * @author sk89q
- */
-public class BlacklistLogger implements BlacklistLoggerHandler {
-    /**
-     * List of logger handlers.
-     */
-    private Set<BlacklistLoggerHandler> handlers
-            = new HashSet<BlacklistLoggerHandler>();
-
-    /**
-     * Add a handler.
-     *
-     * @param handler
-     */
-    public void addHandler(BlacklistLoggerHandler handler) {
-        handlers.add(handler);
-    }
-
-    /**
-     * Add a handler.
-     *
-     * @param handler
-     */
-    public void removeHandler(BlacklistLoggerHandler handler) {
-        handlers.remove(handler);
-    }
-
-    /**
-     * Add a handler.
-     *
-     * @param handler
-     */
-    public void clearHandlers() {
-        handlers.clear();
-    }
-    
-    /**
-     * Log an event.
-     *
-     * @param player
-     * @param event
-     */
-    public void logEvent(BlacklistEvent event, String comment) {
-        for (BlacklistLoggerHandler handler : handlers) {
-            handler.logEvent(event, comment);
-        }
-    }
-
-    /**
-     * Close the connection.
-     */
-    public void close() {
-        for (BlacklistLoggerHandler handler : handlers) {
-            handler.close();
-        }
-    }
-}

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

@@ -1,48 +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.blacklist;
-
-import com.sk89q.worldguard.blacklist.events.BlacklistEvent;
-
-/**
- *
- * @author sk89q
- */
-public class BlacklistTrackedEvent {
-    private BlacklistEvent event;
-    private long time;
-
-    /**
-     * Construct the object.
-     * 
-     * @param id
-     * @param time
-     */
-    public BlacklistTrackedEvent(BlacklistEvent event, long time) {
-        this.event = event;
-        this.time = time;
-    }
-
-    public boolean matches(BlacklistEvent other, long now) {
-        return other.getType() == event.getType()
-                && time > now - 3000
-                && other.getClass() == event.getClass();
-    }
-}

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

@@ -1,85 +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.blacklist.events;
-
-import com.sk89q.worldedit.Vector;
-import com.sk89q.worldguard.LocalPlayer;
-
-/**
- * Represents a blacklist event.
- * 
- * @author sk89q
- */
-public abstract class BlacklistEvent {
-    private Vector pos;
-    private int type;
-    
-    /**
-     * Holds the player that triggered the event.
-     */
-    private LocalPlayer player;
-    
-    /**
-     * Construct the object.
-     * 
-     * @param player
-     * @param pos
-     * @param type
-     */
-    public BlacklistEvent(LocalPlayer player, Vector pos, int type) {
-        this.player = player;
-        this.pos = pos;
-        this.type = type;
-    }
-    
-    /**
-     * Get the player.
-     * 
-     * @return
-     */
-    public LocalPlayer getPlayer() {
-        return player;
-    }
-    
-    /**
-     * Get the position.
-     * 
-     * @return
-     */
-    public Vector getPosition() {
-        return pos;
-    }
-    
-    /**
-     * Get the type.
-     * 
-     * @return
-     */
-    public int getType() {
-        return type;
-    }
-    
-    /**
-     * Get a short description such as "break" or "destroy with."
-     * 
-     * @return
-     */
-    public abstract String getDescription();
-}

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

@@ -1,29 +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.blacklist.events;
-
-import com.sk89q.worldedit.Vector;
-import com.sk89q.worldguard.LocalPlayer;
-
-public abstract class BlockBlacklistEvent extends BlacklistEvent {
-    public BlockBlacklistEvent(LocalPlayer player, Vector pos, int type) {
-        super(player, pos, type);
-    }
-}

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

@@ -1,38 +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.blacklist.events;
-
-import com.sk89q.worldedit.Vector;
-import com.sk89q.worldguard.LocalPlayer;
-
-public class BlockBreakBlacklistEvent extends BlockBlacklistEvent {
-    public BlockBreakBlacklistEvent(LocalPlayer player, Vector pos, int type) {
-        super(player, pos, type);
-    }
-    
-    /**
-     * Get a short description such as "break" or "destroy with."
-     * 
-     * @return
-     */
-    public String getDescription() {
-        return "break";
-    }
-}

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

@@ -1,38 +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.blacklist.events;
-
-import com.sk89q.worldedit.Vector;
-import com.sk89q.worldguard.LocalPlayer;
-
-public class BlockInteractBlacklistEvent extends BlockBlacklistEvent {
-    public BlockInteractBlacklistEvent(LocalPlayer player, Vector pos, int type) {
-        super(player, pos, type);
-    }
-    
-    /**
-     * Get a short description such as "break" or "destroy with."
-     * 
-     * @return
-     */
-    public String getDescription() {
-        return "interact with";
-    }
-}

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

@@ -1,38 +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.blacklist.events;
-
-import com.sk89q.worldedit.Vector;
-import com.sk89q.worldguard.LocalPlayer;
-
-public class BlockPlaceBlacklistEvent extends BlockBlacklistEvent {
-    public BlockPlaceBlacklistEvent(LocalPlayer player, Vector pos, int type) {
-        super(player, pos, type);
-    }
-    
-    /**
-     * Get a short description such as "break" or "destroy with."
-     * 
-     * @return
-     */
-    public String getDescription() {
-        return "place";
-    }
-}

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

@@ -1,38 +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.blacklist.events;
-
-import com.sk89q.worldedit.Vector;
-import com.sk89q.worldguard.LocalPlayer;
-
-public class DestroyWithBlacklistEvent extends BlacklistEvent {
-    public DestroyWithBlacklistEvent(LocalPlayer player, Vector pos, int type) {
-        super(player, pos, type);
-    }
-    
-    /**
-     * Get a short description such as "break" or "destroy with."
-     * 
-     * @return
-     */
-    public String getDescription() {
-        return "destroy with";
-    }
-}

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

@@ -1,38 +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.blacklist.events;
-
-import com.sk89q.worldedit.Vector;
-import com.sk89q.worldguard.LocalPlayer;
-
-public class ItemAcquireBlacklistEvent extends ItemBlacklistEvent {
-    public ItemAcquireBlacklistEvent(LocalPlayer player, Vector pos, int type) {
-        super(player, pos, type);
-    }
-    
-    /**
-     * Get a short description such as "break" or "destroy with."
-     * 
-     * @return
-     */
-    public String getDescription() {
-        return "acquire";
-    }
-}

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

@@ -1,29 +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.blacklist.events;
-
-import com.sk89q.worldedit.Vector;
-import com.sk89q.worldguard.LocalPlayer;
-
-public abstract class ItemBlacklistEvent extends BlacklistEvent {
-    public ItemBlacklistEvent(LocalPlayer player, Vector pos, int type) {
-        super(player, pos, type);
-    }
-}

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

@@ -1,38 +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.blacklist.events;
-
-import com.sk89q.worldedit.Vector;
-import com.sk89q.worldguard.LocalPlayer;
-
-public class ItemDropBlacklistEvent extends ItemBlacklistEvent {
-    public ItemDropBlacklistEvent(LocalPlayer player, Vector pos, int type) {
-        super(player, pos, type);
-    }
-    
-    /**
-     * Get a short description such as "break" or "destroy with."
-     * 
-     * @return
-     */
-    public String getDescription() {
-        return "drop";
-    }
-}

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

@@ -1,38 +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.blacklist.events;
-
-import com.sk89q.worldedit.Vector;
-import com.sk89q.worldguard.LocalPlayer;
-
-public class ItemUseBlacklistEvent extends ItemBlacklistEvent {
-    public ItemUseBlacklistEvent(LocalPlayer player, Vector pos, int type) {
-        super(player, pos, type);
-    }
-    
-    /**
-     * Get a short description such as "break" or "destroy with."
-     * 
-     * @return
-     */
-    public String getDescription() {
-        return "use";
-    }
-}

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

@@ -1,42 +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.blacklist.loggers;
-
-import com.sk89q.worldguard.blacklist.events.BlacklistEvent;
-
-/**
- * Interface for loggers for the blacklist.
- *
- * @author sk89q
- */
-public interface BlacklistLoggerHandler {
-    /**
-     * Log an event.
-     *
-     * @param event
-     * @param comment
-     */
-    public void logEvent(BlacklistEvent event, String comment);
-    
-    /**
-     * Close the logger.
-     */
-    public void close();
-}

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

@@ -1,119 +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.blacklist.loggers;
-
-import java.util.logging.Logger;
-import java.util.logging.Level;
-import com.sk89q.worldedit.blocks.ItemType;
-import com.sk89q.worldguard.blacklist.events.*;
-
-/**
- *
- * @author sk89q
- */
-public class ConsoleLoggerHandler implements BlacklistLoggerHandler {
-    /**
-     * Logger.
-     */
-    private static final Logger logger = Logger.getLogger("Minecraft.WorldGuard");
-    
-    /**
-     * Log an event.
-     *
-     * @param player
-     * @param event
-     */
-    public void logEvent(BlacklistEvent event, String comment) {
-        // Block break
-        if (event instanceof BlockBreakBlacklistEvent) {
-            BlockBreakBlacklistEvent evt = (BlockBreakBlacklistEvent)event;
-            logger.log(Level.INFO, "WorldGuard: " + event.getPlayer().getName()
-                    + " tried to break " + getFriendlyItemName(evt.getType())
-                    + (comment != null ? " (" + comment + ")" : ""));
-        
-        // Block place
-        } else if (event instanceof BlockPlaceBlacklistEvent) {
-            BlockPlaceBlacklistEvent evt = (BlockPlaceBlacklistEvent)event;
-            logger.log(Level.INFO, "WorldGuard: " + event.getPlayer().getName()
-                    + " tried to place " + getFriendlyItemName(evt.getType())
-                    + (comment != null ? " (" + comment + ")" : ""));
-        
-        // Block interact
-        } else if (event instanceof BlockPlaceBlacklistEvent) {
-            BlockPlaceBlacklistEvent evt = (BlockPlaceBlacklistEvent)event;
-            logger.log(Level.INFO, "WorldGuard: " + event.getPlayer().getName()
-                    + " tried to interact with " + getFriendlyItemName(evt.getType())
-                    + (comment != null ? " (" + comment + ")" : ""));
-        
-        // Destroy with
-        } else if (event instanceof DestroyWithBlacklistEvent) {
-            DestroyWithBlacklistEvent evt = (DestroyWithBlacklistEvent)event;
-            logger.log(Level.INFO, "WorldGuard: " + event.getPlayer().getName()
-                    + " tried to destroy with " + getFriendlyItemName(evt.getType())
-                    + (comment != null ? " (" + comment + ")" : ""));
-        
-        // Acquire
-        } else if (event instanceof ItemAcquireBlacklistEvent) {
-            ItemAcquireBlacklistEvent evt = (ItemAcquireBlacklistEvent)event;
-            logger.log(Level.INFO, "WorldGuard: " + event.getPlayer().getName()
-                    + " tried to acquire " + getFriendlyItemName(evt.getType())
-                    + (comment != null ? " (" + comment + ")" : ""));
-        
-        // Drop
-        } else if (event instanceof ItemDropBlacklistEvent) {
-            ItemDropBlacklistEvent evt = (ItemDropBlacklistEvent)event;
-            logger.log(Level.INFO, "WorldGuard: " + event.getPlayer().getName()
-                    + " tried to drop " + getFriendlyItemName(evt.getType())
-                    + (comment != null ? " (" + comment + ")" : ""));
-        
-        // Use
-        } else if (event instanceof ItemUseBlacklistEvent) {
-            ItemUseBlacklistEvent evt = (ItemUseBlacklistEvent)event;
-            logger.log(Level.INFO, "WorldGuard: " + event.getPlayer().getName()
-                    + " tried to use " + getFriendlyItemName(evt.getType())
-                    + (comment != null ? " (" + comment + ")" : ""));
-        
-        // Unknown
-        } else {
-            logger.log(Level.INFO, "WorldGuard: " + event.getPlayer().getName()
-                    + " caught unknown event: " + event.getClass().getCanonicalName());
-        }
-    }
-
-    /**
-     * Get an item's friendly name with its ID.
-     * 
-     * @param id
-     */
-    private static String getFriendlyItemName(int id) {
-        ItemType type = ItemType.fromID(id);
-        if (type != null) {
-            return type.getName() + " (#" + id + ")";
-        } else {
-            return "#" + id + "";
-        }
-    }
-
-    /**
-     * Close the connection.
-     */
-    public void close() {
-    }
-}

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

@@ -1,198 +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.blacklist.loggers;
-
-import java.util.logging.Logger;
-import java.util.logging.Level;
-import java.sql.Connection;
-import java.sql.DriverManager;
-import java.sql.SQLException;
-import java.sql.PreparedStatement;
-import com.sk89q.worldedit.Vector;
-import com.sk89q.worldguard.LocalPlayer;
-import com.sk89q.worldguard.blacklist.events.BlacklistEvent;
-import com.sk89q.worldguard.blacklist.events.BlockBreakBlacklistEvent;
-import com.sk89q.worldguard.blacklist.events.BlockPlaceBlacklistEvent;
-import com.sk89q.worldguard.blacklist.events.DestroyWithBlacklistEvent;
-import com.sk89q.worldguard.blacklist.events.ItemAcquireBlacklistEvent;
-import com.sk89q.worldguard.blacklist.events.ItemDropBlacklistEvent;
-import com.sk89q.worldguard.blacklist.events.ItemUseBlacklistEvent;
-
-/**
- *
- * @author sk89q
- */
-public class DatabaseLoggerHandler implements BlacklistLoggerHandler {
-    /**
-     * Logger.
-     */
-    private static final Logger logger = Logger.getLogger("Minecraft.WorldGuard");
-
-    /**
-     * DSN.
-     */
-    private String dsn;
-    /**
-     * Username.
-     */
-    private String user;
-    /**
-     * Password.
-     */
-    private String pass;
-    /**
-     * Table.
-     */
-    private String table;
-    /**
-     * Database connection.
-     */
-    private Connection conn;
-
-    /**
-     * Construct the object.
-     * 
-     * @param dsn
-     * @param user
-     * @param pass
-     */
-    public DatabaseLoggerHandler(String dsn, String user, String pass, String table) {
-        this.dsn = dsn;
-        this.user = user;
-        this.pass = pass;
-        this.table = table;
-    }
-
-    /**
-     * Gets the database connection.
-     * 
-     * @return
-     * @throws SQLException
-     */
-    private Connection getConnection() throws SQLException {
-        if (conn == null || conn.isClosed()) {
-            conn = DriverManager.getConnection(dsn, user, pass);
-        }
-        return conn;
-    }
-
-    /**
-     * Log an event to the database.
-     * 
-     * @param event
-     * @param name
-     * @param x
-     * @param y
-     * @param z
-     * @param item
-     * @param comment
-     */
-    private void logEvent(String event, LocalPlayer player, Vector pos, int item,
-            String comment) {
-        try {
-            Connection conn = getConnection();
-            PreparedStatement stmt = conn.prepareStatement(
-                    "INSERT INTO " + table
-                  + "(event, player, x, y, z, item, time, comment) VALUES "
-                  + "(?, ?, ?, ?, ?, ?, ?, ?)");
-            stmt.setString(1, event);
-            stmt.setString(2, player.getName());
-            stmt.setInt(3, pos.getBlockX());
-            stmt.setInt(4, pos.getBlockY());
-            stmt.setInt(5, pos.getBlockZ());
-            stmt.setInt(6, item);
-            stmt.setInt(7, (int)(System.currentTimeMillis() / 1000));
-            stmt.setString(8, comment);
-            stmt.executeUpdate();
-        } catch (SQLException e) {
-            logger.log(Level.SEVERE, "Failed to log blacklist event to database: "
-                    + e.getMessage());
-        }
-    }
-    
-    /**
-     * Log an event.
-     *
-     * @param player
-     * @param event
-     */
-    public void logEvent(BlacklistEvent event, String comment) {
-        // Block break
-        if (event instanceof BlockBreakBlacklistEvent) {
-            BlockBreakBlacklistEvent evt = (BlockBreakBlacklistEvent)event;
-            logEvent("BREAK", evt.getPlayer(), evt.getPosition(),
-                    evt.getType(), comment);
-        
-        // Block place
-        } else if (event instanceof BlockPlaceBlacklistEvent) {
-            BlockPlaceBlacklistEvent evt = (BlockPlaceBlacklistEvent)event;
-            logEvent("PLACE", evt.getPlayer(), evt.getPosition(),
-                    evt.getType(), comment);
-            
-        // Block interact
-        } else if (event instanceof BlockPlaceBlacklistEvent) {
-            BlockPlaceBlacklistEvent evt = (BlockPlaceBlacklistEvent)event;
-            logEvent("INTERACT", evt.getPlayer(), evt.getPosition(),
-                    evt.getType(), comment);
-        
-        // Destroy with
-        } else if (event instanceof DestroyWithBlacklistEvent) {
-            DestroyWithBlacklistEvent evt = (DestroyWithBlacklistEvent)event;
-            logEvent("DESTROY_WITH", evt.getPlayer(), evt.getPosition(),
-                    evt.getType(), comment);
-        
-        // Acquire
-        } else if (event instanceof ItemAcquireBlacklistEvent) {
-            ItemAcquireBlacklistEvent evt = (ItemAcquireBlacklistEvent)event;
-            logEvent("ACQUIRE", evt.getPlayer(), evt.getPlayer().getPosition(),
-                    evt.getType(), comment);
-        
-        // Drop
-        } else if (event instanceof ItemDropBlacklistEvent) {
-            ItemDropBlacklistEvent evt = (ItemDropBlacklistEvent)event;
-            logEvent("DROP", evt.getPlayer(), evt.getPlayer().getPosition(),
-                    evt.getType(), comment);
-        
-        // Use
-        } else if (event instanceof ItemUseBlacklistEvent) {
-            ItemDropBlacklistEvent evt = (ItemDropBlacklistEvent)event;
-            logEvent("USE", evt.getPlayer(), evt.getPlayer().getPosition(),
-                    evt.getType(), comment);
-        
-        // Unknown
-        } else {
-            logEvent("UNKNOWN", event.getPlayer(), event.getPlayer().getPosition(),
-                    -1, comment);
-        }
-    }
-
-    /**
-     * Close the connection.
-     */
-    public void close() {
-        try {
-            if (conn != null && !conn.isClosed()) {
-                conn.close();
-            }
-        } catch (SQLException e) {
-            
-        }
-    }
-}

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

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

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

@@ -1,40 +0,0 @@
-// $Id$
-/*
- * WorldGuard
- * Copyright (C) 2010 sk89q <http://www.sk89q.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
-*/
-
-package com.sk89q.worldguard.bukkit;
-
-import org.bukkit.entity.Player;
-import com.sk89q.worldguard.blacklist.Blacklist;
-
-public class BukkitBlacklist extends Blacklist {
-    private WorldGuardPlugin plugin;
-    
-    public BukkitBlacklist(WorldGuardPlugin plugin) {
-        this.plugin = plugin;
-    }
-    
-    public void broadcastNotification(String msg) {
-        for (Player player : plugin.getServer().getOnlinePlayers()) {
-            if (plugin.hasPermission(player, "/worldguardnotify")) {
-                player.sendMessage(msg);
-            }
-        }
-    }
-
-}

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

@@ -1,72 +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.entity.Player;
-import com.sk89q.worldedit.Vector;
-import com.sk89q.worldguard.LocalPlayer;
-
-public class BukkitPlayer extends LocalPlayer {
-    private Player player;
-    private WorldGuardPlugin plugin;
-    
-    public BukkitPlayer(WorldGuardPlugin plugin, Player player) {
-        this.plugin = plugin;
-        this.player = player;
-    }
-
-    @Override
-    public String getName() {
-        return player.getName();
-    }
-
-    @Override
-    public boolean hasGroup(String group) {
-        return plugin.inGroup(player, group);
-    }
-
-    @Override
-    public Vector getPosition() {
-        Location loc = player.getLocation();
-        return new Vector(loc.getX(), loc.getY(), loc.getZ());
-    }
-
-    @Override
-    public void kick(String msg) {
-        player.kickPlayer(msg);
-    }
-
-    @Override
-    public void ban(String msg) {
-        player.kickPlayer(msg);
-    }
-
-    @Override
-    public String[] getGroups() {
-        return plugin.getGroups(player);
-    }
-
-    @Override
-    public void printRaw(String msg) {
-        player.sendMessage(msg);
-    }
-
-}

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

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

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

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

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

@@ -1,138 +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.ChatColor;
-import org.bukkit.entity.Entity;
-import org.bukkit.entity.LivingEntity;
-import org.bukkit.entity.Player;
-import org.bukkit.event.entity.*;
-import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
-import com.sk89q.worldedit.Vector;
-import static com.sk89q.worldguard.bukkit.BukkitUtil.*;
-
-public class WorldGuardEntityListener extends EntityListener {
-    /**
-     * Plugin.
-     */
-    private WorldGuardPlugin plugin;
-    
-    /**
-     * Construct the object;
-     * 
-     * @param plugin
-     */
-    public WorldGuardEntityListener(WorldGuardPlugin plugin) {
-        this.plugin = plugin;
-    }
-
-    @Override
-    public void onEntityDamageByBlock(EntityDamageByBlockEvent event) {
-        Entity defender = event.getEntity();
-        DamageCause type = event.getCause();
-        
-        if (defender instanceof Player) {
-            Player player = (Player)defender;
-
-            if (plugin.invinciblePlayers.contains(player.getName())) {
-                event.setCancelled(true);
-                return;
-            }
-            
-            if (plugin.disableFallDamage && type == DamageCause.FALL) {
-                event.setCancelled(true);
-                return;
-            }
-
-            if (plugin.disableLavaDamage && type == DamageCause.LAVA) {
-                event.setCancelled(true);
-                return;
-            }
-
-            if (plugin.disableFireDamage && (type == DamageCause.FIRE
-                    || type == DamageCause.FIRE_TICK)) {
-                event.setCancelled(true);
-                return;
-            }
-
-            if (plugin.disableDrowningDamage && type == DamageCause.DROWNING) {
-                event.setCancelled(true);
-                return;
-            }
-
-            if (type == DamageCause.DROWNING
-                    && plugin.amphibiousPlayers.contains(player.getName())) {
-                event.setCancelled(true);
-                return;
-            }
-        }
-    }
-
-    @Override
-    public void onEntityDamageByEntity(EntityDamageByEntityEvent event) {
-        Entity attacker = event.getDamager();
-        Entity defender = event.getEntity();
-        
-        if (defender instanceof Player) {
-            Player player = (Player)defender;
-
-            if (plugin.invinciblePlayers.contains(player.getName())) {
-                event.setCancelled(true);
-                return;
-            }
-            
-            if (attacker != null && attacker instanceof Player) {
-                if (plugin.useRegions) {
-                    Vector pt = toVector(defender.getLocation());
-                    
-                    if (!plugin.regionManager.getApplicableRegions(pt).allowsPvP()) {
-                        player.sendMessage(ChatColor.DARK_RED + "You are in a no-PvP area.");
-                        event.setCancelled(true);
-                        return;
-                    }
-                }
-            }
-        }
-    }
-
-    @Override
-    public void onEntityExplode(EntityExplodeEvent event) {
-        if (event.getEntity() instanceof LivingEntity) {
-            if (plugin.blockCreeperBlockDamage) {
-                event.setCancelled(true);
-                return;
-            }
-            
-            if (plugin.blockCreeperExplosions) {
-                event.setCancelled(true);
-                return;
-            }
-            
-            if (plugin.useRegions) {
-                Vector pt = toVector(event.getEntity().getLocation());
-                
-                if (!plugin.regionManager.getApplicableRegions(pt).allowsCreeperExplosions()) {
-                    event.setCancelled(true);
-                    return;
-                }
-            }
-        }
-    }
-}

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

@@ -1,824 +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.IOException;
-import java.util.Arrays;
-import java.util.Map;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-import org.bukkit.*;
-import org.bukkit.block.Block;
-import org.bukkit.entity.Player;
-import org.bukkit.event.player.*;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.plugin.Plugin;
-import com.sk89q.worldedit.BlockVector;
-import com.sk89q.worldedit.blocks.ItemType;
-import com.sk89q.worldedit.bukkit.WorldEditAPI;
-import com.sk89q.worldedit.bukkit.WorldEditPlugin;
-import com.sk89q.worldedit.regions.Region;
-import com.sk89q.worldedit.IncompleteRegionException;
-import com.sk89q.worldedit.LocalSession;
-import com.sk89q.worldedit.Vector;
-import com.sk89q.worldguard.*;
-import com.sk89q.worldguard.blacklist.events.ItemUseBlacklistEvent;
-import com.sk89q.worldguard.domains.*;
-import com.sk89q.worldguard.protection.*;
-import static com.sk89q.worldguard.bukkit.BukkitUtil.*;
-
-/**
- * Handles all events thrown in relation to a Player
- */
-public class WorldGuardPlayerListener extends PlayerListener {
-    /**
-     * Plugin.
-     */
-    private WorldGuardPlugin plugin;
-    /**
-     * Group pattern used to specify groups for the region command.
-     */
-    private static Pattern groupPattern = Pattern.compile("^[gG]:(.+)$");
-
-    private static int CMD_LIST_SIZE = 9;
-    
-    /**
-     * Construct the object;
-     * 
-     * @param plugin
-     */
-    public WorldGuardPlayerListener(WorldGuardPlugin plugin) {
-        this.plugin = plugin;
-    }
-
-    /**
-     * Called when a player joins a server
-     *
-     * @param event Relevant event details
-     */
-    @Override
-    public void onPlayerJoin(PlayerEvent event) {
-        Player player = event.getPlayer();
-        
-        if (plugin.fireSpreadDisableToggle) {
-            player.sendMessage(ChatColor.YELLOW
-                    + "Fire spread is currently globally disabled.");
-        }
-
-        if (plugin.inGroup(player, "wg-invincible")) {
-            plugin.invinciblePlayers.add(player.getName());
-        }
-
-        if (plugin.inGroup(player, "wg-amphibious")) {
-            plugin.amphibiousPlayers.add(player.getName());
-        }
-    }
-
-    /**
-     * Called when a player leaves a server
-     *
-     * @param event Relevant event details
-     */
-    @Override
-    public void onPlayerQuit(PlayerEvent event) {
-        Player player = event.getPlayer();
-        plugin.invinciblePlayers.remove(player.getName());
-        plugin.amphibiousPlayers.remove(player.getName());
-        if (plugin.blacklist != null) {
-            plugin.blacklist.forgetPlayer(plugin.wrapPlayer(player));
-        }
-    }
-    
-    /**
-     * Called when a player uses an item
-     * 
-     * @param event Relevant event details
-     */
-    @Override
-    public void onPlayerItem(PlayerItemEvent event) {
-        Player player = event.getPlayer();
-        Block block = event.getBlockClicked();
-        
-        if (plugin.useRegions && !event.isBlock() && event.getBlockClicked() != null) {
-            Vector pt = toVector(block.getRelative(event.getBlockFace()));
-            LocalPlayer localPlayer = plugin.wrapPlayer(player);
-            
-            if (!plugin.hasPermission(player, "/regionbypass")
-                    && !plugin.regionManager.getApplicableRegions(pt).canBuild(localPlayer)) {
-                player.sendMessage(ChatColor.DARK_RED
-                        + "You don't have permission for this area.");
-                event.setCancelled(true);
-                return;
-            }
-        }
-        
-        if (block != null && plugin.blacklist != null) {
-            if (!plugin.blacklist.check(
-                    new ItemUseBlacklistEvent(plugin.wrapPlayer(player), toVector(block),
-                            block.getTypeId()), false, false)) {
-                event.setCancelled(true);
-                return;
-            }
-        }
-    }
-
-    /**
-     * Called when a player attempts to log in to the server
-     *
-     * @param event Relevant event details
-     */
-    @Override
-    public void onPlayerLogin(PlayerLoginEvent event) {
-        Player player = event.getPlayer();
-        
-        if (plugin.enforceOneSession) {
-            String name = player.getName();
-            
-            for (Player pl : plugin.getServer().getOnlinePlayers()) {
-                if (pl.getName().equalsIgnoreCase(name)) {
-                    pl.kickPlayer("Logged in from another location.");
-                }
-            }
-        }
-    }
-
-    /**
-     * Called when a player attempts to use a command
-     *
-     * @param event Relevant event details
-     */
-    @Override
-    public void onPlayerCommand(PlayerChatEvent event) {
-        if (handleCommand(event)) {
-            event.setCancelled(true);
-        }
-    }
-
-    /**
-     * Called when a player attempts to use a command
-     *
-     * @param event Relevant event details
-     */
-    public boolean handleCommand(PlayerChatEvent event) {
-        Player player = event.getPlayer();
-        String[] split = event.getMessage().split(" ");
-        
-        if (split[0].equalsIgnoreCase("/stopfire") &&
-                plugin.hasPermission(player, "/stopfire")) {
-            if (!plugin.fireSpreadDisableToggle) {
-                plugin.getServer().broadcastMessage(ChatColor.YELLOW
-                        + "Fire spread has been globally disabled by " + player.getName() + ".");
-            } else {
-                player.sendMessage(ChatColor.YELLOW + "Fire spread was already globally disabled.");
-            }
-            
-            plugin.fireSpreadDisableToggle = true;
-        } else if (split[0].equalsIgnoreCase("/allowfire")
-                    && plugin.hasPermission(player, "/stopfire")) {
-            if (plugin.fireSpreadDisableToggle) {
-                plugin.getServer().broadcastMessage(ChatColor.YELLOW
-                        + "Fire spread has been globally re-enabled by " + player.getName() + ".");
-            } else {
-                player.sendMessage(ChatColor.YELLOW + "Fire spread was already globally enabled.");
-            }
-            
-            plugin.fireSpreadDisableToggle = false;
-        } else if (split[0].equalsIgnoreCase("/god")
-                    && plugin.hasPermission(player, "/god")) {
-            // Allow setting other people invincible
-            if (split.length > 1) {
-                if (!plugin.hasPermission(player, "/godother")) {
-                    player.sendMessage(ChatColor.RED + "You don't have permission to make others invincible.");
-                    return true;
-                }
-
-                Player other = matchSinglePlayer(plugin.getServer(), split[1]);
-                if (other == null) {
-                    player.sendMessage(ChatColor.RED + "Player not found.");
-                } else {
-                    if (!plugin.invinciblePlayers.contains(other.getName())) {
-                        plugin.invinciblePlayers.add(other.getName());
-                        player.sendMessage(ChatColor.YELLOW + other.getName() + " is now invincible!");
-                        other.sendMessage(ChatColor.YELLOW + player.getName() + " has made you invincible!");
-                    } else {
-                        plugin.invinciblePlayers.remove(other.getName());
-                        player.sendMessage(ChatColor.YELLOW + other.getName() + " is no longer invincible.");
-                        other.sendMessage(ChatColor.YELLOW + player.getName() + " has taken away your invincibility.");
-                    }
-                }
-            // Invincibility for one's self
-            } else {
-                if (!plugin.invinciblePlayers.contains(player.getName())) {
-                    plugin.invinciblePlayers.add(player.getName());
-                    player.sendMessage(ChatColor.YELLOW + "You are now invincible!");
-                } else {
-                    plugin.invinciblePlayers.remove(player.getName());
-                    player.sendMessage(ChatColor.YELLOW + "You are no longer invincible.");
-                }
-            }
-        } else if ((split[0].equalsIgnoreCase("/stack")
-                || split[0].equalsIgnoreCase("/;"))
-                    && plugin.hasPermission(player, "/stack")) {
-            ItemStack[] items = player.getInventory().getContents();
-            int len = items.length;
-
-            int affected = 0;
-            
-            for (int i = 0; i < len; i++) {
-                ItemStack item = items[i];
-
-                // Avoid infinite stacks and stacks with durability
-                if (item == null || item.getAmount() <= 0
-                        || ItemType.shouldNotStack(item.getTypeId())) {
-                    continue;
-                }
-
-                // Ignore buckets
-                if (item.getTypeId() >= 325 && item.getTypeId() <= 327) {
-                    continue;
-                }
-
-                if (item.getAmount() < 64) {
-                    int needed = 64 - item.getAmount(); // Number of needed items until 64
-
-                    // Find another stack of the same type
-                    for (int j = i + 1; j < len; j++) {
-                        ItemStack item2 = items[j];
-
-                        // Avoid infinite stacks and stacks with durability
-                        if (item2 == null || item2.getAmount() <= 0
-                                || ItemType.shouldNotStack(item.getTypeId())) {
-                            continue;
-                        }
-
-                        // Same type?
-                        // Blocks store their color in the damage value
-                        if (item2.getTypeId() == item.getTypeId() &&
-                                (!ItemType.usesDamageValue(item.getTypeId())
-                                        || item.getDamage() == item2.getDamage())) {
-                            // This stack won't fit in the parent stack
-                            if (item2.getAmount() > needed) {
-                                item.setAmount(64);
-                                item2.setAmount(item2.getAmount() - needed);
-                                break;
-                            // This stack will
-                            } else {
-                                items[j] = null;
-                                item.setAmount(item.getAmount() + item2.getAmount());
-                                needed = 64 - item.getAmount();
-                            }
-
-                            affected++;
-                        }
-                    }
-                }
-            }
-
-            if (affected > 0) {
-                player.getInventory().setContents(items);
-            }
-
-            player.sendMessage(ChatColor.YELLOW + "Items compacted into stacks!");
-        } else if (split[0].equalsIgnoreCase("/rg")
-                || split[0].equalsIgnoreCase("/region")) {
-            if (split.length < 2) {
-                player.sendMessage(ChatColor.RED + "/region <define|claim|flag|delete|info|add|remove|list|save|load> ...");
-                return true;
-            }
-            
-            String action = split[1];
-            String[] args = new String[split.length - 1];
-            System.arraycopy(split, 1, args, 0, split.length - 1);
-            
-            handleRegionCommand(player, action, args);
-        } else if (split[0].equalsIgnoreCase("/reload")
-                && plugin.hasPermission(player, "/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 {
-                    plugin.loadConfiguration();
-                    plugin.postReload();
-                    player.sendMessage("WorldGuard configuration reloaded.");
-                } catch (Throwable t) {
-                    player.sendMessage("Error while reloading: "
-                            + t.getMessage());
-                } finally {
-                    minecraftLogger.removeHandler(handler);
-                }
-
-                return true;
-            }
-        } else {
-            return false;
-        }
-
-        return true;
-    }
-    
-    /**
-     * Handles a region command.
-     * 
-     * @param player
-     * @param action
-     * @param args
-     */
-    private void handleRegionCommand(Player player, String action, String[] args) {
-        if (!plugin.useRegions) {
-            player.sendMessage(ChatColor.RED + "Regions are disabled.");
-            return;
-        }
-        
-        if (action.equalsIgnoreCase("define")) {
-            if (!canUseRegionCommand(player, "/regiondefine")) {
-                player.sendMessage(ChatColor.RED + "You don't have the /regiondefine permission.");
-                return;
-            }
-            
-            if (args.length < 2) {
-                player.sendMessage(ChatColor.RED + "/region define <id> [owner1 [owner2 [owners...]]]");
-                return;
-            }
-            
-            try {
-                String id = args[1].toLowerCase();
-                Plugin wePlugin = plugin.getServer().getPluginManager().getPlugin("WorldEdit");
-                if (plugin == null) {
-                    player.sendMessage(ChatColor.RED + "WorldEdit must be installed and enabled as a plugin.");
-                    return;
-                }
-                
-                WorldEditPlugin worldEdit = (WorldEditPlugin)wePlugin;
-                WorldEditAPI api = worldEdit.getAPI();
-                
-                LocalSession session = api.getSession(player);
-                Region weRegion = session.getRegion();
-                
-                BlockVector min = weRegion.getMinimumPoint().toBlockVector();
-                BlockVector max = weRegion.getMaximumPoint().toBlockVector();
-                
-                ProtectedRegion region = new ProtectedCuboidRegion(min, max);
-                if (args.length >= 3) {
-                    region.setOwners(parseDomainString(args, 2));
-                }
-                plugin.regionManager.addRegion(id, region);
-                plugin.regionLoader.save(plugin.regionManager);
-                player.sendMessage(ChatColor.YELLOW + "Region saved as " + id + ".");
-            } catch (IncompleteRegionException e) {
-                player.sendMessage(ChatColor.RED + "You must first define an area in WorldEdit.");
-            } catch (IOException e) {
-                player.sendMessage(ChatColor.RED + "Region database failed to save: "
-                        + e.getMessage());
-            }
-        } else if (action.equalsIgnoreCase("claim")) {
-            if (!canUseRegionCommand(player, "/regionclaim")) {
-                player.sendMessage(ChatColor.RED + "You don't have the /regionclaim permission.");
-                return;
-            }
-            
-            if (args.length < 1) {
-                player.sendMessage(ChatColor.RED + "/region claim <id>");
-                return;
-            }
-            
-            try {
-                String id = args[1].toLowerCase();
-                Plugin wePlugin = plugin.getServer().getPluginManager().getPlugin("WorldEdit");
-                if (plugin == null) {
-                    player.sendMessage(ChatColor.RED + "WorldEdit must be installed and enabled as a plugin.");
-                    return;
-                }
-
-                ProtectedRegion existing = plugin.regionManager.getRegion(id);
-                
-                if (existing != null) {
-                    if (!existing.getOwners().contains(plugin.wrapPlayer(player))) {
-                        player.sendMessage(ChatColor.RED + "You don't own this region.");
-                        return;
-                    }
-                }
-                
-                WorldEditPlugin worldEdit = (WorldEditPlugin)wePlugin;
-                WorldEditAPI api = worldEdit.getAPI();
-                
-                LocalSession session = api.getSession(player);
-                Region weRegion = session.getRegion();
-                
-                BlockVector min = weRegion.getMinimumPoint().toBlockVector();
-                BlockVector max = weRegion.getMaximumPoint().toBlockVector();
-                
-                ProtectedRegion region = new ProtectedCuboidRegion(min, max);
-                
-                if (plugin.regionManager.overlapsUnownedRegion(region, plugin.wrapPlayer(player))) {
-                    player.sendMessage(ChatColor.RED + "This region overlaps with someone else's region.");
-                    return;
-                }
-                
-                region.getOwners().addPlayer(player.getName());
-                
-                plugin.regionManager.addRegion(id, region);
-                plugin.regionLoader.save(plugin.regionManager);
-                player.sendMessage(ChatColor.YELLOW + "Region saved as " + id + ".");
-            } catch (IncompleteRegionException e) {
-                player.sendMessage(ChatColor.RED + "You must first define an area in WorldEdit.");
-            } catch (IOException e) {
-                player.sendMessage(ChatColor.RED + "Region database failed to save: "
-                        + e.getMessage());
-            }
-        } else if (action.equalsIgnoreCase("flag")) {
-            if (!canUseRegionCommand(player, "/regiondefine")) {
-                player.sendMessage(ChatColor.RED + "You don't have the /regiondefine permission.");
-                return;
-            }
-            
-            if (args.length < 4) {
-                player.sendMessage(ChatColor.RED + "/region flag <id> <flag> <none|allow|deny>");
-                return;
-            }
-            
-            try {
-                String id = args[1].toLowerCase();
-                String flagStr = args[2];
-                String stateStr = args[3];
-                ProtectedRegion region = plugin.regionManager.getRegion(id);
-                
-                if (region == null) {
-                    player.sendMessage(ChatColor.RED + "Could not find a region by that ID.");
-                    return;
-                }
-                
-                AreaFlags.State state = null;
-    
-                if (stateStr.equalsIgnoreCase("allow")) {
-                    state = AreaFlags.State.ALLOW;
-                } else if (stateStr.equalsIgnoreCase("deny")) {
-                    state = AreaFlags.State.DENY;
-                } else if (stateStr.equalsIgnoreCase("none")) {
-                    state = AreaFlags.State.NONE;
-                } else {
-                    player.sendMessage(ChatColor.RED + "Acceptable states: allow, deny, none");
-                    return;
-                }
-                
-                AreaFlags flags = region.getFlags();
-                
-                if (flagStr.equalsIgnoreCase("build")) {
-                    flags.allowBuild = state;
-                } else if (flagStr.equalsIgnoreCase("pvp")) {
-                    flags.allowPvP = state;
-                } else if (flagStr.equalsIgnoreCase("tnt")) {
-                    flags.allowTNT = state;
-                } else if (flagStr.equalsIgnoreCase("lighter")) {
-                    flags.allowLighter = state;
-                } else {
-                    player.sendMessage(ChatColor.RED + "Acceptable flags: build, pvp, tnt, lighter");
-                    return;
-                }
-                
-                plugin.regionLoader.save(plugin.regionManager);
-                player.sendMessage(ChatColor.YELLOW + "Region '" + id + "' updated.");
-            } catch (IOException e) {
-                player.sendMessage(ChatColor.RED + "Region database failed to save: "
-                        + e.getMessage());
-            }
-        /*} else if (action.equalsIgnoreCase("priority")) {
-            if (!canUseRegionCommand(player, "/regiondefine")) {
-                player.sendMessage(ChatColor.RED + "You don't have the /regiondefine permission.");
-                return;
-            }
-            
-            if (args.length < 3) {
-                player.sendMessage(ChatColor.RED + "/region priority <id> <priority>");
-                return;
-            }
-            
-            try {
-                String id = args[1].toLowerCase();
-                int priority = 0;
-                try {
-                    priority = Integer.parseInt(args[2]);
-                } catch (NumberFormatException e) {
-                    player.sendMessage(ChatColor.RED + "The priority must be a number.");
-                    return;
-                }
-                
-                ProtectedRegion region = plugin.regionManager.getRegion(id);
-                
-                if (region == null) {
-                    player.sendMessage(ChatColor.RED + "Could not find a region by that ID.");
-                    return;
-                }
-                
-                region.setPriority(priority);
-                
-                plugin.regionLoader.save(plugin.regionManager);
-                player.sendMessage(ChatColor.YELLOW + "Region '" + id + "' updated.");
-            } catch (IOException e) {
-                player.sendMessage(ChatColor.RED + "Region database failed to save: "
-                        + e.getMessage());
-            }*/
-        } else if (action.equalsIgnoreCase("info")) {
-            if (!canUseRegionCommand(player, "/regioninfo")) {
-                player.sendMessage(ChatColor.RED + "You don't have the /regioninfo permission.");
-                return;
-            }
-            
-            if (args.length < 2) {
-                player.sendMessage(ChatColor.RED + "/region info <id>");
-                return;
-            }
-    
-            String id = args[1].toLowerCase();
-            if (!plugin.regionManager.hasRegion(id)) {
-                player.sendMessage(ChatColor.RED + "A region with ID '"
-                        + id + "' doesn't exist.");
-                return;
-            }
-    
-            ProtectedRegion region = plugin.regionManager.getRegion(id);
-            AreaFlags flags = region.getFlags();
-            DefaultDomain domain = region.getOwners();
-            
-            player.sendMessage(ChatColor.YELLOW + "Region ID: " + id);
-            player.sendMessage(ChatColor.GRAY + "Type: " + region.getClass().getCanonicalName());
-            player.sendMessage(ChatColor.GRAY + "Priority: " + region.getPriority());
-            player.sendMessage(ChatColor.BLUE + "Build: " + flags.allowBuild.name());
-            player.sendMessage(ChatColor.BLUE + "PvP: " + flags.allowPvP.name());
-            player.sendMessage(ChatColor.BLUE + "TNT: " + flags.allowTNT.name());
-            player.sendMessage(ChatColor.BLUE + "Lighter: " + flags.allowLighter.name());
-            player.sendMessage(ChatColor.LIGHT_PURPLE + "Players: " + domain.toPlayersString());
-            player.sendMessage(ChatColor.LIGHT_PURPLE + "Groups: " + domain.toGroupsString());
-        } else if (action.equalsIgnoreCase("addowner")) {
-            if (!canUseRegionCommand(player, "/regiondefine")
-                    && !canUseRegionCommand(player, "/regionclaim")) {
-                player.sendMessage(ChatColor.RED + "You don't have the /regiondefine permission.");
-                return;
-            }
-            
-            if (args.length < 2) {
-                player.sendMessage(ChatColor.RED + "/region addowner <id>");
-                return;
-            }
-    
-            try {
-                String id = args[1].toLowerCase();
-                if (!plugin.regionManager.hasRegion(id)) {
-                    player.sendMessage(ChatColor.RED + "A region with ID '"
-                            + id + "' doesn't exist.");
-                    return;
-                }
-                
-                ProtectedRegion existing = plugin.regionManager.getRegion(id);
-                
-                if (!canUseRegionCommand(player, "/regiondefine")
-                        && !existing.getOwners().contains(plugin.wrapPlayer(player))) {
-                    player.sendMessage(ChatColor.RED + "You don't own this region.");
-                    return;
-                }
-                
-                addToDomain(existing.getOwners(), args, 2);
-                
-                plugin.regionLoader.save(plugin.regionManager);
-                player.sendMessage(ChatColor.YELLOW + "Region updated!");
-            } catch (IOException e) {
-                player.sendMessage(ChatColor.RED + "Region database failed to save: "
-                        + e.getMessage());
-            }
-        } else if (action.equalsIgnoreCase("removeowner")) {
-            if (!canUseRegionCommand(player, "/regiondefine")
-                    && !canUseRegionCommand(player, "/regionclaim")) {
-                player.sendMessage(ChatColor.RED + "You don't have the /regiondefine permission.");
-                return;
-            }
-            
-            if (args.length < 2) {
-                player.sendMessage(ChatColor.RED + "/region removeowner <id>");
-                return;
-            }
-    
-            try {
-                String id = args[1].toLowerCase();
-                if (!plugin.regionManager.hasRegion(id)) {
-                    player.sendMessage(ChatColor.RED + "A region with ID '"
-                            + id + "' doesn't exist.");
-                    return;
-                }
-                
-                ProtectedRegion existing = plugin.regionManager.getRegion(id);
-                
-                if (!canUseRegionCommand(player, "/regiondefine")
-                        && !existing.getOwners().contains(plugin.wrapPlayer(player))) {
-                    player.sendMessage(ChatColor.RED + "You don't own this region.");
-                    return;
-                }
-                
-                removeFromDomain(existing.getOwners(), args, 2);
-                
-                plugin.regionLoader.save(plugin.regionManager);
-                player.sendMessage(ChatColor.YELLOW + "Region updated!");
-            } catch (IOException e) {
-                player.sendMessage(ChatColor.RED + "Region database failed to save: "
-                        + e.getMessage());
-            }
-        } else if (action.equalsIgnoreCase("list")) {
-            if (!canUseRegionCommand(player, "/regiondefine")) {
-                player.sendMessage(ChatColor.RED + "You don't have the /regiondefine permission.");
-                return;
-            }
-            
-            int page = 0;
-            
-            if (args.length >= 2) {
-                try {
-                    page = Math.max(0, Integer.parseInt(args[1]) - 1);
-                } catch (NumberFormatException e) {
-                    page = 0;
-                }
-            }
-    
-            Map<String,ProtectedRegion> regions = plugin.regionManager.getRegions();
-            int size = regions.size();
-            int pages = (int)Math.ceil(size / (float)CMD_LIST_SIZE);
-            
-            String[] regionIDList = new String[size];
-            int index = 0;
-            for (String id : regions.keySet()) {
-                regionIDList[index] = id;
-                index++;
-            }
-            Arrays.sort(regionIDList);
-            
-            
-            player.sendMessage(ChatColor.RED + "Regions (page "
-                    + (page + 1) + " of " + pages + "):");
-            
-            if (page < pages) {
-                for (int i = page * CMD_LIST_SIZE; i < page * CMD_LIST_SIZE + CMD_LIST_SIZE; i++) {
-                    if (i >= size) break;
-                    player.sendMessage(ChatColor.YELLOW.toString() + (i + 1) + ". " + regionIDList[i]);
-                }
-            }
-        } else if (action.equalsIgnoreCase("delete")) {
-            if (!canUseRegionCommand(player, "/regiondelete")
-                    && !canUseRegionCommand(player, "/regionclaim")) {
-                player.sendMessage(ChatColor.RED + "You don't have the /regiondelete permission.");
-                return;
-            }
-            
-            if (args.length < 2) {
-                player.sendMessage(ChatColor.RED + "/region delete <id>");
-                return;
-            }
-    
-            try {
-                String id = args[1].toLowerCase();
-                if (!plugin.regionManager.hasRegion(id)) {
-                    player.sendMessage(ChatColor.RED + "A region with ID '"
-                            + id + "' doesn't exist.");
-                    return;
-                }
-
-                ProtectedRegion existing = plugin.regionManager.getRegion(id);
-                
-                if (!canUseRegionCommand(player, "/regiondelete")
-                        && !existing.getOwners().contains(plugin.wrapPlayer(player))) {
-                    player.sendMessage(ChatColor.RED + "You don't own this region.");
-                    return;
-                }
-                
-                plugin.regionManager.removeRegion(id);
-                plugin.regionLoader.save(plugin.regionManager);
-                player.sendMessage(ChatColor.YELLOW + "Region removed!");
-            } catch (IOException e) {
-                player.sendMessage(ChatColor.RED + "Region database failed to save: "
-                        + e.getMessage());
-            }
-        } else if (action.equalsIgnoreCase("save")) {
-            if (!canUseRegionCommand(player, "/regionsave")) {
-                player.sendMessage(ChatColor.RED + "You don't have the /regionsave permission.");
-                return;
-            }
-            
-            try {
-                plugin.regionLoader.save(plugin.regionManager);
-                player.sendMessage(ChatColor.YELLOW + "Region database saved to file!");
-            } catch (IOException e) {
-                player.sendMessage(ChatColor.RED + "Region database failed to save: "
-                        + e.getMessage());
-            }
-        } else if (action.equalsIgnoreCase("load")) {
-            if (!canUseRegionCommand(player, "/regionload")) {
-                player.sendMessage(ChatColor.RED + "You don't have the /regionload permission.");
-                return;
-            }
-            
-            try {
-                plugin.regionLoader.load(plugin.regionManager);
-                player.sendMessage(ChatColor.YELLOW + "Region database loaded from file!");
-            } catch (IOException e) {
-                player.sendMessage(ChatColor.RED + "Region database failed to load: "
-                        + e.getMessage());
-            }
-        } else {
-            player.sendMessage(ChatColor.RED + "/region <define|claim|flag|delete|info|addowner|removeowner|list|save|load> ...");
-        }
-    }
-    
-    /**
-     * Checks for the command or /region.
-     * 
-     * @param player
-     * @param cmd
-     * @return
-     */
-    private boolean canUseRegionCommand(Player player, String cmd) {
-        return plugin.hasPermission(player, "/region")
-                || plugin.hasPermission(player, cmd);
-    }
-    
-    /**
-     * Parse a group/player DefaultDomain specification for areas.
-     * 
-     * @param domain
-     * @param split
-     * @param startIndex
-     */
-    private static void addToDomain(DefaultDomain domain,
-            String[] split, int startIndex) {        
-        for (int i = startIndex; i < split.length; i++) {
-            String s = split[i];
-            Matcher m = groupPattern.matcher(s);
-            if (m.matches()) {
-                domain.addGroup(m.group(1));
-            } else {
-                domain.addPlayer(s);
-            }
-        }
-    }
-    
-    /**
-     * Parse a group/player DefaultDomain specification for areas.
-     * 
-     * @param domain
-     * @param split
-     * @param startIndex
-     */
-    private static void removeFromDomain(DefaultDomain domain,
-            String[] split, int startIndex) {        
-        for (int i = startIndex; i < split.length; i++) {
-            String s = split[i];
-            Matcher m = groupPattern.matcher(s);
-            if (m.matches()) {
-                domain.removeGroup(m.group(1));
-            } else {
-                domain.removePlayer(s);
-            }
-        }
-    }
-    
-    /**
-     * Parse a group/player DefaultDomain specification for areas.
-     * 
-     * @param split
-     * @param startIndex
-     * @return
-     */
-    private static DefaultDomain parseDomainString(String[] split, int startIndex) {
-        DefaultDomain domain = new DefaultDomain();
-        
-        for (int i = startIndex; i < split.length; i++) {
-            String s = split[i];
-            Matcher m = groupPattern.matcher(s);
-            if (m.matches()) {
-                domain.addGroup(m.group(1));
-            } else {
-                domain.addPlayer(s);
-            }
-        }
-        
-        return domain;
-    }
-}

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

@@ -1,377 +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.FileNotFoundException;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.util.HashSet;
-import java.util.Set;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-import org.bukkit.entity.Player;
-import org.bukkit.Server;
-import org.bukkit.event.Event.Priority;
-import org.bukkit.event.Event;
-import org.bukkit.event.Listener;
-import org.bukkit.plugin.PluginDescriptionFile;
-import org.bukkit.plugin.PluginLoader;
-import org.bukkit.plugin.java.JavaPlugin;
-import org.bukkit.util.config.Configuration;
-import com.sk89q.bukkit.migration.PermissionsResolverManager;
-import com.sk89q.bukkit.migration.PermissionsResolverServerListener;
-import com.sk89q.worldguard.blacklist.Blacklist;
-import com.sk89q.worldguard.blacklist.BlacklistLogger;
-import com.sk89q.worldguard.blacklist.loggers.*;
-import com.sk89q.worldguard.protection.*;
-
-/**
- * Plugin for Bukkit.
- * 
- * @author sk89qs
- */
-public class WorldGuardPlugin extends JavaPlugin {
-    private static final Logger logger = Logger.getLogger("Minecraft.WorldGuard");
-    
-    private final WorldGuardPlayerListener playerListener =
-        new WorldGuardPlayerListener(this);
-    private final WorldGuardBlockListener blockListener =
-        new WorldGuardBlockListener(this);
-    private final WorldGuardEntityListener entityListener =
-        new WorldGuardEntityListener(this);
-    private final PermissionsResolverServerListener permsListener;
-    
-    private final PermissionsResolverManager perms;
-    
-    Blacklist blacklist;
-
-    RegionManager regionManager = new FlatRegionManager();
-    ProtectionDatabase regionLoader;
-    
-    Set<String> invinciblePlayers = new HashSet<String>();
-    Set<String> amphibiousPlayers = new HashSet<String>();
-    boolean fireSpreadDisableToggle;
-    
-    // Configuration follows
-    
-    boolean enforceOneSession;
-    boolean itemDurability;
-
-    boolean classicWater;
-    boolean simulateSponge;
-    int spongeRadius;
-
-    boolean noPhysicsGravel;
-    boolean noPhysicsSand;
-    boolean allowPortalAnywhere;
-    Set<Integer> preventWaterDamage;
-
-    boolean blockTNT;
-    boolean blockLighter;
-
-    boolean disableFireSpread;
-    Set<Integer> disableFireSpreadBlocks;
-    boolean preventLavaFire;
-    Set<Integer> allowedLavaSpreadOver;
-    
-    boolean blockCreeperExplosions;
-    boolean blockCreeperBlockDamage;
-
-    int loginProtection;
-    int spawnProtection;
-    boolean kickOnDeath;
-    boolean exactRespawn;
-    boolean teleportToHome;
-    
-    boolean disableFallDamage;
-    boolean disableLavaDamage;
-    boolean disableFireDamage;
-    boolean disableDrowningDamage;
-    boolean disableSuffocationDamage;
-    boolean teleportOnSuffocation;
-
-    boolean useRegions;
-    int regionWand = 287; 
-    
-    public WorldGuardPlugin(PluginLoader pluginLoader, Server instance,
-            PluginDescriptionFile desc, File folder, File plugin, ClassLoader cLoader) {
-        super(pluginLoader, instance, desc, folder, plugin, cLoader);
-
-        logger.info("WorldGuard " + desc.getVersion() + " loaded.");
-        
-        folder.mkdirs();
-
-        createDefaultConfiguration("config.yml");
-        createDefaultConfiguration("blacklist.txt");
-        
-        regionLoader = new CSVDatabase(new File(folder, "regions.txt"));
-        perms = new PermissionsResolverManager(getConfiguration(), getServer(),
-                "WorldGuard", logger);
-        permsListener = new PermissionsResolverServerListener(perms);
-        loadConfiguration();
-        postReload();
-        registerEvents();
-    }
-
-    public void onEnable() {
-    }
-
-    public void onDisable() {
-    }
-
-    private void registerEvents() {
-        registerEvent(Event.Type.BLOCK_DAMAGED, blockListener, Priority.Normal);
-        registerEvent(Event.Type.BLOCK_FLOW, blockListener, Priority.Normal);
-        registerEvent(Event.Type.BLOCK_IGNITE, blockListener, Priority.Normal);
-        registerEvent(Event.Type.BLOCK_PHYSICS, blockListener, Priority.Normal);
-        registerEvent(Event.Type.BLOCK_INTERACT, blockListener, Priority.Normal);
-        registerEvent(Event.Type.BLOCK_PLACED, blockListener, Priority.Normal);
-        registerEvent(Event.Type.BLOCK_RIGHTCLICKED, blockListener, Priority.Normal);
-
-        registerEvent(Event.Type.ENTITY_DAMAGEDBY_BLOCK, entityListener, Priority.Normal);
-        registerEvent(Event.Type.ENTITY_DAMAGEDBY_ENTITY, entityListener, Priority.Normal);
-        registerEvent(Event.Type.ENTITY_EXPLODE, entityListener, Priority.Normal);
-
-        registerEvent(Event.Type.PLAYER_COMMAND, playerListener, Priority.Normal);
-        registerEvent(Event.Type.PLAYER_ITEM, playerListener, Priority.Normal);
-        registerEvent(Event.Type.PLAYER_JOIN, playerListener, Priority.Normal);
-        registerEvent(Event.Type.PLAYER_LOGIN, playerListener, Priority.Normal);
-        registerEvent(Event.Type.PLAYER_QUIT, playerListener, Priority.Normal);
-        
-        permsListener.register(this);
-    }
-    
-    private void registerEvent(Event.Type type, Listener listener, Priority priority) {
-        getServer().getPluginManager().registerEvent(type, listener, priority, this);
-    }
-    
-    private void createDefaultConfiguration(String name) {
-        File actual = new File(getDataFolder(), name);
-        if (!actual.exists()) {
-            
-            InputStream input =
-                    WorldGuardPlugin.class.getResourceAsStream("/defaults/" + name);
-            if (input != null) {
-                FileOutputStream output = null;
-
-                try {
-                    output = new FileOutputStream(actual);
-                    byte[] buf = new byte[8192];
-                    int length = 0;
-                    while ((length = input.read(buf)) > 0) {
-                        output.write(buf, 0, length);
-                    }
-                    
-                    logger.info("WorldGuard: Default configuration file written: "
-                            + name);
-                } catch (IOException e) {
-                    e.printStackTrace();
-                } finally {
-                    try {
-                        if (input != null)
-                            input.close();
-                    } catch (IOException e) {}
-
-                    try {
-                        if (output != null)
-                            output.close();
-                    } catch (IOException e) {}
-                }
-            }
-        }
-    }
-
-    /**
-     * Load the configuration
-     */
-    public void loadConfiguration() {
-        Configuration config = getConfiguration();
-        config.load();
-
-        enforceOneSession = config.getBoolean("protection.enforce-single-session", true);
-        itemDurability = config.getBoolean("protection.item-durability", true);
-        
-        classicWater = config.getBoolean("simulation.classic-water", false);
-        simulateSponge = config.getBoolean("simulation.sponge.enable", true);
-        spongeRadius = Math.max(1, config.getInt("simulation.sponge.radius", 3)) - 1;
-        
-        noPhysicsGravel = config.getBoolean("physics.no-physics-gravel", false);
-        noPhysicsSand = config.getBoolean("physics.no-physics-sand", false);
-        allowPortalAnywhere = config.getBoolean("physics.allow-portal-anywhere", false);
-        preventWaterDamage = new HashSet<Integer>(config.getIntList("physics.disable-water-damage-blocks", null));
-        
-        blockTNT = config.getBoolean("ignition.block-tnt", false);
-        blockLighter = config.getBoolean("ignition.block-lighter", false);
-        
-        preventLavaFire = config.getBoolean("fire.disable-lava-fire-spread", true);
-        disableFireSpread = config.getBoolean("fire.disable-all-fire-spread", false);
-        disableFireSpreadBlocks = new HashSet<Integer>(config.getIntList("fire.disable-fire-spread-blocks", null));
-        allowedLavaSpreadOver = new HashSet<Integer>(config.getIntList("fire.lava-spread-blocks", null));
-        
-        blockCreeperExplosions = config.getBoolean("mobs.block-creeper-explosions", false);
-        blockCreeperBlockDamage = config.getBoolean("mobs.block-creeper-block-damage", false);
-        
-        loginProtection = config.getInt("spawn.login-protection", 3);
-        spawnProtection = config.getInt("spawn.spawn-protection", 0);
-        kickOnDeath = config.getBoolean("spawn.kick-on-death", false);
-        exactRespawn = config.getBoolean("spawn.exact-respawn", false);
-        teleportToHome = config.getBoolean("spawn.teleport-to-home-on-death", false);
-        
-        disableFallDamage = config.getBoolean("player-damage.disable-fall-damage", false);
-        disableLavaDamage = config.getBoolean("player-damage.disable-lava-damage", false);
-        disableFireDamage = config.getBoolean("player-damage.disable-fire-damage", false);
-        disableDrowningDamage = config.getBoolean("player-damage.disable-water-damage", false);
-        disableSuffocationDamage = config.getBoolean("player-damage.disable-suffocation-damage", false);
-        teleportOnSuffocation = config.getBoolean("player-damage.teleport-on-suffocation", false);
-        
-        useRegions = config.getBoolean("regions.enable", true);
-        regionWand = config.getInt("regions.wand", 287);
-
-        try {
-            regionLoader.load();
-            regionManager.setRegions(regionLoader.getRegions());
-        } catch (FileNotFoundException e) {
-        } catch (IOException e) {
-            logger.warning("WorldGuard: Failed to load regions: "
-                    + e.getMessage());
-        }
-        
-        // Console log configuration
-        boolean logConsole = config.getBoolean("blacklist.logging.console.enable", true);
-
-        // Database log configuration
-        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");
-
-        // File log configuration
-        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));
-        
-        // 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(this);
-            blist.load(new File(getDataFolder(), "blacklist.txt"));
-
-            // If the blacklist is empty, then set the field to null
-            // and save some resources
-            if (blist.isEmpty()) {
-                this.blacklist = null;
-            } else {
-                this.blacklist = blist;
-                logger.log(Level.INFO, "WorldGuard: Blacklist loaded.");
-
-                BlacklistLogger blacklistLogger = blist.getLogger();
-
-                if (logDatabase) {
-                    blacklistLogger.addHandler(new DatabaseLoggerHandler(dsn, user, pass, table));
-                }
-
-                if (logConsole) {
-                    blacklistLogger.addHandler(new ConsoleLoggerHandler());
-                }
-
-                if (logFile) {
-                    FileLoggerHandler handler =
-                            new FileLoggerHandler(logFilePattern, logFileCacheSize);
-                    blacklistLogger.addHandler(handler);
-                }
-            }
-        } catch (FileNotFoundException e) {
-            logger.log(Level.WARNING, "WorldGuard blacklist does not exist.");
-        } catch (IOException e) {
-            logger.log(Level.WARNING, "Could not load WorldGuard blacklist: "
-                    + e.getMessage());
-        }
-
-        // Print an overview of settings
-        if (config.getBoolean("summary-on-start", true)) {
-            logger.log(Level.INFO, enforceOneSession ? "WorldGuard: Single session is enforced."
-                    : "WorldGuard: Single session is NOT ENFORCED.");
-            logger.log(Level.INFO, blockTNT ? "WorldGuard: TNT ignition is blocked."
-                    : "WorldGuard: TNT ignition is PERMITTED.");
-            logger.log(Level.INFO, blockLighter ? "WorldGuard: Lighters are blocked."
-                    : "WorldGuard: Lighters are PERMITTED.");
-            logger.log(Level.INFO, preventLavaFire ? "WorldGuard: Lava fire is blocked."
-                    : "WorldGuard: Lava fire is PERMITTED.");
-            if (disableFireSpread) {
-                logger.log(Level.INFO, "WorldGuard: All fire spread is disabled.");
-            } else {
-                if (disableFireSpreadBlocks.size() > 0) {
-                    logger.log(Level.INFO, "WorldGuard: Fire spread is limited to "
-                            + disableFireSpreadBlocks.size() + " block types.");
-                } else {
-                    logger.log(Level.INFO, "WorldGuard: Fire spread is UNRESTRICTED.");
-                }
-            }
-        }
-        
-        // Temporary
-        perms.load();
-    }
-    
-    /**
-     * Populates various lists.
-     */
-    public void postReload() {
-        invinciblePlayers.clear();
-        amphibiousPlayers.clear();
-
-        try {
-            for (Player player : getServer().getOnlinePlayers()) {
-                if (inGroup(player, "wg-invincible")) {
-                    invinciblePlayers.add(player.getName());
-                }
-
-                if (inGroup(player, "wg-amphibious")) {
-                    amphibiousPlayers.add(player.getName());
-                }
-            }
-        } catch (NullPointerException e) { // Thrown if loaded too early
-        }
-    }
-    
-    boolean inGroup(Player player, String group) {
-        return perms.inGroup(player.getName(), group);
-    }
-    
-    boolean hasPermission(Player player, String perm) {
-        return perms.hasPermission(player.getName(), perm);
-    }
-    
-    String[] getGroups(Player player) {
-        return perms.getGroups(player.getName());
-    }
-
-    BukkitPlayer wrapPlayer(Player player) {
-        return new BukkitPlayer(this, player);
-    }
-}

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

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

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

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

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

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

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

@@ -1,56 +0,0 @@
-// $Id$
-/*
- * WorldGuard
- * Copyright (C) 2010 sk89q <http://www.sk89q.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
-*/
-
-package com.sk89q.worldguard.domains;
-
-import java.util.Arrays;
-import java.util.Set;
-import java.util.LinkedHashSet;
-import com.sk89q.worldguard.LocalPlayer;
-
-public class GroupDomain implements Domain {
-    private Set<String> groups;
-    
-    public GroupDomain() {
-        this.groups = new LinkedHashSet<String>();
-    }
-    
-    public GroupDomain(String[] groups) {
-        this.groups = new LinkedHashSet<String>(Arrays.asList(groups));
-    }
-    
-    public void addGroup(String name) {
-        groups.add(name);
-    }
-
-    public boolean contains(LocalPlayer player) {
-        for (String group : groups) {
-            if (player.hasGroup(group)) {
-                return true;
-            }
-        }
-        
-        return false;
-    }
-    
-    public int size() {
-        return groups.size();
-    }
-
-}

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

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

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

@@ -1,204 +0,0 @@
-// $Id$
-/*
- * WorldGuard
- * Copyright (C) 2010 sk89q <http://www.sk89q.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
-*/
-
-package com.sk89q.worldguard.protection;
-
-import java.util.SortedMap;
-import com.sk89q.worldedit.Vector;
-import com.sk89q.worldguard.LocalPlayer;
-import com.sk89q.worldguard.protection.AreaFlags.State;
-
-/**
- * Represents a set of regions and their rules as applied to one point.
- * 
- * @author sk89q
- */
-public class ApplicableRegionSet {
-    private Vector pt;
-    private SortedMap<String,ProtectedRegion> regions;
-    
-    public ApplicableRegionSet(Vector pt, SortedMap<String,ProtectedRegion> regions) {
-        this.pt = pt;
-        this.regions = regions;
-    }
-    
-    public boolean canBuild(LocalPlayer player) {
-        boolean found = false;
-        int lastPriority = 0;
-        
-        for (ProtectedRegion region : regions.values()) {
-            if (region.getFlags().allowBuild == State.ALLOW) continue;
-            if (!region.contains(pt)) continue;
-            
-            // Ignore lower priority regions
-            if (found && region.getPriority() < lastPriority) {
-                break;
-            }
-            
-            if (!region.getOwners().contains(player)) {
-                return false;
-            }
-            
-            found = true;
-            lastPriority = region.getPriority();
-        }
-        
-        return true;
-    }
-    
-    public boolean allowsPvP() {
-        boolean found = false;
-        int lastPriority = 0;
-        
-        for (ProtectedRegion region : regions.values()) {
-            if (!region.contains(pt)) continue;
-            if (region.getFlags().allowPvP == State.DENY) return false;
-            
-            // Ignore lower priority regions
-            if (found && region.getPriority() < lastPriority) {
-                break;
-            }
-            
-            found = true;
-            lastPriority = region.getPriority();
-        }
-        
-        return true;
-    }
-    
-    public boolean allowsMobDamage() {
-        boolean found = false;
-        int lastPriority = 0;
-        
-        for (ProtectedRegion region : regions.values()) {
-            if (!region.contains(pt)) continue;
-            if (region.getFlags().allowMobDamage == State.DENY) return false;
-            
-            // Ignore lower priority regions
-            if (found && region.getPriority() < lastPriority) {
-                break;
-            }
-            
-            found = true;
-            lastPriority = region.getPriority();
-        }
-        
-        return true;
-    }
-    
-    public boolean allowsCreeperExplosions() {
-        boolean found = false;
-        int lastPriority = 0;
-        
-        for (ProtectedRegion region : regions.values()) {
-            if (!region.contains(pt)) continue;
-            if (region.getFlags().allowCreeperExplosions == State.DENY) return false;
-            
-            // Ignore lower priority regions
-            if (found && region.getPriority() < lastPriority) {
-                break;
-            }
-            
-            found = true;
-            lastPriority = region.getPriority();
-        }
-        
-        return true;
-    }
-    
-    public boolean allowsTNT() {
-        boolean found = false;
-        int lastPriority = 0;
-        
-        for (ProtectedRegion region : regions.values()) {
-            if (!region.contains(pt)) continue;
-            if (region.getFlags().allowTNT == State.DENY) return false;
-            
-            // Ignore lower priority regions
-            if (found && region.getPriority() < lastPriority) {
-                break;
-            }
-            
-            found = true;
-            lastPriority = region.getPriority();
-        }
-        
-        return true;
-    }
-    
-    public boolean allowsLighter() {
-        boolean found = false;
-        int lastPriority = 0;
-        
-        for (ProtectedRegion region : regions.values()) {
-            if (!region.contains(pt)) continue;
-            if (region.getFlags().allowLighter == State.DENY) return false;
-            
-            // Ignore lower priority regions
-            if (found && region.getPriority() < lastPriority) {
-                break;
-            }
-            
-            found = true;
-            lastPriority = region.getPriority();
-        }
-        
-        return true;
-    }
-    
-    public boolean allowsFireSpread() {
-        boolean found = false;
-        int lastPriority = 0;
-        
-        for (ProtectedRegion region : regions.values()) {
-            if (!region.contains(pt)) continue;
-            if (region.getFlags().allowFireSpread == State.DENY) return false;
-            
-            // Ignore lower priority regions
-            if (found && region.getPriority() < lastPriority) {
-                break;
-            }
-            
-            found = true;
-            lastPriority = region.getPriority();
-        }
-        
-        return true;
-    }
-    
-    public boolean allowsLavaFire() {
-        boolean found = false;
-        int lastPriority = 0;
-        
-        for (ProtectedRegion region : regions.values()) {
-            if (!region.contains(pt)) continue;
-            if (region.getFlags().allowLavaFire == State.DENY) return false;
-            
-            // Ignore lower priority regions
-            if (found && region.getPriority() < lastPriority) {
-                break;
-            }
-            
-            found = true;
-            lastPriority = region.getPriority();
-        }
-        
-        return true;
-    }
-}

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

@@ -1,59 +0,0 @@
-// $Id$
-/*
- * WorldGuard
- * Copyright (C) 2010 sk89q <http://www.sk89q.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
-*/
-
-package com.sk89q.worldguard.protection;
-
-/**
- * 
- * @author sk89q
- */
-public class AreaFlags {
-    public enum State {
-        NONE,
-        ALLOW,
-        DENY,
-    };
-
-    public State allowBuild = State.NONE;
-    public State allowPvP = State.NONE;
-    public State allowMobDamage = State.NONE;
-    public State allowCreeperExplosions = State.NONE;
-    public State allowTNT = State.NONE;
-    public State allowLighter = State.NONE;
-    public State allowFireSpread = State.NONE;
-    public State allowLavaFire = State.NONE;
-    
-    @Override
-    public boolean equals(Object obj) {
-        if (!(obj instanceof AreaFlags)) {
-            return false;
-        }
-        
-        AreaFlags other = (AreaFlags)obj;
-        
-        return other.allowBuild == allowBuild
-                && other.allowPvP == allowPvP
-                && other.allowMobDamage == allowMobDamage
-                && other.allowCreeperExplosions == allowCreeperExplosions
-                && other.allowTNT == allowTNT
-                && other.allowLighter == allowLighter
-                && other.allowFireSpread == allowFireSpread
-                && other.allowLavaFire == allowLavaFire;
-    }
-}

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

@@ -1,337 +0,0 @@
-// $Id$
-/*
- * WorldGuard
- * Copyright (C) 2010 sk89q <http://www.sk89q.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
-*/
-
-package com.sk89q.worldguard.protection;
-
-import java.util.HashMap;
-import java.util.Map;
-import java.util.logging.Logger;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-import java.io.*;
-import au.com.bytecode.opencsv.CSVReader;
-import au.com.bytecode.opencsv.CSVWriter;
-import com.sk89q.worldedit.BlockVector;
-import com.sk89q.worldedit.Vector;
-import com.sk89q.worldguard.domains.DefaultDomain;
-import com.sk89q.worldguard.protection.AreaFlags.State;
-
-/**
- * Represents a protected area database that uses CSV files.
- * 
- * @author sk89q
- */
-public class CSVDatabase implements ProtectionDatabase {
-    private static Logger logger = Logger.getLogger("Minecraft.WorldGuard");
-    
-    /**
-     * References the CSV file.
-     */
-    private File file;
-    /**
-     * Holds the list of regions.
-     */
-    private Map<String,ProtectedRegion> regions;
-    
-    /**
-     * Construct the database with a path to a file. No file is read or
-     * written at this time.
-     * 
-     * @param file
-     */
-    public CSVDatabase(File file) {
-        this.file = file;
-    }
-
-    /**
-     * Saves the database.
-     */
-    @Override
-    public void save() throws IOException {
-        CSVWriter writer = new CSVWriter(new FileWriter(file));
-        
-        try {
-            for (Map.Entry<String,ProtectedRegion> entry : regions.entrySet()) {
-                String id = entry.getKey();
-                ProtectedRegion region = entry.getValue();
-                
-                if (!(region instanceof ProtectedCuboidRegion)) {
-                    logger.warning("The CSV database only supports cuboid regions.");
-                    continue;
-                }
-                
-                ProtectedCuboidRegion cuboid = (ProtectedCuboidRegion)region;
-                BlockVector min = cuboid.getMinimumPoint();
-                BlockVector max = cuboid.getMaximumPoint();
-                
-                writer.writeNext(new String[] {
-                        id,
-                        "cuboid",
-                        String.valueOf(min.getBlockX()),
-                        String.valueOf(min.getBlockY()),
-                        String.valueOf(min.getBlockZ()),
-                        String.valueOf(max.getBlockX()),
-                        String.valueOf(max.getBlockY()),
-                        String.valueOf(max.getBlockZ()),
-                        String.valueOf(cuboid.getPriority()),
-                        writeDomains(cuboid.getOwners()),
-                        writeFlags(cuboid.getFlags()),
-                        cuboid.getEnterMessage(),
-                        });
-            }
-        } finally {
-            try {
-                writer.close();
-            } catch (IOException e) {
-            }
-        }
-    }
-
-    /**
-     * Load the database from file.
-     */
-    @Override
-    public void load() throws IOException {
-        Map<String,ProtectedRegion> regions =
-                new HashMap<String,ProtectedRegion>();
-        
-        CSVReader reader = new CSVReader(new FileReader(file));
-        
-        try {
-            String[] line;
-            
-            while ((line = reader.readNext()) != null) {
-                if (line.length >= 12) {
-                    String type = line[1];
-                    if (!type.equalsIgnoreCase("cuboid")) {
-                        logger.warning("Only cuboid region types are supported: "
-                                + line);
-                        break;
-                        
-                    }
-                    
-                    String id = line[0];
-                    Vector pt1 = new Vector(
-                            Integer.parseInt(line[2]),
-                            Integer.parseInt(line[3]),
-                            Integer.parseInt(line[4]));
-                    Vector pt2 = new Vector(
-                            Integer.parseInt(line[5]),
-                            Integer.parseInt(line[6]),
-                            Integer.parseInt(line[7]));
-
-                    BlockVector min = Vector.getMinimum(pt1, pt2).toBlockVector();
-                    BlockVector max = Vector.getMaximum(pt1, pt2).toBlockVector();
-                    
-                    int priority = Integer.parseInt(line[8]);
-                    String ownersData = line[9];
-                    String flagsData = line[10];
-                    String enterMessage = line[11];
-                    
-                    ProtectedRegion region = new ProtectedCuboidRegion(min, max);
-                    region.setPriority(priority);
-                    region.setOwners(this.parseDomains(ownersData));
-                    region.setEnterMessage(enterMessage);
-                    region.setFlags(parseFlags(flagsData));
-                    regions.put(id, region);
-                } else {
-                    logger.warning("Line is invalid: " + line);
-                }
-            }
-        } finally {
-            try {
-                reader.close();
-            } catch (IOException e) {
-            }
-        }
-        
-        this.regions = regions;
-    }
-
-    /**
-     * Load the list of regions into a region manager.
-     * 
-     * @throws IOException
-     */
-    public void load(RegionManager manager) throws IOException {
-        load();
-        manager.setRegions(regions);
-    }
-    
-    /**
-     * Save the list of regions from a region manager.
-     * 
-     * @throws IOException
-     */
-    public void save(RegionManager manager) throws IOException {
-        regions = manager.getRegions();
-        save();
-    }
-    
-    /**
-     * Used to parse the specified domain in the CSV file.
-     * 
-     * @param data
-     * @return
-     */
-    private DefaultDomain parseDomains(String data) {
-        DefaultDomain domain = new DefaultDomain();
-        Pattern pattern = Pattern.compile("^([A-Za-z]):(.*)$");
-        
-        String[] parts = data.split(",");
-        
-        for (String part : parts) {
-            Matcher matcher = pattern.matcher(part);
-            
-            if (!matcher.matches()) {
-                logger.warning("Invalid owner specification: " + part);
-                continue;
-            }
-
-            String type = matcher.group(1);
-            String id = matcher.group(2);
-
-            if (type.equals("u")) {
-                domain.addPlayer(id);
-            } else if (type.equals("g")) {
-                domain.addGroup(id);
-            } else {
-                logger.warning("Unknown owner specification: " + type);
-            }
-        }
-        
-        return domain;
-    }
-    
-    /**
-     * Used to parse the list of flags.
-     * 
-     * @param data
-     * @return
-     */
-    private AreaFlags parseFlags(String data) {
-        AreaFlags flags = new AreaFlags();
-        State curState = State.ALLOW;
-        
-        for (int i = 0; i < data.length(); i++) {
-            char flag = data.charAt(i);
-            if (flag == '+') {
-                curState = State.ALLOW;
-            } else if (flag == '-') {
-                curState = State.DENY;
-            } else if (flag == 'b') {
-                flags.allowBuild = curState;
-            } else if (flag == 'p') {
-                flags.allowPvP = curState;
-            } else if (flag == 'm') {
-                flags.allowMobDamage = curState;
-            } else if (flag == 'c') {
-                flags.allowCreeperExplosions = curState;
-            } else if (flag == 't') {
-                flags.allowTNT = curState;
-            } else if (flag == 'l') {
-                flags.allowLighter = curState;
-            } else if (flag == 'f') {
-                flags.allowFireSpread = curState;
-            } else if (flag == 'F') {
-                flags.allowLavaFire = curState;
-            } else {
-                logger.warning("Unknown area flag/flag modifier: " + flag);
-            }
-        }
-        
-        return flags;
-    }
-    
-    /**
-     * Used to write the list of domains.
-     * 
-     * @param domain
-     * @return
-     */
-    private String writeDomains(DefaultDomain domain) {
-        StringBuilder str = new StringBuilder();
-        
-        for (String player : domain.getPlayers()) {
-            str.append("u:" + player + ",");
-        }
-        
-        for (String group : domain.getGroups()) {
-            str.append("g:" + group + ",");
-        }
-        
-        return str.length() > 0 ?
-                str.toString().substring(0, str.length() - 1) : "";
-    }
-    
-    /**
-     * Helper method to prepend '+' or '-' in front of a flag according
-     * to the flag's state.
-     * 
-     * @param state
-     * @param flag
-     * @return
-     */
-    private String writeFlag(State state, String flag) {
-        if (state == State.ALLOW) {
-            return "+" + flag;
-        } else if (state == State.DENY) {
-            return "-" + flag;
-        }
-        
-        return "";
-    }
-    
-    /**
-     * Used to write the list of flags.
-     * 
-     * @param flags
-     * @return
-     */
-    private String writeFlags(AreaFlags flags) {
-        StringBuilder str = new StringBuilder();
-        str.append(writeFlag(flags.allowBuild, "b"));
-        str.append(writeFlag(flags.allowPvP, "p"));
-        str.append(writeFlag(flags.allowMobDamage, "m"));
-        str.append(writeFlag(flags.allowCreeperExplosions, "c"));
-        str.append(writeFlag(flags.allowTNT, "t"));
-        str.append(writeFlag(flags.allowLighter, "l"));
-        str.append(writeFlag(flags.allowFireSpread, "f"));
-        str.append(writeFlag(flags.allowLavaFire, "F"));
-        return str.toString();
-    }
-
-    /**
-     * Get a list of protected regions.
-     *
-     * @return
-     */
-    public Map<String,ProtectedRegion> getRegions() {
-        return regions;
-    }
-
-    /**
-     * Get a list of protected regions.
-     *
-     * @return
-     */
-    public void setRegions(Map<String,ProtectedRegion> regions) {
-        this.regions = regions;
-    }
-}

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

@@ -1,40 +0,0 @@
-// $Id$
-/*
- * WorldGuard
- * Copyright (C) 2010 sk89q <http://www.sk89q.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
-*/
-
-package com.sk89q.worldguard.protection;
-
-import java.util.Comparator;
-
-class DescendingPriorityComparator implements Comparator<ProtectedRegion> {
-    /**
-     * Compares two regions.
-     * 
-     * @param other
-     * @return
-     */
-    public int compare(ProtectedRegion r1, ProtectedRegion r2) {
-        if (r1.getPriority() == r2.getPriority()) {
-            return 0;
-        } else if (r1.getPriority() > r2.getPriority()) {
-            return -1;
-        } else {
-            return 1;
-        }
-    }
-}

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

@@ -1,168 +0,0 @@
-// $Id$
-/*
- * WorldGuard
- * Copyright (C) 2010 sk89q <http://www.sk89q.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
-*/
-
-package com.sk89q.worldguard.protection;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-import java.util.SortedMap;
-import java.util.TreeMap;
-import com.sk89q.worldedit.Vector;
-import com.sk89q.worldguard.LocalPlayer;
-
-/**
- * A very simple implementation of the region manager that uses a flat list
- * and iterates through the list to identify applicable regions. This method
- * is not very efficient.
- * 
- * @author sk89q
- */
-public class FlatRegionManager implements RegionManager {
-    /**
-     * List of protected regions.
-     */
-    private SortedMap<String,ProtectedRegion> regions;
-    
-    /**
-     * Construct the manager.
-     */
-    public FlatRegionManager() {
-        regions = new TreeMap<String,ProtectedRegion>();
-    }
-    
-    /**
-     * Get a list of protected regions.
-     *
-     * @return
-     */
-    public Map<String,ProtectedRegion> getRegions() {
-        return regions;
-    }
-
-    
-    /**
-     * Set a list of protected regions.
-     *
-     * @return
-     */
-    public void setRegions(Map<String,ProtectedRegion> regions) {
-        this.regions = new TreeMap<String,ProtectedRegion>(regions);
-    }
-    /**
-     * Adds a region.
-     * 
-     * @param id
-     * @param region
-     */
-    public void addRegion(String id, ProtectedRegion region) {
-        regions.put(id, region);
-    }
-    
-    /**
-     * Removes a region.
-     * 
-     * @param id
-     */
-    public void removeRegion(String id) {
-        regions.remove(id);
-    }
-    
-    /**
-     * Return whether a region exists by an ID.
-     * 
-     * @param id
-     * @return
-     */
-    public boolean hasRegion(String id) {
-        return regions.containsKey(id);
-    }
-    
-    /**
-     * Get a region by its ID.
-     * 
-     * @param id
-     */
-    public ProtectedRegion getRegion(String id) {
-        return regions.get(id);
-    }
-    
-    /**
-     * Get an object for a point for rules to be applied with.
-     * 
-     * @param pt
-     * @return
-     */
-    public ApplicableRegionSet getApplicableRegions(Vector pt) {
-        return new ApplicableRegionSet(pt, regions);
-    }
-    
-    /**
-     * Get a list of region IDs that contain a point.
-     * 
-     * @param pt
-     * @return
-     */
-    public List<String> getApplicableRegionsIDs(Vector pt) {
-        List<String> applicable = new ArrayList<String>();
-        
-        for (Map.Entry<String,ProtectedRegion> entry : regions.entrySet()) {
-            if (entry.getValue().contains(pt)) {
-                applicable.add(entry.getKey());
-            }
-        }
-        
-        return applicable;
-    }
-    
-    /**
-     * Returns true if the provided region overlaps with any other region that
-     * is not owned by the player.
-     * 
-     * @param region
-     * @param player
-     * @return
-     */
-    public boolean overlapsUnownedRegion(ProtectedRegion region, LocalPlayer player) {
-        for (ProtectedRegion other : regions.values()) {
-            if (other.getOwners().contains(player)) {
-                continue;
-            }
-            
-            try {
-                if (ProtectedRegion.intersects(region, other)) {
-                    return true;
-                }
-            } catch (UnsupportedIntersectionException e) {
-                // TODO: Maybe do something here
-            }
-        }
-        
-        return false;
-    }
-    
-    /**
-     * Get the number of regions.
-     * 
-     * @return
-     */
-    public int size() {
-        return regions.size();
-    }
-}

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

@@ -1,97 +0,0 @@
-// $Id$
-/*
- * WorldGuard
- * Copyright (C) 2010 sk89q <http://www.sk89q.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
-*/
-
-package com.sk89q.worldguard.protection;
-
-import com.sk89q.worldedit.*;
-
-/**
- * Represents a cuboid region that can be protected.
- *
- * @author sk89q
- */
-public class ProtectedCuboidRegion extends ProtectedRegion {
-    /**
-     * Store the first point.
-     */
-    private BlockVector min;
-    /**
-     * Store the second point.
-     */
-    private BlockVector max;
-
-    /**
-     * Construct a new instance of this cuboid region.
-     *
-     * @param pos1
-     * @param pos2
-     * @param priority
-     */
-    public ProtectedCuboidRegion(BlockVector min, BlockVector max) {
-        super();
-        this.min = min;
-        this.max = max;
-    }
-
-    /**
-     * Get the lower point of the cuboid.
-     *
-     * @return min point
-     */
-    public BlockVector getMinimumPoint() {
-        return min;
-    }
-
-    /**
-     * Set the lower point of the cuboid.
-     *
-     * @param pt
-     */
-    public void setMinimumPoint(BlockVector pt) {
-        min = pt;
-    }
-
-    /**
-     * Get the upper point of the cuboid.
-     *
-     * @return max point
-     */
-    public BlockVector getMaximumPoint() {
-        return max;
-    }
-
-    /**
-     * Set the upper point of the cuboid.
-     *
-     * @param pt
-     */
-    public void setMaximumPoint(BlockVector pt) {
-        max = pt;
-    }
-
-    @Override
-    public boolean contains(Vector pt) {
-        int x = pt.getBlockX();
-        int y = pt.getBlockY();
-        int z = pt.getBlockZ();
-        return x >= min.getBlockX() && x <= max.getBlockX()
-                && y >= min.getBlockY() && y <= max.getBlockY()
-                && z >= min.getBlockZ() && z <= max.getBlockZ();
-    }
-}

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

@@ -1,175 +0,0 @@
-// $Id$
-/*
- * WorldGuard
- * Copyright (C) 2010 sk89q <http://www.sk89q.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
-*/
-
-package com.sk89q.worldguard.protection;
-
-import com.sk89q.worldedit.BlockVector;
-import com.sk89q.worldedit.Vector;
-import com.sk89q.worldguard.domains.DefaultDomain;
-
-/**
- * Represents a region of any shape and size that can be protected.
- * 
- * @author sk89q
- */
-public abstract class ProtectedRegion implements Comparable<ProtectedRegion> {
-    /**
-     * Area message.
-     */
-    private String enterMessage;
-    /**
-     * List of owners.
-     */
-    private DefaultDomain owners = new DefaultDomain();
-    /**
-     * Priority.
-     */
-    private int priority = 0;
-    /**
-     * Area flags.
-     */
-    private AreaFlags flags = new AreaFlags();
-
-    /**
-     * Construct a new instance of this region.
-     *
-     * @param id
-     * @param priority
-     * @param owners
-     * @param enterMessage
-     */
-    public ProtectedRegion() {
-        this.priority = 0;
-        this.owners = new DefaultDomain();
-        this.enterMessage = null;
-    }
-
-    /**
-     * @return the priority
-     */
-    public int getPriority() {
-        return priority;
-    }
-
-    /**
-     * @param priority the priority to set
-     */
-    public void setPriority(int priority) {
-        this.priority = priority;
-    }
-    
-    /**
-     * Se flags.
-     * @param flags
-     */
-    public void setFlags(AreaFlags flags) {
-        this.flags = flags;
-    }
-    
-    /**
-     * @return the enterMessage
-     */
-    public String getEnterMessage() {
-        return enterMessage;
-    }
-
-    /**
-     * @param enterMessage the enterMessage to set
-     */
-    public void setEnterMessage(String enterMessage) {
-        this.enterMessage = enterMessage;
-    }
-
-    /**
-     * @return the owners
-     */
-    public DefaultDomain getOwners() {
-        return owners;
-    }
-
-    /**
-     * @param owners the owners to set
-     */
-    public void setOwners(DefaultDomain owners) {
-        this.owners = owners;
-    }
-
-    /**
-     * Get flags.
-     * 
-     * @return
-     */
-    public AreaFlags getFlags() {
-        return flags;
-    }
-    
-    /**
-     * Check to see if a point is inside this region.
-     * 
-     * @param pt
-     * @return
-     */
-    public abstract boolean contains(Vector pt);
-    
-    /**
-     * Compares to another region.
-     * 
-     * @param other
-     * @return
-     */
-    public int compareTo(ProtectedRegion other) {
-        if (priority == other.priority) {
-            return 0;
-        } else if (priority > other.priority) {
-            return -1;
-        } else {
-            return 1;
-        }
-    }
-    
-    /**
-     * Checks if two region intersects.
-     * 
-     * @param region1
-     * @param region2
-     * @throws UnsupportedIntersectionException
-     * @return
-     */
-    public static boolean intersects(ProtectedRegion region1, ProtectedRegion region2)
-            throws UnsupportedIntersectionException {
-        if (region1 instanceof ProtectedCuboidRegion
-                && region2 instanceof ProtectedCuboidRegion) {
-            ProtectedCuboidRegion r1 = (ProtectedCuboidRegion)region1;
-            ProtectedCuboidRegion r2 = (ProtectedCuboidRegion)region2;
-            BlockVector min1 = r1.getMinimumPoint();
-            BlockVector max1 = r1.getMaximumPoint();
-            BlockVector min2 = r2.getMinimumPoint();
-            BlockVector max2 = r2.getMaximumPoint(); 
-            
-            return !(min1.getBlockX() > max2.getBlockX()
-                    || min1.getBlockY() > max2.getBlockY()
-                    || min1.getBlockZ() > max2.getBlockZ()
-                    || max1.getBlockX() < min2.getBlockX()
-                    || max1.getBlockY() < min2.getBlockY()
-                    || max1.getBlockZ() < min2.getBlockZ());
-        } else {
-            throw new UnsupportedIntersectionException();
-        }
-    }
-}

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

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

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

@@ -1,112 +0,0 @@
-// $Id$
-/*
- * WorldGuard
- * Copyright (C) 2010 sk89q <http://www.sk89q.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
-*/
-
-package com.sk89q.worldguard.protection;
-
-import java.util.List;
-import java.util.Map;
-import com.sk89q.worldedit.Vector;
-import com.sk89q.worldguard.LocalPlayer;
-
-/**
- * An interface for getting, setting, and looking up regions. The most
- * simple implementation uses a flat list and iterates through the entire
- * list to look for applicable regions, but a more complicated (and more
- * efficient) implementation may use space partitioning techniques.
- *
- * @author sk89q
- */
-public interface RegionManager {
-    /**
-     * Get a list of protected regions.
-     *
-     * @return
-     */
-    public Map<String, ProtectedRegion> getRegions();
-    
-    /**
-     * Set a list of protected regions.
-     *
-     * @return
-     */
-    public void setRegions(Map<String,ProtectedRegion> regions);
-    
-    /**
-     * Adds a region.
-     * 
-     * @param id
-     * @param region
-     */
-    public void addRegion(String id, ProtectedRegion region);
-    
-    /**
-     * Return whether a region exists by an ID.
-     * 
-     * @param id
-     * @return
-     */
-    public boolean hasRegion(String id);
-    
-    /**
-     * Get a region by its ID.
-     * 
-     * @param id
-     */
-    public ProtectedRegion getRegion(String id);
-    
-    /**
-     * Removes a region.
-     * 
-     * @param id
-     */
-    public void removeRegion(String id);
-
-    /**
-     * Get an object for a point for rules to be applied with.
-     * 
-     * @param pt
-     * @return
-     */
-    public ApplicableRegionSet getApplicableRegions(Vector pt);
-    
-    /**
-     * Get a list of region IDs that contain a point.
-     * 
-     * @param pt
-     * @return
-     */
-    public List<String> getApplicableRegionsIDs(Vector pt);
-    
-    /**
-     * Returns true if the provided region overlaps with any other region that
-     * is not owned by the player.
-     * 
-     * @param region
-     * @param player
-     * @return
-     */
-    public boolean overlapsUnownedRegion(ProtectedRegion region, LocalPlayer player);
-    
-    /**
-     * Get the number of regions.
-     * 
-     * @return
-     */
-    public int size();
-}

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

@@ -1,24 +0,0 @@
-// $Id$
-/*
- * WorldGuard
- * Copyright (C) 2010 sk89q <http://www.sk89q.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
-*/
-
-package com.sk89q.worldguard.protection;
-
-public class UnsupportedIntersectionException extends Exception {
-    private static final long serialVersionUID = 6423189392345575148L;
-}

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

@@ -0,0 +1,122 @@
+/*
+ * WorldGuard, a suite of tools for Minecraft
+ * Copyright (C) sk89q <http://www.sk89q.com>
+ * Copyright (C) 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 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 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;
+
+import com.sk89q.worldedit.Vector;
+import com.sk89q.worldguard.domains.Association;
+import com.sk89q.worldguard.protection.association.RegionAssociable;
+import com.sk89q.worldguard.protection.regions.ProtectedRegion;
+
+import java.util.List;
+import java.util.UUID;
+
+public abstract class LocalPlayer implements RegionAssociable {
+
+    /**
+     * Get this player's name.
+     * 
+     * @return The player's name
+     */
+    public abstract String getName();
+
+    /**
+     * Get this player's unique ID.
+     *
+     * @return a UUID
+     */
+    public abstract UUID getUniqueId();
+    
+    /**
+     * Returns true if this player is inside a group.
+     * 
+     * @param group The group to check
+     * @return Whether this player is in {@code group}
+     */
+    public abstract boolean hasGroup(String group);
+    
+    /**
+     * Get this player's position.
+     * 
+     * @return The player's position
+     */
+    public abstract Vector getPosition();
+    
+    /**
+     * Kick this player.
+     * 
+     * @param msg The message to kick the player with
+     */
+    public abstract void kick(String msg);
+    
+    /**
+     * Ban this player.
+     * 
+     * @param msg The message to ban the player with
+     */
+    public abstract void ban(String msg);
+    
+    /**
+     * Send this player a message.
+     * 
+     * @param msg The message to send to the player
+     */
+    public abstract void printRaw(String msg);
+    
+    /**
+     * Get this player's list of groups.
+     * 
+     * @return The groups this player is in
+     */
+    public abstract String[] getGroups();
+    
+    /**
+     * Returns whether this player has permission.
+     * 
+     * @param perm The permission to check
+     * @return Whether this player has {@code perm}
+     */
+    public abstract boolean hasPermission(String perm);
+
+    @Override
+    public Association getAssociation(List<ProtectedRegion> regions) {
+        boolean member = false;
+
+        for (ProtectedRegion region : regions) {
+            if (region.isOwner(this)) {
+                return Association.OWNER;
+            } else if (!member && region.isMember(this)) {
+                member = true;
+            }
+        }
+
+        return member ? Association.MEMBER : Association.NON_MEMBER;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        return obj instanceof LocalPlayer && ((LocalPlayer) obj).getName().equals(getName());
+    }
+    
+    @Override
+    public int hashCode() {
+        return getName().hashCode();
+    }
+
+}

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

@@ -0,0 +1,292 @@
+/*
+ * WorldGuard, a suite of tools for Minecraft
+ * Copyright (C) sk89q <http://www.sk89q.com>
+ * Copyright (C) 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 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 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.blacklist;
+
+import com.sk89q.worldguard.blacklist.action.Action;
+import com.sk89q.worldguard.blacklist.action.ActionType;
+import com.sk89q.worldguard.blacklist.event.BlacklistEvent;
+import com.sk89q.worldguard.blacklist.event.EventType;
+import com.sk89q.worldguard.blacklist.target.TargetMatcher;
+import com.sk89q.worldguard.blacklist.target.TargetMatcherParseException;
+import com.sk89q.worldguard.blacklist.target.TargetMatcherParser;
+import com.sk89q.guavabackport.cache.CacheBuilder;
+import com.sk89q.guavabackport.cache.CacheLoader;
+import com.sk89q.guavabackport.cache.LoadingCache;
+import com.sk89q.worldguard.bukkit.commands.CommandUtils;
+import org.bukkit.ChatColor;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+public abstract class Blacklist {
+
+    private static final Logger log = Logger.getLogger(Blacklist.class.getCanonicalName());
+
+    private MatcherIndex index = MatcherIndex.getEmptyInstance();
+    private final BlacklistLoggerHandler blacklistLogger = new BlacklistLoggerHandler();
+    private BlacklistEvent lastEvent;
+    private boolean useAsWhitelist;
+    private LoadingCache<String, TrackedEvent> repeatingEventCache = CacheBuilder.newBuilder()
+            .maximumSize(1000)
+            .expireAfterAccess(30, TimeUnit.SECONDS)
+            .build(new CacheLoader<String, TrackedEvent>() {
+                @Override
+                public TrackedEvent load(String s) throws Exception {
+                    return new TrackedEvent();
+                }
+            });
+
+    public Blacklist(boolean useAsWhitelist) {
+        this.useAsWhitelist = useAsWhitelist;
+    }
+
+    /**
+     * Returns whether the list is empty.
+     *
+     * @return whether the blacklist is empty
+     */
+    public boolean isEmpty() {
+        return index.isEmpty();
+    }
+
+    /**
+     * Get the number of individual items that have blacklist entries.
+     *
+     * @return The number of items in the blacklist
+     */
+    public int getItemCount() {
+        return index.size();
+    }
+
+    /**
+     * Returns whether the blacklist is used as a whitelist.
+     *
+     * @return whether the blacklist is be used as a whitelist
+     */
+    public boolean isWhitelist() {
+        return useAsWhitelist;
+    }
+
+    /**
+     * Get the log.
+     *
+     * @return The logger used in this blacklist
+     */
+    public BlacklistLoggerHandler getLogger() {
+        return blacklistLogger;
+    }
+
+    /**
+     * Method to handle the event.
+     *
+     * @param event The event to check
+     * @param forceRepeat Whether to force quickly repeating notifications
+     * @param silent Whether to force-deny notifications
+     * @return Whether the event is allowed
+     */
+    public boolean check(BlacklistEvent event, boolean forceRepeat, boolean silent) {
+        List<BlacklistEntry> entries = index.getEntries(event.getTarget());
+
+        if (entries == null) {
+            return true;
+        }
+
+        boolean ret = true;
+
+        for (BlacklistEntry entry : entries) {
+            if (!entry.check(useAsWhitelist, event, forceRepeat, silent)) {
+                ret = false;
+            }
+        }
+
+        return ret;
+    }
+
+    /**
+     * Load the blacklist.
+     *
+     * @param file The file to load from
+     * @throws IOException if an error occurred reading from the file
+     */
+    public void load(File file) throws IOException {
+        FileReader input = null;
+        MatcherIndex.Builder builder = new MatcherIndex.Builder();
+        TargetMatcherParser targetMatcherParser = new TargetMatcherParser();
+
+        try {
+            input = new FileReader(file);
+            BufferedReader buff = new BufferedReader(input);
+
+            String line;
+            List<BlacklistEntry> currentEntries = null;
+            while ((line = buff.readLine()) != null) {
+                line = line.trim();
+
+                // Blank line
+                if (line.isEmpty()) {
+                    continue;
+                } else if (line.charAt(0) == ';' || line.charAt(0) == '#') {
+                    continue;
+                }
+
+                if (line.matches("^\\[.*\\]$")) {
+                    String[] items = line.substring(1, line.length() - 1).split(",");
+                    currentEntries = new ArrayList<BlacklistEntry>();
+
+                    for (String item : items) {
+                        try {
+                            TargetMatcher matcher = targetMatcherParser.fromInput(item.trim());
+                            BlacklistEntry entry = new BlacklistEntry(this);
+                            builder.add(matcher, entry);
+                            currentEntries.add(entry);
+                        } catch (TargetMatcherParseException e) {
+                            log.log(Level.WARNING, "Could not parse a block/item heading: " + e.getMessage());
+                        }
+                    }
+                } else if (currentEntries != null) {
+                    String[] parts = line.split("=");
+
+                    if (parts.length == 1) {
+                        log.log(Level.WARNING, "Found option with no value " + file.getName() + " for '" + line + "'");
+                        continue;
+                    }
+
+                    boolean unknownOption = false;
+
+                    for (BlacklistEntry entry : currentEntries) {
+                        if (parts[0].equalsIgnoreCase("ignore-groups")) {
+                            entry.setIgnoreGroups(parts[1].split(","));
+
+                        } else if (parts[0].equalsIgnoreCase("ignore-perms")) {
+                            entry.setIgnorePermissions(parts[1].split(","));
+
+                        } else if (parts[0].equalsIgnoreCase("message")) {
+                            entry.setMessage(CommandUtils.replaceColorMacros(parts[1].trim()));
+
+                        } else if (parts[0].equalsIgnoreCase("comment")) {
+                            entry.setComment(CommandUtils.replaceColorMacros(parts[1].trim()));
+
+                        } else {
+                            boolean found = false;
+
+                            for (EventType type : EventType.values()) {
+                                if (type.getRuleName().equalsIgnoreCase(parts[0])) {
+                                    entry.getActions(type.getEventClass()).addAll(parseActions(entry, parts[1]));
+                                    found = true;
+                                    break;
+                                }
+                            }
+
+                            if (!found) {
+                                unknownOption = true;
+                            }
+                        }
+                    }
+
+                    if (unknownOption) {
+                        log.log(Level.WARNING, "Unknown option '" + parts[0] + "' in " + file.getName() + " for '" + line + "'");
+                    }
+                } else {
+                    log.log(Level.WARNING, "Found option with no heading "
+                            + file.getName() + " for '" + line + "'");
+                }
+            }
+
+            this.index = builder.build();
+        } finally {
+            try {
+                if (input != null) {
+                    input.close();
+                }
+            } catch (IOException ignore) {
+            }
+        }
+    }
+
+    private List<Action> parseActions(BlacklistEntry entry, String raw) {
+        String[] split = raw.split(",");
+        List<Action> actions = new ArrayList<Action>();
+
+        for (String name : split) {
+            name = name.trim();
+
+            boolean found = false;
+
+            for (ActionType type : ActionType.values()) {
+                if (type.getActionName().equalsIgnoreCase(name)) {
+                    actions.add(type.parseInput(this, entry));
+                    found = true;
+                    break;
+                }
+            }
+
+            if (!found) {
+                log.log(Level.WARNING, "Unknown blacklist action: " + name);
+            }
+        }
+
+        return actions;
+    }
+
+    /**
+     * Get the last event.
+     *
+     * @return The last event
+     */
+    public BlacklistEvent getLastEvent() {
+        return lastEvent;
+    }
+
+    /**
+     * Notify administrators.
+     *
+     * @param event The event to notify about
+     * @param comment The comment to notify with
+     */
+    public void notify(BlacklistEvent event, String comment) {
+        lastEvent = event;
+
+        broadcastNotification(ChatColor.GRAY + "WG: "
+                + ChatColor.LIGHT_PURPLE + event.getCauseName()
+                + ChatColor.GOLD + " (" + event.getDescription() + ") "
+                + ChatColor.WHITE
+                + event.getTarget().getFriendlyName()
+                + (comment != null ? " (" + comment + ")" : "") + ".");
+    }
+
+    /**
+     * Sends a notification to all subscribing users.
+     *
+     * @param msg The message to broadcast
+     */
+    public abstract void broadcastNotification(String msg);
+
+    public LoadingCache<String, TrackedEvent> getRepeatingEventCache() {
+        return repeatingEventCache;
+    }
+
+}

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

@@ -0,0 +1,216 @@
+/*
+ * WorldGuard, a suite of tools for Minecraft
+ * Copyright (C) sk89q <http://www.sk89q.com>
+ * Copyright (C) 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 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 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.blacklist;
+
+import com.sk89q.worldguard.LocalPlayer;
+import com.sk89q.worldguard.blacklist.action.Action;
+import com.sk89q.worldguard.blacklist.action.ActionResult;
+import com.sk89q.worldguard.blacklist.event.BlacklistEvent;
+import com.sk89q.guavabackport.cache.LoadingCache;
+
+import javax.annotation.Nullable;
+import java.util.*;
+
+public class BlacklistEntry {
+
+    private Blacklist blacklist;
+    private Set<String> ignoreGroups;
+    private Set<String> ignorePermissions;
+    private Map<Class<? extends BlacklistEvent>, List<Action>> actions = new HashMap<Class<? extends BlacklistEvent>, List<Action>>();
+
+    private String message;
+    private String comment;
+
+    /**
+     * Construct the object.
+     *
+     * @param blacklist The blacklist that contains this entry
+     */
+    public BlacklistEntry(Blacklist blacklist) {
+        this.blacklist = blacklist;
+    }
+
+    /**
+     * @return the ignoreGroups
+     */
+    public String[] getIgnoreGroups() {
+        return ignoreGroups.toArray(new String[ignoreGroups.size()]);
+    }
+
+    /**
+     * @return the ignoreGroups
+     */
+    public String[] getIgnorePermissions() {
+        return ignorePermissions.toArray(new String[ignorePermissions.size()]);
+    }
+
+    /**
+     * @param ignoreGroups the ignoreGroups to set
+     */
+    public void setIgnoreGroups(String[] ignoreGroups) {
+        Set<String> ignoreGroupsSet = new HashSet<String>();
+        for (String group : ignoreGroups) {
+            ignoreGroupsSet.add(group.toLowerCase());
+        }
+        this.ignoreGroups = ignoreGroupsSet;
+    }
+
+    /**
+     * @param ignorePermissions the ignorePermissions to set
+     */
+    public void setIgnorePermissions(String[] ignorePermissions) {
+        Set<String> ignorePermissionsSet = new HashSet<String>();
+        Collections.addAll(ignorePermissionsSet, ignorePermissions);
+        this.ignorePermissions = ignorePermissionsSet;
+    }
+
+    /**
+     * @return the message
+     */
+    public String getMessage() {
+        return message;
+    }
+
+    /**
+     * @param message the message to set
+     */
+    public void setMessage(String message) {
+        this.message = message;
+    }
+
+    /**
+     * @return the comment
+     */
+    public String getComment() {
+        return comment;
+    }
+
+    /**
+     * @param comment the comment to set
+     */
+    public void setComment(String comment) {
+        this.comment = comment;
+    }
+
+    /**
+     * Returns true if this player should be ignored.
+     *
+     * @param player The player to check
+     * @return whether this player should be ignored for blacklist blocking
+     */
+    public boolean shouldIgnore(@Nullable LocalPlayer player) {
+        if (player == null) {
+            return false; // This is the case if the cause is a dispenser, for example
+        }
+
+        if (ignoreGroups != null) {
+            for (String group : player.getGroups()) {
+                if (ignoreGroups.contains(group.toLowerCase())) {
+                    return true;
+                }
+            }
+        }
+
+        if (ignorePermissions != null) {
+            for (String perm : ignorePermissions) {
+                if (player.hasPermission(perm)) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Get the associated actions with an event.
+     *
+     * @param eventCls The event's class
+     * @return The actions for the given event
+     */
+    public List<Action> getActions(Class<? extends BlacklistEvent> eventCls) {
+        List<Action> ret = actions.get(eventCls);
+        if (ret == null) {
+            ret = new ArrayList<Action>();
+            actions.put(eventCls, ret);
+        }
+        return ret;
+    }
+
+    /**
+     * Method to handle the event.
+     *
+     * @param useAsWhitelist Whether this entry is being used in a whitelist
+     * @param event The event to check
+     * @param forceRepeat Whether to force repeating notifications even within the delay limit
+     * @param silent Whether to prevent notifications from happening
+     * @return Whether the action was allowed
+     */
+    public boolean check(boolean useAsWhitelist, BlacklistEvent event, boolean forceRepeat, boolean silent) {
+        LocalPlayer player = event.getPlayer();
+
+        if (shouldIgnore(player)) {
+            return true;
+        }
+
+        boolean repeating = false;
+        String eventCacheKey = event.getCauseName();
+        LoadingCache<String, TrackedEvent> repeatingEventCache = blacklist.getRepeatingEventCache();
+
+        // Check to see whether this event is being repeated
+        TrackedEvent tracked = repeatingEventCache.getUnchecked(eventCacheKey);
+        if (tracked.matches(event)) {
+            repeating = true;
+        } else {
+            tracked.setLastEvent(event);
+            tracked.resetTimer();
+        }
+
+        List<Action> actions = getActions(event.getClass());
+
+        boolean ret = !useAsWhitelist;
+
+        // Nothing to do
+        if (actions == null) {
+            return ret;
+        }
+
+        for (Action action : actions) {
+            ActionResult result = action.apply(event, silent, repeating, forceRepeat);
+            switch (result) {
+                case INHERIT:
+                    continue;
+                case ALLOW:
+                    ret = true;
+                    break;
+                case DENY:
+                    ret = false;
+                    break;
+                case ALLOW_OVERRIDE:
+                    return true;
+                case DENY_OVERRIDE:
+                    return false;
+            }
+        }
+
+        return ret;
+    }
+
+}

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

@@ -0,0 +1,83 @@
+/*
+ * WorldGuard, a suite of tools for Minecraft
+ * Copyright (C) sk89q <http://www.sk89q.com>
+ * Copyright (C) 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 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 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.blacklist;
+
+import com.sk89q.worldguard.blacklist.event.BlacklistEvent;
+import com.sk89q.worldguard.blacklist.logger.LoggerHandler;
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class BlacklistLoggerHandler implements LoggerHandler {
+
+    /**
+     * List of logger handlers.
+     */
+    private Set<LoggerHandler> handlers
+            = new HashSet<LoggerHandler>();
+
+    /**
+     * Add a handler.
+     *
+     * @param handler The handler to add
+     */
+    public void addHandler(LoggerHandler handler) {
+        handlers.add(handler);
+    }
+
+    /**
+     * Remove a handler.
+     *
+     * @param handler The handler to remove
+     */
+    public void removeHandler(LoggerHandler handler) {
+        handlers.remove(handler);
+    }
+
+    /**
+     * Add a handler.
+     */
+    public void clearHandlers() {
+        handlers.clear();
+    }
+
+    /**
+     * Log an event.
+     *
+     * @param event The event to log
+     */
+    @Override
+    public void logEvent(BlacklistEvent event, String comment) {
+        for (LoggerHandler handler : handlers) {
+            handler.logEvent(event, comment);
+        }
+    }
+
+    /**
+     * Close the connection.
+     */
+    @Override
+    public void close() {
+        for (LoggerHandler handler : handlers) {
+            handler.close();
+        }
+    }
+
+}

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

@@ -0,0 +1,80 @@
+/*
+ * WorldGuard, a suite of tools for Minecraft
+ * Copyright (C) sk89q <http://www.sk89q.com>
+ * Copyright (C) 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 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 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.blacklist;
+
+import com.google.common.collect.HashBasedTable;
+import com.google.common.collect.Table;
+import com.sk89q.worldguard.blacklist.target.Target;
+import com.sk89q.worldguard.blacklist.target.TargetMatcher;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map.Entry;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+class MatcherIndex {
+
+    private static final MatcherIndex EMPTY_INSTANCE = new MatcherIndex(HashBasedTable.<Integer, TargetMatcher, BlacklistEntry>create());
+    private final Table<Integer, TargetMatcher, BlacklistEntry> entries;
+
+    private MatcherIndex(Table<Integer, TargetMatcher, BlacklistEntry> entries) {
+        checkNotNull(entries);
+        this.entries = entries;
+    }
+
+    public List<BlacklistEntry> getEntries(Target target) {
+        List<BlacklistEntry> found = new ArrayList<BlacklistEntry>();
+        for (Entry<TargetMatcher, BlacklistEntry> entry : entries.row(target.getTypeId()).entrySet()) {
+            if (entry.getKey().test(target)) {
+                found.add(entry.getValue());
+            }
+        }
+        return found;
+    }
+
+    public int size() {
+        return entries.size();
+    }
+
+    public boolean isEmpty() {
+        return entries.isEmpty();
+    }
+
+    public static MatcherIndex getEmptyInstance() {
+        return EMPTY_INSTANCE;
+    }
+
+    public static class Builder {
+        private final Table<Integer, TargetMatcher, BlacklistEntry> entries = HashBasedTable.create();
+
+        public Builder add(TargetMatcher matcher, BlacklistEntry entry) {
+            checkNotNull(matcher);
+            checkNotNull(entries);
+            entries.put(matcher.getMatchedTypeId(), matcher, entry);
+            return this;
+        }
+
+        public MatcherIndex build() {
+            return new MatcherIndex(entries);
+        }
+    }
+
+}

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

@@ -0,0 +1,47 @@
+/*
+ * WorldGuard, a suite of tools for Minecraft
+ * Copyright (C) sk89q <http://www.sk89q.com>
+ * Copyright (C) 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 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 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.blacklist;
+
+import com.sk89q.worldguard.blacklist.event.BlacklistEvent;
+
+import javax.annotation.Nullable;
+
+class TrackedEvent {
+
+    @Nullable
+    private BlacklistEvent lastEvent;
+    private long time = 0;
+
+    public boolean matches(BlacklistEvent other) {
+        if (lastEvent == null) {
+            return false;
+        }
+        long now = System.currentTimeMillis();
+        return other.getEventType() == lastEvent.getEventType() && time > now - 3000;
+    }
+
+    public void resetTimer() {
+        time = System.currentTimeMillis();
+    }
+
+    public void setLastEvent(@Nullable BlacklistEvent lastEvent) {
+        this.lastEvent = lastEvent;
+    }
+}

src/main/java/com/sk89q/worldguard/blacklist/action/Action.java

@@ -0,0 +1,28 @@
+/*
+ * WorldGuard, a suite of tools for Minecraft
+ * Copyright (C) sk89q <http://www.sk89q.com>
+ * Copyright (C) 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 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 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.blacklist.action;
+
+import com.sk89q.worldguard.blacklist.event.BlacklistEvent;
+
+public interface Action {
+
+    ActionResult apply(BlacklistEvent event, boolean silent, boolean repeating, boolean forceRepeat);
+
+}

src/main/java/com/sk89q/worldguard/blacklist/action/ActionResult.java

@@ -0,0 +1,30 @@
+/*
+ * WorldGuard, a suite of tools for Minecraft
+ * Copyright (C) sk89q <http://www.sk89q.com>
+ * Copyright (C) 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 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 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.blacklist.action;
+
+public enum ActionResult {
+
+    INHERIT,
+    DENY,
+    ALLOW,
+    DENY_OVERRIDE,
+    ALLOW_OVERRIDE
+
+}

src/main/java/com/sk89q/worldguard/blacklist/action/ActionType.java

@@ -0,0 +1,81 @@
+/*
+ * WorldGuard, a suite of tools for Minecraft
+ * Copyright (C) sk89q <http://www.sk89q.com>
+ * Copyright (C) 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 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 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.blacklist.action;
+
+import com.sk89q.worldguard.blacklist.Blacklist;
+import com.sk89q.worldguard.blacklist.BlacklistEntry;
+
+public enum ActionType {
+
+    ALLOW("allow") {
+        @Override
+        public Action parseInput(Blacklist blacklist, BlacklistEntry entry) {
+            return AllowAction.getInstance();
+        }
+    },
+    DENY("deny") {
+        @Override
+        public Action parseInput(Blacklist blacklist, BlacklistEntry entry) {
+            return DenyAction.getInstance();
+        }
+    },
+    BAN("ban") {
+        @Override
+        public Action parseInput(Blacklist blacklist, BlacklistEntry entry) {
+            return new BanAction(entry);
+        }
+    },
+    KICK("kick") {
+        @Override
+        public Action parseInput(Blacklist blacklist, BlacklistEntry entry) {
+            return new KickAction(entry);
+        }
+    },
+    LOG("log") {
+        @Override
+        public Action parseInput(Blacklist blacklist, BlacklistEntry entry) {
+            return new LogAction(blacklist, entry);
+        }
+    },
+    NOTIFY("notify") {
+        @Override
+        public Action parseInput(Blacklist blacklist, BlacklistEntry entry) {
+            return new NotifyAction(blacklist, entry);
+        }
+    },
+    TELL("tell") {
+        @Override
+        public Action parseInput(Blacklist blacklist, BlacklistEntry entry) {
+            return new TellAction(entry);
+        }
+    };
+
+    private final String actionName;
+
+    ActionType(String actionName) {
+        this.actionName = actionName;
+    }
+
+    public abstract Action parseInput(Blacklist blacklist, BlacklistEntry entry);
+
+    public String getActionName() {
+        return actionName;
+    }
+}

src/main/java/com/sk89q/worldguard/blacklist/action/AllowAction.java

@@ -0,0 +1,44 @@
+/*
+ * WorldGuard, a suite of tools for Minecraft
+ * Copyright (C) sk89q <http://www.sk89q.com>
+ * Copyright (C) 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 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 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.blacklist.action;
+
+import com.sk89q.worldguard.blacklist.event.BlacklistEvent;
+
+public final class AllowAction implements Action {
+
+    private static final AllowAction INSTANCE = new AllowAction();
+
+    private AllowAction() {
+    }
+
+    @Override
+    public ActionResult apply(BlacklistEvent event, boolean silent, boolean repeating, boolean forceRepeat) {
+        if (silent) {
+            return ActionResult.ALLOW_OVERRIDE;
+        }
+
+        return ActionResult.ALLOW;
+    }
+
+    public static AllowAction getInstance() {
+        return INSTANCE;
+    }
+
+}

src/main/java/com/sk89q/worldguard/blacklist/action/BanAction.java

@@ -0,0 +1,55 @@
+/*
+ * WorldGuard, a suite of tools for Minecraft
+ * Copyright (C) sk89q <http://www.sk89q.com>
+ * Copyright (C) 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 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 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.blacklist.action;
+
+import com.sk89q.worldguard.blacklist.BlacklistEntry;
+import com.sk89q.worldguard.blacklist.event.BlacklistEvent;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+public class BanAction implements Action {
+
+    private final BlacklistEntry entry;
+
+    public BanAction(BlacklistEntry entry) {
+        checkNotNull(entry);
+        this.entry = entry;
+    }
+
+    @Override
+    public ActionResult apply(BlacklistEvent event, boolean silent, boolean repeating, boolean forceRepeat) {
+        if (silent) {
+            return ActionResult.INHERIT;
+        }
+
+        if (event.getPlayer() != null) {
+            String message = entry.getMessage();
+
+            if (message != null) {
+                event.getPlayer().ban("Banned: " + String.format(message, event.getTarget().getFriendlyName()));
+            } else {
+                event.getPlayer().ban("Banned: You can't " + event.getDescription() + " " + event.getTarget().getFriendlyName());
+            }
+        }
+
+        return ActionResult.INHERIT;
+    }
+
+}

src/main/java/com/sk89q/worldguard/blacklist/action/DenyAction.java

@@ -0,0 +1,44 @@
+/*
+ * WorldGuard, a suite of tools for Minecraft
+ * Copyright (C) sk89q <http://www.sk89q.com>
+ * Copyright (C) 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 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 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.blacklist.action;
+
+import com.sk89q.worldguard.blacklist.event.BlacklistEvent;
+
+public final class DenyAction implements Action {
+
+    private static final DenyAction INSTANCE = new DenyAction();
+
+    private DenyAction() {
+    }
+
+    @Override
+    public ActionResult apply(BlacklistEvent event, boolean silent, boolean repeating, boolean forceRepeat) {
+        if (silent) {
+            return ActionResult.DENY_OVERRIDE;
+        }
+
+        return ActionResult.DENY;
+    }
+
+    public static DenyAction getInstance() {
+        return INSTANCE;
+    }
+
+}

src/main/java/com/sk89q/worldguard/blacklist/action/KickAction.java

@@ -0,0 +1,55 @@
+/*
+ * WorldGuard, a suite of tools for Minecraft
+ * Copyright (C) sk89q <http://www.sk89q.com>
+ * Copyright (C) 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 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 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.blacklist.action;
+
+import com.sk89q.worldguard.blacklist.BlacklistEntry;
+import com.sk89q.worldguard.blacklist.event.BlacklistEvent;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+public class KickAction implements Action {
+
+    private final BlacklistEntry entry;
+
+    public KickAction(BlacklistEntry entry) {
+        checkNotNull(entry);
+        this.entry = entry;
+    }
+
+    @Override
+    public ActionResult apply(BlacklistEvent event, boolean silent, boolean repeating, boolean forceRepeat) {
+        if (silent) {
+            return ActionResult.INHERIT;
+        }
+
+        if (event.getPlayer() != null) {
+            String message = entry.getMessage();
+
+            if (message != null) {
+                event.getPlayer().kick(String.format(message, event.getTarget().getFriendlyName()));
+            } else {
+                event.getPlayer().kick("You can't " + event.getDescription() + " " + event.getTarget().getFriendlyName());
+            }
+        }
+
+        return ActionResult.INHERIT;
+    }
+
+}

src/main/java/com/sk89q/worldguard/blacklist/action/LogAction.java

@@ -0,0 +1,51 @@
+/*
+ * WorldGuard, a suite of tools for Minecraft
+ * Copyright (C) sk89q <http://www.sk89q.com>
+ * Copyright (C) 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 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 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.blacklist.action;
+
+import com.sk89q.worldguard.blacklist.Blacklist;
+import com.sk89q.worldguard.blacklist.BlacklistEntry;
+import com.sk89q.worldguard.blacklist.event.BlacklistEvent;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+public class LogAction extends RepeatGuardedAction {
+
+    private final Blacklist blacklist;
+    private final BlacklistEntry entry;
+
+    public LogAction(Blacklist blacklist, BlacklistEntry entry) {
+        checkNotNull(blacklist);
+        checkNotNull(entry);
+        this.blacklist = blacklist;
+        this.entry = entry;
+    }
+
+    @Override
+    protected ActionResult applyNonRepeated(BlacklistEvent event, boolean silent) {
+        if (silent) {
+            return ActionResult.INHERIT;
+        }
+
+        blacklist.getLogger().logEvent(event, entry.getComment());
+
+        return ActionResult.INHERIT;
+    }
+
+}

src/main/java/com/sk89q/worldguard/blacklist/action/NotifyAction.java

@@ -0,0 +1,51 @@
+/*
+ * WorldGuard, a suite of tools for Minecraft
+ * Copyright (C) sk89q <http://www.sk89q.com>
+ * Copyright (C) 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 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 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.blacklist.action;
+
+import com.sk89q.worldguard.blacklist.Blacklist;
+import com.sk89q.worldguard.blacklist.BlacklistEntry;
+import com.sk89q.worldguard.blacklist.event.BlacklistEvent;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+public class NotifyAction extends RepeatGuardedAction {
+
+    private final Blacklist blacklist;
+    private final BlacklistEntry entry;
+
+    public NotifyAction(Blacklist blacklist, BlacklistEntry entry) {
+        checkNotNull(blacklist);
+        checkNotNull(entry);
+        this.blacklist = blacklist;
+        this.entry = entry;
+    }
+
+    @Override
+    protected ActionResult applyNonRepeated(BlacklistEvent event, boolean silent) {
+        if (silent) {
+            return ActionResult.INHERIT;
+        }
+
+        blacklist.notify(event, entry.getComment());
+
+        return ActionResult.INHERIT;
+    }
+
+}

src/main/java/com/sk89q/worldguard/blacklist/action/RepeatGuardedAction.java

@@ -0,0 +1,37 @@
+/*
+ * WorldGuard, a suite of tools for Minecraft
+ * Copyright (C) sk89q <http://www.sk89q.com>
+ * Copyright (C) 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 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 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.blacklist.action;
+
+import com.sk89q.worldguard.blacklist.event.BlacklistEvent;
+
+public abstract class RepeatGuardedAction implements Action {
+
+    @Override
+    public final ActionResult apply(BlacklistEvent event, boolean silent, boolean repeating, boolean forceRepeat) {
+        if (!repeating || forceRepeat) {
+            return applyNonRepeated(event, silent);
+        }
+
+        return ActionResult.INHERIT;
+    }
+
+    protected abstract ActionResult applyNonRepeated(BlacklistEvent event, boolean silent);
+
+}

src/main/java/com/sk89q/worldguard/blacklist/action/TellAction.java

@@ -0,0 +1,57 @@
+/*
+ * WorldGuard, a suite of tools for Minecraft
+ * Copyright (C) sk89q <http://www.sk89q.com>
+ * Copyright (C) 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 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 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.blacklist.action;
+
+import com.sk89q.worldguard.blacklist.BlacklistEntry;
+import com.sk89q.worldguard.blacklist.event.BlacklistEvent;
+import org.bukkit.ChatColor;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+public class TellAction extends RepeatGuardedAction {
+
+    private final BlacklistEntry entry;
+
+    public TellAction(BlacklistEntry entry) {
+        checkNotNull(entry);
+        this.entry = entry;
+    }
+
+    @Override
+    protected ActionResult applyNonRepeated(BlacklistEvent event, boolean silent) {
+        if (silent) {
+            return ActionResult.INHERIT;
+        }
+
+        String message = entry.getMessage();
+
+        if (event.getPlayer() != null) {
+            if (message != null) {
+                event.getPlayer().printRaw(ChatColor.YELLOW + String.format(message, event.getTarget().getFriendlyName()));
+            } else {
+                event.getPlayer().printRaw(ChatColor.YELLOW + "You're not allowed to " + event.getDescription() + " " +
+                        event.getTarget().getFriendlyName() + ".");
+            }
+        }
+
+        return ActionResult.INHERIT;
+    }
+
+}

src/main/java/com/sk89q/worldguard/blacklist/event/AbstractBlacklistEvent.java

@@ -0,0 +1,77 @@
+/*
+ * WorldGuard, a suite of tools for Minecraft
+ * Copyright (C) sk89q <http://www.sk89q.com>
+ * Copyright (C) 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 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 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.blacklist.event;
+
+import com.sk89q.worldedit.Vector;
+import com.sk89q.worldguard.LocalPlayer;
+import com.sk89q.worldguard.blacklist.target.Target;
+
+import javax.annotation.Nullable;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+abstract class AbstractBlacklistEvent implements BlacklistEvent {
+
+    @Nullable
+    private final LocalPlayer player;
+    private final Vector position;
+    private final Target target;
+    
+    /**
+     * Construct the object.
+     * 
+     * @param player The player associated with this event
+     * @param position The position the event occurred at
+     * @param target The target of the event
+     */
+    AbstractBlacklistEvent(@Nullable LocalPlayer player, Vector position, Target target) {
+        checkNotNull(position);
+        checkNotNull(target);
+        this.player = player;
+        this.position = position;
+        this.target = target;
+    }
+
+    @Nullable
+    @Override
+    public LocalPlayer getPlayer() {
+        return player;
+    }
+
+    @Override
+    public String getCauseName() {
+        return player != null ? player.getName() : position.toString();
+    }
+
+    @Override
+    public Vector getPosition() {
+        return position;
+    }
+    
+    @Override
+    public Target getTarget() {
+        return target;
+    }
+
+    protected String getPlayerName() {
+        return player == null ? "(unknown)" : player.getName();
+    }
+
+}

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

@@ -0,0 +1,87 @@
+/*
+ * WorldGuard, a suite of tools for Minecraft
+ * Copyright (C) sk89q <http://www.sk89q.com>
+ * Copyright (C) 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 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 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.blacklist.event;
+
+import com.sk89q.worldedit.Vector;
+import com.sk89q.worldguard.LocalPlayer;
+import com.sk89q.worldguard.blacklist.target.Target;
+
+import javax.annotation.Nullable;
+
+public interface BlacklistEvent {
+
+    /**
+     * Get the player.
+     *
+     * @return The player associated with this event
+     */
+    @Nullable
+    LocalPlayer getPlayer();
+
+    /**
+     * Get the cause name, which is usually the player name.
+     *
+     * @return the cause name
+     */
+    String getCauseName();
+
+    /**
+     * Get the position.
+     *
+     * @return The position of this event
+     */
+    Vector getPosition();
+
+    /**
+     * Get the position that should be logged.
+     *
+     * @return The position that be logged.
+     */
+    Vector getLoggedPosition();
+
+    /**
+     * Get the item type.
+     *
+     * @return The type associated with this event
+     */
+    Target getTarget();
+
+    /**
+     * Get a short description such as "break" or "destroy with."
+     *
+     * @return The event description
+     */
+    String getDescription();
+
+    /**
+     * Get a message for logger outputs.
+     *
+     * @return A logging message
+     */
+    String getLoggerMessage();
+
+    /**
+     * Get the event type.
+     *
+     * @return the type
+     */
+    EventType getEventType();
+
+}

src/main/java/com/sk89q/worldguard/blacklist/event/BlockBlacklistEvent.java

@@ -0,0 +1,51 @@
+/*
+ * WorldGuard, a suite of tools for Minecraft
+ * Copyright (C) sk89q <http://www.sk89q.com>
+ * Copyright (C) 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 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 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.blacklist.event;
+
+import com.sk89q.worldedit.Vector;
+import com.sk89q.worldguard.LocalPlayer;
+import com.sk89q.worldguard.blacklist.target.Target;
+
+import javax.annotation.Nullable;
+
+abstract class BlockBlacklistEvent extends AbstractBlacklistEvent {
+
+    /**
+     * Construct the object.
+     *
+     * @param player The player associated with this event
+     * @param position The position the event occurred at
+     * @param target The target of the event
+     */
+    BlockBlacklistEvent(@Nullable LocalPlayer player, Vector position, Target target) {
+        super(player, position, target);
+    }
+
+    @Override
+    public String getLoggerMessage() {
+        return getPlayerName() + " tried to " + getDescription() + " " + getTarget().getFriendlyName();
+    }
+
+    @Override
+    public Vector getLoggedPosition() {
+        return getPosition();
+    }
+
+}

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

@@ -0,0 +1,51 @@
+/*
+ * WorldGuard, a suite of tools for Minecraft
+ * Copyright (C) sk89q <http://www.sk89q.com>
+ * Copyright (C) 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 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 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.blacklist.event;
+
+import com.sk89q.worldedit.Vector;
+import com.sk89q.worldguard.LocalPlayer;
+import com.sk89q.worldguard.blacklist.target.Target;
+
+import javax.annotation.Nullable;
+
+public final class BlockBreakBlacklistEvent extends BlockBlacklistEvent {
+
+    /**
+     * Construct the object.
+     *
+     * @param player The player associated with this event
+     * @param position The position the event occurred at
+     * @param target The target of the event
+     */
+    public BlockBreakBlacklistEvent(@Nullable LocalPlayer player, Vector position, Target target) {
+        super(player, position, target);
+    }
+
+    @Override
+    public String getDescription() {
+        return "break";
+    }
+
+    @Override
+    public EventType getEventType() {
+        return EventType.BREAK;
+    }
+
+}

src/main/java/com/sk89q/worldguard/blacklist/event/BlockDispenseBlacklistEvent.java

@@ -0,0 +1,56 @@
+/*
+ * WorldGuard, a suite of tools for Minecraft
+ * Copyright (C) sk89q <http://www.sk89q.com>
+ * Copyright (C) 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 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 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.blacklist.event;
+
+import com.sk89q.worldedit.Vector;
+import com.sk89q.worldguard.LocalPlayer;
+import com.sk89q.worldguard.blacklist.target.Target;
+
+import javax.annotation.Nullable;
+
+public final class BlockDispenseBlacklistEvent extends BlockBlacklistEvent {
+
+    /**
+     * Construct the object.
+     *
+     * @param player The player associated with this event
+     * @param position The position the event occurred at
+     * @param target The target of the event
+     */
+    public BlockDispenseBlacklistEvent(@Nullable LocalPlayer player, Vector position, Target target) {
+        super(player, position, target);
+    }
+
+    @Override
+    public String getDescription() {
+        return "dispense";
+    }
+
+    @Override
+    public String getLoggerMessage() {
+        return getPosition() + " tried to " + getDescription() + " " + getTarget().getFriendlyName();
+    }
+
+    @Override
+    public EventType getEventType() {
+        return EventType.DISPENSE;
+    }
+
+}

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

@@ -0,0 +1,51 @@
+/*
+ * WorldGuard, a suite of tools for Minecraft
+ * Copyright (C) sk89q <http://www.sk89q.com>
+ * Copyright (C) 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 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 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.blacklist.event;
+
+import com.sk89q.worldedit.Vector;
+import com.sk89q.worldguard.LocalPlayer;
+import com.sk89q.worldguard.blacklist.target.Target;
+
+import javax.annotation.Nullable;
+
+public final class BlockInteractBlacklistEvent extends BlockBlacklistEvent {
+
+    /**
+     * Construct the object.
+     *
+     * @param player The player associated with this event
+     * @param position The position the event occurred at
+     * @param target The target of the event
+     */
+    public BlockInteractBlacklistEvent(@Nullable LocalPlayer player, Vector position, Target target) {
+        super(player, position, target);
+    }
+
+    @Override
+    public String getDescription() {
+        return "interact with";
+    }
+
+    @Override
+    public EventType getEventType() {
+        return EventType.INTERACT;
+    }
+
+}

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

@@ -0,0 +1,51 @@
+/*
+ * WorldGuard, a suite of tools for Minecraft
+ * Copyright (C) sk89q <http://www.sk89q.com>
+ * Copyright (C) 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 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 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.blacklist.event;
+
+import com.sk89q.worldedit.Vector;
+import com.sk89q.worldguard.LocalPlayer;
+import com.sk89q.worldguard.blacklist.target.Target;
+
+import javax.annotation.Nullable;
+
+public final class BlockPlaceBlacklistEvent extends BlockBlacklistEvent {
+
+    /**
+     * Construct the object.
+     *
+     * @param player The player associated with this event
+     * @param position The position the event occurred at
+     * @param target The target of the event
+     */
+    public BlockPlaceBlacklistEvent(@Nullable LocalPlayer player, Vector position, Target target) {
+        super(player, position, target);
+    }
+
+    @Override
+    public String getDescription() {
+        return "place";
+    }
+
+    @Override
+    public EventType getEventType() {
+        return EventType.PLACE;
+    }
+
+}

src/main/java/com/sk89q/worldguard/blacklist/event/EventType.java

@@ -0,0 +1,49 @@
+/*
+ * WorldGuard, a suite of tools for Minecraft
+ * Copyright (C) sk89q <http://www.sk89q.com>
+ * Copyright (C) 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 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 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.blacklist.event;
+
+public enum EventType {
+
+    BREAK(BlockBreakBlacklistEvent.class, "on-break"),
+    PLACE(BlockPlaceBlacklistEvent.class, "on-place"),
+    INTERACT(BlockInteractBlacklistEvent.class, "on-interact"),
+    DISPENSE(BlockDispenseBlacklistEvent.class, "on-dispense"),
+    DESTROY_WITH(ItemDestroyWithBlacklistEvent.class, "on-destroy-with"),
+    ACQUIRE(ItemAcquireBlacklistEvent.class, "on-acquire"),
+    DROP(ItemDropBlacklistEvent.class, "on-drop"),
+    USE(ItemUseBlacklistEvent.class, "on-use");
+
+    private final Class<? extends BlacklistEvent> eventClass;
+    private final String ruleName;
+
+    private EventType(Class<? extends BlacklistEvent> eventClass, String ruleName) {
+        this.eventClass = eventClass;
+        this.ruleName = ruleName;
+    }
+
+    public Class<? extends BlacklistEvent> getEventClass() {
+        return eventClass;
+    }
+
+    public String getRuleName() {
+        return ruleName;
+    }
+
+}

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

@@ -0,0 +1,51 @@
+/*
+ * WorldGuard, a suite of tools for Minecraft
+ * Copyright (C) sk89q <http://www.sk89q.com>
+ * Copyright (C) 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 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 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.blacklist.event;
+
+import com.sk89q.worldedit.Vector;
+import com.sk89q.worldguard.LocalPlayer;
+import com.sk89q.worldguard.blacklist.target.Target;
+
+import javax.annotation.Nullable;
+
+public final class ItemAcquireBlacklistEvent extends ItemBlacklistEvent {
+
+    /**
+     * Construct the object.
+     *
+     * @param player The player associated with this event
+     * @param position The position the event occurred at
+     * @param target The target of the event
+     */
+    public ItemAcquireBlacklistEvent(@Nullable LocalPlayer player, Vector position, Target target) {
+        super(player, position, target);
+    }
+
+    @Override
+    public String getDescription() {
+        return "acquire";
+    }
+
+    @Override
+    public EventType getEventType() {
+        return EventType.ACQUIRE;
+    }
+
+}

src/main/java/com/sk89q/worldguard/blacklist/event/ItemBlacklistEvent.java

@@ -0,0 +1,51 @@
+/*
+ * WorldGuard, a suite of tools for Minecraft
+ * Copyright (C) sk89q <http://www.sk89q.com>
+ * Copyright (C) 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 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 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.blacklist.event;
+
+import com.sk89q.worldedit.Vector;
+import com.sk89q.worldguard.LocalPlayer;
+import com.sk89q.worldguard.blacklist.target.Target;
+
+import javax.annotation.Nullable;
+
+abstract class ItemBlacklistEvent extends AbstractBlacklistEvent {
+
+    /**
+     * Construct the object.
+     *
+     * @param player The player associated with this event
+     * @param position The position the event occurred at
+     * @param target The target of the event
+     */
+    ItemBlacklistEvent(@Nullable LocalPlayer player, Vector position, Target target) {
+        super(player, position, target);
+    }
+
+    @Override
+    public String getLoggerMessage() {
+        return getPlayerName() + " tried to " + getDescription() + " " + getTarget().getFriendlyName();
+    }
+
+    @Override
+    public Vector getLoggedPosition() {
+        return getPlayer() != null ? getPlayer().getPosition() : getPosition();
+    }
+
+}

src/main/java/com/sk89q/worldguard/blacklist/event/ItemDestroyWithBlacklistEvent.java

@@ -0,0 +1,57 @@
+/*
+ * WorldGuard, a suite of tools for Minecraft
+ * Copyright (C) sk89q <http://www.sk89q.com>
+ * Copyright (C) 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 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 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.blacklist.event;
+
+import com.sk89q.worldedit.Vector;
+import com.sk89q.worldguard.LocalPlayer;
+import com.sk89q.worldguard.blacklist.target.Target;
+
+import javax.annotation.Nullable;
+
+public final class ItemDestroyWithBlacklistEvent extends ItemBlacklistEvent {
+
+    /**
+     * Construct the object.
+     *
+     * @param player The player associated with this event
+     * @param position The position the event occurred at
+     * @param target The target of the event
+     */
+    public ItemDestroyWithBlacklistEvent(@Nullable LocalPlayer player, Vector position, Target target) {
+        super(player, position, target);
+    }
+
+    @Override
+    public String getDescription() {
+        return "destroy with";
+    }
+
+    @Override
+    public EventType getEventType() {
+        return EventType.DESTROY_WITH;
+    }
+
+    @Override
+    public Vector getLoggedPosition() {
+        // Use the block position instead
+        return getPosition();
+    }
+
+}

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

@@ -0,0 +1,51 @@
+/*
+ * WorldGuard, a suite of tools for Minecraft
+ * Copyright (C) sk89q <http://www.sk89q.com>
+ * Copyright (C) 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 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 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.blacklist.event;
+
+import com.sk89q.worldedit.Vector;
+import com.sk89q.worldguard.LocalPlayer;
+import com.sk89q.worldguard.blacklist.target.Target;
+
+import javax.annotation.Nullable;
+
+public final class ItemDropBlacklistEvent extends ItemBlacklistEvent {
+
+    /**
+     * Construct the object.
+     *
+     * @param player The player associated with this event
+     * @param position The position the event occurred at
+     * @param target The target of the event
+     */
+    public ItemDropBlacklistEvent(@Nullable LocalPlayer player, Vector position, Target target) {
+        super(player, position, target);
+    }
+
+    @Override
+    public String getDescription() {
+        return "drop";
+    }
+
+    @Override
+    public EventType getEventType() {
+        return EventType.DROP;
+    }
+
+}

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

@@ -0,0 +1,51 @@
+/*
+ * WorldGuard, a suite of tools for Minecraft
+ * Copyright (C) sk89q <http://www.sk89q.com>
+ * Copyright (C) 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 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 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.blacklist.event;
+
+import com.sk89q.worldedit.Vector;
+import com.sk89q.worldguard.LocalPlayer;
+import com.sk89q.worldguard.blacklist.target.Target;
+
+import javax.annotation.Nullable;
+
+public final class ItemUseBlacklistEvent extends ItemBlacklistEvent {
+
+    /**
+     * Construct the object.
+     *
+     * @param player The player associated with this event
+     * @param position The position the event occurred at
+     * @param target The target of the event
+     */
+    public ItemUseBlacklistEvent(@Nullable LocalPlayer player, Vector position, Target target) {
+        super(player, position, target);
+    }
+
+    @Override
+    public String getDescription() {
+        return "use";
+    }
+
+    @Override
+    public EventType getEventType() {
+        return EventType.USE;
+    }
+
+}

src/main/java/com/sk89q/worldguard/blacklist/logger/ConsoleHandler.java

@@ -0,0 +1,63 @@
+/*
+ * WorldGuard, a suite of tools for Minecraft
+ * Copyright (C) sk89q <http://www.sk89q.com>
+ * Copyright (C) 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 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 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.blacklist.logger;
+
+import com.sk89q.worldedit.blocks.ItemType;
+import com.sk89q.worldguard.blacklist.event.BlacklistEvent;
+
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+public class ConsoleHandler implements LoggerHandler {
+
+    private String worldName;
+    private final Logger logger;
+
+    public ConsoleHandler(String worldName, Logger logger) {
+        this.worldName = worldName;
+        this.logger = logger;
+    }
+
+    @Override
+    public void logEvent(BlacklistEvent event, String comment) {
+        logger.log(Level.INFO, "[" + worldName + "] " + event.getLoggerMessage() +
+                (comment != null ? " (" + comment + ")" : ""));
+    }
+
+    /**
+     * Get an item's friendly name with its ID.
+     *
+     * @param id The item id
+     * @return The friendly name of the item
+     */
+    private static String getFriendlyItemName(int id) {
+        ItemType type = ItemType.fromID(id);
+        if (type != null) {
+            return type.getName() + " (#" + id + ")";
+        } else {
+            return "#" + id;
+        }
+    }
+
+    @Override
+    public void close() {
+    }
+
+}