Revamped valid spawnpoint algorithm.

src/com/garbagemule/ArenaPlugin/Arena.java

@@ -0,0 +1,116 @@
+package com.garbagemule.ArenaPlugin;
+
+import org.bukkit.entity.Player;
+
+public interface Arena
+{    
+    /**
+     * Start the arena session.
+     * This method should warp all players to their respective warp points, start all
+     * needed timers, clear/populate all sets and lists, and flag all booleans.
+     */
+    public void startArena();
+    
+    /**
+     * Stop the arena session.
+     * Distribute rewards, clean up arena floor and reset everything to how it was before
+     * the arena session was started.
+     */
+    public void endArena();
+    
+    /**
+     * Force the arena to start.
+     * If some players are ready, this method will force all non-ready players to leave,
+     * and the arena will start with only the currently ready players.
+     * @return true, if the arena was successfully started, false otherwise
+     */
+    public boolean forceStart();
+    
+    /**
+     * Force the arena to end.
+     * Returns all players to their entry locations, distributes rewards, cleans the arena
+     * floor, as well as all lists, sets and maps. Calling this method will return the
+     * arena to the state it would be in right after MobArena has loaded.
+     * @return true, if the session was successfully ended.
+     */
+    public boolean forceEnd();
+    
+    /**
+     * Player joins the arena/lobby.
+     * The player should either enter with an empty inventory, or have their inventory
+     * stored upon entering, such that the classes in the lobby/arena will be the only
+     * means of equipment. The player's previous location and health is also stored.
+     * @param p A player
+     * @precondition Calling canJoin(p) for the given player must return true.
+     */
+    public void playerJoin(Player p);
+    
+    /**
+     * Player leaves the arena or lobby.
+     * Upon leaving, the player will have their inventory restored (if it was stored
+     * on join), as well as their health. They will be completely discarded/cleared from
+     * the arena, such that they no longer reside in any collections.
+     * @param p A player
+     * @precondition Calling canLeave(p) for the given player must return true.
+     */
+    public void playerLeave(Player p);
+    
+    /**
+     * Player joins the spectator area.
+     * The player takes a spectator role, meaning they cannot participate in the arena
+     * in any way. The player's location and health is stored upon spectating, and of
+     * course restored upon leaving.
+     * @param p A player
+     * @precondition Calling canSpec(p) for the given player must return true.
+     */
+    public void playerSpec(Player p);
+    
+    /**
+     * Player dies in the arena.
+     */
+    public void playerDeath(Player p);
+    
+    /**
+     * Player signals that they are ready.
+     */
+    public void playerReady(Player p);
+    
+    /**
+     * Check if a player can join the arena.
+     * @param p A player
+     * @return true, if the player is eligible to join the arena.
+     */
+    public boolean canJoin(Player p);
+    
+    /**
+     * Check if a player can leave the arena.
+     * @param p A player
+     * @return true, if the player is eligible to leave the arena.
+     */
+    public boolean canLeave(Player p);
+    
+    /**
+     * Check if a player can spectate the arena.
+     * @param p A player
+     * @return true, if the player is eligible for spectating.
+     */
+    public boolean canSpec(Player p);
+    
+    /**
+     * Check if the arena is enabled.
+     * @return true, if the arena is enabled.
+     */
+    public boolean isEnabled();
+    
+    /**
+     * Check if the arena is set up and ready for use.
+     * @return true, if the arena is ready for use.
+     */
+    public boolean isSetup();
+    
+    /**
+     * Check if the arena is running.
+     * @return true, if the arena is running.
+     */
+    public boolean isRunning();
+}

src/com/garbagemule/ArenaPlugin/ArenaPlugin.java

@@ -0,0 +1,6 @@
+package com.garbagemule.ArenaPlugin;
+
+public interface ArenaPlugin
+{
+    public Master getMaster();
+}

src/com/garbagemule/ArenaPlugin/Master.java

@@ -0,0 +1,16 @@
+package com.garbagemule.ArenaPlugin;
+
+import java.util.List;
+
+import org.bukkit.entity.Player;
+
+public interface Master
+{
+    //public List<Arena> getArenas();
+    
+    //public List<Arena> getEnabledArenas();
+    
+    //public List<Arena> getPermittedArenas(Player p);
+    
+    
+}

src/com/garbagemule/MobArena/AbstractArena.java

@@ -1,65 +1,44 @@
 package com.garbagemule.MobArena;
 
-import java.util.LinkedList;
-import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
-import org.bukkit.Bukkit;
 import org.bukkit.Location;
 import org.bukkit.World;
 import org.bukkit.entity.Player;
-import org.bukkit.inventory.ItemStack;
 
-public abstract class AbstractArena implements Arenaz
+import com.garbagemule.ArenaPlugin.ArenaPlugin;
+
+public abstract class AbstractArena implements ArenaInterface
 {
-
     private String      name;
     private World       world;
-    private MobArena plugin;
+    private ArenaPlugin plugin;
     
     private boolean enabled, setup, running;
     private Set<Player> arenaPlayers, lobbyPlayers, readyPlayers, specPlayers;
     private Map<Player,String> playerClassMap;
     private Map<Player,Location> locations;
-    private Map<Player,Integer> healthMap;
+    private Map<Player,Integer> healths;
+    
+    public AbstractArena(String name, World world, ArenaPlugin plugin)
+    {
+        if (world == null)
+            throw new NullPointerException("[" + plugin.getClass().getSimpleName() + "] ERROR! World for arena '" + name + "' does not exist!");
+        
+        this.name   = name;
+        this.world  = world;
+        this.plugin = plugin;
+    }
 
-    /**
-     * Start the arena session.
-     * This method should warp all players to their respective warp points, start all
-     * needed timers, clear/populate all sets and lists, and flag all booleans.
-     */
     public abstract void startArena();
     
-    /**
-     * Stop the arena session.
-     * Distribute rewards, clean up arena floor and reset everything to how it was before
-     * the arena session was started, false otherwise
-     */
     public abstract void endArena();
 
-    /**
-     * Force the arena to start.
-     * If some players are ready, this method will force all non-ready players to leave,
-     * and the arena will start with only the currently ready players.
-     * @return true, if the arena was successfully started, false otherwise
-     */
     public abstract boolean forceStart();
 
-    /**
-     * Force the arena to end.
-     * Returns all players to their entry locations, distributes rewards, cleans the arena
-     * floor, as well as all lists, sets and maps. Calling this method will return the
-     * arena to the state it would be in right after MobArena has loaded.
-     * @return true, if the session was successfully ended.
-     */
     public abstract boolean forceEnd();
-    
+/*
-    /**
-     * Player joins the arena/lobby.
-     * @param p A player
-     * @precondition Calling canJoin(p) for the given player must return true.
-     */
     public void playerJoin(Player p)
     {
         storePlayerData(p, p.getLocation());
@@ -67,12 +46,7 @@ public abstract class AbstractArena implements Arenaz
         p.setHealth(20);
         movePlayerToLobby(p);
     }
-    
+*/
-    /**
-     * Player leaves the arena or lobby.
-     * @param p A player
-     * @precondition Calling canLeave(p) for the given player must return true.
-     */
     /*
     public void playerLeave(Player p)
     {
@@ -86,66 +60,29 @@ public abstract class AbstractArena implements Arenaz
         endArena();
     }*/
     
-    /**
+
-     * Player joins the spectator area.
-     * @param p A player
-     * @precondition Calling canSpec(p) for the given player must return true.
-     */
     public abstract void playerSpec(Player p);
 
-    /**
-     * Player dies in the arena.
-     */
     public abstract void playerDeath(Player p);
 
-    /**
-     * Player signals that they are ready.
-     */
     public abstract void playerReady(Player p);
 
-    /**
-     * Check if a player can join the arena.
-     * @param p A player
-     * @return true, if the player is eligible to join the arena.
-     */
     public abstract boolean canJoin(Player p);
 
-    /**
-     * Check if a player can leave the arena.
-     * @param p A player
-     * @return true, if the player is eligible to leave the arena.
-     */
     public abstract boolean canLeave(Player p);
 
-    /**
-     * Check if a player can spectate the arena.
-     * @param p A player
-     * @return true, if the player is eligible for spectating.
-     */
     public abstract boolean canSpec(Player p);
 
-    /**
-     * Check if the arena is enabled.
-     * @return true, if the arena is enabled.
-     */
     public boolean isEnabled()
     {
         return enabled;
     }
 
-    /**
-     * Check if the arena is set up and ready for use.
-     * @return true, if the arena is ready for use.
-     */
     public boolean isSetup()
     {
         return setup;
     }
 
-    /**
-     * Check if the arena is running.
-     * @return true, if the arena is running.
-     */
     public boolean isRunning()
     {
         return running;
@@ -159,15 +96,21 @@ public abstract class AbstractArena implements Arenaz
         if (!locations.containsKey(p))
             locations.put(p, loc);
 
-        if (!healthMap.containsKey(p))
+        if (!healths.containsKey(p))
-            healthMap.put(p, p.getHealth());
+            healths.put(p, p.getHealth());
     }
     
     public abstract void movePlayerToLobby(Player p);
     
     public abstract void movePlayerToSpec(Player p);
     
-    public abstract void movePlayerToEntry(Player p);
+    public void movePlayerToEntry(Player p)
+    {
+        Location entry = locations.get(p);
+        if (entry == null) return;
+        
+        p.teleport(entry);
+    }
     
     public abstract void restoreInvAndGiveRewards(final Player p);
 }

src/com/garbagemule/MobArena/Arena.java

@@ -47,6 +47,7 @@ import com.garbagemule.MobArena.MAMessages.Msg;
 import com.garbagemule.MobArena.repairable.Repairable;
 import com.garbagemule.MobArena.repairable.RepairableComparator;
 import com.garbagemule.MobArena.repairable.RepairableContainer;
+import com.garbagemule.MobArena.util.InventoryItem;
 import com.garbagemule.MobArena.util.WaveUtils;
 import com.garbagemule.MobArena.waves.BossWave;
 import com.garbagemule.MobArena.waves.Wave;
@@ -63,7 +64,7 @@ public class Arena
 
     protected boolean edit, waveClear, detCreepers, detDamage, lightning, hellhounds, specOnDeath, shareInArena;
     protected Location p1, p2, l1, l2, arenaLoc, lobbyLoc, spectatorLoc;
-    protected Map<String,Location> spawnpoints;
+    protected Map<String,Location> spawnpoints, containers;
     protected String logging;
 
     // Wave/reward/entryfee fields
@@ -89,7 +90,7 @@ public class Arena
     protected Set<Block>             blocks;
     protected Set<Wolf>              pets;
     protected Map<Player,Integer>    petMap;
-    protected LinkedList<Repairable> repairables, containers;
+    protected LinkedList<Repairable> repairables, containables;
     
     // Spawn overriding
     protected int spawnMonsters;
@@ -137,7 +138,7 @@ public class Arena
         classMap        = new HashMap<Player,String>();
         randoms         = new HashSet<Player>();
         repairables     = new LinkedList<Repairable>();
