Merge branch 'master' of ssh://184.154.0.242:7999/min/Mineplex

Plugins/Mineplex.Core/src/mineplex/core/CustomTagFix.java

@@ -212,6 +212,11 @@ public class CustomTagFix extends MiniPlugin implements IPacketHandler, NCPHook
 				// Ignore Armor stand packets
 				if (spawnPacket.b == 30 || spawnPacket.l == null || spawnPacket.l.c() == null || spawnPacket.a == 777777)
 				{
+					if (spawnPacket.b == 30)
+					{
+				        _ignoreSkulls.add(spawnPacket.a);
+					}
+
 					return;
 				}
 				

Plugins/Mineplex.Core/src/mineplex/core/gadget/types/MorphGadget.java

@@ -2,6 +2,8 @@ package mineplex.core.gadget.types;
 
 import org.bukkit.Material;
 import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.entity.PlayerDeathEvent;
 
 import mineplex.core.common.util.F;
 import mineplex.core.common.util.UtilPlayer;
@@ -29,4 +31,10 @@ public abstract class MorphGadget extends Gadget
 		if (_active.remove(player))
 			UtilPlayer.message(player, F.main("Gadget", "You unmorphed from " + F.elem(GetName()) + "."));
 	}
+	
+	@EventHandler
+	public void playerDeath(PlayerDeathEvent event)
+	{
+		Disable(event.getEntity());
+	}
 }

Plugins/Nautilus.Game.Arcade/src/nautilus/game/arcade/game/Game.java

@@ -155,10 +155,12 @@ public abstract class Game implements Listener
 	public boolean DamageTeamOther = true;
 
 	public boolean BlockBreak = false;
+	public boolean BlockBreakCreative = false;
 	public HashSet<Integer> BlockBreakAllow = new HashSet<Integer>();
 	public HashSet<Integer> BlockBreakDeny = new HashSet<Integer>();
 
 	public boolean BlockPlace = false;
+	public boolean BlockPlaceCreative = false;
 	public HashSet<Integer> BlockPlaceAllow = new HashSet<Integer>();
 	public HashSet<Integer> BlockPlaceDeny = new HashSet<Integer>();
 

Plugins/Nautilus.Game.Arcade/src/nautilus/game/arcade/game/games/event/EventGame.java

@@ -1,20 +1,39 @@
 package nautilus.game.arcade.game.games.event;
 
 import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
 
+import org.bukkit.Bukkit;
 import org.bukkit.Effect;
 import org.bukkit.GameMode;
+import org.bukkit.Material;
+import org.bukkit.OfflinePlayer;
 import org.bukkit.Sound;
+import org.bukkit.World;
 import org.bukkit.block.BlockFace;
+import org.bukkit.craftbukkit.v1_7_R4.entity.CraftLivingEntity;
 import org.bukkit.craftbukkit.v1_7_R4.entity.CraftPlayer;
+import org.bukkit.entity.Ageable;
 import org.bukkit.entity.Entity;
+import org.bukkit.entity.EntityType;
 import org.bukkit.entity.Player;
+import org.bukkit.entity.Skeleton;
+import org.bukkit.entity.Slime;
+import org.bukkit.entity.Villager;
+import org.bukkit.entity.Wolf;
+import org.bukkit.entity.Zombie;
+import org.bukkit.entity.Skeleton.SkeletonType;
+import org.bukkit.entity.Villager.Profession;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
+import org.bukkit.event.entity.EntityExplodeEvent;
 import org.bukkit.event.player.PlayerCommandPreprocessEvent;
 import org.bukkit.event.player.PlayerJoinEvent;
 import org.bukkit.event.player.PlayerToggleFlightEvent;
+import org.bukkit.inventory.ItemStack;
 
+import mineplex.core.command.CommandCenter;
 import mineplex.core.common.Rank;
 import mineplex.core.common.util.C;
 import mineplex.core.common.util.F;
@@ -23,6 +42,7 @@ import mineplex.core.common.util.UtilAction;
 import mineplex.core.common.util.UtilAlg;
 import mineplex.core.common.util.UtilBlock;
 import mineplex.core.common.util.UtilEnt;
