Remake of radius claim method. It now starts in the current chunk and spirals outward, in a repeating task designed to keep from overloading the server. The old method tried to put together a list of chunks, and then tried to claim them immediately starting from one corner of the overall area.

New setting "radiusClaimFailureLimit" (default 9). If claims are unsuccessful that many times in a row during a radius claim, the task will cancel out. There is no longer a limit to the specified radius since the process should no longer cause major server stress, and due to the process canceling out after several failures as just described.

Added some new methods to FLocation to quickly convert between block/chunk/region positions, and rewrote the FLocation hashCode() method to make it faster.

src/com/massivecraft/factions/util/SpiralTask.java

@@ -0,0 +1,213 @@
+package com.massivecraft.factions.util;
+
+import java.util.logging.Level;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.World;
+
+import com.massivecraft.factions.FLocation;
+import com.massivecraft.factions.P;
+
+
+/*
+ * reference diagram, task should move in this pattern out from chunk 0 in the center.
+ *  8 [>][>][>][>][>] etc.
+ * [^][6][>][>][>][>][>][6]
+ * [^][^][4][>][>][>][4][v]
+ * [^][^][^][2][>][2][v][v]
+ * [^][^][^][^][0][v][v][v]
+ * [^][^][^][1][1][v][v][v]
+ * [^][^][3][<][<][3][v][v]
+ * [^][5][<][<][<][<][5][v]
+ * [7][<][<][<][<][<][<][7]
+ */
+
+public abstract class SpiralTask implements Runnable
+{
+	// general task-related reference data
+	private transient World world = null;
+	private transient boolean readyToGo = false;
+	private transient int taskID = -1;
+	private transient int limit = 0;
+
+	// values for the spiral pattern routine
+	private transient int x = 0;
+	private transient int z = 0;
+	private transient boolean isZLeg = false;
+	private transient boolean isNeg = false;
+	private transient int length = -1;
+	private transient int current = 0;
+
+	@SuppressWarnings("LeakingThisInConstructor")
+	public SpiralTask(FLocation fLocation, int radius)
+	{
+		// limit is determined based on spiral leg length for given radius; see insideRadius()
+		this.limit = (radius - 1) * 2;
+
+		this.world = Bukkit.getWorld(fLocation.getWorldName());
+		if (this.world == null)
+		{
+			P.p.log(Level.WARNING, "[SpiralTask] A valid world must be specified!");
+			this.stop();
+			return;
+		}
+
+		this.x = (int)fLocation.getX();
+		this.z = (int)fLocation.getZ();
+
+		this.readyToGo = true;
+
+		// get this party started
+		this.setTaskID(Bukkit.getServer().getScheduler().scheduleSyncRepeatingTask(P.p, this, 2, 2));
+	}
+
+/*
+ * This is where the necessary work is done; you'll need to override this method with whatever you want
+ * done at each chunk in the spiral pattern.
+ * Return false if the entire task needs to be aborted, otherwise return true to continue.
+ */
+	public abstract boolean work();
+
+/*
+ * Returns an FLocation pointing at the current chunk X and Z values.
+ */
+	public final FLocation currentFLocation()
+	{
+		return new FLocation(world.getName(), x, z);
+	}
+/*
+ * Returns a Location pointing at the current chunk X and Z values.
+ * note that the Location is at the corner of the chunk, not the center.
+ */
+	public final Location currentLocation()
+	{
+		return new Location(world, FLocation.chunkToBlock(x), 65.0, FLocation.chunkToBlock(z));
+	}
+/*
+ * Returns current chunk X and Z values.
+ */
+	public final int getX()
+	{
+		return x;
+	}
+	public final int getZ()
+	{
+		return z;
+	}
+
+
+
+/*
+ * Below are the guts of the class, which you normally wouldn't need to mess with.
+ */
+
+	public final void setTaskID(int ID)
+	{	
+		if (ID == -1)
+			this.stop();
+		taskID = ID;
+	}
+
+	public final void run()
+	{
+		if (!this.valid() || !readyToGo) return;
+
+		// this is set so it only does one iteration at a time, no matter how frequently the timer fires
+		readyToGo = false;
+
+		// make sure we're still inside the specified radius
+		if ( ! this.insideRadius()) return;
+
+		// track this to keep one iteration from dragging on too long and possibly choking the system
+		long loopStartTime = now();
+
+		// keep going until the task has been running for 20ms or more, then stop to take a breather
+		while (now() < loopStartTime + 20)
+		{
+			// run the primary task on the current X/Z coordinates
+			if ( ! this.work())
+			{
+				this.finish();
+				return;
+			}
+
+			// move on to next chunk in spiral
+			if ( ! this.moveToNext())
+				return;
+		}
+
+		// ready for the next iteration to run
+		readyToGo = true;
+	}
+
+	// step through chunks in spiral pattern from center; returns false if we're done, otherwise returns true
+	public final boolean moveToNext()
+	{
+		if ( ! this.valid()) return false;
+
+		// make sure we don't need to turn down the next leg of the spiral
+		if (current < length)
+		{
+			current++;
+
+			// if we're outside the radius, we're done
+			if ( ! this.insideRadius()) return false;
+		}
+		else
+		{	// one leg/side of the spiral down...
+			current = 0;
+			isZLeg ^= true;
+			// every second leg (between X and Z legs, negative or positive), length increases
+			if (isZLeg)
+			{
+				isNeg ^= true;
+				length++;
+			}
+		}
+
+		// move one chunk further in the appropriate direction
+		if (isZLeg)
+			z += (isNeg) ? -1 : 1;
+		else
+			x += (isNeg) ? -1 : 1;
+
+		return true;
+	}
+
+	public final boolean insideRadius()
+	{
+		boolean inside = current < limit;
+		if (!inside)
+			this.finish();
+		return inside;
+	}
+
+	// for successful completion
+	public void finish()
+	{
+//		P.p.log("SpiralTask successfully completed!");
+		this.stop();
+	}
+
+	// we're done, whether finished or cancelled
+	public final void stop()
+	{
+		if (!this.valid()) return;
+
+		readyToGo = false;
+		Bukkit.getServer().getScheduler().cancelTask(taskID);
+		taskID = -1;
+	}
+
+	// is this task still valid/workable?
+	public final boolean valid()
+	{
+		return taskID != -1;
+	}
+
+	private static long now()
+	{
+		return System.currentTimeMillis();
+	}
+}