-        containers      = new LinkedList<Repairable>();
+        containables    = new LinkedList<Repairable>();
         
         running         = false;
         edit            = false;
@@ -179,7 +180,10 @@ public class Arena
             p.setHealth(20);
         }
         
-        // Spawn pets.
+        // Set the boolean.
+        running = true;
+        
+        // Spawn pets (must happen after 'running = true;')
         spawnPets();
         
         // Copy the singleWaves Set.
@@ -193,9 +197,6 @@ public class Arena
         log = new ArenaLog(plugin, this);
         log.start();
         
-        // Set the boolean.
-        running = true;
-        
         // Announce and notify.
         MAUtils.tellAll(this, Msg.ARENA_START.get());
         for (MobArenaListener listener : plugin.getAM().listeners)
@@ -339,7 +340,6 @@ public class Arena
         
         if (specOnDeath)
         {
-            //resetPlayer(p);
             clearPlayer(p);
             movePlayerToSpec(p);
         }
@@ -353,7 +353,8 @@ public class Arena
             spawnThread.updateTargets();
         
         MAUtils.tellAll(this, Msg.PLAYER_DIED.get(p.getName()));
-        Bukkit.getServer().getScheduler().scheduleSyncDelayedTask(plugin, new Runnable()
+        Bukkit.getServer().getScheduler().scheduleSyncDelayedTask(plugin,
+            new Runnable()
             {
                 public void run()
                 {
@@ -520,13 +521,11 @@ public class Arena
             {
                 public void run()
                 {
-                    for (int x = p1.getBlockX(); x <= p2.getBlockX(); x++)
+                    for (Location loc : containers.values())
-                        for (int y = p1.getBlockY(); y <= p2.getBlockY(); y++)
-                            for (int z = p1.getBlockZ(); z <= p2.getBlockZ(); z++)
                     {
-                                BlockState state = world.getBlockAt(x,y,z).getState();
+                        BlockState state = world.getBlockAt(loc).getState();
                         if (state instanceof ContainerBlock)
-                                    containers.add(new RepairableContainer(state, false));
+                            containables.add(new RepairableContainer(state, false));
                     }
                 }
             });
@@ -539,7 +538,7 @@ public class Arena
             {
                 public void run()
                 {
-                    for (Repairable r : containers)
+                    for (Repairable r : containables)
                         r.repair();
                 }
             });
@@ -807,6 +806,7 @@ public class Arena
         lobbyLoc         = MAUtils.getArenaCoord(config, world, configName, "lobby");
         spectatorLoc     = MAUtils.getArenaCoord(config, world, configName, "spectator");
         spawnpoints      = MAUtils.getArenaSpawnpoints(config, world, configName);
+        containers       = MAUtils.getArenaContainers(config, world, configName);
         
         // NEW WAVES
         singleWaves      = WaveUtils.getWaves(this, config, WaveBranch.SINGLE);
@@ -1025,12 +1025,12 @@ public class Arena
         return classes;
     }
     
-    public Collection<Location> getAllSpawnpoints()
+    public List<Location> getAllSpawnpoints()
     {
-        return spawnpoints.values();
+        return new ArrayList<Location>(spawnpoints.values());
     }
     
-    public Collection<Location> getSpawnpoints()
+    public List<Location> getSpawnpoints()
     {
         List<Location> result = new ArrayList<Location>(spawnpoints.size());
         
@@ -1040,7 +1040,7 @@ public class Arena
             result.add(entry.getValue());
         }
         
-        return !result.isEmpty() ? result : spawnpoints.values();
+        return !result.isEmpty() ? result : new ArrayList<Location>(spawnpoints.values());
     }
     
     public Location getBossSpawnpoint()
@@ -1200,54 +1200,25 @@ public class Arena
             return true;
         
         PlayerInventory inv = p.getInventory();
-        for (ItemStack stack : entryFee)
+        InventoryItem[] items = InventoryItem.parseItemStacks(inv.getContents());
-        {
+        InventoryItem[] fee   = InventoryItem.parseItemStacks(entryFee);
-            // Economy money
-            if (stack.getTypeId() == MobArena.ECONOMY_MONEY_ID)
-            {
-                if (plugin.Methods.hasMethod() && !plugin.Method.getAccount(p.getName()).subtract(stack.getAmount()))                
-                    return false;
-            }
 
-            // Normal stack
+        // Take some economy money
-            else
+        for (InventoryItem item : InventoryItem.extractAllFromArray(MobArena.ECONOMY_MONEY_ID, fee))
-            {
+            if (plugin.Methods.hasMethod())
-                int id = stack.getTypeId();
+                plugin.Method.getAccount(p.getName()).subtract(item.getAmount());
-                int amount = stack.getAmount();
 
-                while (amount > 0)
+        // Take any other items
-                {
+        for (InventoryItem item : fee)
-                    int pos = inv.first(id);
+            InventoryItem.removeItemFromArray(item, items);
-                    if (pos == -1) return false;
         
-                    ItemStack is = inv.getItem(pos);
+        // Turn everything back into ItemStacks
-                    if (is.getAmount() > amount)
+        for (int i = 0; i < items.length; i++)
-                    {
+            inv.setItem(i, items[i].toItemStack());
-                        is.setAmount(is.getAmount() - amount);
-                        amount = 0;
-                    }
-                    else
-                    {
-                        amount -= is.getAmount();
-                        inv.setItem(pos, null);
-                    }
-                }
-            }
-        }
 
-        hasPaid.add(p);
         return true;
     }
     
-    public void refund(Player p)
-    {
-        if (!hasPaid.contains(p))
-            return;
-        
-        MAUtils.giveItems(p, entryFee, false, plugin);
-        hasPaid.remove(p);
-    }
-    
     public boolean canJoin(Player p)
     {
         if (!enabled)
@@ -1266,12 +1237,14 @@ public class Arena
             MAUtils.tellPlayer(p, Msg.JOIN_PLAYER_LIMIT_REACHED);
         else if (joinDistance > 0 && !inRegionRadius(p.getLocation(), joinDistance))
             MAUtils.tellPlayer(p, Msg.JOIN_TOO_FAR);
-        else if (!canAfford(p) || !takeFee(p))
+        else if (emptyInvJoin && !MAUtils.hasEmptyInventory(p))
+            MAUtils.tellPlayer(p, Msg.JOIN_EMPTY_INV);
+        /*else if (!canAfford(p) || !takeFee(p))
             MAUtils.tellPlayer(p, Msg.JOIN_FEE_REQUIRED, MAUtils.listToString(entryFee, plugin));
         else if (emptyInvJoin && !MAUtils.hasEmptyInventory(p))
             MAUtils.tellPlayer(p, Msg.JOIN_EMPTY_INV);
         else if (!emptyInvJoin && !MAUtils.storeInventory(p))
-            MAUtils.tellPlayer(p, Msg.JOIN_STORE_INV_FAIL);
+            MAUtils.tellPlayer(p, Msg.JOIN_STORE_INV_FAIL);*/
         else return true;
         
         return false;

src/com/garbagemule/MobArena/ArenaInterface.java

@@ -0,0 +1,116 @@
+package com.garbagemule.MobArena;
+
+import org.bukkit.entity.Player;
+
+public interface ArenaInterface
+{    
+    /**
+     * Start the arena session.
+     * This method should warp all players to their respective warp points, start all
+     * needed timers, clear/populate all sets and lists, and flag all booleans.
+     */
+    public void startArena();
+    
+    /**
+     * Stop the arena session.
+     * Distribute rewards, clean up arena floor and reset everything to how it was before
+     * the arena session was started.
+     */
+    public void endArena();
+    
+    /**
+     * Force the arena to start.
+     * If some players are ready, this method will force all non-ready players to leave,
+     * and the arena will start with only the currently ready players.
+     * @return true, if the arena was successfully started, false otherwise
+     */
+    public boolean forceStart();
+    
+    /**
+     * Force the arena to end.
+     * Returns all players to their entry locations, distributes rewards, cleans the arena
+     * floor, as well as all lists, sets and maps. Calling this method will return the
+     * arena to the state it would be in right after MobArena has loaded.
+     * @return true, if the session was successfully ended.
+     */
+    public boolean forceEnd();
+    
+    /**
+     * Player joins the arena/lobby.
+     * The player should either enter with an empty inventory, or have their inventory
+     * stored upon entering, such that the classes in the lobby/arena will be the only
+     * means of equipment. The player's previous location and health is also stored.
+     * @param p A player
+     * @precondition Calling canJoin(p) for the given player must return true.
+     */
+    public void playerJoin(Player p);
+    
+    /**
+     * Player leaves the arena or lobby.
+     * Upon leaving, the player will have their inventory restored (if it was stored
+     * on join), as well as their health. They will be completely discarded/cleared from
+     * the arena, such that they no longer reside in any collections.
+     * @param p A player
+     * @precondition Calling canLeave(p) for the given player must return true.
+     */
+    public void playerLeave(Player p);
+    
+    /**
+     * Player joins the spectator area.
+     * The player takes a spectator role, meaning they cannot participate in the arena
+     * in any way. The player's location and health is stored upon spectating, and of
+     * course restored upon leaving.
+     * @param p A player
+     * @precondition Calling canSpec(p) for the given player must return true.
+     */
+    public void playerSpec(Player p);
+    
+    /**
+     * Player dies in the arena.
+     */
+    public void playerDeath(Player p);
+    
+    /**
+     * Player signals that they are ready.
+     */
+    public void playerReady(Player p);
+    
+    /**
+     * Check if a player can join the arena.
+     * @param p A player
+     * @return true, if the player is eligible to join the arena.
+     */
+    public boolean canJoin(Player p);
+    
+    /**
+     * Check if a player can leave the arena.
+     * @param p A player
+     * @return true, if the player is eligible to leave the arena.
+     */
+    public boolean canLeave(Player p);
+    
+    /**
+     * Check if a player can spectate the arena.
+     * @param p A player
+     * @return true, if the player is eligible for spectating.
+     */
+    public boolean canSpec(Player p);
+    
+    /**
+     * Check if the arena is enabled.
+     * @return true, if the arena is enabled.
+     */
+    public boolean isEnabled();
+    
+    /**
+     * Check if the arena is set up and ready for use.
+     * @return true, if the arena is ready for use.
+     */
+    public boolean isSetup();
+    
+    /**
+     * Check if the arena is running.
+     * @return true, if the arena is running.
+     */
+    public boolean isRunning();
+}

src/com/garbagemule/MobArena/ArenaMaster.java

@@ -15,7 +15,9 @@ import org.bukkit.entity.Player;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.util.config.Configuration;
 
-public class ArenaMaster
+import com.garbagemule.ArenaPlugin.Master;
+
+public class ArenaMaster implements Master
 {
     private MobArena plugin;
     private Configuration config;

src/com/garbagemule/MobArena/ArenaPlayer.java

@@ -3,6 +3,7 @@ package com.garbagemule.MobArena;
 import java.util.LinkedList;
 import java.util.List;
 
+import org.bukkit.block.Block;
 import org.bukkit.entity.Player;
 import org.bukkit.inventory.ItemStack;
 
@@ -13,6 +14,7 @@ public class ArenaPlayer
     public String className;
     public Arena arena;
     public List<ItemStack> rewards;
+    public List<Block> blocks;
     
     protected boolean inArena, inLobby, inSpec, isReady;
     
@@ -34,6 +36,7 @@ public class ArenaPlayer
         
         className   = arena.classMap.get(player);
         rewards     = new LinkedList<ItemStack>();
+        blocks      = new LinkedList<Block>();
     }
     
     public Player getPlayer()    { return player; }

src/com/garbagemule/MobArena/MABlockListener.java

@@ -1,8 +1,10 @@
 package com.garbagemule.MobArena;
 
+import org.bukkit.event.block.BlockBurnEvent;
 import org.bukkit.event.block.BlockIgniteEvent;
 import org.bukkit.event.block.BlockListener;
 import org.bukkit.event.block.BlockBreakEvent;
+import org.bukkit.event.block.BlockPhysicsEvent;
 import org.bukkit.event.block.BlockPlaceEvent;
 
 public class MABlockListener extends BlockListener
@@ -20,6 +22,12 @@ public class MABlockListener extends BlockListener
             arena.eventListener.onBlockBreak(event);
     }
     