+import mineplex.core.common.util.UtilInv;
 import mineplex.core.common.util.UtilMath;
 import mineplex.core.common.util.UtilPlayer;
 import mineplex.core.common.util.UtilServer;
@@ -32,10 +52,12 @@ import mineplex.core.disguise.disguises.DisguiseChicken;
 import mineplex.core.disguise.disguises.DisguiseEnderman;
 import mineplex.core.disguise.disguises.DisguiseWither;
 import mineplex.core.gadget.event.GadgetActivateEvent;
+import mineplex.core.itemstack.ItemStackFactory;
 import mineplex.core.mount.event.MountActivateEvent;
 import mineplex.core.recharge.Recharge;
 import mineplex.core.updater.UpdateType;
 import mineplex.core.updater.event.UpdateEvent;
+import nautilus.game.arcade.events.GameStateChangeEvent;
 import nautilus.game.arcade.game.GameTeam.PlayerState;
 import nautilus.game.arcade.game.games.event.kits.*;
 import nautilus.game.arcade.ArcadeManager;
@@ -56,6 +78,8 @@ public class EventGame extends SoloGame
 	private boolean _gadgetsEnabled = true;
 	private NautHashMap<String, Integer> _radius = new NautHashMap<String, Integer>();
 
+	private NautHashMap<Material, Integer> _kitItems = new NautHashMap<Material, Integer>();
+
 	public EventGame(ArcadeManager manager) 
 	{
 		super(manager, GameType.Event,
@@ -84,6 +108,9 @@ public class EventGame extends SoloGame
 
 		this.PrepareFreeze = false;
 
+		this.BlockPlaceCreative = true;
+		this.BlockBreakCreative = true;
+
 		//Dont timeout
 		this.GameTimeout = -1;
 
@@ -98,23 +125,23 @@ public class EventGame extends SoloGame
 			joinTeam(event.getPlayer());
 	}
 
-//	@EventHandler
+	//	@EventHandler
-//	public void specToTeam(UpdateEvent event)
+	//	public void specToTeam(UpdateEvent event)
-//	{
+	//	{
-//		if (!InProgress())
+	//		if (!InProgress())
-//			return;
+	//			return;
-//
+	//
-//		if (event.getType() != UpdateType.FAST)
+	//		if (event.getType() != UpdateType.FAST)
-//			return;
+	//			return;
-//
+	//
-//		for (Player player : UtilServer.getPlayers())
+	//		for (Player player : UtilServer.getPlayers())
-//		{
+	//		{
-//			if (!GetTeamList().get(0).HasPlayer(player))
+	//			if (!GetTeamList().get(0).HasPlayer(player))
-//			{
+	//			{
-//				joinTeam(player);
+	//				joinTeam(player);
-//			}
+	//			}
-//		}
+	//		}
-//	}
+	//	}
 
 	public void joinTeam(Player player)
 	{
@@ -158,6 +185,25 @@ public class EventGame extends SoloGame
 		UtilPlayer.message(player, F.value("/e scoreboard <Line #> [Text]", "Sets Scoreboard Text"));
 	}
 
+	private void commandHelpSettings(Player player) 
+	{
+		UtilPlayer.message(player, F.main("Event", "Displaying Settings Commands;"));
+		UtilPlayer.message(player, F.value("/e damage all", "Toggles All Damage"));
+		UtilPlayer.message(player, F.value("/e damage pvp", "Toggles PvP Damage"));
+		UtilPlayer.message(player, F.value("/e damage pve", "Toggles PvE Damage"));
+		UtilPlayer.message(player, F.value("/e damage pve", "Toggles EvP Damage"));
+		UtilPlayer.message(player, F.value("/e health <-1 to 20>", "Locks Players Health"));
+		UtilPlayer.message(player, F.value("/e hunger <-1 to 20>", "Locks Players Hunger"));
+		UtilPlayer.message(player, F.value("/e item drop", "Toggles Item Drop"));
+		UtilPlayer.message(player, F.value("/e item pickup", "Toggles Item Pickup"));
+		UtilPlayer.message(player, F.value("/e blockplace", "Toggles Block Placing (On/Off)"));
+		UtilPlayer.message(player, F.value("/e blockplace whitelist <id>", "Whitelists Block Place"));
+		UtilPlayer.message(player, F.value("/e blockplace blacklist <id>", "Whitelists Block Place"));
+		UtilPlayer.message(player, F.value("/e blockbreak", "Toggles Block Breaking (On/Off)"));
+		UtilPlayer.message(player, F.value("/e blockbreak whitelist <id>", "Whitelists Block Break"));
+		UtilPlayer.message(player, F.value("/e blockbreak blacklist <id>", "Blacklists Block Break"));
+	}
+
 	//Command Handler
 	@EventHandler(priority = EventPriority.LOWEST)
 	public void commandHandler(PlayerCommandPreprocessEvent event)
@@ -176,10 +222,16 @@ public class EventGame extends SoloGame
 		//Trim off /e and split to args
 		String[] args = event.getMessage().substring(3, event.getMessage().length()).split(" ");
 
-		if (args.length == 0)
+		if (args.length == 0 || args[0].equalsIgnoreCase("help"))
 		{
 			commandHelp(event.getPlayer());
 		}
+		else if (args[0].equalsIgnoreCase("settings"))
+		{
+			commandHelpSettings(event.getPlayer());
+		}
+
+		//XXX Commands
 		else if (args[0].equalsIgnoreCase("tp"))
 		{
 			commandTeleport(event.getPlayer(), args);
@@ -208,6 +260,221 @@ public class EventGame extends SoloGame
 		{
 			commandScoreboard(event.getPlayer(), args);
 		}
+		else if (args[0].equalsIgnoreCase("whitelist"))
+		{
+			commandWhitelist(event.getPlayer(), args);
+		}
+
+
+		//XXX Settings
+		else if (event.getMessage().toLowerCase().equals("/e damage all"))
+		{
+			Damage = !Damage;
+			Announce(F.main("Event Settings", F.value("Damage All", F.tf(Damage))));
+		}
+		else if (event.getMessage().toLowerCase().equals("/e damage pvp"))
+		{
+			DamagePvP = !DamagePvP;
+			Announce(F.main("Event Settings", F.value("Damage PvP", F.tf(DamagePvP))));
+		}
+		else if (event.getMessage().toLowerCase().equals("/e damage pve"))
+		{
+			DamagePvE = !DamagePvE;
+			Announce(F.main("Event Settings", F.value("Damage PvE", F.tf(DamagePvE))));
+		}
+		else if (event.getMessage().toLowerCase().equals("/e damage evp"))
+		{
+			DamageEvP = !DamageEvP;
+			Announce(F.main("Event Settings", F.value("Damage EvP", F.tf(DamageEvP))));
+		}
+		else if (args[0].equalsIgnoreCase("health"))
+		{
+			commandHealth(event.getPlayer(), args);
+		}
+		else if (args[0].equalsIgnoreCase("hunger"))
+		{
+			commandHunger(event.getPlayer(), args);
+		}
+		else if (event.getMessage().toLowerCase().equals("/e item drop"))
+		{
+			ItemDrop = !ItemDrop;
+			Announce(F.main("Event Settings", F.value("Item Drop", F.tf(ItemDrop))));
+		}
+		else if (event.getMessage().toLowerCase().equals("/e item pickup"))
+		{
+			ItemPickup = !ItemPickup;
+			Announce(F.main("Event Settings", F.value("Item Pickup", F.tf(ItemPickup))));
+		}
+		else if (event.getMessage().toLowerCase().equals("/e blockplace"))
+		{
+			BlockPlace = !BlockPlace;
+			Announce(F.main("Event Settings", F.value("Block Place", F.tf(BlockPlace))));
+		}
+		else if (args.length >= 4 && args[0].equalsIgnoreCase("blockplace") 
+				&& (args[1].equalsIgnoreCase("whitelist") || args[1].equalsIgnoreCase("blacklist"))
+				&& (args[2].equalsIgnoreCase("add") || args[2].equalsIgnoreCase("remove")))
+		{
+			commandBlockPlace(event.getPlayer(), args, args[1].equalsIgnoreCase("whitelist"), args[2].equalsIgnoreCase("add"));
+		}
+		else if (event.getMessage().toLowerCase().equals("/e blockbreak"))
+		{
+			BlockBreak = !BlockBreak;
+			Announce(F.main("Event Settings", F.value("Block Break", F.tf(BlockBreak))));
+		}
+		else if (args.length >= 4 && args[0].equalsIgnoreCase("blockbreak") 
+				&& (args[1].equalsIgnoreCase("whitelist") || args[1].equalsIgnoreCase("blacklist"))
+				&& (args[2].equalsIgnoreCase("add") || args[2].equalsIgnoreCase("remove")))
+		{
+			commandBlockBreak(event.getPlayer(), args, args[1].equalsIgnoreCase("whitelist"), args[2].equalsIgnoreCase("add"));
+		}
+	}
+
+	private void commandBlockPlace(Player player, String[] args, boolean whitelist, boolean add)
+	{
+		try
+		{
+			int blockId = Integer.parseInt(args[3]);
+
+			if (whitelist)
+			{
+				if (add)
+				{
+					BlockPlaceAllow.add(blockId);
+					UtilPlayer.message(player, F.main("Event Settings", F.value("Block Place Whitelist", "Added " + blockId)));
+				}
+				else
+				{
+					BlockPlaceAllow.remove(blockId);
+					UtilPlayer.message(player, F.main("Event Settings", F.value("Block Place Whitelist", "Removed " + blockId)));
+				}
+			}
+			else
+			{
+				if (add)
+				{
+					BlockPlaceDeny.add(blockId);
+					UtilPlayer.message(player, F.main("Event Settings", F.value("Block Place Blacklist", "Added " + blockId)));
+				}
+				else
+				{
+					BlockPlaceDeny.remove(blockId);
+					UtilPlayer.message(player, F.main("Event Settings", F.value("Block Place Blacklist", "Removed " + blockId)));
+				}
+			}
+
+			return;
+		}
+		catch (Exception e)
+		{
+
+		}
+
+		commandHelpSettings(player);
+	}
+
+	private void commandBlockBreak(Player player, String[] args, boolean whitelist, boolean add)
+	{
+		try
+		{
+			int blockId = Integer.parseInt(args[3]);
+
+			if (whitelist)
+			{
+				if (add)
+				{
+					BlockBreakAllow.add(blockId);
+					UtilPlayer.message(player, F.main("Event Settings", F.value("Block Break Whitelist", "Added " + blockId)));
+				}
+				else
+				{
+					BlockBreakAllow.remove(blockId);
+					UtilPlayer.message(player, F.main("Event Settings", F.value("Block Break Whitelist", "Removed " + blockId)));
+				}
+			}
+			else
+			{
+				if (add)
+				{
+					BlockBreakDeny.add(blockId);
+					UtilPlayer.message(player, F.main("Event Settings", F.value("Block Break Blacklist", "Added " + blockId)));
+				}
+				else
+				{
+					BlockBreakDeny.remove(blockId);
+					UtilPlayer.message(player, F.main("Event Settings", F.value("Block Break Blacklist", "Removed " + blockId)));
+				}
+			}
+
+			return;
+		}
+		catch (Exception e)
+		{
+
+		}
+
+		commandHelpSettings(player);
+	}
+
+	private void commandHealth(Player player, String[] args) 
+	{
+		try
+		{
+			if (args.length >= 2)
+			{
+				int health = Integer.parseInt(args[1]);
+
+				if (health <= 0)
+					health = -1;
+				if (health > 20)
+					health = 20;
+
+				HealthSet = health;
+
+				if (HealthSet == -1)
+					Announce(F.main("Event Settings", F.value("Health Set", "Disabled")));
+				else
+					Announce(F.main("Event Settings", F.value("Health Set", HealthSet + "")));
+
+				return;
+			}
+		}
+		catch (Exception e)
+		{
+
+		}
+
+		commandHelpSettings(player);
+	}
+
+	private void commandHunger(Player player, String[] args) 
+	{
+		try
+		{
+			if (args.length >= 2)
+			{
+				int hunger = Integer.parseInt(args[1]);
+
+				if (hunger <= 0)
+					hunger = -1;
+				if (hunger > 20)
+					hunger = 20;
+
+				HungerSet = hunger;
+
+				if (HungerSet == -1)
+					Announce(F.main("Event Settings", F.value("Hunger Set", "Disabled")));
+				else
+					Announce(F.main("Event Settings", F.value("Hunger Set", HungerSet + "")));
+
+				return;
+			}
+		}
+		catch (Exception e)
+		{
+
+		}
+
+		commandHelpSettings(player);
 	}
 
 	//Teleport Command (To, Here, All)
@@ -359,13 +626,6 @@ public class EventGame extends SoloGame
 
 	}
 
-	//Game Settings - PvP, Blocks, etc
-	@EventHandler
-	public void commandSetting(Player player, String[] args)
-	{
-
-	}
-
 	//Double Jump
 	@EventHandler
 	public void commandDoubleJump(Player player, String[] args)
@@ -448,6 +708,255 @@ public class EventGame extends SoloGame
 		}
 	}
 
+	@EventHandler
+	public void commandWhitelist(Player player, String[] args)
+	{
+		//On and Off
+		if (args.length >= 2)
+		{
+			if (args[1].equalsIgnoreCase("on") || args[1].equalsIgnoreCase("of"))
+			{
+				UtilServer.getServer().setWhitelist(args[1].equalsIgnoreCase("on"));
+				return;
+			}
+		}
+
+		//Add and Remove
+		if (args.length >= 3)
+		{
+			if (args[1].equalsIgnoreCase("add") || args[1].equalsIgnoreCase("remove"))
+			{
+				OfflinePlayer target = Bukkit.getOfflinePlayer(args[2]);
+
+				if (args[1].equalsIgnoreCase("add"))
+					UtilServer.getServer().getWhitelistedPlayers().add(target);
+				else
+					UtilServer.getServer().getWhitelistedPlayers().remove(target);
+
+				return;
+			}
+		}
+
+		commandHelp(player);
+	}
+
+	@EventHandler
+	protected void commandMob(Player caller, String[] args)
+	{
+		if (args.length == 1)
+		{
+			HashMap<EntityType, Integer> entMap = new HashMap<EntityType, Integer>();
+
+			int count = 0;
+			for (World world : UtilServer.getServer().getWorlds())
+			{
+				for (Entity ent : world.getEntities())
+				{
+					if (!entMap.containsKey(ent.getType()))
+						entMap.put(ent.getType(), 0);
+
+					entMap.put(ent.getType(), 1 + entMap.get(ent.getType()));
+					count++;
+				}
+			}
+
+			UtilPlayer.message(caller, F.main("Creature", "Listing Entities:"));
+			for (EntityType cur : entMap.keySet())
+			{
+				UtilPlayer.message(caller, F.desc(UtilEnt.getName(cur), entMap.get(cur)+""));
+			}
+
+			UtilPlayer.message(caller, F.desc("Total", count+""));
+		}
+		else
+		{
+			EntityType type = UtilEnt.searchEntity(caller, args[1], true);
+
+			if (type == null)
+				return;
+
+			UtilPlayer.message(caller, F.main("Creature", "Spawning Creature(s);"));
+
+			//Store Args
+			HashSet<String> argSet = new HashSet<String>();
+			for (int i = 2 ; i < args.length ; i++)
+				if (args[i].length() > 0)
+					argSet.add(args[i]);
+
+
+			//Search Count
+			int count = 1;
+			HashSet<String> argHandle = new HashSet<String>();
+			for (String arg : argSet)
+			{
+				try
+				{
+					int newCount = Integer.parseInt(arg);
+
+					if (newCount <= 0)
+						continue;
+
+					//Set Count
+					count = newCount;
+					UtilPlayer.message(caller, F.desc("Amount", count+""));
+
+					//Flag Arg
+					argHandle.add(arg);
+					break;
+				}
+				catch (Exception e)
+				{
+					//None
+				}
+			}
+			for (String arg : argHandle)
+				argSet.remove(arg);
+
+			//Spawn
+			HashSet<Entity> entSet = new HashSet<Entity>();
+			for (int i = 0 ; i < count ; i++)
+			{
+				CreatureAllowOverride = true;
+				entSet.add(Manager.GetCreature().SpawnEntity(caller.getTargetBlock(null, 0).getLocation().add(0.5, 1, 0.5), type));
+				CreatureAllowOverride = false;
+			}
+
+			//Search Vars
+			for (String arg : argSet)
+			{
+				if (arg.length() == 0)
+					continue;
+
+				//Baby
+				else if (arg.equalsIgnoreCase("baby") || arg.equalsIgnoreCase("b"))
+				{
+					for (Entity ent : entSet)
+					{
+						if (ent instanceof Ageable)
+							((Ageable)ent).setBaby();
+						else if (ent instanceof Zombie)
+							((Zombie)ent).setBaby(true);
+					}
+
+					UtilPlayer.message(caller, F.desc("Baby", "True"));
+					argHandle.add(arg);
+				}
+
+				//Lock
+				else if (arg.equalsIgnoreCase("age") || arg.equalsIgnoreCase("lock"))
+				{
+					for (Entity ent : entSet)
+						if (ent instanceof Ageable)
+						{
+							((Ageable)ent).setAgeLock(true);
+							UtilPlayer.message(caller, F.desc("Age", "False"));
+						}					
+
+					argHandle.add(arg);
+				}
+
+				//Angry
+				else if (arg.equalsIgnoreCase("angry") || arg.equalsIgnoreCase("a"))
+				{
+					for (Entity ent : entSet)
+						if (ent instanceof Wolf)
+							((Wolf)ent).setAngry(true);
+
+					for (Entity ent : entSet)
+						if (ent instanceof Skeleton)
+							((Skeleton)ent).setSkeletonType(SkeletonType.WITHER);
+
+					UtilPlayer.message(caller, F.desc("Angry", "True"));
+					argHandle.add(arg);
+				}
+
+				//Profession
+				else if (arg.toLowerCase().charAt(0) == 'p')
+				{
+					try
+					{
+						String prof = arg.substring(1, arg.length());
+
+						Profession profession = null;
+						for (Profession cur : Profession.values())
+							if (cur.name().toLowerCase().contains(prof.toLowerCase()))
+								profession = cur;
+
+						UtilPlayer.message(caller, F.desc("Profession", profession.name()));
+
+						for (Entity ent : entSet)
+							if (ent instanceof Villager)
+								((Villager)ent).setProfession(profession);			
+					}
+					catch (Exception e)
+					{
+						UtilPlayer.message(caller, F.desc("Profession", "Invalid [" + arg + "] on " + type.name()));
+					}
+					argHandle.add(arg);
+				}
+
+				//Size
+				else if (arg.toLowerCase().charAt(0) == 's')
+				{
+					try
+					{
+						String size = arg.substring(1, arg.length());
+
+						UtilPlayer.message(caller, F.desc("Size", Integer.parseInt(size)+""));
+
+						for (Entity ent : entSet)
+							if (ent instanceof Slime)
+								((Slime)ent).setSize(Integer.parseInt(size));
+					}
+					catch (Exception e)
+					{
+						UtilPlayer.message(caller, F.desc("Size", "Invalid [" + arg + "] on " + type.name()));
+					}
+					argHandle.add(arg);
+				}
+
+				else if (arg.toLowerCase().charAt(0) == 'n' && arg.length() > 1)
+				{
+					try
+					{
+						String name = "";
+
+						for (char c : arg.substring(1, arg.length()).toCharArray())
+						{
+							if (c != '_')
+								name += c;
+							else
+								name += " ";
+						}
+
+						for (Entity ent : entSet)
+						{
+							if (ent instanceof CraftLivingEntity)
+							{
+								CraftLivingEntity cEnt = (CraftLivingEntity)ent;
+								cEnt.setCustomName(name); 
+								cEnt.setCustomNameVisible(true);
+							}
+						}
+					}
+					catch (Exception e)
+					{
+						UtilPlayer.message(caller, F.desc("Size", "Invalid [" + arg + "] on " + type.name()));
+					}
+					argHandle.add(arg);	
+				}
+			}
+			for (String arg : argHandle)
+				argSet.remove(arg);
+
+			for (String arg : argSet)
+				UtilPlayer.message(caller, F.desc("Unhandled", arg));
+
+			//Inform
+			UtilPlayer.message(caller, F.main("Creature", "Spawned " + count + " " + UtilEnt.getName(type) + "."));
+		}
+	}
+
 	@EventHandler
 	public void doubleJumpTrigger(PlayerToggleFlightEvent event)
 	{
@@ -556,46 +1065,52 @@ public class EventGame extends SoloGame
 		}
 	}
 