+    public void onBlockBurn(BlockBurnEvent event)
+    {
+        for (Arena arena : am.arenas)
+            arena.eventListener.onBlockBurn(event);
+    }
+
     public void onBlockPlace(BlockPlaceEvent event)
     {
         for (Arena arena : am.arenas)
@@ -31,4 +39,10 @@ public class MABlockListener extends BlockListener
         for (Arena arena : am.arenas)
             arena.eventListener.onBlockIgnite(event);
     }
+    
+    public void onBlockPhysics(BlockPhysicsEvent event)
+    {
+        for (Arena arena : am.arenas)
+            arena.eventListener.onBlockPhysics(event);
+    }
 }

src/com/garbagemule/MobArena/MACommands.java

@@ -11,6 +11,7 @@ import org.bukkit.Material;
 import org.bukkit.Server;
 import org.bukkit.World;
 import org.bukkit.entity.Player;
+import org.bukkit.block.ContainerBlock;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandSender;
 import org.bukkit.command.CommandExecutor;
@@ -56,13 +57,15 @@ public class MACommands implements CommandExecutor
         COMMANDS.add("spawnpoints");       // List spawnpoints
         COMMANDS.add("addspawn");          // Add a spawnpoint
         COMMANDS.add("delspawn");          // Delete a spawnpoint
+        COMMANDS.add("containers");        // List containers
+        COMMANDS.add("addcontainer");      // Add a container block
+        COMMANDS.add("delcontainer");      // Delete a container block
         COMMANDS.add("reset");             // Reset arena coordinates
         COMMANDS.add("addclass");          // Add a new class
         COMMANDS.add("delclass");          // Delete a class
         COMMANDS.add("checkdata");         // Check arena well formedness
         COMMANDS.add("auto-generate");     // Auto-generate arena
         COMMANDS.add("auto-degenerate");   // Restore cuboid
-        COMMANDS.add("lol");
     }
     private boolean meanAdmins, showingRegion;
     private Server server;
@@ -155,6 +158,10 @@ public class MACommands implements CommandExecutor
             if (p.isInsideVehicle())
                 p.leaveVehicle();
             
+            // Take entry fee and store inventory
+            arena.takeFee(p);
+            if (!arena.emptyInvJoin) MAUtils.storeInventory(p);
+            
             // If player is in a bed, unbed!
             if (p.isSleeping())
             {
@@ -1070,6 +1077,77 @@ public class MACommands implements CommandExecutor
             return true;
         }
         
+        if (base.equals("containers"))
+        {
+            if (!console && !(player && plugin.has(p, "mobarena.setup.containers")) && !op)
+            {
+                MAUtils.tellPlayer(sender, Msg.MISC_NO_ACCESS);
+                return true;
+            }
+            
+            StringBuffer buffy = new StringBuffer();
+            List<String> containers = plugin.getConfig().getKeys("arenas." + am.selectedArena.configName() + ".coords.containers");
+            
+            if (containers != null)
+            {
+                for (String s : containers)
+                {
+                    buffy.append(s);
+                    buffy.append(" ");
+                }
+            }
+            else
+            {
+                buffy.append(Msg.MISC_NONE);
+            }
+            
+            MAUtils.tellPlayer(sender, "Containers for arena '" + am.selectedArena.configName() + "': " + buffy.toString());
+            return true;
+        }
+        
+        if (base.equals("addcontainer"))
+        {
+            if (!(player && plugin.has(p, "mobarena.setup.addchest")) && !op)
+            {
+                MAUtils.tellPlayer(sender, Msg.MISC_NO_ACCESS);
+                return true;
+            }
+            if (arg1 == null || !arg1.matches("^[a-zA-Z][a-zA-Z0-9]*$"))
+            {
+                MAUtils.tellPlayer(sender, "Usage: /ma addchest <container name>");
+                return true;
+            }
+            if (!(p.getTargetBlock(null, 50).getState() instanceof ContainerBlock))
+            {
+                MAUtils.tellPlayer(sender, "You must look at container.");
+                return true;
+            }
+            
+            MAUtils.setArenaCoord(plugin.getConfig(), am.selectedArena, "containers." + arg1, p.getTargetBlock(null, 50).getLocation());
+            MAUtils.tellPlayer(sender, "Container '" + arg1 + "' added for arena \"" + am.selectedArena.configName() + "\"");
+            return true;
+        }
+        
+        if (base.equals("delcontainer"))
+        {
+            if (!console && !(player && plugin.has(p, "mobarena.setup.delcontainer")) && !op)
+            {
+                MAUtils.tellPlayer(sender, Msg.MISC_NO_ACCESS);
+                return true;
+            }
+            if (arg1 == null || !arg1.matches("^[a-zA-Z][a-zA-Z0-9]*$"))
+            {
+                MAUtils.tellPlayer(sender, "Usage: /ma delcontainer <container name>");
+                return true;
+            }
+
+            if (MAUtils.delArenaCoord(plugin.getConfig(), am.selectedArena, "containers." + arg1))
+                MAUtils.tellPlayer(sender, "Container '" + arg1 + "' deleted for arena '" + am.selectedArena.configName() + "'");
+            else
+                MAUtils.tellPlayer(sender, "Could not find the container '" + arg1 + "' for arena '" + am.selectedArena.configName() + "'");
+            return true;
+        }
+        
         if (base.equals("checkdata"))
         {
             if (!console && !(player && plugin.has(p, "mobarena.setup.checkdata")) && !op)

src/com/garbagemule/MobArena/MAListener.java

@@ -11,12 +11,15 @@ import org.bukkit.block.Sign;
 import org.bukkit.entity.Entity;
 import org.bukkit.entity.LivingEntity;
 import org.bukkit.entity.Player;
+import org.bukkit.entity.Slime;
 import org.bukkit.entity.Wolf;
 import org.bukkit.event.Event.Result;
 import org.bukkit.event.block.Action;
 import org.bukkit.event.block.BlockBreakEvent;
+import org.bukkit.event.block.BlockBurnEvent;
+import org.bukkit.event.block.BlockEvent;
 import org.bukkit.event.block.BlockIgniteEvent;
-import org.bukkit.event.block.BlockIgniteEvent.IgniteCause;
+import org.bukkit.event.block.BlockPhysicsEvent;
 import org.bukkit.event.block.BlockPlaceEvent;
 import org.bukkit.event.entity.CreatureSpawnEvent;
 import org.bukkit.event.entity.EntityCombustEvent;
@@ -41,6 +44,7 @@ import org.bukkit.inventory.ItemStack;
 import org.bukkit.material.Attachable;
 import org.bukkit.material.Bed;
 import org.bukkit.material.Door;
+import org.bukkit.material.MaterialData;
 import org.bukkit.material.Redstone;
 
 import com.garbagemule.MobArena.MAMessages.Msg;
@@ -57,14 +61,40 @@ public class MAListener implements ArenaListener
         this.plugin = plugin;
     }
     
+    public void onBlockPhysics(BlockPhysicsEvent event)
+    {
+        if (!arena.inRegion(event.getBlock().getLocation()) || arena.softRestore)
+            return;
+        
+        MaterialData data = event.getBlock().getState().getData();
+        if (data instanceof Attachable || data instanceof Bed || data instanceof Door || data instanceof Redstone)
+            event.setCancelled(true);
+    }
+    
     public void onBlockBreak(BlockBreakEvent event)
     {
-        if (!arena.inRegion(event.getBlock().getLocation()) || arena.edit || (!arena.protect && arena.running))
+        if (onBlockDestroy(event))
             return;
         
+        event.setCancelled(true);
+    }
+    
+    public void onBlockBurn(BlockBurnEvent event)
+    {
+        if (onBlockDestroy(event))
+            return;
+        
+        event.setCancelled(true);
+    }
+    
+    private boolean onBlockDestroy(BlockEvent event)
+    {
+        if (!arena.inRegion(event.getBlock().getLocation()) || arena.edit || (!arena.protect && arena.running))
+            return true;
+        
         Block b = event.getBlock();
         if (arena.blocks.remove(b) || b.getType() == Material.TNT)
-            return;
+            return true;
         
         if (arena.softRestore && arena.running)
         {
@@ -85,10 +115,10 @@ public class MAListener implements ArenaListener
             if (!arena.softRestoreDrops)
                 b.setTypeId(0);
             
-            return;
+            return true;
         }
         
-        event.setCancelled(true);
+        return false;
     }
     
     public void onBlockPlace(BlockPlaceEvent event)
@@ -104,6 +134,7 @@ public class MAListener implements ArenaListener
             
             if (mat == Material.WOODEN_DOOR || mat == Material.IRON_DOOR_BLOCK)
                 arena.blocks.add(b.getRelative(0,1,0));
+            
             return;
         }
 
@@ -116,8 +147,21 @@ public class MAListener implements ArenaListener
         if (!arena.inRegion(event.getBlock().getLocation()))
             return;
         
-        if (event.getCause() == IgniteCause.LIGHTNING)
+        switch (event.getCause())
+        {
+            case LIGHTNING:
                 event.setCancelled(true);
+                break;
+            case SPREAD:
+            case FLINT_AND_STEEL:
+                if (arena.running)
+                    arena.blocks.add(event.getBlock());
+                else
+                    event.setCancelled(true);
+                break;
+            default:
+                break;
+        }
     }
 
     public void onCreatureSpawn(CreatureSpawnEvent event)
@@ -125,6 +169,10 @@ public class MAListener implements ArenaListener
         if (!arena.inRegion(event.getLocation())) // || event.getSpawnReason() == SpawnReason.CUSTOM)
             return;
         