-//	@EventHandler
+	@EventHandler(priority = EventPriority.LOW)
-//	public void updateVisibility(UpdateEvent event)
+	public void explosionBlocks(EntityExplodeEvent event)
-//	{
+	{
-//		if (!InProgress())
+		event.blockList().clear();	
-//			return;
+	}
-//		
+
-//		if (event.getType() != UpdateType.FAST)
+	//	@EventHandler
-//			return;
+	//	public void updateVisibility(UpdateEvent event)
-//
+	//	{
-//		for (Player player : UtilServer.getPlayers())
+	//		if (!InProgress())
-//		{
+	//			return;
-//			if (!Manager.getPreferences().Get(player).ShowPlayers)
+	//		
-//			{
+	//		if (event.getType() != UpdateType.FAST)
-//				for (Player other : UtilServer.getPlayers())
+	//			return;
-//				{
+	//
-//					if (player.equals(other))
+	//		for (Player player : UtilServer.getPlayers())
-//						continue;
+	//		{
-//					
+	//			if (!Manager.getPreferences().Get(player).ShowPlayers)
-//					((CraftPlayer)player).hidePlayer(other, true, false);
+	//			{
-//				}
+	//				for (Player other : UtilServer.getPlayers())
-//			}
+	//				{
-//			else
+	//					if (player.equals(other))
-//			{
+	//						continue;
-//				for (Player other : UtilServer.getPlayers())
+	//					
-//				{
+	//					((CraftPlayer)player).hidePlayer(other, true, false);
-//					if (player.equals(other))
+	//				}
-//						continue;
+	//			}
-//
+	//			else
-//					if ((Manager.getPreferences().Get(player).Invisibility && _mps.isAdmin(player, false)) || )
+	//			{
-//					{
+	//				for (Player other : UtilServer.getPlayers())
-//						((CraftPlayer)other).hidePlayer(player, true, false);
+	//				{
-//					}
+	//					if (player.equals(other))
-//					else
+	//						continue;
-//					{
+	//
-//						other.showPlayer(player);
+	//					if ((Manager.getPreferences().Get(player).Invisibility && _mps.isAdmin(player, false)) || )
-//					}
+	//					{
-//				}
+	//						((CraftPlayer)other).hidePlayer(player, true, false);
-//			}
+	//					}
-//		}
+	//					else
-//	}	
+	//					{
+	//						other.showPlayer(player);
+	//					}
+	//				}
+	//			}
+	//		}
+	//	}	
 
 	@Override
 	public void EndCheck()
@@ -630,9 +1145,20 @@ public class EventGame extends SoloGame
 
 	//This re-enables cosmetic hotbar, because MPS disables it
 	@EventHandler(priority = EventPriority.MONITOR)
-	public void fixHotbarItemTemp(PlayerCommandPreprocessEvent event)
+	public void fixHotbarItemTemp(GameStateChangeEvent event)
 	{	
-		if (event.getMessage().toLowerCase().startsWith("/sethost"))
+		Manager.GetServerConfig().HotbarInventory = true;
-			Manager.GetServerConfig().HotbarInventory = true;
+	}
+
+	public void giveItems(Player player)
+	{
+		UtilInv.Clear(player);
+
+		for (Material mat : _kitItems.keySet())
+		{
+			int amount = _kitItems.get(mat);
+
+			player.getInventory().addItem(new ItemStack(mat, amount));
+		}
 	}
 }

Plugins/Nautilus.Game.Arcade/src/nautilus/game/arcade/game/games/event/kits/KitPlayer.java

@@ -6,6 +6,7 @@ import org.bukkit.entity.Player;
 import org.bukkit.inventory.ItemStack;
 
 import nautilus.game.arcade.ArcadeManager;
+import nautilus.game.arcade.game.games.event.EventGame;
 import nautilus.game.arcade.kit.Kit;
 import nautilus.game.arcade.kit.KitAvailability;
 import nautilus.game.arcade.kit.Perk;