+        LivingEntity entity = (LivingEntity) event.getEntity();
+        if (arena.running && entity instanceof Slime)
+            arena.monsters.add(entity);
+        else
             // If running == true, setCancelled(false), and vice versa.
             event.setCancelled(!arena.running);
     }
@@ -532,7 +580,7 @@ public class MAListener implements ArenaListener
 
     public void onPlayerTeleport(PlayerTeleportEvent event)
     {
-        if (arena.edit || !arena.enabled || !arena.setup || arena.allowWarp)
+        if (!arena.running || arena.edit || !arena.enabled || !arena.setup || arena.allowWarp)
             return;
         
         if (!arena.inRegion(event.getTo()) && !arena.inRegion(event.getFrom()))

src/com/garbagemule/MobArena/MAMessages.java

@@ -106,6 +106,11 @@ public class MAMessages
         {
             m.msg = msg;
         }
+        
+        public String toString()
+        {
+            return msg;
+        }
     }
     
     /**

src/com/garbagemule/MobArena/MAPlayerListener.java

@@ -13,6 +13,7 @@ import org.bukkit.event.player.PlayerListener;
 import org.bukkit.event.player.PlayerQuitEvent;
 import org.bukkit.event.player.PlayerTeleportEvent;
 
+
 public class MAPlayerListener extends PlayerListener
 {
     private MobArena plugin;
@@ -90,6 +91,6 @@ public class MAPlayerListener extends PlayerListener
                 {
                     MAUtils.checkForUpdates(plugin, p, false);
                 }
-            }, 100);
+            }, 60);
     }
 }

src/com/garbagemule/MobArena/MASpawnThread.java

@@ -64,6 +64,10 @@ public class MASpawnThread implements Runnable
         if (arena.waveClear && wave > 1 && !arena.monsters.isEmpty())
             return;
         
+        // Check if we're on a boss wave
+        if (!arena.waveClear && arena.bossWave != null)
+            return;
+        
         // Grant rewards (if any) for this wave
         grantRewards(wave);
         
@@ -82,7 +86,7 @@ public class MASpawnThread implements Runnable
     {
         List<Entity> tmp = new LinkedList<Entity>(arena.monsters);
         for (Entity e : tmp)
-            if (e.isDead())
+            if (e.isDead() || !arena.inRegion(e.getLocation()))
                 arena.monsters.remove(e);
     }
     

src/com/garbagemule/MobArena/MAUtils.java

@@ -15,6 +15,8 @@ import java.util.Map;
 import java.util.HashMap;
 import java.util.Random;
 import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 import net.minecraft.server.WorldServer;
 
@@ -36,7 +38,7 @@ import org.bukkit.util.config.Configuration;
 
 import com.garbagemule.MobArena.MAMessages.Msg;
 import com.garbagemule.MobArena.util.EntityPosition;
-import com.garbagemule.MobArena.util.MAInventoryItem;
+import com.garbagemule.MobArena.util.InventoryItem;
 
 public class MAUtils
 {         
@@ -133,6 +135,20 @@ public class MAUtils
     
     // ///////////////////////////////////////////////////////////////////// */
     
+    public static Map<String,Location> getArenaContainers(Configuration config, World world, String arena)
+    {
+        Map<String,Location> containers = new HashMap<String,Location>();
+        String arenaPath = "arenas." + arena + ".coords.containers";
+        
+        if (config.getKeys(arenaPath) == null)
+            return containers;
+        
+        for (String point : config.getKeys(arenaPath))
+            containers.put(point, makeLocation(world, config.getString(arenaPath + "." + point)));
+        
+        return containers;
+    }
+    
     /**
      * Grab all the spawnpoints for a specific arena.
      */
@@ -353,11 +369,11 @@ public class MAUtils
         {
             backupFile.createNewFile();
             
-            MAInventoryItem[] inv = new MAInventoryItem[armor.length + items.length];
+            InventoryItem[] inv = new InventoryItem[armor.length + items.length];
             for (int i = 0; i < armor.length; i++)
-                inv[i] = stackToItem(armor[i]);
+                inv[i] = InventoryItem.parseItemStack(armor[i]);
             for (int i = 0; i < items.length; i++)
-                inv[armor.length + i] = stackToItem(items[i]);
+                inv[armor.length + i] = InventoryItem.parseItemStack(items[i]);
             
             FileOutputStream   fos = new FileOutputStream(backupFile);
             ObjectOutputStream oos = new ObjectOutputStream(fos);
@@ -389,7 +405,7 @@ public class MAUtils
             // Grab the MAInventoryItem array from the backup-file.
             FileInputStream   fis      = new FileInputStream(backupFile);
             ObjectInputStream ois      = new ObjectInputStream(fis);
-            MAInventoryItem[] fromFile = (MAInventoryItem[]) ois.readObject();
+            InventoryItem[] fromFile   = (InventoryItem[]) ois.readObject();
             ois.close();
             
             // Split that shit.
@@ -397,17 +413,20 @@ public class MAUtils
             ItemStack[] items = new ItemStack[fromFile.length-4];
             
             for (int i = 0; i < 4; i++)
-                armor[i] = itemToStack(fromFile[i]);
+                armor[i] = InventoryItem.toItemStack(fromFile[i]);
             for (int i = 4; i < fromFile.length; i++)
-                items[i - 4] = itemToStack(fromFile[i]);
+                items[i - 4] = InventoryItem.toItemStack(fromFile[i]);
             
             // Restore the inventory.
             PlayerInventory inv = p.getInventory();
             inv.setArmorContents(armor);
+            for (int i = 0; i < items.length; i++)
+                inv.setItem(i, items[i]);
+            /*
             for (ItemStack stack : items)
                 if (stack != null)
                     inv.addItem(stack);
-            
+            */
             // Remove the backup-file.
             backupFile.delete();
         }
@@ -421,20 +440,6 @@ public class MAUtils
         return true;
     }
     