@@ -32,6 +33,6 @@ public class KitPlayer extends Kit
 	@Override
 	public void GiveItems(Player player) 
 	{
-		
+		((EventGame)Manager.GetGame()).giveItems(player);
 	}
 }

Plugins/Nautilus.Game.Arcade/src/nautilus/game/arcade/game/games/searchanddestroy/TeamBomb.java

@@ -315,8 +315,7 @@ class TeamBomb implements Comparable<TeamBomb>
 
     public void setupHologram()
     {
-        _hologram = new Hologram(this._game.getArcadeManager().getHologramManager(), getBlockLocation().clone().add(0, 1, 0))
+        _hologram = new Hologram(this._game.getArcadeManager().getHologramManager(), getBlockLocation().clone().add(0, 1, 0));
-                .setUsesWitherSkull();
         _hologram.setText(getTeam().GetColor() + C.Bold + getTeam().GetName() + " Team's Bomb");
         _hologram.start();
     }

Plugins/Nautilus.Game.Arcade/src/nautilus/game/arcade/managers/GameChatManager.java

@@ -7,6 +7,7 @@ import mineplex.core.common.util.C;
 import mineplex.core.common.util.F;
 import mineplex.core.party.Party;
 import nautilus.game.arcade.ArcadeManager;
+import nautilus.game.arcade.GameType;
 import nautilus.game.arcade.game.GameTeam;
 import nautilus.game.arcade.game.Game.GameState;
 
@@ -68,11 +69,17 @@ public class GameChatManager implements Listener
 		//Rank Prefix  & MPS Host Prefix
 		if (Manager.GetGameHostManager().isHost(event.getPlayer()))
 		{
-			rankStr = C.cDGreen + C.Bold + "MPS Host ";
+			if (Manager.GetGame() != null && Manager.GetGame().GetType() == GameType.Event)
+				rankStr = C.cDGreen + C.Bold + "Event Host ";
+			else
+				rankStr = C.cDGreen + C.Bold + "MPS Host ";
 		}
 		else if (Manager.GetGameHostManager().isAdmin(event.getPlayer(), false))
 		{
-			rankStr = C.cDGreen + C.Bold +  "MPS Admin ";
+			if (Manager.GetGame() != null && Manager.GetGame().GetType() == GameType.Event)
+				rankStr = C.cDGreen + C.Bold + "Event Admin ";
+			else
+				rankStr = C.cDGreen + C.Bold +  "MPS Admin ";
 		}
 		else
 		{

Plugins/Nautilus.Game.Arcade/src/nautilus/game/arcade/managers/GameFlagManager.java

@@ -319,6 +319,10 @@ public class GameFlagManager implements Listener
 				if (!player.isOp() || player.getGameMode() != GameMode.CREATIVE)	
 					event.setCancelled(true);
 			}
+			else if (game.BlockPlaceCreative && player.getGameMode() == GameMode.CREATIVE) // Event Server Allowance
+			{
+				return;
+			}
 			else
 			{
 				if (game.BlockPlace)
@@ -356,6 +360,10 @@ public class GameFlagManager implements Listener
 			{
 				event.setCancelled(true);
 			}
+			else if (game.BlockBreakCreative && player.getGameMode() == GameMode.CREATIVE) // Event Server Allowance
+			{
+				return;
+			}
 			else
 			{
 				if (game.BlockBreak)