-    private static MAInventoryItem stackToItem(ItemStack stack)
-    {
-        if (stack == null)
-            return new MAInventoryItem(-1, -1, (short)0);
-        return new MAInventoryItem(stack.getTypeId(), stack.getAmount(), stack.getDurability());
-    }
-    
-    private static ItemStack itemToStack(MAInventoryItem item)
-    {
-        if (item.getTypeId() == -1)
-            return null;
-        return new ItemStack(item.getTypeId(), item.getAmount(), item.getDurability());
-    }
-    
     /* Checks if all inventory and armor slots are empty. */
     public static boolean hasEmptyInventory(Player p)
     {
@@ -636,6 +641,20 @@ public class MAUtils
     
     // ///////////////////////////////////////////////////////////////////// */
     
+    /**
+     * Check if a Location is inside two points (x1,y1,z1) (x2,y2,z2)
+     */
+    public static boolean inRegion(Location loc, double x1, double y1, double z1, double x2, double y2, double z2)
+    {
+        double x = loc.getBlockX();
+        double y = loc.getBlockY();
+        double z = loc.getBlockZ();
+        
+        return x >= x1 && x <= x2 &&
+               y >= y1 && y <= y2 &&
+               z >= z1 && z <= z2;
+    }
+    
     /**
      * Create a frame spanned by the two input coordinates.
      * @return An int arry holding x,y,z and the original type IDs of each block.
@@ -1153,6 +1172,7 @@ public class MAUtils
             
             // Open the connection and don't redirect.
             HttpURLConnection con = (HttpURLConnection) baseURI.toURL().openConnection();
+            con.setConnectTimeout(5000);
             con.setInstanceFollowRedirects(false);
             
             String header = con.getHeaderField("Location");
@@ -1167,18 +1187,27 @@ public class MAUtils
             // Otherwise, grab the location header to get the real URI.
             String url = new URI(con.getHeaderField("Location")).toString();
             
-            // If the current version is the same as the thread version.
+            // Set up the regex and matcher
-            if (url.contains(plugin.getDescription().getVersion().replace(".", "-")))
+            Pattern regex   = Pattern.compile("v([0-9]+-)*[0-9]+");
-            {
+            Matcher matcher = regex.matcher(url);
-                if (!response)
+            if (!matcher.find())
                 return;
 
-                tellPlayer(p, "Your version of MobArena is up to date!");
+            // Split the version strings
+            String[] forumVersion = matcher.group().substring(1).split("-");
+            String[] thisVersion  = plugin.getDescription().getVersion().split("\\.");
+
+            // If the current version is older than the forum version, notify.
+            for (int i = 0; i < Math.min(forumVersion.length, thisVersion.length); i++)
+            {
+                if (Integer.parseInt(forumVersion[i]) > Integer.parseInt(thisVersion[i]))
+                {
+                    tellPlayer(p, "There is a new version of MobArena available!");;
                     return;
                 }
+            }
             
-            // Otherwise, notify the player that there is a new version.
+            if (response) tellPlayer(p, "Your version of MobArena is up to date!");
-            tellPlayer(p, "There is a new version of MobArena available!");;
         }
         catch (Exception e)
         {

src/com/garbagemule/MobArena/MobArena.java

@@ -1,6 +1,7 @@
 package com.garbagemule.MobArena;
 
 import java.io.File;
+import java.util.Random;
 
 import org.bukkit.Bukkit;
 import org.bukkit.entity.Player;
@@ -20,12 +21,14 @@ import com.nijikokun.bukkit.Permissions.Permissions;
 import com.garbagemule.MobArena.util.FileUtils;
 import com.garbagemule.register.payment.Method;
 import com.garbagemule.register.payment.Methods;
+import com.garbagemule.ArenaPlugin.ArenaPlugin;
+import com.garbagemule.ArenaPlugin.Master;
 
 /**
  * MobArena
  * @author garbagemule
  */
-public class MobArena extends JavaPlugin
+public class MobArena extends JavaPlugin implements ArenaPlugin
 {
     private Configuration config;
     private ArenaMaster am;
@@ -40,8 +43,10 @@ public class MobArena extends JavaPlugin
     // Global variables
     public static PluginDescriptionFile desc;
     public static File dir, arenaDir;
-    public static final double MIN_PLAYER_DISTANCE = 256.0;
+    public static final double MIN_PLAYER_DISTANCE = 15.0;
+    public static final double MIN_PLAYER_DISTANCE_SQUARED = MIN_PLAYER_DISTANCE * MIN_PLAYER_DISTANCE;
     public static final int ECONOMY_MONEY_ID = -29;
+    public static Random random = new Random();
 
     public void onEnable()
     {        
@@ -109,8 +114,10 @@ public class MobArena extends JavaPlugin
         
         // Register events.
         pm.registerEvent(Event.Type.BLOCK_BREAK,               blockListener,    Priority.Highest, this);
+        pm.registerEvent(Event.Type.BLOCK_BURN,                blockListener,    Priority.Highest, this);
         pm.registerEvent(Event.Type.BLOCK_PLACE,               blockListener,    Priority.Highest, this);
-        pm.registerEvent(Event.Type.BLOCK_IGNITE,              blockListener,    Priority.Normal,  this);
+        pm.registerEvent(Event.Type.BLOCK_PHYSICS,             blockListener,    Priority.Normal,  this);
+        pm.registerEvent(Event.Type.BLOCK_IGNITE,              blockListener,    Priority.Highest, this);
         pm.registerEvent(Event.Type.PLAYER_INTERACT,           playerListener,   Priority.Normal,  this);
         pm.registerEvent(Event.Type.PLAYER_DROP_ITEM,          playerListener,   Priority.Normal,  this);
         pm.registerEvent(Event.Type.PLAYER_BUCKET_EMPTY,       playerListener,   Priority.Normal,  this);
@@ -174,6 +181,11 @@ public class MobArena extends JavaPlugin
     public ArenaMaster   getAM()          { return am; } // More convenient.
     public ArenaMaster   getArenaMaster() { return am; }
     
+    public Master getMaster()
+    {
+        return am;
+    }
+    
     private String getHeader()
     {
         String sep = System.getProperty("line.separator");

src/com/garbagemule/MobArena/MobArenaHandler.java

@@ -3,13 +3,12 @@ package com.garbagemule.MobArena;
 import org.bukkit.Bukkit;
 import org.bukkit.Location;
 import org.bukkit.entity.Entity;
+import org.bukkit.entity.LivingEntity;
 import org.bukkit.entity.Player;
-import org.bukkit.plugin.Plugin;
 
 public class MobArenaHandler
 {
-    MobArena plugin;
+    private MobArena plugin;
-    boolean ma = false;
     
     /**
      * Primary constructor.
@@ -17,26 +16,24 @@ public class MobArenaHandler
      */
     public MobArenaHandler()
     {
-        Plugin maPlugin = (MobArena) Bukkit.getServer().getPluginManager().getPlugin("MobArena");
+        plugin = (MobArena) Bukkit.getServer().getPluginManager().getPlugin("MobArena");
-        
-        if (maPlugin == null)
-            return;
-
-        ma = true;
-        plugin = (MobArena) maPlugin;
     }
     
+    
+    
+    /*//////////////////////////////////////////////////////////////////
+    
+                 REGION/LOCATION METHODS
+     
+    //////////////////////////////////////////////////////////////////*/
+    
     /**
-     * Check if a Location is inside of an arena region.
+     * Check if a Location is inside of any arena region.
      * @param loc A location.
      * @return true, if the Location is inside of any arena region.
      */
     public boolean inRegion(Location loc)
     {
-        // If the plugin doesn't exist, always return false.
-        if (!ma || plugin.getAM() == null) return false;
-        
-        // Return true if location is within just one arena's region.
         for (Arena arena : plugin.getAM().arenas)
             if (arena.inRegion(loc))
                 return true;
@@ -45,26 +42,50 @@ public class MobArenaHandler
     }
     
     /**
-     * Check if a Location is inside of a specific arena region.
+     * Check if a Location is inside of a specific arena region (by arena object).
      * @param arena An Arena object
      * @param loc A location
      * @return true, if the Location is inside of the arena region.
      */
-    public boolean inRegion(Arena arena, Location loc) { return (ma && arena != null && arena.inRegion(loc)); }
+    public boolean inRegion(Arena arena, Location loc)
+    {
+        return (arena != null && arena.inRegion(loc));
+    }
+    
+    /**
+     * Check if a Location is inside of a specific arena region (by arena name).
+     * @param arenaName The name of an arena
+     * @param loc A location
+     * @return true, if the Location is inside of the arena region.
+     */
+    public boolean inRegion(String arenaName, Location loc)
+    {
+        Arena arena = plugin.getAM().getArenaWithName(arenaName);
+        if (arena == null)
+            throw new NullPointerException("There is no arena with that name");
+        
+        return arena.inRegion(loc);
+    }
     
     /**
      * Check if a Location is inside of the region of an arena that is currently running.
      * @param loc A location.
      * @return true, if the Location is inside of the region of an arena that is currently running.
      */
-    public boolean inRunningRegion(Location loc) { return inRegion(loc, false, true); }
+    public boolean inRunningRegion(Location loc)
+    {
+        return inRegion(loc, false, true);
+    }
     
     /**
      * Check if a Location is inside of the region of an arena that is currently enabled.
      * @param loc A location.
      * @return true, if the Location is inside of the region of an arena that is currently enabled.
      */
-    public boolean inEnabledRegion(Location loc) { return inRegion(loc, true, false); }
+    public boolean inEnabledRegion(Location loc)
+    {
+        return inRegion(loc, true, false);
+    }
     
     /**
      * Private helper method for inRunningRegion and inEnabledRegion
@@ -76,7 +97,7 @@ public class MobArenaHandler
     private boolean inRegion(Location loc, boolean enabled, boolean running)
     {
         // If the plugin doesn't exist, always return false.
-        if (!ma || plugin.getAM() == null) return false;
+        if (plugin.getAM() == null) return false;
         
         // Return true if location is within just one arena's region.
         for (Arena arena : plugin.getAM().arenas)
@@ -87,40 +108,124 @@ public class MobArenaHandler
         return false;
     }
     
+    
+    
+    /*//////////////////////////////////////////////////////////////////
+    
+                 PLAYER/MONSTER/PET METHODS
+     
+    //////////////////////////////////////////////////////////////////*/
+    
+    /**
+     * Check if a player is in a MobArena arena (by Player).
+     * @param player The player
+     * @return true, if the player is in an arena
+     */
+    public boolean isPlayerInArena(Player player)
+    {
+        return (plugin.getAM().getArenaWithPlayer(player) != null);
+    }
+    
+    /**
+     * Check if a player is in a MobArena arena (by name).
+     * @param playerName The name of the player
+     * @return true, if the player is in an arena
+     */
+    public boolean isPlayerInArena(String playerName)
+    {
+        return (plugin.getAM().getArenaWithPlayer(playerName) != null);
+    }
+    
+    /**
+     * Get the MobArena class of a given player.
+     * @param player The player
+     * @return The class name of the player if the player is in the arena, null otherwise
+     */
+    public String getPlayerClass(Player player)
+    {
+        Arena arena = plugin.getAM().getArenaWithPlayer(player);
+        if (arena == null) return null;
+        
+        return arena.classMap.get(player);
+    }
+    
+    /**
+     * Get the MobArena class of a given player in a given arena.
+     * This method is faster than the above method, granted the Arena object is known.
+     * @param arena The MobArena arena to check in
+     * @param player The player to look up
+     * @return The class name of the player, if the player is in the arena, null otherwise
+     */
+    public String getPlayerClass(Arena arena, Player player)
+    {
+        return arena.classMap.get(player);
+    }
+    
+    /**
+     * Check if a monster is in a MobArena arena.
+     * @param entity The monster entity
+     * @return true, if the monster is in an arena
+     */
+    public boolean isMonsterInArena(LivingEntity entity)
+    {
+        return plugin.getAM().getArenaWithMonster(entity) != null;
+    }
+    
+    /**
+     * Check if a pet is in a MobArena arena.
+     * @param wolf The pet wolf
+     * @return true, if the pet is in an arena
+     */
+    public boolean isPetInArena(LivingEntity wolf)
+    {
+        return plugin.getAM().getArenaWithPet(wolf) != null;
+    }
+    
+    
+    
+    /*//////////////////////////////////////////////////////////////////
+    
+                 ARENA GETTERS
+     
+    //////////////////////////////////////////////////////////////////*/
+    
     /**
      * Get an Arena object at the given location.
      * @param loc A location
      * @return an Arena object, or null
      */
-    public Arena getArenaAtLocation(Location loc) { return (ma) ? plugin.getAM().getArenaAtLocation(loc) : null; }
+    public Arena getArenaAtLocation(Location loc)
+    {
+        return plugin.getAM().getArenaAtLocation(loc);
+    }
     
     /**
      * Get the Arena object that the given player is currently in.
      * @param p A player
      * @return an Arena object, or null
      */
-    public Arena getArenaWithPlayer(Player p) { return (ma) ? plugin.getAM().getArenaWithPlayer(p) : null; }
+    public Arena getArenaWithPlayer(Player p)
+    {
+        return plugin.getAM().getArenaWithPlayer(p);
+    }
     
     /**
      * Get the Arena object that the given pet is currently in.
      * @param wolf A pet wolf
      * @return an Arena object, or null
      */
-    public Arena getArenaWithPet(Entity wolf) { return (ma) ? plugin.getAM().getArenaWithPet(wolf) : null; }
+    public Arena getArenaWithPet(Entity wolf)
+    {
+        return plugin.getAM().getArenaWithPet(wolf);
+    }
     
     /**
      * Get the Arena object that the given monster is currently in.
      * @param monster A monster
      * @return an Arena object, or null
      */
-    public Arena getArenaWithMonster(Entity monster) { return (ma) ? plugin.getAM().getArenaWithMonster(monster) : null; }
+    public Arena getArenaWithMonster(Entity monster)
-    
-    /**
-     * Check if the server is running MobArena.
-     * @return true, if MobArena exists on the server.
-     */
-    public boolean hasMA()
     {
-        return ma;
+        return plugin.getAM().getArenaWithMonster(monster);
     }
 }

src/com/garbagemule/MobArena/repairable/RepairableContainer.java

@@ -5,17 +5,28 @@ import org.bukkit.block.ContainerBlock;
 import org.bukkit.inventory.Inventory;
 import org.bukkit.inventory.ItemStack;
 
+import com.garbagemule.MobArena.util.InventoryItem;
+
 public class RepairableContainer extends RepairableBlock
 {
-    private ItemStack[] contents;
+    private InventoryItem[] items;
     
     public RepairableContainer(BlockState state, boolean clear)
     {
         super(state);
 
+        // Grab the inventory and its contents
         Inventory inv = ((ContainerBlock) state).getInventory();
-        contents = inv.getContents().clone();
+        ItemStack[] contents = inv.getContents();
         
+        // Initialize the items array
+        items = new InventoryItem[contents.length];
+        
+        // Turn every ItemStack into an InventoryItem
+        for (int i = 0; i < items.length; i++)
+            items[i] = InventoryItem.parseItemStack(contents[i]);
+        
+        // Clear the inventory if prompted
         if (clear) inv.clear();
     }
     
@@ -31,7 +42,15 @@ public class RepairableContainer extends RepairableBlock
     {
         super.repair();
         
+        // Grab the inventory
         ContainerBlock cb = (ContainerBlock) getWorld().getBlockAt(getX(),getY(),getZ()).getState();
-        cb.getInventory().setContents(contents);
+        Inventory inv = cb.getInventory();
+        
+        // Turn every InventoryItem into an ItemStack
+        for (int i = 0; i < items.length; i++)
+        {
+            InventoryItem item = items[i]; 
+            inv.setItem(i, item != null ? item.toItemStack() : null);
+        }
     }
 }

src/com/garbagemule/MobArena/util/InventoryItem.java

@@ -0,0 +1,259 @@
+package com.garbagemule.MobArena.util;
+
+import java.io.Serializable;
+import java.util.LinkedList;
+import java.util.List;
+
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.material.MaterialData;
+
+public class InventoryItem implements Serializable
+{
+    private static final long serialVersionUID = 739709220350581510L;
+    private int id;
+    private int amount;
+    private Byte data;
+    private short durability;
+    
+    /**
+     * Default constructor.
+     * @param id The data value/type id of the ItemStack
+     * @param amount The amount of the stack
+     * @param data The MaterialData (possibly null) of the stack
+     * @param durability The durability of the stack
+     */
+    public InventoryItem(int id, int amount, Byte data, short durability)
+    {
+        this.id         = id;
+        this.amount     = amount;
+        this.data       = data;
+        this.durability = durability;
+    }
+    
+    /**
+     * ItemStack constructor.
+     * @param stack The ItemStack to base the InventoryItem off of.
+     */
+    public InventoryItem(ItemStack stack)
+    {
+        if (stack == null)
+            id = -1;
+        
+        id = stack.getTypeId();
+        amount = stack.getAmount();
+        
+        // In case of "odd" items, don't attempt to get data and durability
+        if (id < 0) return;
+        
+        data = stack.getData() == null ? null : stack.getData().getData();
+        durability = stack.getDurability();
+    }
+    
+    /**
+     * Static method for turning a (possibly null) InventoryItem into an ItemStack.
+     * The method is useful if it is unknown whether an InventoryItem object is
+     * null or not.
+     * @param item The Inventory item to convert
+     * @return An ItemStack representation of the InventoryItem, or null
+     */
+    public static ItemStack toItemStack(InventoryItem item)
+    {
+        if (item == null)
+            return null;
+        
+        return item.toItemStack();
+    }
+    
+    /**
+     * Static method for converting an ItemStack to an InventoryItems.
+     * @param stack The ItemStack to convert
+     * @return An InventoryItem representation of the ItemStack, or null
+     */
+    public static InventoryItem parseItemStack(ItemStack stack)
+    {
+        if (stack == null)
+            return new InventoryItem(-1, -1, null, (short) 0);
+        
+        return new InventoryItem(stack);
+    }
+    
+    /**
+     * Static method for converting an ItemStack array to an InventoryItem array.
+     * @param stacks The ItemStack array
+     * @return An InventoryItem array
+     */
+    public static InventoryItem[] parseItemStacks(ItemStack[] stacks)
+    {
+        InventoryItem[] items = new InventoryItem[stacks.length];
+        
+        for (int i = 0; i < items.length; i++)
+            items[i] = parseItemStack(stacks[i]);
+        
+        return items;
+    }
+    
+    /**
+     * Convert a list of ItemStacks into an array of InventoryItems
+     * @param stacks List of ItemStacks to convert
+     * @return An InventoryItem array
+     */
+    public static InventoryItem[] parseItemStacks(List<ItemStack> stacks)
+    {
+        InventoryItem[] items = new InventoryItem[stacks.size()];
+        
+        for (int i = 0; i < items.length; i++)
+            items[i] = parseItemStack(stacks.get(i));
+        
+        return items;
+    }
+    
+    /**
+     * Static method for extracting all InventoryItems from an InventoryItem array.
+     * @param id The type id of the items to extract
+     * @param items The InventoryItem array
+     * @return A list of all InventoryItems removed
+     */
+    public static List<InventoryItem> extractAllFromArray(int id, InventoryItem[] items)
+    {
+        List<InventoryItem> list = new LinkedList<InventoryItem>();
+
+        for (int i = 0; i < items.length; i++)
+        {
+            if (items[i].getTypeId() == id)
+            {
+                list.add(items[i]);
+                items[i].setTypeId(-1);
+            }
+        }
+        
+        return list;
+    }
+    
+    /**
+     * Static method for removing an InventoryItem from an InventoryItem array.
+     * @param item The InventoryItem to remove
+     * @param items The InventoryItem array to remove from
+     * @return true, if the item was removed successfully, false otherwise
+     */
+    public static boolean removeItemFromArray(InventoryItem item, InventoryItem[] items)
+    {
+        // Grab the total amount to remove
+        int leftToRemove = item.getAmount();
+        
+        for (int i = 0; i < items.length; i++)
+        {
+            if (items[i].getTypeId() != item.getTypeId())
+                continue;
+            
+            // Grab the amount
+            int amount = items[i].getAmount();
+            
+            // Reduce amount/nullify item
+            if (amount > leftToRemove)
+            {
+                items[i].setAmount(amount - leftToRemove);
+                leftToRemove = 0;
+            }
+            else
+            {
+                items[i].setTypeId(-1);
+                leftToRemove -= amount;
+            }
+            
+            // If nothing left to remove, return true.
+            if (leftToRemove == 0)
+                return true;
+        }
+        
+        return false;
+    }
+
+    /**
+     * Get the data value/type id of the item
+     * @return A type id
+     */
+    public int getTypeId()
+    {
+        return id;
+    }
+    
+    /**
+     * Set the data value/type id of the item
+     * @param id A type id
+     */
+    public void setTypeId(int id)
+    {
+        this.id = id;
+    }
+    
+    /**
+     * Get the amount of the item
+     * @return An amount
+     */
+    public int getAmount()
+    {
+        return amount;
+    }
+    
+    /**
+     * Set the amount of the item
+     * @param amount An amount
+     */
+    public void setAmount(int amount)
+    {
+        this.amount = amount;
+    }
+    
+    /**
+     * Get the MaterialData of the item
+     * @return A MaterialData
+     */
+    public MaterialData getData()
+    {
+        return new MaterialData(id, data == null ? (byte) 0 : data);
+    }
+    
+    /**
+     * Set the MaterialData of the item
+     * @param data A MaterialData
+     */
+    public void setData(MaterialData data)
+    {
+        this.data = data.getData();
+    }
+    
+    /**
+     * Get the durability of the item
+     * @return The item durability
+     */
+    public short getDurability()
+    {
+        return durability;
+    }
+    
+    /**
+     * Set the durability of the item
+     * @param durability An item durability
+     */
+    public void setDurability(short durability)
+    {
+        this.durability = durability;
+    }
+    
+    /**
+     * Convert this InventoryItem to an ItemStack representation
+     * @return An ItemStack representation of this InventoryItem, or null if the type id is -1
+     */
+    public ItemStack toItemStack()
+    {
+        if (id == -1)
+            return null;
+        
+        ItemStack stack = new ItemStack(id, amount, durability);
+        
+        if (data != null)
+            stack.setData(getData());
+        
+        return stack;
+    }
+}

src/com/garbagemule/MobArena/util/WaveUtils.java

@@ -12,6 +12,7 @@ import org.bukkit.entity.Player;
 import org.bukkit.util.config.Configuration;
 
 import com.garbagemule.MobArena.Arena;
+import com.garbagemule.MobArena.MAUtils;
 import com.garbagemule.MobArena.MobArena;
 import com.garbagemule.MobArena.waves.*;
 import com.garbagemule.MobArena.waves.Wave.*;
@@ -23,33 +24,53 @@ public class WaveUtils
      */    
     public static List<Location> getValidSpawnpoints(Arena arena, Collection<Player> players)
     {
+        long start = System.nanoTime();
         List<Location> result = new ArrayList<Location>();
 
-        for (Location s : arena.getAllSpawnpoints())
+        double x1 = Double.NaN, y1 = Double.NaN, z1 = Double.NaN, // Bottom
-        {
+               x2 = Double.NaN, y2 = Double.NaN, z2 = Double.NaN; // Top
+        
+        // Get the region that the players span.
         for (Player p : players)
         {
-                // If the player somehow got out of the arena world, kick him.
+            double x = p.getLocation().getBlockX();
-                if (!s.getWorld().getName().equals(p.getWorld().getName()))
+            double y = p.getLocation().getBlockY();
+            double z = p.getLocation().getBlockZ();
+            
+            // Initialize the coordinates if they aren't already.
+            if (Double.isNaN(x1))
             {
-                    MobArena.info("Player '" + p.getName() + "' is not in the right world. Kicking...");
+                x1 = x; y1 = y; z1 = z; // Bottom
-                    p.kickPlayer("[MobArena] Cheater! (Warped out of the arena world.)");
+                x2 = x; y2 = y; z2 = z; // Top
                 continue;
             }
             
-                if (s.distanceSquared(p.getLocation()) > MobArena.MIN_PLAYER_DISTANCE)
+            // Update x
-                    continue;
+            if (x < x1)       x1 = x;
+            else if (x > x2)  x2 = x;
             
+            // Update y
+            if (y < y1)       y1 = y;
+            else if (y > y2)  y2 = y;
+            
+            // Update z
+            if (z < z1)       z1 = z;
+            else if (z > z2)  z2 = z;
+        }
+        
+        // Expand by the minimum player distance.
+        x1 -= MobArena.MIN_PLAYER_DISTANCE; y1 -= MobArena.MIN_PLAYER_DISTANCE; z1 -= MobArena.MIN_PLAYER_DISTANCE;
+        x2 += MobArena.MIN_PLAYER_DISTANCE; y2 += MobArena.MIN_PLAYER_DISTANCE; z2 += MobArena.MIN_PLAYER_DISTANCE;
+        
+        for (Location s : arena.getAllSpawnpoints())
+            if (MAUtils.inRegion(s, x1, y1, z1, x2, y2, z2))
                 result.add(s);
-                break;
-            }
-        }
         
         // If no players are in range, just use all the spawnpoints.
         if (result.isEmpty())
         {
             MobArena.warning("Spawnpoints of arena '" + arena.configName() + "' may be too far apart!");
-            result.addAll(arena.getAllSpawnpoints());
+            return arena.getAllSpawnpoints();//result.addAll(arena.getAllSpawnpoints());
         }
         
         // Else, return the valid spawnpoints.
@@ -75,7 +96,7 @@ public class WaveUtils
             }
             
             dist = p.getLocation().distanceSquared(e.getLocation());
-            if (dist < current && dist < MobArena.MIN_PLAYER_DISTANCE)
+            if (dist < current && dist < MobArena.MIN_PLAYER_DISTANCE_SQUARED)
             {
                 current = dist;
                 result = p;

src/com/garbagemule/MobArena/waves/BossAbility.java

@@ -0,0 +1,316 @@
+package com.garbagemule.MobArena.waves;
+
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Random;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.entity.Creature;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Fireball;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.util.Vector;
+
+import com.garbagemule.MobArena.Arena;
+import com.garbagemule.MobArena.util.WaveUtils;
+
+
+public enum BossAbility
+{
+    ARROWS("Arrow")
+    {
+        public void run(Arena arena, LivingEntity boss)
+        {
+            boss.shootArrow();
+        }
+    },
+    FIREBALLS("Fireball")
+    {
+        public void run(Arena arena, LivingEntity boss)
+        {
+            Location bLoc = boss.getLocation();
+            Location loc = bLoc.add(bLoc.getDirection().normalize().multiply(2).toLocation(boss.getWorld(), bLoc.getYaw(), bLoc.getPitch()));
+            Fireball fireball = boss.getWorld().spawn(loc, Fireball.class);
+            fireball.setIsIncendiary(false);
+        }
+    },
+    FIREAURA("Fire Aura")
+    {
+        public void run(Arena arena, LivingEntity boss)
+        {
+            for (Player p : getNearbyPlayers(arena, boss, 5))
+                    p.setFireTicks(20);
+        }
+    },
+    LIGHTNINGAURA("Lightning Aura")
+    {
+        public void run(Arena arena, LivingEntity boss)
+        {
+            Location base = boss.getLocation();
+            Location ne = base.getBlock().getRelative( 2,  0,  2).getLocation();
+            Location nw = base.getBlock().getRelative(-2,  0,  2).getLocation();
+            Location se = base.getBlock().getRelative( 2,  0, -2).getLocation();
+            Location sw = base.getBlock().getRelative(-2,  0, -2).getLocation();
+
+            arena.getWorld().strikeLightning(ne);
+            arena.getWorld().strikeLightning(nw);
+            arena.getWorld().strikeLightning(se);
+            arena.getWorld().strikeLightning(sw);
+        }
+    },
+    DISORIENTTARGET("Disorient Target")
+    {
+        public void run(Arena arena, LivingEntity boss)
+        {
+            LivingEntity target = getTarget(boss);
+            if (target == null) return;
+
+            Location loc = target.getLocation();
+            loc.setYaw(target.getLocation().getYaw() + 45 + (new Random()).nextInt(270));
+            target.teleport(loc);
+        }
+    },
+    ROOTTARGET("Root Target")
+    {
+        public void run(final Arena arena, LivingEntity boss)
+        {
+            final LivingEntity target = getTarget(boss);
+            if (target == null) return;
+            
+            final Location loc = target.getLocation();
+            final int freezeTaskId = Bukkit.getServer().getScheduler().scheduleSyncRepeatingTask(arena.getPlugin(),
+                new Runnable()
+                {
+                    public void run()
+                    {
+                        if (arena.getLivingPlayers().contains(target))
+                            target.teleport(loc);
+                    }
+                }, 3, 3);
+            
+            Bukkit.getServer().getScheduler().scheduleSyncDelayedTask(arena.getPlugin(),
+                new Runnable()
+                {
+                    public void run()
+                    {
+                        Bukkit.getServer().getScheduler().cancelTask(freezeTaskId);
+                    }
+                }, 45);
+        }
+    },
+    LIVINGBOMB("Living Bomb")
+    {
+        public void run(final Arena arena, LivingEntity boss)
+        {
+            final LivingEntity target = getTarget(boss);
+            if (target == null) return;
+            
+            // Set the target on fire
+            target.setFireTicks(60);
+            
+            // Create an explosion after 3 seconds
+            Bukkit.getServer().getScheduler().scheduleSyncDelayedTask(arena.getPlugin(),
+                new Runnable()
+                {
+                    public void run()
+                    {
+                        if (!arena.getLivingPlayers().contains(target))
+                            return;
+                        
+                        arena.getWorld().createExplosion(target.getLocation(), 2F);
+                        for(Player p : getNearbyPlayers(arena, target, 3))
+                            p.setFireTicks(40);
+                    }
+                }, 61);
+        }
+    },
+    CHAINLIGHTNING("Chain Lightning")
+    {
+        public void run(Arena arena, LivingEntity boss)
+        {
+            final LivingEntity target = getTarget(boss);
+            if (target == null) return;
+            
+            strikeLightning(arena, (Player) target, new LinkedList<Player>());
+        }
+        
+        private void strikeLightning(final Arena arena, final Player p, final List<Player> done)
+        {
+            Bukkit.getServer().getScheduler().scheduleSyncDelayedTask(arena.getPlugin(),
+                new Runnable()
+                {
+                    public void run()
+                    {
+                        if (!arena.getLivingPlayers().contains(p))
+                            return;
+                        
+                        // Smite the target
+                        arena.getWorld().strikeLightning(p.getLocation());
+                        done.add(p);
+                        
+                        // Grab all nearby players
+                        List<Player> nearby = getNearbyPlayers(arena, p, 4);
+                        
+                        // Remove all that are "done", and return if empty
+                        nearby.removeAll(done);
+                        if (nearby.isEmpty()) return;
+                        
+                        // Otherwise, smite the next target!
+                        strikeLightning(arena, nearby.get(0), done);
+                    }
+                }, 8);
+        }
+    },
+    WARPTOPLAYER("Warp")
+    {
+        public void run(Arena arena, LivingEntity boss)
+        {
+            List<Player> list = arena.getLivingPlayers();
+            boss.teleport(list.get((new Random()).nextInt(list.size())));
+        }
+    },
+    THROWTARGET("Throw Target")
+    {
+        public void run(Arena arena, LivingEntity boss)
+        {
+            LivingEntity target = getTarget(boss);
+            if (target == null) return;
+            
+            Location bLoc       = boss.getLocation();
+            Location loc        = target.getLocation();
+            Vector v            = new Vector(loc.getX() - bLoc.getX(), 0, loc.getZ() - bLoc.getZ());
+            target.setVelocity(v.normalize().setY(0.8));
+        }
+    },
+    THROWNEARBY("Throw Nearby Players")
+    {
+        public void run(Arena arena, LivingEntity boss)
+        {
+            for (Player p : getNearbyPlayers(arena, boss, 5))
+            {
+                Location bLoc = boss.getLocation();
+                Location loc  = p.getLocation();
+                Vector v      = new Vector(loc.getX() - bLoc.getX(), 0, loc.getZ() - bLoc.getZ());
+                p.setVelocity(v.normalize().setY(0.8));
+            }
+        }
+    },
+    THROWDISTANT("Throw Distant Players")
+    {
+        public void run(Arena arena, LivingEntity boss)
+        {
+            for (Player p : getDistantPlayers(arena, boss, 8))
+            {
+                Location bLoc = boss.getLocation();
+                Location loc  = p.getLocation();
+                Vector v      = new Vector(loc.getX() - bLoc.getX(), 0, loc.getZ() - bLoc.getZ());
+                p.setVelocity(v.normalize().setY(0.8));
+            }
+        }
+    },
+    FETCHTARGET("Fetch Target")
+    {
+        public void run(Arena arena, LivingEntity boss)
+        {
+            LivingEntity target = getTarget(boss);
+            if (target != null) target.teleport(boss);
+        }
+    },
+    FETCHNEARBY("Fetch Nearby Players")
+    {
+        public void run(Arena arena, LivingEntity boss)
+        {
+            for (Player p : getNearbyPlayers(arena, boss, 5))
+                p.teleport(boss);
+        }
+    },
+    FETCHDISTANT("Fetch Distant Players")
+    {
+        public void run(Arena arena, LivingEntity boss)
+        {
+            for (Player p : getDistantPlayers(arena, boss, 8))
+                p.teleport(boss);
+        }
+    };
+    
+    private String name;
+    
+    private BossAbility(String name)
+    {
+        this.name = name;
+    }
+    
+    /**
+     * The run-method that all boss abilities must define.
+     * The method is called in the ability cycle for the given boss.
+     * @param arena The Arena the boss is in
+     * @param boss The boss entity
+     */
+    public abstract void run(Arena arena, LivingEntity boss);
+    
+    /**
+     * Get the target player of the LivingEntity if possible.
+     * @param entity The entity whose target to get
+     * @return The target player, or null
+     */
+    protected LivingEntity getTarget(LivingEntity entity)
+    {
+        if (entity instanceof Creature)
+        {
+            LivingEntity target = null;
+            try
+            {
+                target = ((Creature) entity).getTarget();
+            }
+            catch (Exception e) {}
+            
+            if (target instanceof Player)
+                return target;
+        }
+        return null;
+    }
+    
+    /**
+     * Get a list of nearby players
+     * @param arena The arena
+     * @param boss The boss
+     * @param x The 'radius' in which to grab players
+     * @return A list of nearby players
+     */
+    protected List<Player> getNearbyPlayers(Arena arena, Entity boss, int x)
+    {
+        List<Player> result = new LinkedList<Player>();
+        for (Entity e : boss.getNearbyEntities(x, x, x))
+            if (arena.getLivingPlayers().contains(e))
+                result.add((Player) e);
+        return result;
+    }
+    
+    /**
+     * Get a list of distant players
+     * @param arena The arena
+     * @param boss The boss
+     * @param x The 'radius' in which to exclude players 
+     * @return A list of distant players
+     */
+    protected List<Player> getDistantPlayers(Arena arena, Entity boss, int x)
+    {
+        List<Player> result = new LinkedList<Player>();
+        for (Player p : arena.getLivingPlayers())
+            if (p.getLocation().distanceSquared(boss.getLocation()) > x*x)
+                result.add(p);
+        return result;
+    }
+    
+    public static BossAbility fromString(String string)
+    {
+        return WaveUtils.getEnumFromString(BossAbility.class, string);
+    }
+    
+    public String toString()
+    {
+        return name;
+    }
+}

src/com/garbagemule/MobArena/waves/DefaultWave.java

@@ -9,8 +9,8 @@ import org.bukkit.Location;
 import org.bukkit.util.config.Configuration;
 
 import com.garbagemule.MobArena.Arena;
-import com.garbagemule.MobArena.MAMessages.Msg;
 import com.garbagemule.MobArena.MAUtils;
+import com.garbagemule.MobArena.MAMessages.Msg;
 import com.garbagemule.MobArena.util.WaveUtils;
 
 public class DefaultWave extends NormalWave

src/com/garbagemule/MobArena/waves/MACreature.java

@@ -9,6 +9,7 @@ import org.bukkit.entity.Slime;
 import org.bukkit.entity.Wolf;
 
 import com.garbagemule.MobArena.Arena;
+import com.garbagemule.MobArena.MobArena;
 import com.garbagemule.MobArena.util.WaveUtils;
 
 public enum MACreature
@@ -25,7 +26,6 @@ public enum MACreature
     POWERED_CREEPER(CreatureType.CREEPER),  POWERED_CREEPERS(CreatureType.CREEPER),
     ANGRY_WOLF(CreatureType.WOLF),          ANGRY_WOLVES(CreatureType.WOLF),
     HUMAN(CreatureType.MONSTER),            HUMANS(CreatureType.MONSTER),
-    SLIME(CreatureType.SLIME),              SLIMES(CreatureType.SLIME),
     GIANT(CreatureType.GIANT),              GIANTS(CreatureType.GIANT),
     GHAST(CreatureType.GHAST),              GHASTS(CreatureType.GHAST),
     
@@ -33,7 +33,18 @@ public enum MACreature
     CHICKEN(CreatureType.CHICKEN),          CHICKENS(CreatureType.CHICKEN),
     COW(CreatureType.COW),                  COWS(CreatureType.COW),
     PIG(CreatureType.PIG),                  PIGS(CreatureType.PIG),
-    SHEEP(CreatureType.SHEEP),              EXPLODING_SHEEP(CreatureType.SHEEP);
+    SHEEP(CreatureType.SHEEP),
+    SQUID(CreatureType.SQUID),              SQUIDS(CreatureType.SQUID),
+    
+    // Extended creatures
+    EXPLODING_SHEEP(CreatureType.SHEEP),
+    
+    // Slimes
+    SLIME(CreatureType.SLIME),              SLIMES(CreatureType.SLIME),
+    SLIME_TINY(CreatureType.SLIME),         SLIMES_TINY(CreatureType.SLIME),
+    SLIME_SMALL(CreatureType.SLIME),        SLIMES_SMALL(CreatureType.SLIME),
+    SLIME_BIG(CreatureType.SLIME),          SLIMES_BIG(CreatureType.SLIME),
+    SLIME_HUGE(CreatureType.SLIME),         SLIMES_HUGE(CreatureType.SLIME);
     
     private CreatureType type;
     
@@ -68,30 +79,25 @@ public enum MACreature
             case ANGRY_WOLVES:
                 ((Wolf) e).setAngry(true);
                 break;
+            case SLIME:
             case SLIMES:
+                ((Slime) e).setSize( (1 + MobArena.random.nextInt(3)) );
+                break;
+            case SLIME_TINY:
+            case SLIMES_TINY:
+                ((Slime) e).setSize(1);
+                break;
+            case SLIME_SMALL:
+            case SLIMES_SMALL:
                 ((Slime) e).setSize(2);
                 break;
-            default:
+            case SLIME_BIG:
+            case SLIMES_BIG:
+                ((Slime) e).setSize(3);
                 break;
-        }
+            case SLIME_HUGE:
-        
+            case SLIMES_HUGE:
-        return e;
+                ((Slime) e).setSize(4);
-    }
-    
-    public static LivingEntity spawn(MACreature creature, World world, Location loc)
-    {
-        LivingEntity e = world.spawnCreature(loc, creature.type);
-        
-        switch (creature)
-        {
-            case POWERED_CREEPERS:
-                ((Creeper) e).setPowered(true);
-                break;
-            case ANGRY_WOLVES:
-                ((Wolf) e).setAngry(true);
-                break;
-            case SLIMES:
-                ((Slime) e).setSize(2);
                 break;
             default:
                 break;

src/com/garbagemule/MobArena/waves/Wave.java

@@ -1,18 +1,5 @@
 package com.garbagemule.MobArena.waves;
 
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Random;
-
-import org.bukkit.Bukkit;
-import org.bukkit.Location;
-import org.bukkit.entity.Creature;
-import org.bukkit.entity.Entity;
-import org.bukkit.entity.Fireball;
-import org.bukkit.entity.LivingEntity;
-import org.bukkit.entity.Player;
-import org.bukkit.util.Vector;
-
 import com.garbagemule.MobArena.Arena;
 import com.garbagemule.MobArena.util.WaveUtils;
 
@@ -60,245 +47,9 @@ public interface Wave
         }
     }
 
-    public enum BossAbility
-    {
-        ARROWS("Arrow")
-        {
-            public void run(Arena arena, LivingEntity boss)
-            {
-                boss.shootArrow();
-            }
-        },
-        FIREBALLS("Fireball")
-        {
-            public void run(Arena arena, LivingEntity boss)
-            {
-                Location bLoc = boss.getLocation();
-                Location loc = bLoc.add(bLoc.getDirection().normalize().multiply(2).toLocation(boss.getWorld(), bLoc.getYaw(), bLoc.getPitch()));
-                Fireball fireball = boss.getWorld().spawn(loc, Fireball.class);
-                fireball.setIsIncendiary(false);
-            }
-        },
-        FIREAURA("Fire aura")
-        {
-            public void run(Arena arena, LivingEntity boss)
-            {
-                for (Player p : getNearbyPlayers(arena, boss, 5))
-                        p.setFireTicks(20);
-            }
-        },
-        LIGHTNINGAURA("Lightning aura")
-        {
-            public void run(Arena arena, LivingEntity boss)
-            {
-                Location base = boss.getLocation();
-                Location ne = base.getBlock().getRelative( 2,  0,  2).getLocation();
-                Location nw = base.getBlock().getRelative(-2,  0,  2).getLocation();
-                Location se = base.getBlock().getRelative( 2,  0, -2).getLocation();
-                Location sw = base.getBlock().getRelative(-2,  0, -2).getLocation();
-
-                arena.getWorld().strikeLightning(ne);
-                arena.getWorld().strikeLightning(nw);
-                arena.getWorld().strikeLightning(se);
-                arena.getWorld().strikeLightning(sw);
-            }
-        },
-        DISORIENTTARGET("Disorient target")
-        {
-            public void run(Arena arena, LivingEntity boss)
-            {
-                LivingEntity target = getTarget(boss);
-                if (target == null) return;
-
-                Location loc = target.getLocation();
-                loc.setYaw(target.getLocation().getYaw() + 45 + (new Random()).nextInt(270));
-                target.teleport(loc);
-            }
-        },
-        ROOTTARGET("Root target")
-        {
-            public void run(final Arena arena, LivingEntity boss)
-            {
-                final LivingEntity target = getTarget(boss);
-                if (target == null) return;
-                
-                final Location loc = target.getLocation();
-                final int freezeTaskId = Bukkit.getServer().getScheduler().scheduleSyncRepeatingTask(arena.getPlugin(),
-                    new Runnable()
-                    {
-                        public void run()
-                        {
-                            if (arena.getLivingPlayers().contains(target))
-                                    target.teleport(loc);
-                        }
-                    }, 3, 3);
-                
-                Bukkit.getServer().getScheduler().scheduleSyncDelayedTask(arena.getPlugin(),
-                    new Runnable()
-                    {
-                        public void run()
-                        {
-                            Bukkit.getServer().getScheduler().cancelTask(freezeTaskId);
-                        }
-                    }, 45);
-            }
-        },
-        WARPTOPLAYER("Warp to player")
-        {
-            public void run(Arena arena, LivingEntity boss)
-            {
-                List<Player> list = arena.getLivingPlayers();
-                boss.teleport(list.get((new Random()).nextInt(list.size())));
-            }
-        },
-        THROWTARGET("Throw target")
-        {
-            public void run(Arena arena, LivingEntity boss)
-            {
-                System.out.println("Throw target");
-                LivingEntity target = getTarget(boss);
-                if (target == null) return;
-                
-                Location bLoc       = boss.getLocation();
-                Location loc        = target.getLocation();
-                Vector v            = new Vector(loc.getX() - bLoc.getX(), 0, loc.getZ() - bLoc.getZ());
-                target.setVelocity(v.normalize().setY(0.8));
-            }
-        },
-        THROWNEARBY("Throw nearby players")
-        {
-            public void run(Arena arena, LivingEntity boss)
-            {
-                for (Player p : getNearbyPlayers(arena, boss, 5))
-                {
-                    Location bLoc = boss.getLocation();
-                    Location loc  = p.getLocation();
-                    Vector v      = new Vector(loc.getX() - bLoc.getX(), 0, loc.getZ() - bLoc.getZ());
-                    p.setVelocity(v.normalize().setY(0.8));
-                }
-            }
-        },
-        THROWDISTANT("Throw distant players")
-        {
-            public void run(Arena arena, LivingEntity boss)
-            {
-                for (Player p : getDistantPlayers(arena, boss, 8))
-                {
-                    Location bLoc = boss.getLocation();
-                    Location loc  = p.getLocation();
-                    Vector v      = new Vector(loc.getX() - bLoc.getX(), 0, loc.getZ() - bLoc.getZ());
-                    p.setVelocity(v.normalize().setY(0.8));
-                }
-            }
-        },
-        FETCHTARGET("Fetch target")
-        {
-            public void run(Arena arena, LivingEntity boss)
-            {
-                LivingEntity target = getTarget(boss);
-                if (target != null) target.teleport(boss);
-            }
-        },
-        FETCHNEARBY("Fetch nearby players")
-        {
-            public void run(Arena arena, LivingEntity boss)
-            {
-                for (Player p : getNearbyPlayers(arena, boss, 5))
-                    p.teleport(boss);
-            }
-        },
-        FETCHDISTANT("Fetch distant players")
-        {
-            public void run(Arena arena, LivingEntity boss)
-            {
-                for (Player p : getDistantPlayers(arena, boss, 8))
-                    p.teleport(boss);
-            }
-        };
-        
-        private String name;
-        
-        private BossAbility(String name)
-        {
-            this.name = name;
-        }
-        
-        /**
-         * The run-method that all boss abilities must define.
-         * The method is called in the ability cycle for the given boss.
-         * @param arena The Arena the boss is in
-         * @param boss The boss entity
-         */
-        public abstract void run(Arena arena, LivingEntity boss);
-        
-        /**
-         * Get the target player of the LivingEntity if possible.
-         * @param entity The entity whose target to get
-         * @return The target player, or null
-         */
-        protected LivingEntity getTarget(LivingEntity entity)
-        {
-            if (entity instanceof Creature)
-            {
-                LivingEntity target = null;
-                try
-                {
-                    target = ((Creature) entity).getTarget();
-                }
-                catch (Exception e) {}
-                
-                if (target instanceof Player)
-                    return target;
-            }
-            return null;
-        }
-        
-        /**
-         * Get a list of nearby players
-         * @param arena The arena
-         * @param boss The boss
-         * @param x The 'radius' in which to grab players
-         * @return A list of nearby players
-         */
-        protected List<Player> getNearbyPlayers(Arena arena, Entity boss, int x)
-        {
-            List<Player> result = new LinkedList<Player>();
-            for (Entity e : boss.getNearbyEntities(x, x, x))
-                if (arena.getLivingPlayers().contains(e))
-                    result.add((Player) e);
-            return result;
-        }
-        
-        /**
-         * Get a list of distant players
-         * @param arena The arena
-         * @param boss The boss
-         * @param x The 'radius' in which to exclude players 
-         * @return A list of distant players
-         */
-        protected List<Player> getDistantPlayers(Arena arena, Entity boss, int x)
-        {
-            List<Player> result = new LinkedList<Player>();
-            for (Player p : arena.getLivingPlayers())
-                if (p.getLocation().distanceSquared(boss.getLocation()) > x*x)
-                    result.add(p);
-            return result;
-        }
-        
-        public static BossAbility fromString(String string)
-        {
-            return WaveUtils.getEnumFromString(BossAbility.class, string);
-        }
-        
-        public String toString()
-        {
-            return name;
-        }
-    }
-    
     public enum BossHealth
     {
-        LOW(5), MEDIUM(9), HIGH(14), PSYCHO(25);
+        LOW(8), MEDIUM(15), HIGH(25), PSYCHO(40);
         private int multiplier;
         
         private BossHealth(int multiplier)