Removed Files

These two directories contain code that was removed from the src and dependencies of the compiled files. They were removed due to being either a. unnecessary or b. a royal pain in my booty.

GOD DAMN COSMETICS/bonuses/BonusAmount.java

@@ -0,0 +1,231 @@
+package mineplex.core.bonuses;
+
+import java.util.List;
+
+import mineplex.core.common.util.C;
+
+public class BonusAmount
+{
+	private int _gems;
+	private int _shards;
+	private GoldAmount _gold = new GoldAmount();
+	private int _bonusGems;
+	private int _bonusShards;
+	private GoldAmount _bonusGold = new GoldAmount();
+	private int _experience;
+	private int _bonusExperience;
+	private int _tickets;
+	private int _oldChests;
+	private int _ancientChests;
+	private int _mythicalChests;
+	private int _illuminatedChests;
+	private int _omegaChests;
+
+	public BonusAmount()
+	{
+
+	}
+
+	public int getGems()
+	{
+		return _gems;
+	}
+
+	public void setGems(int gems)
+	{
+		_gems = gems;
+	}
+
+	public int getShards()
+	{
+		return _shards;
+	}
+
+	public void setShards(int shards)
+	{
+		_shards = shards;
+	}
+
+	public GoldAmount getGold()
+	{
+		return _gold;
+	}
+
+	public void setGold(Integer serverId, Integer gold)
+	{
+		_gold.setGoldFor(serverId, gold);
+	}
+
+	public int getBonusGems()
+	{
+		return _bonusGems;
+	}
+
+	public void setBonusGems(int bonusGems)
+	{
+		_bonusGems = bonusGems;
+	}
+
+	public int getBonusShards()
+	{
+		return _bonusShards;
+	}
+
+	public void setBonusShards(int bonusShards)
+	{
+		_bonusShards = bonusShards;
+	}
+
+	public GoldAmount getBonusGold()
+	{
+		return _bonusGold;
+	}
+
+	public void setBonusGold(Integer serverId, Integer bonusGold)
+	{
+		_bonusGold.setGoldFor(serverId, bonusGold);
+	}
+
+	public int getTotalGems()
+	{
+		return getGems() + getBonusGems();
+	}
+
+	public int getTotalShards()
+	{
+		return getShards() + getBonusShards();
+	}
+
+	public int getTotalGold()
+	{
+		return getGold().getTotalGold() + getBonusGold().getTotalGold();
+	}
+
+	public int getExperience()
+	{
+		return _experience;
+	}
+
+	public void setExperience(int experience)
+	{
+		_experience = experience;
+	}
+
+	public int getBonusExperience()
+	{
+		return _bonusExperience;
+	}
+
+	public void setBonusExperience(int bonusExperience)
+	{
+		_bonusExperience = bonusExperience;
+	}
+
+	public int getTotalExperience()
+	{
+		return getExperience() + getBonusExperience();
+	}
+
+	public int getTickets()
+	{
+		return _tickets;
+	}
+
+	public void setTickets(int tickets)
+	{
+		_tickets = tickets;
+	}
+
+	public int getOldChests()
+	{
+		return _oldChests;
+	}
+
+	public void setOldChests(int oldChests)
+	{
+		_oldChests = oldChests;
+	}
+
+	public int getAncientChests()
+	{
+		return _ancientChests;
+	}
+
+	public void setAncientChests(int ancientChests)
+	{
+		_ancientChests = ancientChests;
+	}
+
+	public int getMythicalChests()
+	{
+		return _mythicalChests;
+	}
+
+	public void setMythicalChests(int mythicalChests)
+	{
+		_mythicalChests = mythicalChests;
+	}
+
+	public int getIlluminatedChests()
+	{
+		return _illuminatedChests;
+	}
+
+	public void setIlluminatedChests(int illuminatedChests)
+	{
+		_illuminatedChests = illuminatedChests;
+	}
+
+	public int getOmegaChests()
+	{
+		return _omegaChests;
+	}
+
+	public void setOmegaChests(int omegaChests)
+	{
+		_omegaChests = omegaChests;
+	}
+
+	public boolean isGreaterThanZero()
+	{
+		return _bonusShards > 0 || _shards > 0 || _bonusGems > 0 || _gems > 0 || _gold.getTotalGold() > 0 || _bonusGold.getTotalGold() > 0 || _oldChests > 0 || _ancientChests > 0 || _mythicalChests > 0;
+	}
+
+	public void addLore(List<String> lore)
+	{
+		lore.add(C.cYellow + "Rewards");
+		addLore(lore, getTickets(), 0, "Carl Spin Ticket" + (getTickets() > 1 ? "s" : ""));
+		addLore(lore, getShards(), getBonusShards(), "Treasure Shards");
+		addLore(lore, getGems(), getBonusGems(), "Gems");
+		addLore(lore, getGold().getTotalGold(), getBonusGold().getTotalGold(), "Gold");
+		addLore(lore, getExperience(), getBonusExperience(), "Experience");
+		addLore(lore, getOldChests(), 0, "Old Chest", "Old Chests");
+		addLore(lore, getAncientChests(), 0, "Ancient Chest", "Ancient Chests");
+		addLore(lore, getMythicalChests(), 0, "Mythical Chest", "Mythical Chests");
+		addLore(lore, getIlluminatedChests(), 0, "Illuminated Chest", "Illuminated Chests");
+		addLore(lore, getOmegaChests(), 0, "Omega Chest", "Omega Chests");
+	}
+
+	private void addLore(List<String> lore, int amount, int bonus, String suffix)
+	{
+		if (amount > 0)
+		{
+			lore.add("  " + C.cWhite + amount + " " + suffix);
+		}
+
+//		if (bonus > 0)
+//			lore.add(C.cYellow + "Streak Bonus: " + C.cWhite + bonus + " " + suffix);
+	}
+
+	private void addLore(List<String> lore, int amount, int bonus, String suffix, String plural)
+	{
+		if (amount == 1)
+		{
+			lore.add("  " + C.cWhite + amount + " " + plural);
+		}
+		else if (amount > 0)
+		{
+			lore.add("  " + C.cWhite + amount + " " + suffix);
+		}
+	}
+}

GOD DAMN COSMETICS/bonuses/BonusClientData.java

@@ -0,0 +1,148 @@
+package mineplex.core.bonuses;
+
+import java.sql.Date;
+import java.sql.Timestamp;
+
+import mineplex.core.hologram.Hologram;
+
+public class BonusClientData
+{
+	private Hologram _hologram;
+
+	private int _accountId;
+	private Timestamp _dailyTime;
+	private Timestamp _clansDailyTime;
+	private Date _rankTime;
+	private Date _voteTime;
+	private Date _clansVoteTime;
+	private int _dailyStreak;
+	private int _maxDailyStreak;
+	private int _voteStreak;
+	private int _maxVoteStreak;
+	private int _tickets;
+
+	public BonusClientData()
+	{
+		_accountId = -1;
+	}
+
+	public void setAccountId(Integer value)
+	{
+		_accountId = value;
+	}
+
+	public Integer getAccountId()
+	{
+		return _accountId;
+	}
+
+	public void setDailyTime(Timestamp value)
+	{
+		_dailyTime = value;
+	}
+
+	public Timestamp getDailyTime()
+	{
+		return _dailyTime;
+	}
+	
+	public void setClansDailyTime(Timestamp value)
+	{
+		_clansDailyTime = value;
+	}
+
+	public Timestamp getClansDailyTime()
+	{
+		return _clansDailyTime;
+	}
+
+	public void setRankTime(Date value)
+	{
+		_rankTime = value;
+	}
+
+	public Date getRankTime()
+	{
+		return _rankTime;
+	}
+
+	public void setVoteTime(Date value)
+	{
+		_voteTime = value;
+	}
+
+	public Date getVoteTime()
+	{
+		return _voteTime;
+	}
+	
+	public void setClansVoteTime(Date value)
+	{
+		_clansVoteTime = value;
+	}
+
+	public Date getClansVoteTime()
+	{
+		return _clansVoteTime;
+	}
+
+	public void setDailyStreak(Integer value)
+	{
+		_dailyStreak = value;
+	}
+
+	public Integer getDailyStreak()
+	{
+		return _dailyStreak;
+	}
+
+	public void setMaxDailyStreak(Integer value)
+	{
+		_maxDailyStreak = value;
+	}
+
+	public Integer getMaxDailyStreak()
+	{
+		return _maxDailyStreak;
+	}
+
+	public void setVoteStreak(Integer value)
+	{
+		_voteStreak = value;
+	}
+
+	public Integer getVoteStreak()
+	{
+		return _voteStreak;
+	}
+
+	public void setMaxVoteStreak(Integer value)
+	{
+		_maxVoteStreak = value;
+	}
+
+	public Integer getMaxVoteStreak()
+	{
+		return _maxVoteStreak;
+	}
+
+	public void setTickets(Integer value)
+	{
+		_tickets = value;
+	}
+
+	public Integer getTickets()
+	{
+		return _tickets;
+	}
+
+	public Hologram getHologram()
+	{
+		return _hologram;
+	}
+
+	public void setHologram(Hologram hologram)
+	{
+		_hologram = hologram;
+	}
+}

GOD DAMN COSMETICS/bonuses/BonusRepository.java

@@ -0,0 +1,527 @@
+package mineplex.core.bonuses;
+
+import java.sql.CallableStatement;
+import java.sql.Connection;
+import java.sql.Date;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Timestamp;
+import java.sql.Types;
+
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.jooq.DSLContext;
+import org.jooq.Record2;
+import org.jooq.SQLDialect;
+import org.jooq.TableField;
+import org.jooq.impl.DSL;
+
+import mineplex.core.common.Pair;
+import mineplex.core.common.util.Callback;
+import mineplex.core.common.util.UtilServer;
+import mineplex.core.donation.DonationManager;
+import mineplex.core.recharge.Recharge;
+import mineplex.database.Tables;
+import mineplex.database.tables.records.BonusRecord;
+import mineplex.serverdata.database.DBPool;
+import mineplex.serverdata.database.RepositoryBase;
+import mineplex.serverdata.database.ResultSetCallable;
+
+public class BonusRepository extends RepositoryBase
+{
+	private static String CREATE_BONUS_TABLE = "CREATE TABLE IF NOT EXISTS bonus (accountId INT NOT NULL AUTO_INCREMENT, dailytime TIMESTAMP NULL DEFAULT NULL, clansdailytime TIMESTAMP NULL DEFAULT NULL, ranktime DATE NULL DEFAULT NULL, votetime DATE NULL DEFAULT NULL, clansvotetime DATE NULL DEFAULT NULL, PRIMARY KEY (accountId), FOREIGN KEY (accountId) REFERENCES accounts(id));";
+	private BonusManager _manager;
+	private DonationManager _donationManager;
+
+	public BonusRepository(JavaPlugin plugin, BonusManager bonusManager, DonationManager donationManager)
+	{
+		super(DBPool.getAccount());
+		_manager = bonusManager;
+		_donationManager = donationManager;
+	}
+
+	public BonusRecord loadRecord(String playerName, int accountId)
+	{
+		DSLContext create = jooq();
+
+		BonusRecord record = create.selectFrom(Tables.bonus).where(Tables.bonus.accountId.eq(accountId)).fetchOne();
+
+		if (record == null)
+		{
+			// Need to create new record!
+			record = create.newRecord(Tables.bonus);
+			record.setAccountId(accountId);
+			record.setDailyStreak(0);
+			record.setMaxDailyStreak(0);
+			record.setVoteStreak(0);
+			record.setMaxVoteStreak(0);
+			record.setTickets(0);
+			record.store(); // Todo - is this necessary?
+		}
+		System.out.println("Loaded record. Daily time: " + record.getDailytime());
+		return record;
+	}
+	
+	public int loadClansServerId(int accountId)
+	{
+		try (Connection connection = getConnection())
+		{
+			PreparedStatement s = connection.prepareStatement("SELECT clans.serverId FROM accountClan INNER JOIN clans ON clans.id = accountClan.clanId WHERE accountClan.accountId = " + accountId + ";");
+			ResultSet rs = s.executeQuery();
+			boolean hasRow = rs.next();
+			if (hasRow)
+			{
+				return rs.getInt(1);
+			}
+			else
+			{
+				return -1;
+			}
+		}
+		catch (SQLException e)
+		{
+			e.printStackTrace();
+			return -1;
+		}
+	}
+
+	public BonusClientData loadData(final int accountId, ResultSet resultSet) throws SQLException
+	{
+		BonusClientData clientData = new BonusClientData();
+		clientData.setAccountId(accountId);
+
+		boolean foundClient = false;
+		while (resultSet.next())
+		{
+			foundClient = true;
+			clientData.setDailyTime(resultSet.getTimestamp(2));
+			clientData.setClansDailyTime(resultSet.getTimestamp(3));
+			clientData.setRankTime(resultSet.getDate(4));
+			clientData.setVoteTime(resultSet.getDate(5));
+			clientData.setClansVoteTime(resultSet.getDate(6));
+			clientData.setDailyStreak(resultSet.getInt(7));
+			clientData.setMaxDailyStreak(resultSet.getInt(8));
+			clientData.setVoteStreak(resultSet.getInt(9));
+			clientData.setMaxVoteStreak(resultSet.getInt(10));
+			clientData.setTickets(resultSet.getInt(11));
+		}
+
+		if (!foundClient)
+		{
+			UtilServer.runAsync(() -> executeInsert("INSERT IGNORE INTO bonus (accountId) VALUES (" + accountId + ")", null));
+		}
+
+		return clientData;
+	}
+
+	public void getDailyStreakRecord(Callback<StreakRecord> callback)
+	{
+		getStreakRecord(Tables.bonus.maxDailyStreak, callback);
+	}
+
+	public void getVoteStreakRecord(Callback<StreakRecord> callback)
+	{
+		getStreakRecord(Tables.bonus.maxVoteStreak, callback);
+	}
+
+	private void getStreakRecord(final TableField<BonusRecord, Integer> field, final Callback<StreakRecord> callback)
+	{
+		Bukkit.getScheduler().runTaskAsynchronously(_manager.getPlugin(), new Runnable()
+		{
+			@Override
+			public void run()
+			{
+				final Record2<String, Integer> record = jooq().select(Tables.accounts.name, field)
+						.from(Tables.bonus.join(Tables.accounts).on(Tables.bonus.accountId.eq(Tables.accounts.id)))
+						.orderBy(field.desc()).limit(1).fetchOne();
+
+				Bukkit.getScheduler().runTask(_manager.getPlugin(), new Runnable()
+				{
+					@Override
+					public void run()
+					{
+						if (record.value1() != null && record.value2() != null)
+						{
+							callback.run(new StreakRecord(record.value1(), record.value2()));
+						}
+					}
+				});
+			}
+		});
+	}
+
+	public void attemptAddTickets(final int accountId, final BonusClientData client, final int tickets, final Callback<Boolean> callback)
+	{
+		if (client.getTickets() + tickets < 0)
+			callback.run(false);
+
+		Bukkit.getScheduler().runTaskAsynchronously(_manager.getPlugin(), new Runnable()
+		{
+			@Override
+			public void run()
+			{
+				try
+				{
+					DSLContext create = DSL.using(DBPool.getAccount(), SQLDialect.MYSQL);
+					create.update(Tables.bonus).set(Tables.bonus.tickets, Tables.bonus.tickets.add(tickets)).
+							where(Tables.bonus.accountId.eq(accountId)).execute();
+					final int newTickets = create.select(Tables.bonus.tickets).from(Tables.bonus).where(Tables.bonus.accountId.eq(accountId)).fetchOne().value1();
+
+					Bukkit.getScheduler().runTask(_manager.getPlugin(), new Runnable()
+					{
+						@Override
+						public void run()
+						{
+							client.setTickets(newTickets);
+							callback.run(true);
+						}
+					});
+				}
+				catch (Exception e)
+				{
+					e.printStackTrace();
+					callback.run(false);
+				}
+			}
+		});
+	}
+
+	public void attemptDailyBonus(final Player player, final boolean clans, final Callback<Boolean> result)
+	{
+		final int accountId = _manager.getClientManager().Get(player).getAccountId();
+		final int serverId = _manager.getClansHomeServer(player).getRight();
+		final int shards = 0;
+		final int gems = 0;
+		final int gold = 500;
+		/*
+		 * if (shards == 0 && gems == 0) { result.accept(false); return; }
+		 */
+		final JavaPlugin plug = _manager.getPlugin();
+
+		Bukkit.getScheduler().runTaskAsynchronously(plug, new Runnable()
+		{
+			@Override
+			public void run()
+			{
+				if (clans)
+				{
+					try (Connection connection = getConnection();
+							CallableStatement callableStatement = connection.prepareCall("{call check_clans_daily(?, ?, ?, ?, ?)}"))
+						{
+							callableStatement.setInt(1, accountId);
+							callableStatement.setInt(2, serverId);
+							callableStatement.setInt(3, gold);
+							callableStatement.registerOutParameter(4, java.sql.Types.BOOLEAN);
+							callableStatement.registerOutParameter(5, java.sql.Types.TIMESTAMP);
+
+							callableStatement.executeUpdate();
+
+							final boolean pass = callableStatement.getBoolean(4);
+
+							final Timestamp timeStamp = callableStatement.getTimestamp(5);
+
+							Bukkit.getScheduler().runTask(plug, new Runnable()
+							{
+								@Override
+								public void run()
+								{
+
+									if (pass)
+									{
+										_manager.Get(player).setClansDailyTime(new Timestamp(BonusManager.getSqlTime()));
+										result.run(true);
+									}
+									else
+									{
+										Recharge.Instance.use(player, "AttemptDailyBonus", 1000 * 10, false, false);
+										_manager.Get(player).setClansDailyTime(timeStamp);
+										result.run(false);
+									}
+								}
+							});
+						}
+						catch (Exception e)
+						{
+							Recharge.Instance.use(player, "AttemptDailyBonus", 1000 * 30, false, false);
+							e.printStackTrace();
+							result.run(false);
+						}
+				}
+				else
+				{
+					try (Connection connection = getConnection();
+						CallableStatement callableStatement = connection.prepareCall("{call check_daily(?, ?, ?, ?, ?)}"))
+					{
+						callableStatement.setInt(1, accountId);
+						callableStatement.setInt(2, shards);
+						callableStatement.setInt(3, gems);
+						callableStatement.registerOutParameter(4, java.sql.Types.BOOLEAN);
+						callableStatement.registerOutParameter(5, java.sql.Types.TIMESTAMP);
+
+						callableStatement.executeUpdate();
+
+						final boolean pass = callableStatement.getBoolean(4);
+
+						final Timestamp timeStamp = callableStatement.getTimestamp(5);
+
+						Bukkit.getScheduler().runTask(plug, new Runnable()
+						{
+							@Override
+							public void run()
+							{
+
+								if (pass)
+								{
+									_manager.Get(player).setDailyTime(new Timestamp(BonusManager.getSqlTime()));
+									result.run(true);
+								}
+								else
+								{
+									Recharge.Instance.use(player, "AttemptDailyBonus", 1000 * 10, false, false);
+									_manager.Get(player).setDailyTime(timeStamp);
+									result.run(false);
+								}
+							}
+						});
+					}
+					catch (Exception e)
+					{
+						Recharge.Instance.use(player, "AttemptDailyBonus", 1000 * 30, false, false);
+						e.printStackTrace();
+						result.run(false);
+					}
+				}
+			}
+		});
+	}
+
+	@Deprecated
+	public void giveTickets(final Player player, final Callback<Boolean> result)
+	{
+		final int accountId = _manager.getClientManager().Get(player).getAccountId();
+
+		Bukkit.getScheduler().runTaskAsynchronously(_manager.getPlugin(), new Runnable()
+		{
+			@Override
+			public void run()
+			{
+				final int newTickets = jooq().update(Tables.bonus).set(Tables.bonus.tickets, Tables.bonus.tickets.sub(-1)).
+						where(Tables.bonus.accountId.eq(accountId)).returning(Tables.bonus.tickets).fetchOne().getTickets();
+
+				Bukkit.getScheduler().runTask(_manager.getPlugin(), new Runnable()
+				{
+					@Override
+					public void run()
+					{
+
+
+					}
+				});
+
+			}
+		});
+	}
+
+	public void attemptRankBonus(final Player player, final Callback<Boolean> result)
+	{
+		if (!Recharge.Instance.usable(player, "AttemptRankBonus")) 
+		{
+			result.run(false);
+			return;
+		}
+
+		final BonusAmount bonusAmount = _manager.getRankBonusAmount(player);
+		final int accountId = _manager.getClientManager().Get(player).getAccountId();
+
+		if (!_manager.getRankBonusAmount(player).isGreaterThanZero()) 
+		{
+			result.run(false);
+			return;
+		}
+
+		UtilServer.runAsync(() ->
+		{
+			try (Connection connection = getConnection();
+				CallableStatement callableStatement = connection.prepareCall("{call rankBonus(?, ?, ?, ?, ?, ?, ?, ?)}");
+				)
+			{
+				callableStatement.setInt(1, accountId);
+				callableStatement.setInt(2, bonusAmount.getShards());
+				callableStatement.setInt(3, bonusAmount.getGems());
+				callableStatement.setInt(4, bonusAmount.getMythicalChests());
+				callableStatement.setInt(5, bonusAmount.getOmegaChests());
+				callableStatement.setInt(6, bonusAmount.getIlluminatedChests());
+				callableStatement.registerOutParameter(7, java.sql.Types.BOOLEAN);
+				callableStatement.registerOutParameter(8, java.sql.Types.DATE);
+
+				callableStatement.executeUpdate();
+
+				final boolean pass = callableStatement.getBoolean(7);
+
+				final Date date = callableStatement.getDate(8);
+
+				UtilServer.runSync(() -> 
+				{
+					_manager.Get(player).setRankTime(date);
+
+					if (pass)
+					{
+						result.run(true);
+					}
+					else
+					{
+						Recharge.Instance.use(player, "AttemptRankBonus", 1000 * 10, false, false);
+						result.run(false);
+					}
+				});
+			} 
+			catch (Exception e) 
+			{
+				Recharge.Instance.use(player, "AttemptRankBonus", 1000 * 30, false, false);
+				e.printStackTrace();
+				System.out.println("Error : " + e.getMessage());
+				result.run(false);
+			}
+		});
+	}
+
+	public void attemptVoteBonus(final int accountId, final boolean clans, final Callback<Pair<Boolean, Date>> result)
+	{
+		final int serverId = 0;
+		final int shards = 0;
+		final int gems = 0;
+		final int gold = 1000;
+
+		final JavaPlugin plug = _manager.getPlugin();
+
+		Bukkit.getScheduler().runTaskAsynchronously(plug, new Runnable() {
+
+			@Override
+			public void run()
+			{
+				if (clans)
+				{
+					try (Connection connection = getConnection();
+							CallableStatement callableStatement = connection.prepareCall("{call check_clans_vote(?, ?, ?, ?, ?)}")) {
+						callableStatement.setInt(1, accountId);
+						callableStatement.setInt(2, serverId);
+						callableStatement.setInt(3, gold);
+						callableStatement.registerOutParameter(4, Types.BOOLEAN);
+						callableStatement.registerOutParameter(5, Types.DATE);
+
+						callableStatement.executeUpdate();
+
+						final boolean pass = callableStatement.getBoolean(4);
+						final Date date = callableStatement.getDate(5);
+
+						Bukkit.getScheduler().runTask(plug, new Runnable()
+						{
+							@Override
+							public void run()
+							{
+								//							_manager.Get(player).setVoteTime(date);
+								result.run(Pair.create(pass, date));
+							}
+						});
+					} catch (Exception e) {
+						e.printStackTrace();
+						result.run(null);
+					}
+				}
+				else
+				{
+					try (Connection connection = getConnection();
+							CallableStatement callableStatement = connection.prepareCall("{call check_vote(?, ?, ?, ?, ?)}")) {
+						callableStatement.setInt(1, accountId);
+						callableStatement.setInt(2, shards);
+						callableStatement.setInt(3, gems);
+						callableStatement.registerOutParameter(4, Types.BOOLEAN);
+						callableStatement.registerOutParameter(5, Types.DATE);
+
+						callableStatement.executeUpdate();
+
+						final boolean pass = callableStatement.getBoolean(4);
+						final Date date = callableStatement.getDate(5);
+
+						Bukkit.getScheduler().runTask(plug, new Runnable() {
+							@Override
+							public void run()
+							{
+								//							_manager.Get(player).setVoteTime(date);
+								result.run(Pair.create(pass, date));
+							}
+						});
+					} catch (Exception e) {
+						e.printStackTrace();
+						result.run(null);
+					}
+				}
+			}
+		});
+	}
+
+	public void getTimeOffset(final Callback<Long> callback)
+	{
+		final long startTime = System.currentTimeMillis();
+		final Plugin plugin = _manager.getPlugin();
+
+		Bukkit.getScheduler().runTaskAsynchronously(plugin, new Runnable() {
+			@Override
+			public void run()
+			{
+				executeQuery("SELECT CURRENT_TIMESTAMP", new ResultSetCallable() {
+					@Override
+					public void processResultSet(ResultSet resultSet) throws SQLException
+					{
+						resultSet.next();
+
+						long theirTimeUnadjusted = resultSet.getTimestamp(1).getTime();
+
+						long ourCurrentTime = System.currentTimeMillis();
+
+						long latencyOffset = (ourCurrentTime - startTime) / 2;
+
+						long theirTime = theirTimeUnadjusted - latencyOffset;
+
+						final long offSet = theirTime - ourCurrentTime;
+
+						Bukkit.getScheduler().runTask(plugin, new Runnable() {
+							@Override
+							public void run()
+							{
+								callback.run(offSet);
+							}
+						});
+					}
+				});
+			}
+		});
+	}
+
+	public void getClientData(final int accountId, final Callback<BonusClientData> callback)
+	{
+		String query = "SELECT * FROM bonus WHERE accountId = '" + accountId + "';";
+
+		executeQuery(query, new ResultSetCallable()
+		{
+			@Override
+			public void processResultSet(ResultSet resultSet) throws SQLException
+			{
+				BonusClientData clientData = loadData(accountId, resultSet);
+				callback.run(clientData);
+			}
+		});
+	}
+
+	public void saveStreak(int accountId, BonusClientData clientData)
+	{
+		jooq().update(Tables.bonus).set(Tables.bonus.dailyStreak, clientData.getDailyStreak())
+				.set(Tables.bonus.maxDailyStreak, clientData.getMaxDailyStreak())
+				.set(Tables.bonus.voteStreak, clientData.getVoteStreak())
+				.set(Tables.bonus.maxVoteStreak, clientData.getMaxVoteStreak())
+				.where(Tables.bonus.accountId.eq(accountId)).execute();
+	}
+}

GOD DAMN COSMETICS/bonuses/GoldAmount.java

@@ -0,0 +1,51 @@
+package mineplex.core.bonuses;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+
+public class GoldAmount
+{
+	private Map<Integer, Integer> _goldAmounts;
+	
+	public GoldAmount()
+	{
+		_goldAmounts = new HashMap<>();
+	}
+	
+	public Collection<Integer> getServerIds()
+	{
+		return _goldAmounts.keySet();
+	}
+	
+	public Integer getGoldFor(Integer serverId)
+	{
+		return _goldAmounts.getOrDefault(serverId, 0);
+	}
+	
+	public Integer getTotalGold()
+	{
+		Integer gold = 0;
+		for (Integer g : _goldAmounts.values())
+		{
+			gold += g;
+		}
+		
+		return gold;
+	}
+	
+	public void setGoldFor(Integer serverId, Integer gold)
+	{
+		_goldAmounts.put(serverId, gold);
+	}
+	
+	public void addGold(Integer serverId, Integer gold)
+	{
+		_goldAmounts.put(serverId, getGoldFor(serverId) + gold);
+	}
+	
+	public void clearGoldFor(Integer serverId)
+	{
+		_goldAmounts.remove(serverId);
+	}
+}

GOD DAMN COSMETICS/bonuses/StreakRecord.java

@@ -0,0 +1,23 @@
+package mineplex.core.bonuses;
+
+public class StreakRecord
+{
+	private String _playerName;
+	private int _streak;
+
+	public StreakRecord(String playerName, int streak)
+	{
+		_playerName = playerName;
+		_streak = streak;
+	}
+
+	public String getPlayerName()
+	{
+		return _playerName;
+	}
+
+	public int getStreak()
+	{
+		return _streak;
+	}
+}

GOD DAMN COSMETICS/bonuses/animations/AnimationCarl.java

@@ -0,0 +1,312 @@
+package mineplex.core.bonuses.animations;
+
+import java.util.HashSet;
+import java.util.Iterator;
+
+import mineplex.core.bonuses.powerplay.PowerPlayAnimation;
+import mineplex.core.common.skin.SkinData;
+import mineplex.core.common.util.*;
+import mineplex.core.common.util.UtilParticle.ViewDist;
+import mineplex.core.itemstack.ItemStackFactory;
+import mineplex.core.reward.Reward;
+import mineplex.core.reward.RewardData;
+import org.bukkit.Color;
+import org.bukkit.FireworkEffect.Type;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Item;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.util.Vector;
+
+public class AnimationCarl
+{
+//	private boolean _isDone;
+//	private Block _creeper;
+//	private Object _type;
+//	private Player _player;
+//
+//	private HashSet<Item> _items = new HashSet<Item>();
+//
+//	public AnimationCarl(Entity creeper)
+//	{
+//		_creeper = creeper.getLocation().getBlock();
+//	}
+//
+//	@Override
+//	protected void tick()
+//	{
+//		if(_type instanceof String)
+//		{
+//			if(((String) _type).contentEquals("DAILY") || ((String) _type).contentEquals("POLL"))
+//			{
+//				for (int i = 50; i < 60; i++)
+//				{
+//					Item gem = _creeper.getWorld().dropItem(_creeper.getLocation().add(0.5, 1.5, 0.5), ItemStackFactory.Instance.CreateStack(Material.EMERALD, (byte) 0, 1, " " + i));
+//					Item shard = _creeper.getWorld().dropItem(_creeper.getLocation().add(0.5, 1.5, 0.5), ItemStackFactory.Instance.CreateStack(Material.PRISMARINE_SHARD, (byte) 0, 1, " " + i));
+//					_items.add(gem);
+//					_items.add(shard);
+//
+//					Vector vel = new Vector(Math.sin(i * 9/5d), 0, Math.cos(i * 9/5d));
+//					UtilAction.velocity(gem, vel, Math.abs(Math.sin(i * 12/3000d)), false, 0, 0.2 + Math.abs(Math.cos(i * 12/3000d))*0.6, 1, false);
+//					UtilAction.velocity(shard, vel, Math.abs(Math.sin(UtilMath.r(i) * 30/3000d)), false, 0, 0.2 + Math.abs(Math.cos(UtilMath.r(i) * 30/3000d))*0.6, 1, false);
+//
+//				}
+//			}
+//			if(((String) _type).contentEquals("RANK"))
+//			{
+//				for (int i = 50; i < 60; i++)
+//				{
+//					Item shard = _creeper.getWorld().dropItem(_creeper.getLocation().add(0.5, 1.5, 0.5), ItemStackFactory.Instance.CreateStack(Material.PRISMARINE_SHARD, (byte) 0, 1, " " + i));
+//					_items.add(shard);
+//
+//					Vector vel = new Vector(Math.sin(UtilMath.r(i) * 7/5d), 0, Math.cos(UtilMath.r(i) * 7/5d));
+//					UtilAction.velocity(shard, vel, Math.abs(Math.sin(UtilMath.r(i) * 7/3000d)), false, 0, 0.2 + Math.abs(Math.cos(UtilMath.r(i) * 7/3000d))*0.6, 1, false);
+//
+//				}
+//			}
+//			if(!((String) _type).contentEquals("DAILY") && !((String) _type).contentEquals("RANK") && !((String) _type).contentEquals("POLL"))
+//			{
+//
+//				Item paper = _creeper.getWorld().dropItem(_creeper.getLocation().add(0.5, 1.5, 0.5), ItemStackFactory.Instance.CreateStack(Material.PAPER, (byte) 0, 1, " " + 64));
+//				_items.add(paper);
+//
+//				Vector vel = new Vector(Math.sin(64 * 8/5d), 0, Math.cos(64 * 8/5d));
+//				UtilAction.velocity(paper, vel, Math.abs(Math.sin(64 * 9/3000d)), false, 0, 0.2 + Math.abs(Math.cos(64 + 9/3000d))*0.6, 1, false);
+//
+//				for (int i = 50; i < 60; i++)
+//				{
+//					Item gem = _creeper.getWorld().dropItem(_creeper.getLocation().add(0.5, 1.5, 0.5), ItemStackFactory.Instance.CreateStack(Material.EMERALD, (byte) 0, 1, " " + i));
+//					_items.add(gem);
+//
+//					Vector velo = new Vector(Math.sin(i * 8/5d), 0, Math.cos(i * 8/5d));
+//					UtilAction.velocity(gem, velo, Math.abs(Math.sin(i * 8/3000d)), false, 0, 0.2 + Math.abs(Math.cos(i + 8/3000d))*0.6, 1, false);
+//
+//				}
+//			}
+//			finish();
+//		}
+//		if(_type instanceof Reward)
+//		{
+//			if(getTicks() == 0)
+//			{
+//				RewardData rewardData = ((Reward)_type).getFakeRewardData(_player);
+//				ItemStack itemStack = rewardData.getDisplayItem();
+//				Item item = _creeper.getWorld().dropItem(_creeper.getLocation().add(0.5, 1.7, 0.5), itemStack);
+//				_items.add(item);
+//
+//				Vector vel = new Vector(_player.getLocation().getX() - _creeper.getLocation().getX(), 0, _player.getLocation().getZ() - _creeper.getLocation().getZ());
+//
+//				UtilAction.velocity(item, vel, 0.1, false, 0, 0.2 + 1*0.4, 1, false);
+//			}
+//
+//			if(((Reward)_type).getRarity() == RewardRarity.RARE)
+//			{
+//				RareAnimation();
+//			}
+//			else if(((Reward)_type).getRarity() == RewardRarity.LEGENDARY)
+//			{
+//				LegendAnimation();
+//			}
+//			else if(((Reward)_type).getRarity() == RewardRarity.MYTHICAL)
+//			{
+//				MythicalAnimation();
+//			}
+//			else
+//			{
+//				finish();
+//			}
+//		}
+//		if (_type instanceof PowerPlayAnimation)
+//		{
+//			for (int i = 50; i < 65; i++)
+//			{
+//				// Gem amplifier
+//				Item gem = _creeper.getWorld().dropItem(_creeper.getLocation().add(0.5, 1.5, 0.5), ItemStackFactory.Instance.CreateStack(Material.EMERALD, (byte) 0, 1, " " + i));
+//				_items.add(gem);
+//
+//				Vector vel = new Vector(Math.sin(UtilMath.r(i) * 7/5d), 0, Math.cos(UtilMath.r(i) * 7/5d));
+//				UtilAction.velocity(gem, vel, Math.abs(Math.sin(UtilMath.r(i) * 7/3000d)), false, 0, 0.2 + Math.abs(Math.cos(UtilMath.r(i) * 7/3000d))*0.6, 1, false);
+//
+//				// Omega chest
+//				Item omega = _creeper.getWorld().dropItem(_creeper.getLocation().add(0.5, 1.5, 0.5), SkinData.OMEGA_CHEST.getSkull());
+//				_items.add(omega);
+//
+//				vel = new Vector(Math.sin(UtilMath.r(i) * 7/5d), 0, Math.cos(UtilMath.r(i) * 7/5d));
+//				UtilAction.velocity(omega, vel, Math.abs(Math.sin(UtilMath.r(i) * 7/3000d)), false, 0, 0.2 + Math.abs(Math.cos(UtilMath.r(i) * 7/3000d))*0.6, 1, false);
+//
+//				// Monthly items
+//				PowerPlayAnimation powerPlayAnimation = (PowerPlayAnimation) _type;
+//				for (ItemStack itemStack : powerPlayAnimation.getAnimationItems())
+//				{
+//					Item monthly = _creeper.getWorld().dropItem(_creeper.getLocation().add(0.5, 1.5, 0.5), itemStack);
+//					_items.add(monthly);
+//
+//					vel = new Vector(Math.sin(UtilMath.r(i) * 7/5d), 0, Math.cos(UtilMath.r(i) * 7/5d));
+//					UtilAction.velocity(monthly, vel, Math.abs(Math.sin(UtilMath.r(i) * 7/3000d)), false, 0, 0.2 + Math.abs(Math.cos(UtilMath.r(i) * 7/3000d))*0.6, 1, false);
+//				}
+//			}
+//			finish();
+//		}
+//	}
+//
+//	@Override
+//	protected void onFinish() {
+//		_isDone = true;
+//		_player = null;
+//		setTicks(0);
+//	}
+//
+//	public boolean isDone()
+//	{
+//		return _isDone;
+//	}
+//
+//	public void setDone(boolean b)
+//	{
+//		_isDone = b;
+//	}
+//
+//	public void setType(Object type)
+//	{
+//		_type = type;
+//	}
+//
+//	public void setPlayer(Player player)
+//	{
+//		_player = player;
+//	}
+//
+//	public void LegendAnimation()
+//	{
+//		if (getTicks() < 1)
+//		{
+//			UtilFirework.playFirework(_creeper.getLocation().add(0.5, 0.5, 0.5), Type.BALL_LARGE, Color.LIME, true, true);
+//		}
+//
+//		if (getTicks() == 1)
+//		{
+//			_creeper.getLocation().getWorld().playSound(_creeper.getLocation().add(0.5, 0.5, 0.5), Sound.ENDERDRAGON_DEATH, 10F, 2.0F);
+//		}
+//		else if (getTicks() < 35)
+//		{
+//			double radius = 2 - (getTicks() / 10D * 2);
+//			int particleAmount = 20 - (getTicks() * 2);
+//			Location _centerLocation = _creeper.getLocation().add(0.5, 0.1, 0.5);
+//			for (int i = 0; i < particleAmount; i++)
+//			{
+//				double xDiff = Math.sin(i/(double)particleAmount * 2 * Math.PI) * radius;
+//				double zDiff = Math.cos(i/(double)particleAmount * 2 * Math.PI) * radius;
+//				for(double e = 0.1 ; e < 3 ; e += 0.6)
+//				{
+//					Location location = _centerLocation.clone().add(xDiff, e, zDiff);
+//					UtilParticle.PlayParticle(UtilParticle.ParticleType.HAPPY_VILLAGER, location, 0, 0, 0, 0, 1, ViewDist.NORMAL, UtilServer.getPlayers());
+//				}
+//			}
+//		}
+//		else
+//		{
+//			finish();
+//		}
+//	}
+//
+//	public void MythicalAnimation()
+//	{
+//		if (getTicks() < 30)
+//		{
+//			UtilFirework.playFirework(_creeper.getLocation().add(0.5, 0.5, 0.5), Type.BALL_LARGE, Color.RED, true, true);
+//		}
+//
+//		if (getTicks() == 1)
+//		{
+//			_creeper.getLocation().getWorld().playSound(_creeper.getLocation().add(0.5, 0.5, 0.5), Sound.PORTAL_TRAVEL, 10F, 2.0F);
+//			_creeper.getLocation().getWorld().playSound(_creeper.getLocation().add(0.5, 0.5, 0.5), Sound.ZOMBIE_UNFECT, 10F, 0.1F);
+//		}
+//		else if (getTicks() < 40)
+//		{
+//			UtilFirework.launchFirework(_creeper.getLocation().add(0.5, 0.5, 0.5), Type.BALL_LARGE, Color.RED, true, true,
+//					new Vector((Math.random()-0.5)*0.05, 0.1, (Math.random()-0.5)*0.05), 1);
+//
+//			//Particle Spiral Up
+//			double radius = getTicks() / 20D;
+//			int particleAmount = getTicks() / 2;
+//			for (int i = 0; i < particleAmount; i++)
+//			{
+//				double xDiff = Math.sin(i/(double)particleAmount * 2 * Math.PI) * radius;
+//				double zDiff = Math.cos(i/(double)particleAmount * 2 * Math.PI) * radius;
+//
+//				Location location = _creeper.getLocation().add(0.5, 0, 0.5).clone().add(xDiff, -1.3, zDiff);
+//				UtilParticle.PlayParticle(UtilParticle.ParticleType.WITCH_MAGIC, location, 0, 0, 0, 0, 1,
+//						ViewDist.NORMAL, UtilServer.getPlayers());
+//			}
+//
+//			Location _centerLocation = _creeper.getLocation().add(0.5, 0.1, 0.5);
+//			for (int i = 0; i < particleAmount; i++)
+//			{
+//				double xDiff = Math.sin(i/(double)particleAmount * 2 * Math.PI) * radius;
+//				double zDiff = Math.cos(i/(double)particleAmount * 2 * Math.PI) * radius;
+//				for(double e = 0.1 ; e < 3 ; e += 0.5)
+//				{
+//					Location location = _centerLocation.clone().add(xDiff, e, zDiff);
+//					UtilParticle.PlayParticle(UtilParticle.ParticleType.WITCH_MAGIC, location, 0, 0, 0, 0, 1, ViewDist.NORMAL, UtilServer.getPlayers());
+//				}
+//			}
+//		}
+//		else
+//		{
+//			finish();
+//		}
+//	}
+//
+//	public void RareAnimation()
+//	{
+//		if (getTicks() == 1)
+//		{
+//			for(int i = 0; i < 3; i++)
+//			{
+//				UtilFirework.playFirework(_creeper.getLocation().add(0.5, i, 0.5), Type.BALL, Color.FUCHSIA, false, false);
+//			}
+//			_creeper.getWorld().playSound(_creeper.getLocation(), Sound.WITHER_SPAWN, 10F, 1.2F);
+//		}
+//		else if (getTicks() >= 60)
+//		{
+//			finish();
+//		}
+//
+//		else if (getTicks() < 35)
+//		{
+//			double radius = 2 - (getTicks() / 10D * 2);
+//			int particleAmount = 20 - (getTicks() * 2);
+//			Location _centerLocation = _creeper.getLocation().add(0.5, 0.1, 0.5);
+//			for (int i = 0; i < particleAmount; i++)
+//			{
+//				double xDiff = Math.sin(i/(double)particleAmount * 2 * Math.PI) * radius;
+//				double zDiff = Math.cos(i/(double)particleAmount * 2 * Math.PI) * radius;
+//				for(double e = 0.1 ; e < 3 ; e += 0.6)
+//				{
+//					Location location = _centerLocation.clone().add(xDiff, e, zDiff);
+//					UtilParticle.PlayParticle(UtilParticle.ParticleType.WITCH_MAGIC, location, 0, 0, 0, 0, 1, ViewDist.NORMAL, UtilServer.getPlayers());
+//				}
+//			}
+//		}
+//	}
+//
+//	public void itemClean()
+//	{
+//		Iterator<Item> itemIterator = _items.iterator();
+//
+//		while (itemIterator.hasNext())
+//		{
+//			Item item = itemIterator.next();
+//
+//			if (item.isOnGround() || !item.isValid() || item.getTicksLived() > 60)
+//			{
+//				item.remove();
+//				itemIterator.remove();
+//			}
+//		}
+//	}
+}

GOD DAMN COSMETICS/bonuses/commands/AllowCommand.java

@@ -0,0 +1,77 @@
+package mineplex.core.bonuses.commands;
+
+import org.bukkit.entity.Player;
+
+import mineplex.core.bonuses.BonusManager;
+import mineplex.core.command.CommandBase;
+import mineplex.core.command.CommandCenter;
+import mineplex.core.command.ICommand;
+import mineplex.core.common.util.F;
+import mineplex.core.common.util.NautHashMap;
+import mineplex.core.common.util.UtilPlayer;
+
+/**
+ * Allows players to run rank-specific commands
+ * Found no better place to create it
+ */
+public class AllowCommand extends CommandBase<BonusManager>
+{
+	private BonusManager _plugin;
+
+	public AllowCommand(BonusManager plugin)
+	{
+		super(plugin, BonusManager.Perm.ALLOW_COMMAND, "allowCommand", "allowCmd");
+		_plugin = plugin;
+	}
+
+	@Override
+	public void Execute(Player caller, String[] args)
+	{
+		if (args.length < 2 || args.length > 3)
+		{
+			UtilPlayer.message(caller, F.main("Allow Command", "Usage: /allowCmd <player> <command> [disallow]"));
+			return;
+		}
+		NautHashMap<String, ICommand> commands = CommandCenter.getCommands();
+		if (!commands.containsKey(args[1].toLowerCase()))
+		{
+			UtilPlayer.message(caller, F.main("Allow Command", "Command not found!"));
+			return;
+		}
+		ICommand iCommand = commands.get(args[1]);
+		if (!_plugin.getClientManager().Get(caller).hasPermission(iCommand.getPermission()))
+		{
+			UtilPlayer.message(caller, F.main("Allow Command", "You're not allowed to use that command!"));
+			return;
+		}
+		boolean disallow = false;
+		if (args.length == 3)
+			disallow = Boolean.parseBoolean(args[2]);
+		Player receiver = UtilPlayer.searchExact(args[0]);
+		if (receiver == null)
+		{
+			UtilPlayer.message(caller, F.main("Allow Command", "Could not find player " + F.name(args[0]) + "!"));
+			return;
+		}
+		if (receiver.getUniqueId().equals(caller.getUniqueId()))
+		{
+			UtilPlayer.message(caller, F.main("Allow Command", "You can't use that for yourself!"));
+			return;
+		}
+		if (disallow)
+		{
+			boolean canDisallow = UtilPlayer.disallowCommand(receiver, args[1].toLowerCase());
+			if (!canDisallow)
+			{
+				UtilPlayer.message(caller, F.main("Allow Command", "That command was not allowed for the player " + F.name(receiver.getName()) + "!"));
+				return;
+			}
+			UtilPlayer.message(caller, F.main("Allow Command", "You disallowed the player " + F.name(receiver.getName()) + " to use the command " + F.elem(args[1]) + "!"));
+			UtilPlayer.message(receiver, F.main("Allow Command", "The player " + F.name(caller.getName()) + " disallowed you to use the command " + F.elem(args[1]) + "!"));
+			return;
+		}
+		UtilPlayer.allowCommand(receiver, args[1].toLowerCase());
+		UtilPlayer.message(caller, F.main("Allow Command", "You allowed the player " + F.name(receiver.getName()) + " to use the command " + F.elem(args[1]) + "!"));
+		UtilPlayer.message(receiver, F.main("Allow Command", "The player " + F.name(caller.getName()) + " allowed you to use the command " + F.elem(args[1]) + "!"));
+	}
+}

GOD DAMN COSMETICS/bonuses/commands/AnimationCommand.java

@@ -0,0 +1,32 @@
+package mineplex.core.bonuses.commands;
+
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+
+import mineplex.core.bonuses.BonusManager;
+import mineplex.core.command.CommandBase;
+import mineplex.core.reward.RewardType;
+
+public class AnimationCommand extends CommandBase<BonusManager>{
+
+	private BonusManager _plugin; 
+
+	public AnimationCommand(BonusManager plugin)
+	{
+		super(plugin, BonusManager.Perm.ANIMATION_COMMAND, "animation");
+		_plugin = plugin;
+	}
+
+	@Override
+	public void Execute(Player caller, String[] args)
+	{
+		caller = Bukkit.getPlayer(args[0]);
+		//plugin.addPendingExplosion(caller, _plugin.getRewardManager().nextReward(caller, null, false, RewardType.SPINNER_FILLER, true));
+
+		if (args.length >= 2)
+		{
+			_plugin.addPendingExplosion(caller, args[1]);
+		}
+
+	}
+}

GOD DAMN COSMETICS/bonuses/commands/GuiCommand.java

@@ -0,0 +1,23 @@
+package mineplex.core.bonuses.commands;
+
+import org.bukkit.entity.Player;
+
+import mineplex.core.Managers;
+import mineplex.core.bonuses.BonusManager;
+import mineplex.core.bonuses.gui.BonusGui;
+import mineplex.core.command.CommandBase;
+import mineplex.core.treasure.reward.TreasureRewardManager;
+
+public class GuiCommand extends CommandBase<BonusManager>
+{
+	public GuiCommand(BonusManager plugin)
+	{
+		super(plugin, BonusManager.Perm.GUI_COMMAND, "bonus");
+	}
+
+	@Override
+	public void Execute(Player caller, String[] args)
+	{
+		new BonusGui(Plugin.getPlugin(), caller, Plugin, Managers.require(TreasureRewardManager.class), Plugin.getYoutubeManager(), Plugin.getThankManager()).openInventory();
+	}	
+}

GOD DAMN COSMETICS/bonuses/commands/PowerPlayCommand.java

@@ -0,0 +1,47 @@
+package mineplex.core.bonuses.commands;
+
+import java.time.LocalDate;
+import java.time.YearMonth;
+
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.entity.Player;
+
+import mineplex.core.bonuses.BonusManager;
+import mineplex.core.command.CommandBase;
+import mineplex.core.common.util.F;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.powerplayclub.PowerPlayData;
+
+public class PowerPlayCommand extends CommandBase<BonusManager>
+{
+	private BonusManager _bonusManager;
+
+	public PowerPlayCommand(BonusManager manager)
+	{
+		super(manager, BonusManager.Perm.POWER_PLAY_COMMAND, "powerplay");
+		_bonusManager = manager;
+	}
+
+	@Override
+	public void Execute(Player caller, String[] args)
+	{
+		if (args.length < 1)
+		{
+			UtilPlayer.message(caller, F.main("Power Play Club", "Missing Args: " + F.elem("/powerplay <player>")));
+			return;
+		}
+
+		Player player = Bukkit.getPlayer(args[0]);
+		if (player == null) {
+			caller.sendMessage(ChatColor.RED + "Couldn't find player");
+			return;
+		}
+
+		PowerPlayData cached = _bonusManager.getPowerPlayClubRepository().getCachedData(player);
+		cached.getUnclaimedMonths().add(YearMonth.now());
+		_bonusManager.getPowerPlayClubRepository().addSubscription(_bonusManager.getClientManager().Get(player).getAccountId(), LocalDate.now(), "month");
+
+		caller.sendMessage(ChatColor.GREEN + "Gave a month's subscription to " + player.getName());
+	}
+}

GOD DAMN COSMETICS/bonuses/commands/TicketCommand.java

@@ -0,0 +1,67 @@
+package mineplex.core.bonuses.commands;
+
+import org.bukkit.entity.Player;
+
+import mineplex.core.bonuses.BonusManager;
+import mineplex.core.command.CommandBase;
+import mineplex.core.common.util.Callback;
+import mineplex.core.common.util.F;
+import mineplex.core.common.util.UtilPlayer;
+
+public class TicketCommand extends CommandBase<BonusManager>
+{
+	public TicketCommand(BonusManager plugin)
+	{
+		super(plugin, BonusManager.Perm.TICKET_COMMAND, "ticket");
+	}
+
+	@Override
+	public void Execute(final Player caller, String[] args)
+	{
+		if (args.length < 2)
+		{
+			UtilPlayer.message(caller, F.main("Carl", "Missing Args: " + F.elem("/ticket <player> <amount>")));
+			return;
+		}
+
+		final String targetName = args[0];
+		final String ticketString = args[1];
+		Player target = UtilPlayer.searchExact(targetName);
+
+
+		rewardTickets(caller, target, target.getName(), ticketString);
+	}
+
+	private void rewardTickets(final Player caller, final Player target, final String targetName, String ticketString)
+	{
+		try
+		{
+			final int tickets = Integer.parseInt(ticketString);
+			int accountId = Plugin.getClientManager().getAccountId(target);
+			Plugin.getRepository().attemptAddTickets(accountId, Plugin.Get(target), tickets, new Callback<Boolean>()
+			{
+				@Override
+				public void run(Boolean data)
+				{
+					if (data)
+					{
+						UtilPlayer.message(caller, F.main("Carl", "You gave " + F.elem(tickets + " Carl Tickets") + " to " + F.name(targetName) + "."));
+
+						if (target != null && !target.equals(caller))
+						{
+							UtilPlayer.message(target, F.main("Carl", F.name(caller.getName()) + " gave you " + F.elem(tickets + " Carl Tickets") + "."));
+						}
+					}
+					else
+					{
+						UtilPlayer.message(caller, F.main("Carl", "Failed to give tickets. Try again later!"));
+					}
+				}
+			});
+		}
+		catch (Exception e)
+		{
+			UtilPlayer.message(caller, F.main("Carl", "Invalid Ticket Amount"));
+		}
+	}
+}

GOD DAMN COSMETICS/bonuses/event/CarlSpinnerEvent.java

@@ -0,0 +1,54 @@
+package mineplex.core.bonuses.event;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+
+/**
+ * Called when a player attempts to purchase a spin through carl
+ */
+public class CarlSpinnerEvent extends Event implements Cancellable
+{
+	private static final HandlerList handlers = new HandlerList();
+
+	private Player _player;
+	private boolean _cancelled;
+
+	public CarlSpinnerEvent(Player player)
+	{
+		_player = player;
+	}
+
+	public HandlerList getHandlers()
+	{
+		return handlers;
+	}
+
+	public static HandlerList getHandlerList()
+	{
+		return handlers;
+	}
+
+	public Player getPlayer()
+	{
+		return _player;
+	}
+
+	public void setPlayer(Player player)
+	{
+		_player = player;
+	}
+
+	@Override
+	public boolean isCancelled()
+	{
+		return _cancelled;
+	}
+
+	@Override
+	public void setCancelled(boolean b)
+	{
+		_cancelled = b;
+	}
+}

GOD DAMN COSMETICS/bonuses/gui/BonusGui.java

@@ -0,0 +1,71 @@
+package mineplex.core.bonuses.gui;
+
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.Plugin;
+
+import mineplex.core.bonuses.BonusManager;
+import mineplex.core.bonuses.gui.buttons.CarlSpinButton;
+import mineplex.core.bonuses.gui.buttons.ClaimTipsButton;
+import mineplex.core.bonuses.gui.buttons.DailyBonusButton;
+import mineplex.core.bonuses.gui.buttons.DiscordButton;
+import mineplex.core.bonuses.gui.buttons.SocialMediaButton;
+import mineplex.core.bonuses.gui.buttons.LevelRewardsButton;
+import mineplex.core.bonuses.gui.buttons.PollButton;
+import mineplex.core.bonuses.gui.buttons.PowerPlayClubButton;
+import mineplex.core.bonuses.gui.buttons.RankBonusButton;
+import mineplex.core.bonuses.gui.buttons.VoteButton;
+import mineplex.core.bonuses.gui.buttons.YoutubeButton;
+import mineplex.core.gui.SimpleGui;
+import mineplex.core.thank.ThankManager;
+import mineplex.core.treasure.reward.TreasureRewardManager;
+import mineplex.core.youtube.YoutubeManager;
+
+public class BonusGui extends SimpleGui
+{
+	private static final int VOTE_SLOT = 32;
+	private static final int RANK_BONUS_SLOT = 10;
+	private static final int DAILY_BONUS_SLOT = 12;
+	private static final int POLL_SLOT = 28;
+	private static final int DISCORD_SLOT = 20;
+	private static final int CLAIM_TIPS_SLOT = 30;
+	private static final int POWER_PLAY_SLOT = 16;
+	private static final int CARL_SPINNER_SLOT = 14;
+	private static final int YOUTUBE_SLOT = 24;
+	private static final int SOCIAL_MEDIA_SLOT = 34;
+	private static final int LEVEL_REWARDS_SLOT = 22;
+
+	private static final int INV_SIZE = 45;
+
+	public BonusGui(Plugin plugin, Player player, BonusManager manager, TreasureRewardManager rewardManager, YoutubeManager youtubeManager, ThankManager thankManager)
+	{
+		super(plugin, player, player.getName() + "'s Bonuses", INV_SIZE);
+
+		setItem(VOTE_SLOT, new VoteButton(plugin, player, this, manager));
+		
+		setItem(RANK_BONUS_SLOT, new RankBonusButton(getPlugin(), player, this, manager));
+		
+		setItem(DAILY_BONUS_SLOT, new DailyBonusButton(getPlugin(), player, this, manager));
+
+		setItem(POLL_SLOT, new PollButton(getPlugin(), player, manager.getPollManager(), manager.getClientManager(), this, manager));
+
+		setItem(SOCIAL_MEDIA_SLOT, new SocialMediaButton(player));
+
+		setItem(YOUTUBE_SLOT, new YoutubeButton(player, youtubeManager));
+
+		setItem(DISCORD_SLOT, new DiscordButton(player));
+
+		setItem(CLAIM_TIPS_SLOT, new ClaimTipsButton(getPlugin(), player, this, manager, thankManager));
+
+		setItem(POWER_PLAY_SLOT, new PowerPlayClubButton(player, manager));
+
+		setItem(CARL_SPINNER_SLOT, new CarlSpinButton(getPlugin(), player, manager, rewardManager));
+
+		setItem(LEVEL_REWARDS_SLOT, new LevelRewardsButton(manager.getLevelingManager(), player));
+	}
+	
+	@Override
+	protected void finalize() throws Throwable
+	{
+		super.finalize();
+	}
+}

GOD DAMN COSMETICS/bonuses/gui/SpinGui.java

@@ -0,0 +1,276 @@
+package mineplex.core.bonuses.gui;
+
+import java.util.ArrayList;
+
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.inventory.InventoryCloseEvent;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.plugin.Plugin;
+
+import mineplex.core.bonuses.BonusManager;
+import mineplex.core.bonuses.gui.buttons.RewardButton;
+import mineplex.core.common.util.C;
+import mineplex.core.common.util.F;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.gui.DisplayItem;
+import mineplex.core.gui.SimpleGui;
+import mineplex.core.itemstack.ItemStackFactory;
+import mineplex.core.reward.Reward;
+import mineplex.core.reward.RewardData;
+import mineplex.core.shop.item.ShopItem;
+import mineplex.core.treasure.reward.RewardRarity;
+import mineplex.core.treasure.reward.TreasureRewardManager;
+import mineplex.core.treasure.types.CarlTreasure;
+import mineplex.core.updater.UpdateType;
+import mineplex.core.updater.event.UpdateEvent;
+
+public class SpinGui extends SimpleGui
+{
+
+	private static final int HOPPER_SLOT = 4;
+	private static final int CARL_SLOT = 22;
+	private static final int[] LINE_NUMS = { /*-27, -18,*/ -9, 9/*, 18*/};
+	private static final CarlTreasure TREASURE = new CarlTreasure();
+
+	private RewardData _rewardData;
+	private Reward _reward;
+	private BonusManager _manager;
+	private int _currentRewardIndex;
+	private int _ticksThisSwap;
+	private int _ticksPerSwap;
+	private Reward[] _rewards;
+	private boolean _stopped;
+	private boolean _rewarded;
+	private ArrayList<Integer> _ticks;
+	private int _frame;
+	private float _pitch;
+	private int _stopSpinnerAt;
+
+	public SpinGui(Plugin plugin, Player player, TreasureRewardManager rewardManager, BonusManager manager)
+	{
+		super(plugin, player, "Carl's Spinner", 27);
+
+		_manager = manager;
+
+		ShopItem carlItem = new ShopItem(Material.SKULL_ITEM, (byte) 4, "Carl's Spinner", new String[]{ChatColor.RESET + "Good Luck!"}, 1, false, false);
+
+		setItem(HOPPER_SLOT, new DisplayItem(new ItemStack(Material.HOPPER)));
+		//setItem(CARL_SLOT, new DisplayItem(carlItem));
+
+
+		_ticks = new ArrayList<>();
+		_frame = 0;
+		_pitch = 1;
+
+
+		_ticksPerSwap = 1;
+
+		for (int i = 0; i < 40; i++)
+			_ticks.add(1);
+
+		for (int i = 0; i < 20; i++)
+			_ticks.add(2);
+
+		for (int i = 0; i < 10; i++)
+			_ticks.add(4);
+
+		for (int i = 0; i < 4; i++)
+			_ticks.add(6);
+
+		for (int i = 0; i < 3; i++)
+			_ticks.add(8);
+
+		if (Math.random() > 0.5)
+		{
+			_ticks.add(12);
+		}
+
+		_stopSpinnerAt = _ticks.size();
+
+		//Create Rewards
+		_rewards = new Reward[_stopSpinnerAt + 10];        //Adding 10, so theres items to the right still.
+		for (int i = 0; i < _stopSpinnerAt + 10; i++)
+		{
+			if (i != _stopSpinnerAt + 4)
+			{
+				_rewards[i] = TREASURE.nextReward(player, true);
+			}
+			else
+			{
+				_rewards[i] = TREASURE.nextReward(player, false);
+				_reward = _rewards[i];
+			}
+		}
+
+		_reward.giveReward(player, data -> _rewardData = data);
+	}
+
+	private void tick()
+	{
+
+		if (_stopped)
+			return;
+
+		_ticksThisSwap++;
+
+		// Swap
+		if (_ticksThisSwap >= _ticksPerSwap)
+		{
+			_ticksThisSwap = 0;
+
+			if (_pitch == 1)
+				_pitch = (float) 1.5;
+			else if (_pitch == 1.5)
+				_pitch = 2;
+			else if (_pitch == 2)
+				_pitch = 1;
+
+			getPlayer().playSound(getPlayer().getEyeLocation(), Sound.NOTE_PLING, 1, _pitch);
+
+			_currentRewardIndex++;
+
+			updateGui();
+
+			// Slow
+			_ticksPerSwap = _ticks.get(_currentRewardIndex - 1);
+
+			if (_currentRewardIndex == _stopSpinnerAt)
+				_stopped = true;
+		}
+	}
+
+	public void updateGui()
+	{
+		for (int i = 0; i < 9; i++)
+		{
+			int index = _currentRewardIndex + i;
+
+			int slot = 9 + i;
+			RewardData data = _rewards[index].getFakeRewardData(getPlayer());
+			setItem(slot, new RewardButton(data));
+
+			// Glass Panes
+			for (int j = 0; j < LINE_NUMS.length; j++)
+			{
+				int paneSlot = slot + LINE_NUMS[j];
+				if (paneSlot == HOPPER_SLOT)
+					continue;
+
+				setItem(paneSlot, new DisplayItem(data.getRarity().getItemStack()));
+			}
+		}
+	}
+
+	@EventHandler
+	public void update(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.TICK)
+			return;
+
+		tick();
+		checkIfDone();
+	}
+
+	@EventHandler(priority = EventPriority.HIGHEST)
+	public void close(InventoryCloseEvent event)
+	{
+		if (_rewarded)
+			return;
+
+		if (event.getPlayer() != getPlayer())
+			return;
+
+		_manager.addPendingExplosion(getPlayer(), _reward);
+
+		if (_reward.getRarity() == RewardRarity.RARE)
+		{
+			Bukkit.broadcastMessage(F.main("Treasure", F.name(event.getPlayer().getName()) + " won " + C.cPurple + "Rare " + _rewardData.getFriendlyName() + C.cGray + " from Carl's Spinner."));
+		}
+		else if (_reward.getRarity() == RewardRarity.LEGENDARY)
+		{
+			Bukkit.broadcastMessage(F.main("Treasure", F.name(event.getPlayer().getName()) + " won " + C.cGreen + "Legendary " + _rewardData.getFriendlyName() + C.cGray + " from Carl's Spinner."));
+		}
+		else if (_reward.getRarity() == RewardRarity.MYTHICAL)
+		{
+			Bukkit.broadcastMessage(F.main("Treasure", F.name(event.getPlayer().getName()) + " won " + C.cRed + "Mythical " + _rewardData.getFriendlyName() + C.cGray + " from Carl's Spinner."));
+		}
+		else
+		{
+			UtilPlayer.message(getPlayer(), F.main("Carl's Spinner", "You won " + _rewardData.getRarity().getColor() + _rewardData.getFriendlyName() + C.cGray + " from Carl's Spinner."));
+		}
+	}
+
+	@EventHandler
+	public void Glass(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.FAST)
+			return;
+
+		if (!_stopped)
+			return;
+
+		if (!_rewarded)
+			return;
+
+		if (_frame == 0)
+		{
+			setItem(CARL_SLOT, new DisplayItem(_rewardData.getRarity().getItemStack()));
+			setItem(HOPPER_SLOT, new DisplayItem(_rewardData.getRarity().getItemStack()));
+			_frame++;
+		}
+		else if (_frame < 5)
+		{
+			setItem(HOPPER_SLOT + _frame, new DisplayItem(_rewardData.getRarity().getItemStack()));
+			setItem(HOPPER_SLOT - _frame, new DisplayItem(_rewardData.getRarity().getItemStack()));
+
+			setItem(CARL_SLOT + _frame, new DisplayItem(_rewardData.getRarity().getItemStack()));
+			setItem(CARL_SLOT - _frame, new DisplayItem(_rewardData.getRarity().getItemStack()));
+
+			setItem(13 + _frame, new DisplayItem(_rewardData.getRarity().getItemStack()));
+			setItem(13 - _frame, new DisplayItem(_rewardData.getRarity().getItemStack()));
+			_frame++;
+		}
+		if (_frame == 6)
+		{
+
+		}
+	}
+
+	public void checkIfDone()
+	{
+		if (!_stopped)
+			return;
+
+		if (_rewarded)
+			return;
+
+		_manager.addPendingExplosion(getPlayer(), _reward);
+		if (_reward.getRarity() == RewardRarity.RARE)
+		{
+			Bukkit.broadcastMessage(F.main("Treasure", F.name(getPlayer().getName()) + " won " + C.cPurple + "Rare " + _rewardData.getFriendlyName() + C.cGray + " from Carl's Spinner."));
+		}
+		else if (_reward.getRarity() == RewardRarity.LEGENDARY)
+		{
+			Bukkit.broadcastMessage(F.main("Treasure", F.name(getPlayer().getName()) + " won " + C.cGreen + "Legendary " + _rewardData.getFriendlyName() + C.cGray + " from Carl's Spinner."));
+		}
+		else if (_reward.getRarity() == RewardRarity.MYTHICAL)
+		{
+			Bukkit.broadcastMessage(F.main("Treasure", F.name(getPlayer().getName()) + " won " + C.cRed + "Mythical " + _rewardData.getFriendlyName() + C.cGray + " from Carl's Spinner."));
+		}
+		else
+		{
+			UtilPlayer.message(getPlayer(), F.main("Carl's Spinner", "You won " + _rewardData.getRarity().getColor() + _rewardData.getFriendlyName() + C.cGray + " from Carl's Spinner."));
+		}
+		ItemStack item = getInventory().getItem(13);
+		getInventory().setItem(13, ItemStackFactory.Instance.CreateStack(item.getType(), (byte) 0, 1, _rewardData.getFriendlyName()));
+		_rewarded = true;
+
+	}
+
+}

GOD DAMN COSMETICS/bonuses/gui/buttons/CarlSpinButton.java

@@ -0,0 +1,85 @@
+package mineplex.core.bonuses.gui.buttons;
+
+import java.util.ArrayList;
+
+import org.bukkit.ChatColor;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.event.inventory.ClickType;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.plugin.Plugin;
+
+import mineplex.core.common.util.C;
+import mineplex.core.gui.GuiItem;
+import mineplex.core.treasure.reward.TreasureRewardManager;
+import mineplex.core.shop.item.ShopItem;
+import mineplex.core.bonuses.BonusClientData;
+import mineplex.core.bonuses.BonusManager;
+
+public class CarlSpinButton implements GuiItem
+{
+	private Plugin _plugin;
+	private Player _player;
+	private BonusManager _bonusManager;
+	private TreasureRewardManager _rewardManager;
+
+	public CarlSpinButton(Plugin plugin, Player player, BonusManager bonusManager, TreasureRewardManager rewardManager)
+	{
+		_plugin = plugin;
+		_player = player;
+		_bonusManager = bonusManager;
+		_rewardManager = rewardManager;
+	}
+
+	@Override
+	public void setup()
+	{
+	}
+
+	@Override
+	public void close()
+	{
+
+	}
+
+	@Override
+	public void click(ClickType clickType)
+	{
+		BonusClientData client = _bonusManager.Get(_player);
+		int tickets = client.getTickets();
+
+		if (tickets > 0)
+		{
+			_bonusManager.attemptCarlSpin(_player);
+		}
+			
+//		new SpinGui(_plugin, _player, _rewardManager).openInventory();
+	}
+
+	@Override
+	public ItemStack getObject()
+	{
+		BonusClientData client = _bonusManager.Get(_player);
+		int tickets = client.getTickets();
+
+		String name = (tickets > 0 ? C.cGreen : C.cRed) + C.Bold + "Carl's Spinner";
+		ArrayList<String> lore = new ArrayList<String>();
+		Material material = Material.SKULL_ITEM;
+		byte data = (byte) 4;
+
+		lore.add(" ");
+		if (tickets > 0)
+		{
+			lore.add(ChatColor.RESET + "Click to Spin");
+		}
+		else
+		{
+			lore.add(ChatColor.RESET + "You need a Carl Spin Ticket to Spin");
+		}
+
+		lore.add(" ");
+		lore.add(ChatColor.YELLOW + "Your Tickets: " + C.cWhite + tickets);
+
+		return new ShopItem(material, data, name, lore.toArray(new String[0]), 1, false, false);
+	}
+}

GOD DAMN COSMETICS/bonuses/gui/buttons/ClaimTipsButton.java

@@ -0,0 +1,185 @@
+package mineplex.core.bonuses.gui.buttons;
+
+import mineplex.core.bonuses.BonusManager;
+import mineplex.core.common.currency.GlobalCurrency;
+import mineplex.core.common.util.C;
+import mineplex.core.common.util.F;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.gui.GuiItem;
+import mineplex.core.gui.ItemRefresher;
+import mineplex.core.gui.pages.LoadingWindow;
+import mineplex.core.gui.pages.TimedMessageWindow;
+import mineplex.core.itemstack.ItemStackFactory;
+import mineplex.core.recharge.Recharge;
+import mineplex.core.shop.item.ShopItem;
+import mineplex.core.thank.ThankManager;
+import org.bukkit.*;
+import org.bukkit.entity.Player;
+import org.bukkit.event.HandlerList;
+import org.bukkit.event.Listener;
+import org.bukkit.event.inventory.ClickType;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.plugin.Plugin;
+
+import java.util.ArrayList;
+
+public class ClaimTipsButton implements GuiItem, Listener
+{
+	private ItemStack _item;
+
+	private Player _player;
+	private Plugin _plugin;
+	private ItemRefresher _gui;
+
+	private BonusManager _bonusManager;
+	private ThankManager _thankManager;
+
+	public ClaimTipsButton(Plugin plugin, Player player, ItemRefresher gui, BonusManager bonusManager, ThankManager thankManager)
+	{
+		_bonusManager = bonusManager;
+		_thankManager = thankManager;
+		_player = player;
+		_plugin = plugin;
+		_gui = gui;
+	}
+
+	@Override
+	public void setup()
+	{
+		Bukkit.getPluginManager().registerEvents(this, getPlugin());
+		setItem();
+	}
+
+	@Override
+	public void close()
+	{
+		HandlerList.unregisterAll(this);
+	}
+
+	@Override
+	public void click(ClickType clickType)
+	{
+		if (!Recharge.Instance.use(_player, "Claim Tips Button", 1000, false, false))
+		{
+			return;
+		}
+		
+		if (isAvailable()) {
+			_item = ItemStackFactory.Instance.CreateStack(Material.LAPIS_BLOCK, (byte)0, 1, ChatColor.BLUE + "Processing...");
+			refreshItem();
+			new LoadingWindow(getPlugin(), getPlayer(), 6*9);
+			_thankManager.claimThanks(getPlayer(), claimThankResult -> {
+				if (claimThankResult != null && claimThankResult.getClaimed() > 0)
+				{
+					// Woo, success!
+					setItem();
+
+					if (getPlayer().getOpenInventory() != null)
+					{
+						new TimedMessageWindow(getPlugin(), getPlayer(), ItemStackFactory.Instance.CreateStack(Material.STAINED_GLASS_PANE, DyeColor.LIME.getDyeData(), 1, ChatColor.GREEN + "Amplifier Thanks Collected"), "Thanks Collected", 6*9, 20*3, getGui()).openInventory();
+					}
+
+					UtilPlayer.message(getPlayer(), F.main("Carl", "You collected " + F.currency(GlobalCurrency.TREASURE_SHARD, claimThankResult.getClaimed()) + " from " + F.elem(claimThankResult.getUniqueThanks()) + " players!"));
+					// Pending explosions are strange.. Not sure why we are using strings. Either way, lets display a rank reward effect
+					_bonusManager.addPendingExplosion(getPlayer(), "RANK");
+					getPlayer().playSound(getPlayer().getLocation(), Sound.NOTE_PLING, 1, 1.6f);
+				}
+				else if (claimThankResult != null && claimThankResult.getClaimed() == 0)
+				{
+					// No tips to claim
+					if (getPlayer().getOpenInventory() != null)
+					{
+						new TimedMessageWindow(getPlugin(), getPlayer(), ItemStackFactory.Instance.CreateStack(Material.STAINED_GLASS_PANE, DyeColor.RED.getDyeData(), 1, ChatColor.RED + "No Thanks to Claim!"), "You have no thank to claim!", 6*9, 20*3, getGui()).openInventory();
+					}
+
+					UtilPlayer.message(getPlayer(), F.main("Carl", "You have no rewards to claim!"));
+					getPlayer().playSound(getPlayer().getLocation(), Sound.ENDERDRAGON_GROWL, 1, 10);
+				}
+				else
+				{
+					// Failed to claim
+					if (getPlayer().getOpenInventory() != null)
+					{
+						new TimedMessageWindow(getPlugin(), getPlayer(), ItemStackFactory.Instance.CreateStack(Material.STAINED_GLASS_PANE, DyeColor.RED.getDyeData(), 1, ChatColor.RED + "Error collecting rewards. Try again later."), "Error", 6*9, 20*3, getGui()).openInventory();
+					}
+
+					UtilPlayer.message(getPlayer(), F.main("Carl", "Error collecting rewards. Try again later."));
+					getPlayer().playSound(getPlayer().getLocation(), Sound.ENDERDRAGON_GROWL, 1, 10);
+				}
+
+				getPlayer().closeInventory();
+			});
+		}
+		else
+		{
+			getPlayer().playSound(getPlayer().getLocation(), Sound.ITEM_BREAK, 1, 10);
+		}
+	}
+
+	private void setItem()
+	{
+		ArrayList<String> lore = new ArrayList<String>();
+		Material material;
+		String itemName;
+
+		if (isAvailable())
+		{
+			material = Material.EMERALD;
+			itemName = C.cGreen + C.Bold + "Thank Rewards";
+			lore.add(" ");
+			lore.add(C.cYellow + "Your Rewards");
+			lore.add("  " + C.cWhite + getTips() + " Treasure Shards");
+			lore.add(" ");
+			lore.add(ChatColor.RESET + "Click to Claim!");
+		}
+		else
+		{
+			material = Material.REDSTONE_BLOCK;
+			itemName = C.cRed + C.Bold + "Thank Rewards";
+
+			lore.add(" ");
+			lore.add(C.cGray + "Earn Thank Rewards from players using /thank");
+			lore.add(C.cGray + "on you, or by enabling Game Amplifiers.");
+			lore.add(" ");
+			lore.add(C.cWhite + "Get Amplifiers at " + C.cGreen + "mineplex.com/shop");
+		}
+
+		_item =  new ShopItem(material, itemName, lore.toArray(new String[0]), 1, false, false);
+	}
+
+	@Override
+	public ItemStack getObject()
+	{
+		return _item;
+	}
+
+	public void refreshItem()
+	{
+		getGui().refreshItem(this);
+	}
+
+	private int getTips()
+	{
+		return _thankManager.Get(_player).getThankToClaim();
+	}
+
+	private boolean isAvailable()
+	{
+		return getTips() > 0;
+	}
+
+	public Plugin getPlugin()
+	{
+		return _plugin;
+	}
+
+	public Player getPlayer()
+	{
+		return _player;
+	}
+
+	public ItemRefresher getGui()
+	{
+		return _gui;
+	}
+}

GOD DAMN COSMETICS/bonuses/gui/buttons/DailyBonusButton.java

@@ -0,0 +1,255 @@
+package mineplex.core.bonuses.gui.buttons;
+
+import java.util.ArrayList;
+
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.DyeColor;
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.HandlerList;
+import org.bukkit.event.Listener;
+import org.bukkit.event.inventory.ClickType;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.plugin.Plugin;
+
+import mineplex.core.bonuses.BonusAmount;
+import mineplex.core.bonuses.BonusClientData;
+import mineplex.core.bonuses.BonusManager;
+import mineplex.core.common.util.C;
+import mineplex.core.common.util.Callback;
+import mineplex.core.common.util.F;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.common.util.UtilTime;
+import mineplex.core.common.util.UtilTime.TimeUnit;
+import mineplex.core.gui.GuiItem;
+import mineplex.core.gui.ItemRefresher;
+import mineplex.core.gui.pages.LoadingWindow;
+import mineplex.core.gui.pages.TimedMessageWindow;
+import mineplex.core.itemstack.ItemStackFactory;
+import mineplex.core.recharge.Recharge;
+import mineplex.core.shop.item.ShopItem;
+import mineplex.core.updater.UpdateType;
+import mineplex.core.updater.event.UpdateEvent;
+
+public class DailyBonusButton implements GuiItem, Listener
+{
+	private ItemStack _item;
+	
+	private Player _player;
+	private Plugin _plugin;
+	private ItemRefresher _gui;
+	
+	private BonusManager _bonusManager;
+	
+	public DailyBonusButton(Plugin plugin, Player player, ItemRefresher gui, BonusManager bonusManager)
+	{
+		this._bonusManager = bonusManager;
+		this._player = player;
+		this._plugin = plugin;
+		this._gui = gui;
+	}
+
+	@Override
+	public void setup()
+	{
+		Bukkit.getPluginManager().registerEvents(this, getPlugin());
+		setItem();
+	}
+
+	@Override
+	public void close()
+	{
+		HandlerList.unregisterAll(this);
+	}
+
+	@Override
+	public void click(ClickType clickType)
+	{
+		if (!Recharge.Instance.use(_player, "Carl Daily Bonus", 1000, false, false))
+		{
+			return;
+		}
+		
+		if (isAvailable() && canUse())
+		{
+			_item = ItemStackFactory.Instance.CreateStack(Material.LAPIS_BLOCK, (byte)0, 1, ChatColor.BLUE + "Processing...");
+			refreshItem();
+			new LoadingWindow(getPlugin(), getPlayer(), 6*9);
+			_bonusManager.attemptDailyBonus(getPlayer(), _bonusManager.ClansBonus ? _bonusManager.getClansDailyBonusAmount(_player) : _bonusManager.getDailyBonusAmount(_player), _bonusManager.ClansBonus, new Callback<Boolean>()
+			{
+				@Override
+				public void run(Boolean t)
+				{
+					if (t)
+					{
+						setItem();
+
+						if (getPlayer().getOpenInventory() != null)
+						{
+							new TimedMessageWindow(getPlugin(), getPlayer(), ItemStackFactory.Instance.CreateStack(Material.STAINED_GLASS_PANE, DyeColor.LIME.getDyeData(), 1, ChatColor.GREEN + "Bonus collected!"), "Bonus collected!", 6*9, 20*3, getGui()).openInventory();
+						}
+						else
+						{
+							UtilPlayer.message(getPlayer(), F.main("Bonus", "Bonus collected!"));
+						}
+						_bonusManager.addPendingExplosion(getPlayer(), "DAILY");
+						getPlayer().playSound(getPlayer().getLocation(), Sound.NOTE_PLING, 1, 1.6f);
+					}
+					else
+					{
+						if (getPlayer().getOpenInventory() != null)
+						{
+							new TimedMessageWindow(getPlugin(), getPlayer(), ItemStackFactory.Instance.CreateStack(Material.STAINED_GLASS_PANE, DyeColor.RED.getDyeData(), 1, ChatColor.RED + "Failed to collect bonus!"), "Failed to collect bonus!", 6*9, 20*3, getGui()).openInventory();
+						}
+						else
+						{
+							UtilPlayer.message(getPlayer(), F.main("Bonus", "Failed to collect bonus!"));
+						}
+						getPlayer().playSound(getPlayer().getLocation(), Sound.ENDERDRAGON_GROWL, 1, 10);
+					}
+					getPlayer().closeInventory();
+				}
+			});
+		}
+		else
+		{
+			getPlayer().playSound(getPlayer().getLocation(), Sound.ITEM_BREAK, 1, 10);
+		}
+		return;
+	}
+	
+	@EventHandler
+	public void onUpdate(UpdateEvent event)
+	{
+		if (!event.getType().equals(UpdateType.SEC))
+			return;
+//		refreshItem(); // Todo Unnecessary?
+	}
+
+	private void setItem()
+	{
+		ArrayList<String> lore = new ArrayList<String>();
+		Material material;
+		String itemName;
+		byte data = 0;
+
+		if (isAvailable() && canUse())
+		{
+			material = Material.CHEST;
+			itemName = C.cGreen + C.Bold + "Daily Reward";
+
+			lore.add(" ");
+			lore.add(ChatColor.RESET + "Click to Claim!");
+		}
+		else if (!canUse())
+		{
+			material = Material.REDSTONE_BLOCK;
+			itemName = C.cRed + C.Bold + "Daily Reward";
+
+			lore.add(" ");
+			lore.add(ChatColor.RESET + "You must set your home server by joining a clan to claim this!");
+		}
+		else
+		{
+			material = Material.REDSTONE_BLOCK;
+			itemName = C.cRed + C.Bold + "Daily Reward";
+
+			lore.add(" ");
+			lore.add(ChatColor.RESET + "Next reward in " + UtilTime.convertString(timeLeft(), 0, TimeUnit.FIT) + "!");
+		}
+
+		lore.add(" ");
+		
+		if (!_bonusManager.ClansBonus)
+		{
+			BonusClientData client = _bonusManager.Get(_player);
+			
+			BonusAmount bonusAmount = _bonusManager.getDailyBonusAmount(_player);
+			bonusAmount.addLore(lore);
+			lore.add(" ");
+
+			lore.add(C.cYellow + "Current Streak: " + C.cWhite + client.getDailyStreak());
+			lore.add(C.cYellow + "Streak Bonus: " + C.cWhite + _bonusManager.getDailyMultiplier(_player) + "%");
+			lore.add(" ");
+			lore.add(C.cYellow + "Highest Streak: " + C.cWhite + client.getMaxDailyStreak());
+
+			if (client.getDailyTime() != null)
+			{
+				long lastBonus = BonusManager.getLocalTime(client.getDailyTime().getTime());
+				long timeLeft = _bonusManager.getStreakTimeRemaining(lastBonus, BonusManager.DAILY_STREAK_RESET_TIME);
+
+				if (timeLeft > 0)
+				{
+					lore.add(C.cYellow + "Streak Reset: " + C.cWhite + UtilTime.convertString(timeLeft, 1, TimeUnit.FIT));
+				}
+			}
+			
+//			StreakRecord streakRecord = _bonusManager.getDailyStreak();
+//			if (streakRecord != null)
+//			{
+//				lore.add(" ");
+//				lore.add(C.cYellow + "Record: " + C.cWhite + streakRecord.getPlayerName());
+//				lore.add(C.cYellow + "Streak: " + C.cWhite + streakRecord.getStreak());
+//			}
+		}
+		else
+		{
+			lore.add(C.cYellow + "Home Server: " + C.cWhite + _bonusManager.getClansHomeServer(getPlayer()).getLeft());
+			lore.add(" ");
+			BonusAmount amount = _bonusManager.getClansDailyBonusAmount(_player);
+			amount.addLore(lore);
+		}
+
+		_item =  new ShopItem(material, itemName, lore.toArray(new String[0]), 1, false, false);
+	}
+	
+	@Override
+	public ItemStack getObject()
+	{
+		return _item;
+	}
+	
+	public void refreshItem()
+	{
+		getGui().refreshItem(this);
+	}
+	
+	public long timeLeft()
+	{
+		long timeLeft = _bonusManager.nextDailyBonus(getPlayer()) - System.currentTimeMillis();
+		return timeLeft;
+	}
+	
+	public boolean isAvailable()
+	{
+		return (timeLeft() <= 0);
+	}
+	
+	public boolean canUse()
+	{
+		if (!_bonusManager.ClansBonus)
+		{
+			return true;
+		}
+		
+		return _bonusManager.getClansHomeServer(getPlayer()).getRight() != -1;
+	}
+	
+	public Plugin getPlugin()
+	{
+		return _plugin;
+	}
+
+	public Player getPlayer()
+	{
+		return _player;
+	}
+
+	public ItemRefresher getGui()
+	{
+		return _gui;
+	}
+}

GOD DAMN COSMETICS/bonuses/gui/buttons/DiscordButton.java

@@ -0,0 +1,65 @@
+package mineplex.core.bonuses.gui.buttons;
+
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.entity.Player;
+import org.bukkit.event.inventory.ClickType;
+import org.bukkit.inventory.ItemStack;
+
+import mineplex.core.common.jsonchat.ClickEvent;
+import mineplex.core.common.jsonchat.JsonMessage;
+import mineplex.core.common.util.C;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.gui.GuiItem;
+import mineplex.core.itemstack.ItemBuilder;
+
+public class DiscordButton implements GuiItem
+{
+	private static final ItemStack ICON = new ItemBuilder(Material.STAINED_GLASS)
+			// Cyan
+			.setData((short) 9)
+			.setTitle(C.cGreen + C.Bold + "Visit our Discord Server")
+			.addLore(
+					C.cWhite + "Check out our official Discord server where",
+					C.cWhite + "you can find news, changelogs and giveaways,",
+					C.cWhite + "give direct feedback to our admins, and more!",
+					" ",
+					C.cGreen + "Click to visit our Discord!"
+			)
+			.build();
+	
+	private static final String URL = "http://discord.mineplex.com";
+	private final Player _player;
+
+	public DiscordButton(Player player)
+	{
+		_player = player;
+	}
+
+	@Override
+	public void setup() {}
+
+	@Override
+	public void close() {}
+
+	@Override
+	public void click(ClickType clickType)
+	{
+		_player.closeInventory();
+		
+		_player.playSound(_player.getLocation(), Sound.NOTE_PLING, 1, 1.6f);
+		
+		UtilPlayer.message(_player, C.cGold + C.Bold + C.Strike + "=============================================");
+		UtilPlayer.message(_player, "");
+		new JsonMessage("      " + C.Bold + "Click to Open in Web Browser").click(ClickEvent.OPEN_URL, URL).sendToPlayer(_player);
+		new JsonMessage("      " + C.cGreen + C.Line + URL).click(ClickEvent.OPEN_URL, URL).sendToPlayer(_player);
+		UtilPlayer.message(_player, "");
+		UtilPlayer.message(_player, C.cGold + C.Bold + C.Strike + "=============================================");
+	}
+
+	@Override
+	public ItemStack getObject()
+	{
+		return ICON;
+	}
+}

GOD DAMN COSMETICS/bonuses/gui/buttons/LevelRewardsButton.java

@@ -0,0 +1,56 @@
+package mineplex.core.bonuses.gui.buttons;
+
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.event.inventory.ClickType;
+import org.bukkit.inventory.ItemStack;
+
+import mineplex.core.achievement.leveling.LevelingManager;
+import mineplex.core.common.util.C;
+import mineplex.core.gui.GuiItem;
+import mineplex.core.itemstack.ItemBuilder;
+
+public class LevelRewardsButton implements GuiItem
+{
+
+	private final LevelingManager _manager;
+	private final Player _player;
+	private final ItemStack _itemStack;
+
+	public LevelRewardsButton(LevelingManager manager, Player player)
+	{
+		_manager = manager;
+		_player = player;
+		long levelsToClaim = manager.getUnclaimedLevels(player);
+		boolean anyToClaim = levelsToClaim > 0;
+		_itemStack = new ItemBuilder(anyToClaim ? Material.EMERALD_BLOCK : Material.REDSTONE_BLOCK)
+				.setTitle((anyToClaim ? C.cGreenB : C.cRedB) + "Level Rewards")
+				.addLore("", "Earn rewards every time you", "level up your Mineplex Level!", "Unclaimed Rewards: " + C.cYellow + levelsToClaim, "", C.cGreen + "Click here to view rewards")
+				.setGlow(anyToClaim)
+				.build();
+	}
+
+	@Override
+	public void setup()
+	{
+
+	}
+
+	@Override
+	public void close()
+	{
+
+	}
+
+	@Override
+	public void click(ClickType clickType)
+	{
+		_manager.getShop().attemptShopOpen(_player);
+	}
+
+	@Override
+	public ItemStack getObject()
+	{
+		return _itemStack;
+	}
+}

GOD DAMN COSMETICS/bonuses/gui/buttons/PollButton.java

@@ -0,0 +1,231 @@
+package mineplex.core.bonuses.gui.buttons;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+import org.bukkit.ChatColor;
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.entity.Player;
+import org.bukkit.event.inventory.ClickType;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.plugin.Plugin;
+
+import mineplex.core.account.CoreClientManager;
+import mineplex.core.bonuses.BonusAmount;
+import mineplex.core.bonuses.BonusManager;
+import mineplex.core.common.util.C;
+import mineplex.core.common.util.UtilText;
+import mineplex.core.gui.GuiInventory;
+import mineplex.core.gui.GuiItem;
+import mineplex.core.gui.SimpleGui;
+import mineplex.core.gui.SimpleGuiItem;
+import mineplex.core.gui.botton.BackBotton;
+import mineplex.core.gui.pages.TimedMessageWindow;
+import mineplex.core.itemstack.ItemStackFactory;
+import mineplex.core.poll.Poll;
+import mineplex.core.poll.PollManager;
+import mineplex.core.recharge.Recharge;
+
+public class PollButton extends SimpleGui implements GuiItem {
+	
+	protected boolean _create;
+	
+	private PollManager _pollManager;
+	private BonusManager _bonusManager;
+	private CoreClientManager _clientManager;
+	private GuiInventory _master;
+
+	private HashMap<Integer, GuiItem> hard = new HashMap<Integer, GuiItem>();
+
+	private Poll _poll;
+
+	public PollButton(Plugin plugin, Player player, PollManager pollManager, CoreClientManager clientManager, GuiInventory master, BonusManager bonusManager)
+	{
+		super(plugin, player, "Poll:", 6 * 9);
+		this._create = true;
+		this._master = master;
+		this._clientManager = clientManager;
+		this._pollManager = pollManager;
+		hard.put(0, new BackBotton(master));
+		_bonusManager = bonusManager;
+	}
+	
+	@Override
+	public void setup()
+	{
+		if (_create)
+		{
+			_poll = _pollManager.getNextPoll(_pollManager.Get(getPlayer()), _clientManager.Get(getPlayer()).getPrimaryGroup());
+			
+			if (_poll != null)
+			{
+			
+				setItem(13, getQuestionItem(_poll.getQuestion()));
+
+				int[] slots = even(9, _poll.getAnswers().length);
+
+				for (int i = 0; i < slots.length; i++)
+				{
+					AnswerItem item = new AnswerItem(_poll, i);
+					setItem(9 * 3 + slots[i], item);
+				}
+			}
+		}
+	}
+	
+	@Override
+	public ItemStack getObject()
+	{
+		List<String> lore = new ArrayList<>();
+		if (_poll == null)
+		{
+			lore.add("");
+			lore.add(C.cWhite + "You've voted on all of the polls!");
+			return ItemStackFactory.Instance.CreateStack(Material.REDSTONE_BLOCK, (byte) 0, 1, ChatColor.RED + C.Bold + "Vote on Poll", lore);
+		}
+		else
+		{
+			lore.add("");
+			lore.add(C.cWhite + _poll.getQuestion());
+			lore.add("");
+			int i = 1;
+			for(String str : _poll.getAnswers())
+			{
+				lore.add(C.cAqua + "" + i + ".) " + C.cWhite + str);
+				i++;
+			}
+			lore.add("");
+			BonusAmount amount = new BonusAmount();
+			amount.setShards(_poll.getCoinReward());
+			amount.setGems(_poll.getCoinReward());
+			amount.addLore(lore);
+//			lore.add(C.cYellow + "Reward:" + C.cWhite + " 500 Gems");
+			lore.add("");
+			lore.add(C.cGreen + "Click to go to the vote page!");
+			return ItemStackFactory.Instance.CreateStack(Material.BOOK_AND_QUILL, (byte) 0, 1, C.cGreen + C.Bold + "Vote on Poll", lore);
+		}
+	}
+
+	@Override
+	public void click(ClickType clickType)
+	{
+		if (!Recharge.Instance.use(getPlayer(), "Poll Main Button", 1000, false, false))
+		{
+			return;
+		}
+		
+		if (_poll == null)
+		{
+			getPlayer().playSound(getPlayer().getLocation(), Sound.ITEM_BREAK, 1, 1.6f);
+		}
+		else
+		{
+			getPlayer().playSound(getPlayer().getLocation(), Sound.NOTE_PLING, 1, 1.6f);
+			openInventory();
+		}
+	}
+
+	public GuiItem getQuestionItem(String question)
+	{
+		List<String> lore = new ArrayList<>();
+		lore.add("");
+		for (String string : wrap(question))
+		{
+			lore.add(C.cWhite + string);
+		}
+		lore.add("");
+		int i = 1;
+		for (String str : _poll.getAnswers())
+		{
+			lore.add(C.cAqua + "" + i + ".) " + C.cWhite + str);
+			i++;
+		}
+		lore.add("");
+		BonusAmount amount = new BonusAmount();
+		amount.setShards(_poll.getCoinReward());
+		amount.setGems(_poll.getCoinReward());
+		amount.addLore(lore);
+		
+		return new SimpleGuiItem(ItemStackFactory.Instance.CreateStack(Material.BOOK_AND_QUILL, (byte) 0, 1, ChatColor.GREEN + C.cGreen + C.Bold + "Vote on Poll",
+				lore));
+	}
+
+	public static String[] wrap(String text)
+	{
+		return UtilText.wrap(text, 40);
+	}
+
+	public static int[] even(int size, int amount)
+	{
+		int[] list = new int[amount];
+
+		float interval = (size / amount);
+		float offset = -(interval / 2);
+
+		for (int i = 1; i <= amount; i++)
+		{
+			list[i - 1] = (int) (Math.ceil(i * interval) + offset);
+		}
+		return list;
+	}
+
+	public Poll getPoll()
+	{
+		return _poll;
+	}
+
+	public GuiInventory getMaster()
+	{
+		return _master;
+	}
+
+	private class AnswerItem implements GuiItem
+	{
+		private int _num;
+
+		private AnswerItem(Poll poll, int num)
+		{
+			_num = num;
+		}
+
+		@Override
+		public ItemStack getObject()
+		{
+			List<String> lore = new ArrayList<>();
+			lore.add("");
+			lore.add(C.cWhite + getPoll().getAnswers()[_num]);
+			return ItemStackFactory.Instance.CreateStack(Material.EMERALD, (byte) 0, 1, ChatColor.GREEN + "Option " + (_num + 1), lore);
+		}
+
+		@Override
+		public void click(ClickType clickType)
+		{
+			if (!Recharge.Instance.use(getPlayer(), "Poll Answer Button", 1000, false, false))
+			{
+				return;
+			}
+			
+			_create = true;
+			
+			_pollManager.answerPoll(getPlayer(), _poll, _num + 1);
+		
+			getPlayer().playSound(getPlayer().getLocation(), Sound.NOTE_PLING, 1, 1.6f);
+		
+			new TimedMessageWindow(getPlugin(), getPlayer(), ItemStackFactory.Instance.CreateStack(Material.EMERALD_BLOCK, (byte) 0, 1, ChatColor.GREEN + "Your anwser:", wrap(getPoll().getAnswers()[_num])), ChatColor.GREEN + "Moo", 6 * 9, 50, getMaster()).openInventory();
+			_bonusManager.addPendingExplosion(getPlayer(), "POLL");
+			getPlayer().closeInventory();
+		}
+
+		@Override
+		public void setup() {}
+
+		@Override
+		public void close() {}
+
+	}
+
+	@Override
+	public void close() {}
+}

GOD DAMN COSMETICS/bonuses/gui/buttons/PowerPlayClubButton.java

@@ -0,0 +1,177 @@
+package mineplex.core.bonuses.gui.buttons;
+
+import java.time.LocalDate;
+import java.time.YearMonth;
+import java.time.format.TextStyle;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.entity.Player;
+import org.bukkit.event.inventory.ClickType;
+import org.bukkit.inventory.ItemStack;
+
+import mineplex.core.bonuses.BonusManager;
+import mineplex.core.common.util.C;
+import mineplex.core.common.util.F;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.gui.GuiItem;
+import mineplex.core.inventory.InventoryManager;
+import mineplex.core.powerplayclub.PowerPlayClubRepository;
+import mineplex.core.powerplayclub.PowerPlayClubRewards;
+import mineplex.core.powerplayclub.PowerPlayData;
+import mineplex.core.shop.item.ShopItem;
+
+public class PowerPlayClubButton implements GuiItem
+{
+
+	private ItemStack _item;
+	private Player _player;
+	private PowerPlayClubRepository _powerPlayClubRepository;
+	private InventoryManager _inventoryManager;
+
+	public PowerPlayClubButton(Player player, BonusManager manager)
+	{
+		_player = player;
+		_powerPlayClubRepository = manager.getPowerPlayClubRepository();
+		_inventoryManager = manager.getInventoryManager();
+	}
+
+	@Override
+	public void setup()
+	{
+		setItem();
+	}
+
+	@Override
+	public void close()
+	{
+
+	}
+
+	@Override
+	public void click(ClickType clickType)
+	{
+		if (isAvailable())
+		{
+			_player.closeInventory();
+			_player.playSound(_player.getLocation(), Sound.NOTE_PLING, 1, 1.6f);
+			PowerPlayClubRewards.giveAllItems(_player, _inventoryManager, _powerPlayClubRepository);
+		}
+		else
+		{
+			_player.playSound(_player.getLocation(), Sound.ITEM_BREAK, 1, 10);
+			if (_powerPlayClubRepository.getCachedData(_player).isSubscribed())
+			{
+				UtilPlayer.message(_player, F.main("Power Play Club", "Already claimed! Come back next month!"));
+			}
+			else
+			{
+				UtilPlayer.message(_player, F.main("Power Play Club", "You have no months left! Buy more months at " + F.greenElem("www.mineplex.com/shop") + "!"));
+			}
+		}
+	}
+
+	@Override
+	public ItemStack getObject()
+	{
+		return _item;
+	}
+
+	private void setItem()
+	{
+		final Material material;
+		final String itemName;
+		final List<String> lore = new ArrayList<>();
+
+
+		PowerPlayData cached = _powerPlayClubRepository.getCachedData(_player);
+		Optional<LocalDate> maybeNextClaimDate = cached.getNextClaimDate();
+		Set<YearMonth> unclaimed = cached.getUnclaimedMonths();
+
+		if (!cached.getUsableCosmeticMonths().isEmpty())
+		{
+			lore.addAll(buildCosmeticsLore(cached.getUsableCosmeticMonths()));
+		}
+
+		if (!unclaimed.isEmpty())
+		{
+			// Player has unclaimed rewards, even if s/he's not currently subscribed
+			material = Material.GOLD_INGOT;
+			itemName = C.cGreenB + "Power Play Club";
+
+			lore.addAll(buildOtherRewardsLore(unclaimed.size()));
+			lore.add(C.cGold + "Click to claim!");
+
+		} else if (maybeNextClaimDate.isPresent()) // Player is still subscribed, and has claimed everything so far
+		{
+			LocalDate nextClaimDate = maybeNextClaimDate.get();
+
+			material = Material.REDSTONE_BLOCK;
+			itemName = C.cRedB + "Power Play Club";
+
+			lore.add(C.cYellow + "Come back " + C.cGreen + nextClaimDate.getMonth().getDisplayName(TextStyle.FULL, Locale.US) + " " + nextClaimDate.getDayOfMonth());
+			lore.add(C.cWhite + "  " + PowerPlayClubRewards.AMPLIFIERS_PER_MONTH + " Game Amplifier");
+			lore.add(C.cWhite + "  " + PowerPlayClubRewards.CHESTS_PER_MONTH + " Omega Chest");
+
+		} else
+		{
+			// Player isn't subscribed; show them the rewards for this current month and tell them to subscribe
+			material = Material.REDSTONE_BLOCK;
+			itemName = C.cRedB + "Power Play Club";
+
+			lore.add(C.cYellow + YearMonth.now().getMonth().getDisplayName(TextStyle.FULL, Locale.US) + "'s Cosmetic");
+			lore.add(C.cWhite + "  " + PowerPlayClubRewards.getReward(YearMonth.now()).getPrizeName());
+			lore.add(" ");
+			lore.addAll(buildOtherRewardsLore(1));
+			lore.add(C.cRed + "Get Power Play Club months at");
+			lore.add(C.cAqua + "mineplex.com/shop");
+		}
+
+		_item = new ShopItem(material, (byte)0, itemName, lore.toArray(new String[lore.size()]), 1, false, false);
+	}
+
+	private List<String> buildCosmeticsLore(Set<YearMonth> cosmeticsMonths)
+	{
+		List<String> lore = new ArrayList<>();
+		lore.add(C.cYellow + "Unlocked cosmetics");
+		PowerPlayClubRewards.rewards().entrySet().stream()
+				.filter(entry -> cosmeticsMonths.contains(entry.getKey()))
+				.sorted(Comparator.comparing(Map.Entry::getKey))
+				.forEach(entry ->
+				{
+					YearMonth yearMonth = entry.getKey();
+					lore.add(C.cWhite + "  " + entry.getValue().getPrizeName() + " " + C.cGold + yearMonth.getMonth().getDisplayName(TextStyle.SHORT, Locale.US) + " " + yearMonth.getYear());
+				});
+		lore.add(" ");
+		return lore;
+	}
+
+	private List<String> buildOtherRewardsLore(int unclaimed)
+	{
+		List<String> lore = new ArrayList<>();
+		lore.add(C.cYellow + "Other Rewards");
+		lore.add("  " + C.cWhite + (PowerPlayClubRewards.AMPLIFIERS_PER_MONTH * unclaimed) + " Game Amplifier");
+		lore.add("  " + C.cWhite + (PowerPlayClubRewards.CHESTS_PER_MONTH * unclaimed) + " Omega Chest");
+		lore.add(" ");
+		return lore;
+	}
+
+	private boolean isAvailable()
+	{
+		return !_powerPlayClubRepository.getCachedData(_player).getUnclaimedMonths().isEmpty();
+	}
+
+	public static boolean isAvailable(Player player, PowerPlayClubRepository repo)
+	{
+		PowerPlayData data = repo.getCachedData(player);
+		return data != null && !data.getUnclaimedMonths().isEmpty();
+	}
+
+}

GOD DAMN COSMETICS/bonuses/gui/buttons/RankBonusButton.java

@@ -0,0 +1,249 @@
+package mineplex.core.bonuses.gui.buttons;
+
+import java.util.ArrayList;
+
+import mineplex.core.common.util.C;
+import mineplex.core.common.util.Callback;
+import mineplex.core.common.util.F;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.common.util.UtilTime;
+import mineplex.core.common.util.UtilTime.TimeUnit;
+import mineplex.core.gui.GuiItem;
+import mineplex.core.gui.ItemRefresher;
+import mineplex.core.gui.pages.LoadingWindow;
+import mineplex.core.gui.pages.TimedMessageWindow;
+import mineplex.core.itemstack.ItemStackFactory;
+import mineplex.core.recharge.Recharge;
+import mineplex.core.shop.item.ShopItem;
+import mineplex.core.updater.UpdateType;
+import mineplex.core.updater.event.UpdateEvent;
+import mineplex.core.bonuses.BonusAmount;
+import mineplex.core.bonuses.BonusManager;
+
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.DyeColor;
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.HandlerList;
+import org.bukkit.event.Listener;
+import org.bukkit.event.inventory.ClickType;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.plugin.Plugin;
+
+public class RankBonusButton implements GuiItem, Listener {
+	
+	private boolean hasRank;
+	
+	private ItemStack _item;
+	
+	private Player _player;
+	private Plugin _plugin;
+	private ItemRefresher _gui;
+	
+	private BonusManager _bonusManager;
+	
+	public RankBonusButton(Plugin plugin, Player player, ItemRefresher gui, BonusManager bonusManager)
+	{
+		this._bonusManager = bonusManager;
+		this._player = player;
+		this._plugin = plugin;
+		this._gui = gui;
+	}
+	
+	@Override
+	public void setup()
+	{
+		if (_bonusManager.getRankBonusAmount(getPlayer()).isGreaterThanZero())
+		{
+			this.hasRank = true;
+			Bukkit.getPluginManager().registerEvents(this, getPlugin());
+		}
+		else
+		{
+			this.hasRank = false;
+		}
+
+		setItem();
+	}
+
+	@Override
+	public void close()
+	{
+		HandlerList.unregisterAll(this);
+	}
+
+
+	@Override
+	public void click(ClickType clickType)
+	{
+		if (!Recharge.Instance.use(_player, "Claim Rank Bonus", 1000, false, false))
+		{
+			return;
+		}
+		
+		if (isAvailable() && _bonusManager.isPastAugust()) {
+			_item = ItemStackFactory.Instance.CreateStack(Material.LAPIS_BLOCK, (byte)0, 1, ChatColor.BLUE + "Processing...");
+			refreshItem();
+			new LoadingWindow(getPlugin(), getPlayer(), 6*9);
+			_bonusManager.attemptRankBonus(getPlayer(), new Callback<Boolean>()
+			{
+				@Override
+				public void run(Boolean t)
+				{
+					setItem();
+
+					if (t)
+					{
+						if (getPlayer().getOpenInventory() != null)
+						{
+							new TimedMessageWindow(getPlugin(), getPlayer(), ItemStackFactory.Instance.CreateStack(Material.STAINED_GLASS_PANE, DyeColor.LIME.getDyeData(), 1, ChatColor.GREEN + "Bonus collected!"), "Bonus collected!", 6 * 9, 20 * 3, getGui()).openInventory();
+						}
+						else
+						{
+							UtilPlayer.message(getPlayer(), F.main("Bonus", "Bonus collected!"));
+						}
+						_bonusManager.addPendingExplosion(getPlayer(), "RANK");
+						getPlayer().playSound(getPlayer().getLocation(), Sound.NOTE_PLING, 1, 1.6f);
+					}
+					else
+					{
+						if (getPlayer().getOpenInventory() != null)
+						{
+							new TimedMessageWindow(getPlugin(), getPlayer(), ItemStackFactory.Instance.CreateStack(Material.STAINED_GLASS_PANE, DyeColor.RED.getDyeData(), 1, ChatColor.RED + "Failed to collect bonus!"), "Failed to collect bonus!", 6 * 9, 20 * 3, getGui()).openInventory();
+						}
+						else
+						{
+							UtilPlayer.message(getPlayer(), F.main("Bonus", "Failed to collect bonus!"));
+						}
+						getPlayer().playSound(getPlayer().getLocation(), Sound.ENDERDRAGON_GROWL, 1, 10);
+					}
+					getPlayer().closeInventory();
+				}
+			});
+		} else
+			getPlayer().playSound(getPlayer().getLocation(), Sound.ITEM_BREAK, 1, 10);
+		return;
+
+	}
+	
+	@EventHandler
+	public void onUpdate(UpdateEvent event)
+	{
+		if (!event.getType().equals(UpdateType.SEC))
+			return;
+//		refreshItem(); // Todo Unnecessary?
+	}
+	
+	@Override
+	public ItemStack getObject()
+	{
+		return _item;
+	}
+
+	private void setItem()
+	{
+		ArrayList<String> lore = new ArrayList<String>();
+		Material material;
+		String itemName;
+		byte data = 0;
+
+		if (_bonusManager.isPastAugust())
+		{
+			if (!hasRank)
+			{
+				material = Material.REDSTONE_BLOCK;
+				itemName = C.cRed + ChatColor.BOLD + "Rank Monthly Bonus";
+				lore.add(" ");
+				lore.add(ChatColor.WHITE + "Players with a Rank get a Monthly Bonus!");
+				lore.add(ChatColor.WHITE + "");
+				lore.add(ChatColor.AQUA + "Ultra receives 1 Mythical Chest Monthly");
+				lore.add(ChatColor.LIGHT_PURPLE + "Hero receives 2 Mythical Chests Monthly");
+				lore.add(ChatColor.GREEN + "Legend receives 3 Mythical Chests Monthly");
+				lore.add(ChatColor.RED + "Titan receives 5 Mythical Chests Monthly");
+				lore.add(ChatColor.WHITE + "");
+				lore.add(ChatColor.WHITE + "Purchase a Rank at;");
+				lore.add(ChatColor.WHITE + "www.mineplex.com/shop");
+			}
+			else
+			{
+				if (isAvailable())
+				{
+					material = Material.ENDER_CHEST;
+					itemName = C.cGreen + C.Bold + "Rank Monthly Bonus";
+
+					lore.add(" ");
+					lore.add(ChatColor.RESET + "Click to Claim!");
+				}
+				else
+				{
+					material = Material.REDSTONE_BLOCK;
+					itemName = C.cRed + C.Bold + "Rank Monthly Bonus";
+
+					lore.add(" ");
+					lore.add(ChatColor.RESET + "Next reward in " + UtilTime.convertString(timeLeft(), 0, TimeUnit.FIT) + "!");
+				}
+
+				lore.add(" ");
+				lore.add(C.cYellow + "Rank: " + C.cWhite + _bonusManager.getClientManager().Get(_player).getPrimaryGroup().getDisplay(false, false, false, true));
+				BonusAmount bonusAmount = _bonusManager.getRankBonusAmount(_player);
+				bonusAmount.addLore(lore);
+			}
+		}
+		else
+		{
+			itemName = C.cRed + ChatColor.BOLD + "Rank Monthly Bonus";
+			material = Material.REDSTONE_BLOCK;
+			lore.add(" ");
+			lore.add(ChatColor.RESET + "You can claim your Monthly Bonus");
+			lore.add(ChatColor.RESET + "here, starting from September!");
+		}
+
+
+		_item = new ShopItem(material, itemName, lore.toArray(new String[0]), 1, false, false);
+	}
+
+	public void refreshItem()
+	{
+		_gui.refreshItem(this);
+	}
+	
+	public long timeLeft()
+	{
+		return _bonusManager.nextRankBonus(getPlayer()) - System.currentTimeMillis();
+	}
+	
+	public boolean isAvailable()
+	{
+		if (!hasRank)
+		{
+			UtilPlayer.message(getPlayer(), "----------------------------------------");
+			UtilPlayer.message(getPlayer(), "");
+			UtilPlayer.message(getPlayer(), "Purchase a Rank at the Mineplex Shop:");
+			UtilPlayer.message(getPlayer(), C.cGreen + "www.mineplex.com/shop");
+			UtilPlayer.message(getPlayer(), "");
+			UtilPlayer.message(getPlayer(), "----------------------------------------");
+			
+			getPlayer().closeInventory();
+			return false;
+		}
+		return (timeLeft() <= 0);
+	}
+	
+	public Plugin getPlugin()
+	{
+		return _plugin;
+	}
+
+	public Player getPlayer()
+	{
+		return _player;
+	}
+
+	public ItemRefresher getGui()
+	{
+		return _gui;
+	}
+}

GOD DAMN COSMETICS/bonuses/gui/buttons/RewardButton.java

@@ -0,0 +1,46 @@
+package mineplex.core.bonuses.gui.buttons;
+
+import org.bukkit.event.inventory.ClickType;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+
+import mineplex.core.gui.GuiItem;
+import mineplex.core.reward.RewardData;
+
+public class RewardButton implements GuiItem
+{
+	private RewardData _data;
+
+	public RewardButton(RewardData data)
+	{
+		_data = data;
+	}
+
+	@Override
+	public void setup()
+	{
+
+	}
+
+	@Override
+	public void close()
+	{
+
+	}
+
+	@Override
+	public void click(ClickType clickType)
+	{
+		// Do nothing
+	}
+
+	@Override
+	public ItemStack getObject()
+	{
+		ItemStack stack = _data.getDisplayItem();
+		ItemMeta meta = stack.getItemMeta();
+		meta.setDisplayName(_data.getFriendlyName());
+		stack.setItemMeta(meta);
+		return stack;
+	}
+}

GOD DAMN COSMETICS/bonuses/gui/buttons/SocialMediaButton.java

@@ -0,0 +1,72 @@
+package mineplex.core.bonuses.gui.buttons;
+
+import mineplex.core.common.jsonchat.ClickEvent;
+import mineplex.core.common.jsonchat.JsonMessage;
+import mineplex.core.common.util.C;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.gui.GuiItem;
+import mineplex.core.itemstack.ItemBuilder;
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.entity.Player;
+import org.bukkit.event.inventory.ClickType;
+import org.bukkit.inventory.ItemStack;
+
+public class SocialMediaButton implements GuiItem
+{
+	private static final ItemStack ICON = new ItemBuilder(Material.LAPIS_BLOCK)
+			.setTitle(C.cGreen + C.Bold + "Visit our Social Media")
+			.addLore(
+					C.cWhite + "Be sure to \"Like\" us on",
+					C.cWhite + "Facebook for Giveaways, Announcements,",
+					C.cWhite + "and Much More!",
+					" ",
+					C.cWhite + "Check out and follow Mineplex on",
+					C.cWhite + "Twitter for Giveaways, Announcements,",
+					C.cWhite + "Teasers, and Tips!",
+					" ",
+					C.cGreen + "Click to visit us on Facebook and Twitter!"
+			)
+			.build();
+	
+	private final Player _player;
+
+	public SocialMediaButton(Player player)
+	{
+		_player = player;
+	}
+
+	@Override
+	public void setup() {}
+
+	@Override
+	public void close() {}
+
+	@Override
+	public void click(ClickType clickType)
+	{
+		_player.closeInventory();
+		
+		_player.playSound(_player.getLocation(), Sound.NOTE_PLING, 1, 1.6f);
+		
+		UtilPlayer.message(_player, C.cGold + C.Bold + C.Strike + "=============================================");
+		// FB
+		UtilPlayer.message(_player, "");
+		new JsonMessage("      " + C.Bold + "Click to Open in Web Browser").click(ClickEvent.OPEN_URL, "https://www.facebook.com/MineplexGames").sendToPlayer(_player);
+		new JsonMessage("      " + C.cGreen + C.Line + "https://www.facebook.com/MineplexGames").click(ClickEvent.OPEN_URL, "https://www.facebook.com/MineplexGames").sendToPlayer(_player);
+		UtilPlayer.message(_player, "");
+		// Twitter
+		UtilPlayer.message(_player, "");
+		new JsonMessage("      " + C.Bold + "Click to Open in Web Browser").click(ClickEvent.OPEN_URL, "https://www.twitter.com/Mineplex").sendToPlayer(_player);
+		new JsonMessage("      " + C.cGreen + C.Line + "https://www.twitter.com/Mineplex").click(ClickEvent.OPEN_URL, "https://www.twitter.com/Mineplex").sendToPlayer(_player);
+		UtilPlayer.message(_player, "");
+
+		UtilPlayer.message(_player, C.cGold + C.Bold + C.Strike + "=============================================");
+	}
+
+	@Override
+	public ItemStack getObject()
+	{
+		return ICON;
+	}
+}

GOD DAMN COSMETICS/bonuses/gui/buttons/SpecificChannelButton.java

@@ -0,0 +1,114 @@
+package mineplex.core.bonuses.gui.buttons;
+
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.entity.Player;
+import org.bukkit.event.inventory.ClickType;
+import org.bukkit.inventory.ItemStack;
+
+import mineplex.core.Managers;
+import mineplex.core.bonuses.BonusManager;
+import mineplex.core.common.Pair;
+import mineplex.core.common.jsonchat.ClickEvent;
+import mineplex.core.common.jsonchat.JsonMessage;
+import mineplex.core.common.util.C;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.gui.GuiItem;
+import mineplex.core.itemstack.ItemBuilder;
+import mineplex.core.recharge.Recharge;
+import mineplex.core.youtube.YoutubeManager;
+
+public class SpecificChannelButton implements GuiItem
+{
+	private final Player _player;
+	private final YoutubeManager _youtubeManager;
+	private Pair<String, String> _channel;
+	private ItemStack _item;
+
+	public SpecificChannelButton(Player player, YoutubeManager youtubeManager)
+	{
+		_player = player;
+		_youtubeManager = youtubeManager;
+	}
+
+	@Override
+	public void setup()
+	{
+		_channel = Pair.create("", "");
+		if (_youtubeManager.canSpecificYoutube(_player))
+		{
+			_item = new ItemBuilder(Material.APPLE)
+			.setTitle(C.cGreen + C.Bold + "Visit our featured creator " + C.cGoldB + _channel.getLeft())
+			.addLore(
+					C.cYellow + "Claim a Daily Reward",
+					C.cWhite + "by checking out the latest Video",
+					C.cWhite + "by " + C.cGold + _channel.getLeft() + C.cWhite + "!",
+					C.cWhite + " ",
+					C.cWhite + "Be sure and Subscribe if you",
+					C.cWhite + "enjoy their videos!",
+					" ",
+					C.cGreen + "Click to visit " + C.cGold + _channel.getLeft() + C.cGreen + " on YouTube!"
+			)
+			.build();
+		}
+		else
+		{
+			_item = new ItemBuilder(Material.APPLE)
+			.setTitle(C.cGreen + C.Bold + "Visit our featured creator " + C.cGoldB + _channel.getLeft())
+			.addLore(
+					C.cWhite + "Come back tomorrow for your",
+					C.cWhite + "Daily Reward!",
+					" ",
+					C.cWhite + "Check out the latest Video",
+					C.cWhite + "by " + C.cGold + _channel.getLeft() + C.cWhite + "!",
+					" ",
+					C.cWhite + "Be sure and Subscribe if you",
+					C.cWhite + "enjoy their videos!",
+					" ",
+					C.cGreen + "Click to visit " + C.cGold + _channel.getLeft() + C.cGreen + " on YouTube!"
+			)
+			.build();
+		}
+	}
+
+	@Override
+	public void close() {}
+
+	@Override
+	public void click(ClickType clickType)
+	{
+		if (!Recharge.Instance.use(_player, "Use Youtube Button", 1000, false, false))
+		{
+			return;
+		}
+		
+		_player.closeInventory();
+		
+		_player.playSound(_player.getLocation(), Sound.NOTE_PLING, 1, 1.6f);
+		
+		final String message;
+		if (_youtubeManager.canSpecificYoutube(_player))
+		{
+			message = "claim your Reward!";
+			_youtubeManager.attemptSpecificYoutube(_player, Managers.get(BonusManager.class).ClansBonus, Managers.get(BonusManager.class).getClansHomeServer(_player).getRight());
+		}
+		else
+		{
+			message = "visit " + _channel.getLeft() + " on YouTube!";
+		}
+		
+		UtilPlayer.message(_player, C.cGold + C.Bold + C.Strike + "=============================================");
+		UtilPlayer.message(_player, "");
+
+		new JsonMessage("      " + C.Bold + "Click to Open in Web Browser and " + message).click(ClickEvent.OPEN_URL, _channel.getRight()).sendToPlayer(_player);
+		new JsonMessage( "      " + C.cGreen + C.Line + _channel.getRight().replace("?sub_confirmation=1", "")).click(ClickEvent.OPEN_URL, _channel.getRight()).sendToPlayer(_player);
+		UtilPlayer.message(_player, "");
+		UtilPlayer.message(_player, C.cGold + C.Bold + C.Strike + "=============================================");
+	}
+
+	@Override
+	public ItemStack getObject()
+	{
+		return _item;
+	}
+}

GOD DAMN COSMETICS/bonuses/gui/buttons/VoteButton.java

@@ -0,0 +1,213 @@
+package mineplex.core.bonuses.gui.buttons;
+
+import java.util.ArrayList;
+
+import mineplex.core.bonuses.BonusAmount;
+import mineplex.core.bonuses.BonusClientData;
+import mineplex.core.bonuses.BonusManager;
+import mineplex.core.common.jsonchat.ClickEvent;
+import mineplex.core.common.jsonchat.JsonMessage;
+import mineplex.core.common.util.C;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.common.util.UtilTime;
+import mineplex.core.common.util.UtilTime.TimeUnit;
+import mineplex.core.gui.GuiItem;
+import mineplex.core.gui.ItemRefresher;
+import mineplex.core.shop.item.ShopItem;
+
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.entity.Player;
+import org.bukkit.event.HandlerList;
+import org.bukkit.event.Listener;
+import org.bukkit.event.inventory.ClickType;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.plugin.Plugin;
+
+public class VoteButton implements GuiItem, Listener
+{
+	private ItemStack _item;
+	
+	private String _url;
+	
+	private Player _player;
+	private Plugin _plugin;
+	private ItemRefresher _gui;
+	
+	private BonusManager _bonusManager;
+	
+	public VoteButton(Plugin plugin, Player player, ItemRefresher gui, BonusManager bonusManager)
+	{
+		_bonusManager = bonusManager;
+		_player = player;
+		_plugin = plugin;
+		_gui = gui;
+	}
+
+	@Override
+	public void setup()
+	{
+		//TODO get url from db
+		_url = _bonusManager.getVoteLink();
+
+		setItem();
+		Bukkit.getPluginManager().registerEvents(this, getPlugin());
+	}
+
+	@Override
+	public void close()
+	{
+		HandlerList.unregisterAll(this);
+	}
+
+	@Override
+	public void click(ClickType clickType)
+	{
+		if (isAvailable())
+		{
+			getPlayer().closeInventory();
+			
+			getPlayer().playSound(getPlayer().getLocation(), Sound.NOTE_PLING, 1, 1.6f);
+			
+			UtilPlayer.message(getPlayer(), C.cGold + C.Bold + C.Strike + "=============================================");
+			UtilPlayer.message(getPlayer(), "");
+
+			new JsonMessage("      " + C.Bold + "Click to Open in Web Browser").click(ClickEvent.OPEN_URL, _url).sendToPlayer(getPlayer());
+			new JsonMessage( "      " + C.cGreen + C.Line + _url).click(ClickEvent.OPEN_URL, _url).sendToPlayer(getPlayer());
+			UtilPlayer.message(getPlayer(), "");
+			UtilPlayer.message(getPlayer(), "      Please be patient. Votes may take a few minutes to register.");
+			UtilPlayer.message(getPlayer(), "");
+			UtilPlayer.message(getPlayer(), C.cGold + C.Bold + C.Strike + "=============================================");
+
+			getPlayer().closeInventory();
+			
+		}
+		else
+		{
+			getPlayer().playSound(getPlayer().getLocation(), Sound.ITEM_BREAK, 1, 10);
+		}
+	}
+	
+	@Override
+	public ItemStack getObject()
+	{
+		return _item;
+	}
+	
+	private void setItem()
+	{
+		ArrayList<String> lore = new ArrayList<String>();
+		Material material;
+		String itemName;
+		byte data = 0;
+
+		if (isAvailable() && canUse())
+		{
+			material = Material.JUKEBOX;
+			itemName = C.cGreen + C.Bold + "Vote for Mineplex";
+
+			lore.add(" ");
+			lore.add(ChatColor.RESET + "Click to Vote!");
+		}
+		else if (!canUse())
+		{
+			material = Material.REDSTONE_BLOCK;
+			itemName = C.cRed + C.Bold + "Vote for Mineplex";
+
+			lore.add(" ");
+			lore.add(ChatColor.RESET + "You must set your home server by joining a clan to receive voting rewards!");
+		}
+		else
+		{
+			material = Material.REDSTONE_BLOCK;
+			itemName = C.cRed + C.Bold + "Vote for Mineplex";
+
+			lore.add(" ");
+			lore.add(ChatColor.RESET + "Next vote in " + UtilTime.convertString(timeLeft(), 0, TimeUnit.FIT) + "!");
+		}
+
+		lore.add(" ");
+		
+		if (!_bonusManager.ClansBonus)
+		{
+			BonusClientData client = _bonusManager.Get(_player);
+
+			BonusAmount bonusAmount = _bonusManager.getVoteBonusAmount(_player);
+			bonusAmount.addLore(lore);
+			lore.add(" ");
+
+			lore.add(C.cYellow + "Current Streak: " + C.cWhite + client.getVoteStreak());
+			lore.add(C.cYellow + "Streak Bonus: " + C.cWhite + "+" + _bonusManager.getVoteMultiplier(client.getVoteStreak()) + "%");
+			if (client.getVoteTime() != null)
+			{
+				long lastBonus = _bonusManager.getLocalTime(client.getVoteTime().getTime());
+				long timeLeft = _bonusManager.getStreakTimeRemaining(lastBonus, BonusManager.VOTE_STREAK_RESET_TIME);
+
+				if (timeLeft > 0)
+				{
+					lore.add(C.cYellow + "Streak Reset: " + C.cWhite + UtilTime.convertString(timeLeft, 1, TimeUnit.FIT));
+				}
+			}
+
+			lore.add(" ");
+			lore.add(C.cYellow + "Highest Streak: " + C.cWhite + client.getMaxVoteStreak());
+			
+//			StreakRecord streakRecord = _bonusManager.getVoteStreak();
+//			if (streakRecord != null)
+//			{
+//				lore.add(" ");
+//				lore.add(C.cYellow + "Record: " + C.cWhite + streakRecord.getPlayerName());
+//				lore.add(C.cYellow + "Streak: " + C.cWhite + streakRecord.getStreak());
+//			}
+		}
+		else
+		{
+			lore.add(C.cYellow + "Home Server: " + C.cWhite + _bonusManager.getClansHomeServer(getPlayer()).getLeft());
+			lore.add(" ");
+			BonusAmount amount = _bonusManager.getClansVoteBonusAmount(_player);
+			amount.addLore(lore);
+		}
+
+		_item =  new ShopItem(material, itemName, lore.toArray(new String[0]), 1, false, false);
+	}
+	
+	public long timeLeft()
+	{
+		return _bonusManager.nextVoteTime(getPlayer()) - System.currentTimeMillis();
+	}
+	
+	public boolean isAvailable()
+	{
+		if (_url == null)
+			return false;
+
+		return (timeLeft() <= 0);
+	}
+	
+	public boolean canUse()
+	{
+		if (!_bonusManager.ClansBonus)
+		{
+			return true;
+		}
+		
+		return _bonusManager.getClansHomeServer(getPlayer()).getRight() != -1;
+	}
+	
+	public Plugin getPlugin()
+	{
+		return _plugin;
+	}
+
+	public Player getPlayer()
+	{
+		return _player;
+	}
+
+	public ItemRefresher getGui()
+	{
+		return _gui;
+	}
+}

GOD DAMN COSMETICS/bonuses/gui/buttons/YoutubeButton.java

@@ -0,0 +1,101 @@
+package mineplex.core.bonuses.gui.buttons;
+
+import mineplex.core.Managers;
+import mineplex.core.bonuses.BonusManager;
+import mineplex.core.common.jsonchat.ClickEvent;
+import mineplex.core.common.jsonchat.JsonMessage;
+import mineplex.core.common.util.C;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.gui.GuiItem;
+import mineplex.core.itemstack.ItemBuilder;
+import mineplex.core.recharge.Recharge;
+import mineplex.core.youtube.YoutubeManager;
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.entity.Player;
+import org.bukkit.event.inventory.ClickType;
+import org.bukkit.inventory.ItemStack;
+
+public class YoutubeButton implements GuiItem
+{
+	private static final ItemStack DISABLED_ICON = new ItemBuilder(Material.APPLE)
+			.setTitle(C.cGreen + C.Bold + "Visit us on YouTube")
+			.addLore(
+					C.cWhite + "Come back tomorrow for your",
+					C.cWhite + "Daily Reward!",
+					" ",
+					C.cWhite + "Check out the latest Video",
+					C.cWhite + "on the MineplexGames Channel!",
+					" ",
+					C.cWhite + "Be sure and Subscribe so you",
+					C.cWhite + "don't miss a video!",
+					" ",
+					C.cGreen + "Click to visit us on YouTube!"
+			)
+			.build();
+	private static final ItemStack ENABLED_ICON = new ItemBuilder(Material.APPLE)
+			.setTitle(C.cGreen + C.Bold + "Visit us on YouTube")
+			.addLore(
+					C.cYellow + "Claim your Daily Reward",
+					C.cWhite + "by checking out the latest Video",
+					C.cWhite + "on the MineplexGames Channel!",
+					C.cWhite + " ",
+					C.cWhite + "Be sure and Subscribe so you",
+					C.cWhite + "don't miss a video!",
+					" ",
+					C.cGreen + "Click to visit us on YouTube!"
+			)
+			.build();
+	private final Player _player;
+	private final YoutubeManager _youtubeManager;
+
+	public YoutubeButton(Player player, YoutubeManager youtubeManager)
+	{
+		this._player = player;
+		this._youtubeManager = youtubeManager;
+	}
+
+	@Override
+	public void setup() {}
+
+	@Override
+	public void close() {}
+
+	@Override
+	public void click(ClickType clickType)
+	{
+		if (!Recharge.Instance.use(_player, "Use Youtube Button", 1000, false, false))
+		{
+			return;
+		}
+		
+		_player.closeInventory();
+		
+		_player.playSound(_player.getLocation(), Sound.NOTE_PLING, 1, 1.6f);
+		
+		final String message;
+		if (_youtubeManager.canYoutube(_player))
+		{
+			message = "claim YouTube Prize!";
+			_youtubeManager.attemptYoutube(_player, Managers.get(BonusManager.class).ClansBonus, Managers.get(BonusManager.class).getClansHomeServer(_player).getRight());
+		}
+		else
+		{
+			message = "visit our YouTube page!";
+		}
+		
+		UtilPlayer.message(_player, C.cGold + C.Bold + C.Strike + "=============================================");
+		UtilPlayer.message(_player, "");
+
+		new JsonMessage("      " + C.Bold + "Click to Open in Web Browser and " + message).click(ClickEvent.OPEN_URL, "http://file.mineplex.com/ads.php").sendToPlayer(_player);
+		new JsonMessage( "      " + C.cGreen + C.Line + "http://youtube.com/mineplexgamesofficial").click(ClickEvent.OPEN_URL, "http://file.mineplex.com/ads.php").sendToPlayer(_player);
+		UtilPlayer.message(_player, "");
+		UtilPlayer.message(_player, C.cGold + C.Bold + C.Strike + "=============================================");
+	}
+
+	@Override
+	public ItemStack getObject()
+	{
+		return _youtubeManager.canYoutube(_player) ? ENABLED_ICON : DISABLED_ICON;
+	}
+}

GOD DAMN COSMETICS/bonuses/powerplay/PowerPlayAnimation.java

@@ -0,0 +1,29 @@
+package mineplex.core.bonuses.powerplay;
+
+import java.util.List;
+
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+
+public class PowerPlayAnimation
+{
+
+	private List<ItemStack> _animationItems;
+	private Player _player;
+
+	public PowerPlayAnimation(Player player, List<ItemStack> animationItems)
+	{
+		_animationItems = animationItems;
+		_player = player;
+	}
+
+	public List<ItemStack> getAnimationItems()
+	{
+		return _animationItems;
+	}
+
+	public Player getPlayer()
+	{
+		return _player;
+	}
+}

GOD DAMN COSMETICS/bonuses/redis/VoteHandler.java

@@ -0,0 +1,31 @@
+package mineplex.core.bonuses.redis;
+
+import org.bukkit.entity.Player;
+
+import mineplex.core.bonuses.BonusManager;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.serverdata.commands.CommandCallback;
+import mineplex.serverdata.commands.ServerCommand;
+
+public class VoteHandler implements CommandCallback
+{
+	private BonusManager _bonusManager;
+
+	public VoteHandler(BonusManager bonusManager)
+	{
+		_bonusManager = bonusManager;
+	}
+
+	@Override
+	public void run(ServerCommand command)
+	{
+		VotifierCommand v = ((VotifierCommand) command);
+
+		Player player = UtilPlayer.searchExact(v.getPlayerName());
+
+		if (player != null)
+		{
+			_bonusManager.handleVote(player, v.getRewardReceived(), v.isClans());
+		}
+	}
+}

GOD DAMN COSMETICS/bonuses/redis/VotifierCommand.java

@@ -0,0 +1,34 @@
+package mineplex.core.bonuses.redis;
+
+import mineplex.serverdata.commands.ServerCommand;
+
+public class VotifierCommand extends ServerCommand
+{
+	private String _playerName;
+	private int _rewardReceived;
+	private boolean _clans;
+
+	public VotifierCommand(String playerName, int rewardReceived, boolean clans, String... targetServer)
+	{
+		super(targetServer);
+
+		_playerName = playerName;
+		_rewardReceived = rewardReceived;
+		_clans = clans;
+	}
+
+	public String getPlayerName()
+	{
+		return _playerName;
+	}
+
+	public int getRewardReceived()
+	{
+		return _rewardReceived;
+	}
+	
+	public boolean isClans()
+	{
+		return _clans;
+	}
+}

GOD DAMN COSMETICS/boosters/Booster.java

@@ -0,0 +1,146 @@
+package mineplex.core.boosters;
+
+import com.mojang.authlib.properties.PropertyMap;
+import mineplex.core.common.util.UtilTime;
+
+import java.util.Date;
+import java.util.UUID;
+
+/**
+ * @author Shaun Bennett
+ */
+public class Booster
+{
+	private int _id;
+	private String _playerName;
+	private UUID _uuid;
+	private int _accountId;
+	private int _duration;
+	private double _multiplier;
+	private Date _startTime;
+	private Date _endTime;
+	private Date _activationTime;
+//	private PropertyMap _propertyMap;
+
+	public Booster()
+	{
+	}
+
+	public int getId()
+	{
+		return _id;
+	}
+
+	public String getPlayerName()
+	{
+		return _playerName;
+	}
+
+	public UUID getUuid()
+	{
+		return _uuid;
+	}
+
+	public int getAccountId()
+	{
+		return _accountId;
+	}
+
+	public int getDuration()
+	{
+		return _duration;
+	}
+
+	public Date getStartTime()
+	{
+		return _startTime;
+	}
+
+	public Date getEndTime()
+	{
+		return _endTime;
+	}
+
+	public Date getActivationTime()
+	{
+		return _activationTime;
+	}
+
+	public boolean isActive()
+	{
+		Date now = new Date();
+		return getStartTime().before(now) && getEndTime().after(now);
+	}
+
+	public long getTimeRemaining()
+	{
+		if (isActive())
+		{
+			return Math.max(0, getEndTime().getTime() - System.currentTimeMillis());
+		}
+		else if (getEndTime().after(new Date()))
+		{
+			return _duration * 1000L;
+		}
+		else
+		{
+			return 0;
+		}
+	}
+
+	public String getTimeRemainingString()
+	{
+		return UtilTime.convertColonString(getTimeRemaining(), UtilTime.TimeUnit.MINUTES, UtilTime.TimeUnit.SECONDS);
+	}
+
+	public double getMultiplier()
+	{
+		return _multiplier;
+	}
+
+//	public PropertyMap getPropertyMap()
+//	{
+//		return _propertyMap;
+//	}
+
+	@Override
+	public boolean equals(Object o)
+	{
+		if (this == o) return true;
+		if (o == null || getClass() != o.getClass()) return false;
+
+		Booster booster = (Booster) o;
+
+		if (_id != booster._id) return false;
+		return _accountId == booster._accountId;
+	}
+
+	@Override
+	public int hashCode()
+	{
+		int result = _id;
+		result = 31 * result + _accountId;
+		return result;
+	}
+
+	public int getIncreasePercent()
+	{
+		return (int) (getMultiplier() - 1) * 100;
+	}
+
+	@Override
+	public String toString()
+	{
+		return "Booster{" +
+				"_id=" + _id +
+				", _playerName='" + _playerName + '\'' +
+				", _uuid=" + _uuid +
+				", _accountId=" + _accountId +
+				", _duration=" + _duration +
+				", _multiplier=" + _multiplier +
+				", _startTime=" + _startTime +
+				", _endTime=" + _endTime +
+				", _activationTime=" + _activationTime +
+				'}';
+	}
+}

GOD DAMN COSMETICS/boosters/BoosterApiResponse.java

@@ -0,0 +1,26 @@
+package mineplex.core.boosters;
+
+import mineplex.core.common.api.ApiResponse;
+
+import java.util.Date;
+
+/**
+ * @author Shaun Bennett
+ */
+public class BoosterApiResponse extends ApiResponse
+{
+	private Date startTime;
+
+	public Date getStartTime()
+	{
+		return startTime;
+	}
+
+	@Override
+	public String toString()
+	{
+		return "BoosterApiResponse{" +
+				"startTime='" + startTime + '\'' +
+				"} " + super.toString();
+	}
+}

GOD DAMN COSMETICS/boosters/BoosterManager.java

@@ -0,0 +1,430 @@
+//package mineplex.core.boosters;
+//
+//import java.util.ArrayList;
+//import java.util.Collections;
+//import java.util.Date;
+//import java.util.HashMap;
+//import java.util.Iterator;
+//import java.util.List;
+//import java.util.Map;
+//import java.util.UUID;
+//
+//import org.bukkit.Bukkit;
+//import org.bukkit.ChatColor;
+//import org.bukkit.Material;
+//import org.bukkit.entity.Player;
+//import org.bukkit.event.Event;
+//import org.bukkit.event.EventHandler;
+//import org.bukkit.event.player.PlayerInteractEvent;
+//import org.bukkit.event.player.PlayerJoinEvent;
+//import org.bukkit.inventory.ItemStack;
+//import org.bukkit.plugin.java.JavaPlugin;
+//
+//import mineplex.core.MiniPlugin;
+//import mineplex.core.account.CoreClientManager;
+//import mineplex.core.account.permissions.Permission;
+//import mineplex.core.account.permissions.PermissionGroup;
+//import mineplex.core.boosters.command.BoosterCommand;
+//import mineplex.core.boosters.event.BoosterActivateEvent;
+//import mineplex.core.boosters.event.BoosterExpireEvent;
+//import mineplex.core.boosters.event.BoosterItemGiveEvent;
+//import mineplex.core.boosters.event.BoosterUpdateEvent;
+//import mineplex.core.boosters.gui.BoosterShop;
+//import mineplex.core.boosters.redis.BoosterUpdateRepository;
+//import mineplex.core.boosters.tips.BoosterThankManager;
+//import mineplex.core.common.util.C;
+//import mineplex.core.common.util.Callback;
+//import mineplex.core.common.util.UtilGear;
+//import mineplex.core.common.util.UtilInv;
+//import mineplex.core.common.util.UtilServer;
+//import mineplex.core.donation.DonationManager;
+//import mineplex.core.inventory.InventoryManager;
+//import mineplex.core.itemstack.ItemStackFactory;
+//import mineplex.core.thank.ThankManager;
+//import mineplex.core.updater.UpdateType;
+//import mineplex.core.updater.event.UpdateEvent;
+//
+///**
+// * BoosterManager handles the majority of logic for creating and getting Boosters. Every BoosterManager stores a cache
+// * for all boosters across all servers. We pull all boosters from the API when the server boots up. To keep them in sync,
+// * instead of consistently polling the API I have decided to go with a redis pub/sub solution to ensuring all boosters
+// * across all servers are up to date. Whenever the Booster API receives a call to add or modify boosters, it will publish
+// * an updated version of all boosters over redis.
+// *
+// * Boosters are enabled on live servers using "Booster Groups". A {@link mineplex.serverdata.data.ServerGroup} can specify
+// * which BoosterGroup applies to it. If there is no BoosterGroup, then it means the server does not use boosters. To add
+// * a BoosterGroup, you must add to the "boostergroups" set on redis (the same way the servergroups set works), otherwise
+// * the API will return an error saying that BoosterGroup does not exist. Currently BoosterGroups are no more than a String
+// * key for Boosters. In the future we may want to look into implementing BoosterGroup specific data such as default
+// * booster length and multiplier.
+// *
+// * @author Shaun Bennett
+// */
+//public class BoosterManager extends MiniPlugin
+//{
+//	// The InventoryManager item name for boosters. This is required to activate a booster on servers
+//	public static final String BOOSTER_ITEM = "Game Booster";
+//	// Item in arcade lobbies that opens the booster gui
+//	public static final ItemStack INTERFACE_ITEM = ItemStackFactory.Instance.CreateStack(Material.EMERALD, (byte)0, 1, ChatColor.RESET + C.cGreen + "Game Amplifiers");
+//	// Slot for the booster gui item
+//	public static final int INTERFACE_SLOT = 7;
+//
+//	public enum Perm implements Permission
+//	{
+//		ADD_BOOSTER_COMMAND,
+//		BOOSTER_COMMAND,
+//		BOOSTER_GUI_COMMAND,
+//		RELOAD_BOOSTERS_COMMAND,
+//		THANK_COMMAND,
+//	}
+//
+//	private BoosterRepository _repository;
+//	private CoreClientManager _clientManager;
+//	private DonationManager _donationManager;
+//	private InventoryManager _inventoryManager;
+//	private BoosterThankManager _boosterThankManager;
+//
+//	private BoosterShop _shop;
+//	private String _boosterGroup;
+//
+//	private boolean _giveInterfaceItem;
+//
+//	private long _cacheLastUpdated;
+//	private Map<String, List<Booster>> _boosterCache = new HashMap<>();
+//
+//	public BoosterManager(JavaPlugin plugin, String boosterGroup, CoreClientManager clientManager, DonationManager donationManager, InventoryManager inventoryManager, ThankManager thankManager)
+//	{
+//		super("Booster Manager", plugin);
+//
+//		_repository = new BoosterRepository();
+//		_boosterGroup = boosterGroup;
+//		_clientManager = clientManager;
+//		_donationManager = donationManager;
+//		_inventoryManager = inventoryManager;
+//
+//		_boosterThankManager = new BoosterThankManager(plugin, clientManager, thankManager);
+//		_shop = new BoosterShop(this, clientManager, donationManager);
+//
+//		try
+//		{
+//			Map<String, List<Booster>> boosters = _repository.getBoosters();
+//			if (boosters != null) _boosterCache = boosters;
+//		}
+//		catch (Exception e)
+//		{
+//			System.out.println("Failed to load boosters on server start.");
+//			e.printStackTrace();
+//		}
+//
+//		_giveInterfaceItem = canActivateBoosters();
+//
+//		new BoosterUpdateRepository(plugin);
+//
+//		generatePermissions();
+//	}
+//
+//	private void generatePermissions()
+//	{
+//		PermissionGroup.PLAYER.setPermission(Perm.BOOSTER_COMMAND, true, true);
+//		PermissionGroup.PLAYER.setPermission(Perm.THANK_COMMAND, true, true);
+//		PermissionGroup.DEV.setPermission(Perm.ADD_BOOSTER_COMMAND, true, true);
+//		PermissionGroup.DEV.setPermission(Perm.RELOAD_BOOSTERS_COMMAND, true, true);
+//		PermissionGroup.DEV.setPermission(Perm.BOOSTER_GUI_COMMAND, true, true);
+//	}
+//
+//	@Override
+//	public void addCommands()
+//	{
+//		addCommand(new BoosterCommand(this));
+//	}
+//
+//	/**
+//	 * Make an API call to grab all Boosters
+//	 */
+//	@Deprecated
+//	public void getBoostersAsync(Callback<Map<String, List<Booster>>> callback)
+//	{
+//		runAsync(() -> {
+//			try
+//			{
+//				long time = System.currentTimeMillis();
+//				Map<String, List<Booster>> boosters = _repository.getBoosters();
+//				long timeTaken = System.currentTimeMillis() - time;
+//				runSync(() -> {
+//					handleBoosterUpdate(boosters);
+//					if (callback != null) callback.run(boosters);
+//				});
+//			}
+//			catch (Exception e)
+//			{
+//				System.err.println("Failed to grab boosters;");
+//				e.printStackTrace();
+//			}
+//		});
+//	}
+//
+//	/**
+//	 * Make an API call to grab all boosters for a specific booster group
+//	 * @param boosterGroup
+//	 * @param callback
+//	 */
+//	@Deprecated
+//	public void getBoostersAsync(String boosterGroup, Callback<List<Booster>> callback)
+//	{
+//		runAsync(() -> {
+//			try
+//			{
+//				List<Booster> boosters = _repository.getBoosters(boosterGroup);
+//				if (callback != null) runSync(() -> callback.run(boosters));
+//			}
+//			catch (Exception e)
+//			{
+//				System.err.println("Failed to grab boosters for boostergroup: " + boosterGroup);
+//				e.printStackTrace();
+//			}
+//		});
+//	}
+//
+//	/**
+//	 * Process the new boosterMap whenever a BoosterUpdateEvent is sent. This will compare itself to the current
+//	 * cached BoosterMap and call events when it finds a booster was activated or deactivated
+//	 * @param boosterMap The new booster map
+//	 */
+//	private void handleBoosterUpdate(Map<String, List<Booster>> boosterMap)
+//	{
+//		_boosterCache.entrySet().stream()
+//				.filter(entry -> entry.getValue().size() > 0)
+//				.filter(entry -> boosterMap.get(entry.getKey()) == null)
+//				.forEach(entry -> callNextTick(new BoosterExpireEvent(entry.getKey(), entry.getValue().get(0))));
+//
+//		for (Map.Entry<String, List<Booster>> entry : boosterMap.entrySet())
+//		{
+//			List<Booster> current = _boosterCache.get(entry.getKey());
+//			if (entry.getValue() != null && !entry.getValue().isEmpty())
+//			{
+//				if (current == null || current.isEmpty())
+//				{
+//					// New booster was added
+//					callNextTick(new BoosterActivateEvent(entry.getKey(), entry.getValue().get(0)));
+//				} else if (!current.get(0).equals(entry.getValue().get(0)))
+//				{
+//					// First booster was deactivated, new booster replaced it
+//					callNextTick(new BoosterExpireEvent(entry.getKey(), current.get(0)));
+//					callNextTick(new BoosterActivateEvent(entry.getKey(), entry.getValue().get(0)));
+//				}
+//			}
+//		}
+//
+//		_cacheLastUpdated = System.currentTimeMillis();
+//		_boosterCache = boosterMap;
+//	}
+//
+//	private void tickBoosterCache()
+//	{
+//		List<Event> events = new ArrayList<>(3);
+//		for (Map.Entry<String, List<Booster>> entry : _boosterCache.entrySet())
+//		{
+//			Iterator<Booster> iterator = entry.getValue().iterator();
+//			boolean removedOne = false;
+//			while (iterator.hasNext())
+//			{
+//				Booster booster = iterator.next();
+//				if (!booster.isActive())
+//				{
+//					iterator.remove();
+//					removedOne = true;
+//					events.add(new BoosterExpireEvent(entry.getKey(), booster));
+//				}
+//				else
+//				{
+//					if (removedOne) events.add(new BoosterActivateEvent(entry.getKey(), booster));
+//					break;
+//				}
+//			}
+//		}
+//
+//		events.forEach(Bukkit.getPluginManager()::callEvent);
+//	}
+//
+//	@EventHandler
+//	public void tickBoosters(UpdateEvent event)
+//	{
+//		if (event.getType() == UpdateType.MIN_10)
+//		{
+//			// sync with API every 10 minutes, incase pubsub fails
+//			getBoostersAsync(null);
+//		}
+//		else if (event.getType() == UpdateType.SEC)
+//		{
+//			tickBoosterCache();
+//		}
+//	}
+//
+//	/**
+//	 * Return all boosters for the active booster group
+//	 * @return list of boosters, or null if there is no active booster group
+//	 */
+//	public List<Booster> getBoosters()
+//	{
+//		if (_boosterGroup == null || _boosterGroup.length() == 0)
+//		{
+//			return null;
+//		}
+//		else
+//		{
+//			List<Booster> boosters = _boosterCache.get(_boosterGroup);
+//			return boosters == null ? Collections.emptyList() : boosters;
+//		}
+//	}
+//
+//	public String getBoosterGroup()
+//	{
+//		return _boosterGroup;
+//	}
+//
+//	public long getBoostTime()
+//	{
+//		return getBoostTime(_boosterGroup);
+//	}
+//
+//	public long getBoostTime(String boosterGroup)
+//	{
+//		long time = 0;
+//		List<Booster> boosters = _boosterCache.get(boosterGroup);
+//		if (boosters != null && boosters.size() > 0)
+//		{
+//			for (Booster booster : boosters)
+//			{
+//				time += booster.getTimeRemaining();
+//			}
+//		}
+//
+//		return time;
+//	}
+//
+//	public Booster getActiveBooster()
+//	{
+//		return getActiveBooster(_boosterGroup);
+//	}
+//
+//	public Booster getActiveBooster(String boosterGroup)
+//	{
+//		List<Booster> boosters = _boosterCache.get(boosterGroup);
+//		if (boosters != null)
+//		{
+//			for (Booster booster : boosters)
+//			{
+//				if (booster.getEndTime().after(new Date()))
+//					return booster;
+//			}
+//		}
+//
+//		return null;
+//	}
+//
+//	public void activateBooster(Player player, Callback<BoosterApiResponse> callback)
+//	{
+//		activateBooster(_boosterGroup, player, callback);
+//	}
+//
+//	public void activateBooster(String serverGroup, Player player, Callback<BoosterApiResponse> callback)
+//	{
+//		String playerName = player.getName();
+//		UUID uuid = player.getUniqueId();
+//		int accountId = _clientManager.getAccountId(player);
+////		PropertyMap propertyMap = ((CraftPlayer) player).getHandle().getProfile().getProperties();
+//
+//		runAsync(() -> {
+//			BoosterApiResponse response = _repository.addBooster(serverGroup, playerName, uuid, accountId, 3600);
+//			callback.run(response);
+//		});
+//	}
+//
+//	public void chargeBooster(Player player, Callback<Boolean> callback)
+//	{
+//		_inventoryManager.addItemToInventory(callback, player, BOOSTER_ITEM, -1);
+//	}
+//
+//	public void refundBooster(Player player, Callback<Boolean> callback)
+//	{
+//		_inventoryManager.addItemToInventory(callback, player, BOOSTER_ITEM, 1);
+//	}
+//
+//	public void openShop(Player player)
+//	{
+//		_shop.attemptShopOpen(player);
+//	}
+//
+//	/**
+//	 * Booster updates are sent from {@link mineplex.core.boosters.redis.BoosterUpdateListener}
+//	 */
+//	@EventHandler
+//	public void onBoosterUpdate(BoosterUpdateEvent event)
+//	{
+//		handleBoosterUpdate(event.getBoosterMap());
+//	}
+//
+//	public BoosterThankManager getBoosterThankManager()
+//	{
+//		return _boosterThankManager;
+//	}
+//
+//	/**
+//	 * Returns the number of unactivated game boosters a player owns
+//	 * @param player
+//	 * @return The amount of unactivated game boosters the player owns
+//	 */
+//	public int getAvailableBoosterCount(Player player)
+//	{
+//		return _inventoryManager.Get(player).getItemCount(BOOSTER_ITEM);
+//	}
+//
+//	/**
+//	 * Can players activate boosters on this server?
+//	 * @return true if players are able to activate a booster on this server
+//	 */
+//	public boolean canActivateBoosters()
+//	{
+//		return _boosterGroup != null && _boosterGroup.length() > 0;
+//	}
+//
+//	public void giveInterfaceItem(Player player)
+//	{
+//		if (_giveInterfaceItem && !UtilGear.isMat(player.getInventory().getItem(INTERFACE_SLOT), Material.EMERALD))
+//		{
+//			BoosterItemGiveEvent event = new BoosterItemGiveEvent(player);
+//			UtilServer.CallEvent(event);
+//			if (event.isCancelled())
+//				return;
+//
+//			player.getInventory().setItem(INTERFACE_SLOT, INTERFACE_ITEM);
+//
+//			UtilInv.Update(player);
+//		}
+//	}
+//
+//	@EventHandler
+//	public void onJoin(PlayerJoinEvent event)
+//	{
+//		giveInterfaceItem(event.getPlayer());
+//	}
+//
+//	@EventHandler
+//	public void onInteract(PlayerInteractEvent event)
+//	{
+//		if (INTERFACE_ITEM.equals(event.getPlayer().getItemInHand()))
+//		{
+//			openShop(event.getPlayer());
+//		}
+//	}
+//
+//	public Map<String, List<Booster>> getBoosterCache()
+//	{
+//		return _boosterCache;
+//	}
+//
+//	private void callNextTick(Event event)
+//	{
+//		runSync(() -> getPluginManager().callEvent(event));
+//	}
+//}

GOD DAMN COSMETICS/boosters/BoosterProcessor.java

@@ -0,0 +1,63 @@
+//package mineplex.core.boosters;
+//
+//import mineplex.core.common.util.C;
+//import mineplex.core.common.util.F;
+//import mineplex.core.common.util.UtilTime;
+//import mineplex.core.shop.confirmation.ConfirmationCallback;
+//import mineplex.core.shop.confirmation.ConfirmationProcessor;
+//import org.bukkit.entity.Player;
+//import org.bukkit.inventory.Inventory;
+//
+///**
+// * @author Shaun Bennett
+// */
+//public class BoosterProcessor implements ConfirmationProcessor
+//{
+//	private BoosterManager _boosterManager;
+//	private Player _player;
+//
+//	public BoosterProcessor(BoosterManager boosterManager, Player player)
+//	{
+//		_boosterManager = boosterManager;
+//		_player = player;
+//	}
+//
+//	@Override
+//	public void init(Inventory inventory) {}
+//
+//	@Override
+//	public void process(ConfirmationCallback callback)
+//	{
+//		_boosterManager.chargeBooster(_player, data -> {
+//			if (data)
+//			{
+//				_boosterManager.activateBooster(_player, response -> {
+//					if (response.isSuccess())
+//					{
+//						long timeToStart = response.getStartTime().getTime() - System.currentTimeMillis();
+//						if (timeToStart <= 0) _player.sendMessage(F.main("Amplifier", "Game Amplifier Activated!"));
+//						else                  _player.sendMessage(F.main("Amplifier", "Game Amplifier Added. It will start in " + F.elem(UtilTime.convertString(timeToStart, 2, UtilTime.TimeUnit.FIT))));
+//						callback.resolve("Success!");
+//					}
+//					else
+//					{
+//						_player.sendMessage(C.cRed + "There was an error trying to enable your Game Amplifier");
+//						if (response.getStatusCode() == 503 && response.getError() != null && response.getError().length() > 0)
+//						{
+//							// Service Unavailable HTTP Code
+//							_player.sendMessage(C.cRed + "Error: " + response.getError());
+//						}
+//
+//						_boosterManager.refundBooster(_player, null);
+//						callback.reject("Failed. Try again later.");
+//					}
+//				});
+//			}
+//			else
+//			{
+//				callback.reject("Failed charging account.");
+//				_player.sendMessage(F.main("Amplifier", "There was an error charging your account. Try again later!"));
+//			}
+//		});
+//	}
+//}

GOD DAMN COSMETICS/boosters/BoosterRepository.java

@@ -0,0 +1,51 @@
+//package mineplex.core.boosters;
+//
+//import com.google.gson.GsonBuilder;
+//import com.google.gson.JsonObject;
+//import com.mineplex.shaded.google.reflect.TypeToken;
+//import com.mojang.authlib.properties.PropertyMap;
+//import mineplex.core.common.api.ApiEndpoint;
+//import mineplex.core.common.api.ApiFieldNamingStrategy;
+//import mineplex.core.common.api.ApiHost;
+//
+//import java.util.Arrays;
+//import java.util.List;
+//import java.util.Map;
+//import java.util.UUID;
+//
+///**
+// * Boosters interaction is handled through a web API. All data is represented as JSON and then parsed using gson.
+// *
+// * @author Shaun Bennett
+// */
+//public class BoosterRepository extends ApiEndpoint
+//{
+//	public BoosterRepository()
+//	{
+//		super(ApiHost.getAmplifierService(), "/booster", new GsonBuilder().setFieldNamingStrategy(new ApiFieldNamingStrategy())
+//				.registerTypeAdapter(PropertyMap.class, new PropertyMap.Serializer())
+//				.setDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSX").create());
+//	}
+//
+//	public Map<String, List<Booster>> getBoosters()
+//	{
+//		return getWebCall().get("/", new TypeToken<Map<String, List<Booster>>>(){}.getType());
+//	}
+//
+//	public List<Booster> getBoosters(String serverGroup)
+//	{
+//		return Arrays.asList(getWebCall().get("/" + serverGroup, Booster[].class));
+//	}
+//
+//	public BoosterApiResponse addBooster(String serverGroup, String playerName, UUID uuid, int accountId, int duration)
+//	{
+//		JsonObject body = new JsonObject();
+//		body.addProperty("playerName", playerName);
+//		body.addProperty("uuid", uuid.toString());
+//		body.addProperty("accountId", accountId);
+//		body.addProperty("duration", duration);
+////		body.add("propertyMap", getGson().toJsonTree(propertyMap));
+//
+//		return getWebCall().post("/" + serverGroup, BoosterApiResponse.class, body);
+//	}
+//}

GOD DAMN COSMETICS/boosters/command/AddCommand.java

@@ -0,0 +1,55 @@
+//package mineplex.core.boosters.command;
+//
+//import org.bukkit.ChatColor;
+//import org.bukkit.entity.Player;
+//
+//import mineplex.core.boosters.BoosterApiResponse;
+//import mineplex.core.boosters.BoosterManager;
+//import mineplex.core.command.CommandBase;
+//import mineplex.core.common.util.Callback;
+//import mineplex.core.common.util.F;
+//import mineplex.core.common.util.UtilPlayer;
+//
+///**
+// * @author Shaun Bennett
+// */
+//public class AddCommand extends CommandBase<BoosterManager>
+//{
+//	public AddCommand(BoosterManager plugin)
+//	{
+//		super(plugin, BoosterManager.Perm.ADD_BOOSTER_COMMAND, "add");
+//	}
+//
+//	@Override
+//	public void Execute(Player caller, String[] args)
+//	{
+//		if (args != null && args.length > 0)
+//		{
+//			String serverGroup = args[0];
+//			Plugin.activateBooster(serverGroup, caller, new Callback<BoosterApiResponse>()
+//			{
+//				@Override
+//				public void run(BoosterApiResponse response)
+//				{
+//					if (response.isSuccess())
+//					{
+//						UtilPlayer.message(caller, F.main("Amplifier", "Successfully added amplifier to " + F.elem(serverGroup)));
+//					}
+//					else
+//					{
+//						UtilPlayer.message(caller, F.main("Amplifier", "Failed to add amplifier. Error: " + F.elem(response.getError())));
+//					}
+//				}
+//			});
+//		}
+//		else
+//		{
+//			help(caller);
+//		}
+//	}
+//
+//	private void help(Player caller)
+//	{
+//		UtilPlayer.message(caller, F.help("amplifier add <servergroup>", "Add an amplifier to that server group", ChatColor.DARK_RED));
+//	}
+//}

GOD DAMN COSMETICS/boosters/command/BoosterCommand.java

@@ -0,0 +1,51 @@
+//package mineplex.core.boosters.command;
+//
+//import org.bukkit.ChatColor;
+//import org.bukkit.entity.Player;
+//
+//import mineplex.core.account.CoreClientManager;
+//import mineplex.core.boosters.BoosterManager;
+//import mineplex.core.command.MultiCommandBase;
+//import mineplex.core.common.util.F;
+//import mineplex.core.common.util.UtilPlayer;
+//
+//import static mineplex.core.Managers.require;
+//
+///**
+// * @author Shaun Bennett
+// */
+//public class BoosterCommand extends MultiCommandBase<BoosterManager>
+//{
+//	CoreClientManager _coreClientManager;
+//
+//	public BoosterCommand(BoosterManager plugin)
+//	{
+//		super(plugin, BoosterManager.Perm.BOOSTER_COMMAND, "amplifier");
+//
+//		_coreClientManager = require(CoreClientManager.class);
+//
+//		AddCommand(new AddCommand(plugin));
+//		AddCommand(new GuiCommand(plugin));
+//		AddCommand(new ReloadCommand(plugin));
+//		AddCommand(new ThankCommand(plugin));
+//	}
+//
+//	@Override
+//	protected void Help(Player caller, String[] args)
+//	{
+//		if (_coreClientManager.Get(caller).hasPermission(BoosterManager.Perm.ADD_BOOSTER_COMMAND))
+//		{
+//			UtilPlayer.message(caller, F.help("amplifier add <group>", "Add an amplifier to that group", ChatColor.DARK_RED));
+//		}
+//
+//		if (_coreClientManager.Get(caller).hasPermission(BoosterManager.Perm.BOOSTER_GUI_COMMAND))
+//		{
+//			UtilPlayer.message(caller, F.help("amplifier gui", "Open Amplifier GUI", ChatColor.DARK_RED));
+//		}
+//
+//		if (_coreClientManager.Get(caller).hasPermission(BoosterManager.Perm.THANK_COMMAND))
+//		{
+//			UtilPlayer.message(caller, F.help("amplifier thank <group>", "Thank an Amplifier for a specific Booster Group", ChatColor.WHITE));
+//		}
+//	}
+//}

GOD DAMN COSMETICS/boosters/command/GuiCommand.java

@@ -0,0 +1,23 @@
+//package mineplex.core.boosters.command;
+//
+//import org.bukkit.entity.Player;
+//
+//import mineplex.core.boosters.BoosterManager;
+//import mineplex.core.command.CommandBase;
+//
+///**
+// * @author Shaun Bennett
+// */
+//public class GuiCommand extends CommandBase<BoosterManager>
+//{
+//	public GuiCommand(BoosterManager plugin)
+//	{
+//		super(plugin, BoosterManager.Perm.BOOSTER_GUI_COMMAND, "gui");
+//	}
+//
+//	@Override
+//	public void Execute(Player caller, String[] args)
+//	{
+//		Plugin.openShop(caller);
+//	}
+//}

GOD DAMN COSMETICS/boosters/command/ReloadCommand.java

@@ -0,0 +1,31 @@
+//package mineplex.core.boosters.command;
+//
+//import org.bukkit.entity.Player;
+//
+//import mineplex.core.boosters.BoosterManager;
+//import mineplex.core.command.CommandBase;
+//import mineplex.core.common.util.F;
+//import mineplex.core.common.util.UtilPlayer;
+//
+///**
+// * @author Shaun Bennett
+// */
+//public class ReloadCommand extends CommandBase<BoosterManager>
+//{
+//	public ReloadCommand(BoosterManager plugin)
+//	{
+//		super(plugin, BoosterManager.Perm.RELOAD_BOOSTERS_COMMAND, "reload");
+//	}
+//
+//	@Override
+//	public void Execute(Player caller, String[] args)
+//	{
+//		Plugin.getBoostersAsync(data ->
+//		{
+//			if (data != null)
+//			{
+//				UtilPlayer.message(caller, F.main("Amplifier", "Amplifiers reloaded!"));
+//			}
+//		});
+//	}
+//}

GOD DAMN COSMETICS/boosters/command/ThankCommand.java

@@ -0,0 +1,74 @@
+//package mineplex.core.boosters.command;
+//
+//import org.apache.commons.lang3.StringUtils;
+//import org.bukkit.Sound;
+//import org.bukkit.entity.Player;
+//
+//import mineplex.core.boosters.Booster;
+//import mineplex.core.boosters.BoosterManager;
+//import mineplex.core.boosters.tips.BoosterThankManager;
+//import mineplex.core.boosters.tips.TipAddResult;
+//import mineplex.core.command.CommandBase;
+//import mineplex.core.common.currency.GlobalCurrency;
+//import mineplex.core.common.util.F;
+//import mineplex.core.common.util.UtilPlayer;
+//
+///**
+// * @author Shaun Bennett
+// */
+//public class ThankCommand extends CommandBase<BoosterManager>
+//{
+//	public ThankCommand(BoosterManager plugin)
+//	{
+//		super(plugin, BoosterManager.Perm.THANK_COMMAND, "thank");
+//	}
+//
+//	@Override
+//	public void Execute(Player caller, String[] args)
+//	{
+//		if (args == null || args.length == 0)
+//		{
+//			// try to thank the current amplifier group
+//			String boosterGroup = Plugin.getBoosterGroup();
+//			if (boosterGroup == null || boosterGroup.length() <= 0)
+//			{
+//				UtilPlayer.message(caller, F.main("Amplifier", "You must specify an Amplifier Group"));
+//				return;
+//			}
+//
+//			attemptToTipGroup(caller, boosterGroup);
+//		}
+//		else
+//		{
+//			String boosterGroup = StringUtils.join(args, ' ');
+//			attemptToTipGroup(caller, boosterGroup);
+//		}
+//	}
+//
+//	private void attemptToTipGroup(Player caller, String boosterGroup)
+//	{
+//		Booster booster = Plugin.getActiveBooster(boosterGroup);
+//		if (booster == null)
+//		{
+//			// Give a friendly oops message
+//			UtilPlayer.message(caller, F.main("Amplifier", "There was an error handling your request. Try again later"));
+//			return;
+//		}
+//		else
+//		{
+//			Plugin.getBoosterThankManager().addTip(caller, booster, result ->
+//			{
+//				if (result == TipAddResult.SUCCESS)
+//				{
+//					UtilPlayer.message(caller, F.main("Tip", "You thanked " + F.name(booster.getPlayerName()) + ". They earned " + F.currency(GlobalCurrency.TREASURE_SHARD, BoosterThankManager.TIP_FOR_SPONSOR) + " and you got "
+//							+ F.currency(GlobalCurrency.TREASURE_SHARD, BoosterThankManager.TIP_FOR_TIPPER)) + " in return!");
+//					caller.playSound(caller.getLocation(), Sound.LEVEL_UP, 1f, 1f);
+//				}
+//				else if (result.getFriendlyMessage() != null)
+//				{
+//					UtilPlayer.message(caller, F.main("Amplifier", result.getFriendlyMessage()));
+//				}
+//			});
+//		}
+//	}
+//}

GOD DAMN COSMETICS/boosters/event/BoosterActivateEvent.java

@@ -0,0 +1,46 @@
+package mineplex.core.boosters.event;
+
+import mineplex.core.boosters.Booster;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+
+/**
+ * Called when a Booster is activated. This will be called regardless of which "BoosterGroup" the current server is set
+ * to, so if you only want Boosters on the current BoosterGroup, you will need to verify it.
+ *
+ * @author Shaun Bennett
+ */
+public class BoosterActivateEvent extends Event
+{
+	private String _boosterGroup;
+	private Booster _booster;
+
+	public BoosterActivateEvent(String boosterGroup, Booster booster)
+	{
+		_boosterGroup = boosterGroup;
+		_booster = booster;
+	}
+
+	public String getBoosterGroup()
+	{
+		return _boosterGroup;
+	}
+
+	public Booster getBooster()
+	{
+		return _booster;
+	}
+
+	private static final HandlerList _handlers = new HandlerList();
+	private static HandlerList getHandlerList()
+	{
+		return _handlers;
+	}
+
+	@Override
+	public HandlerList getHandlers()
+	{
+		return getHandlerList();
+	}
+
+}

GOD DAMN COSMETICS/boosters/event/BoosterExpireEvent.java

@@ -0,0 +1,45 @@
+package mineplex.core.boosters.event;
+
+import mineplex.core.boosters.Booster;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+
+/**
+ * Called when a Booster is finished.
+ *
+ * @author Shaun Bennett
+ */
+public class BoosterExpireEvent extends Event
+{
+	private String _boosterGroup;
+	private Booster _booster;
+
+	public BoosterExpireEvent(String boosterGroup, Booster booster)
+	{
+		_boosterGroup = boosterGroup;
+		_booster = booster;
+	}
+
+	public String getBoosterGroup()
+	{
+		return _boosterGroup;
+	}
+
+	public Booster getBooster()
+	{
+		return _booster;
+	}
+
+	private static final HandlerList _handlers = new HandlerList();
+	private static HandlerList getHandlerList()
+	{
+		return _handlers;
+	}
+
+	@Override
+	public HandlerList getHandlers()
+	{
+		return getHandlerList();
+	}
+
+}

GOD DAMN COSMETICS/boosters/event/BoosterItemGiveEvent.java

@@ -0,0 +1,48 @@
+package mineplex.core.boosters.event;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+
+/**
+ * Called when a player is about to receive a booster gem. If cancelled the player will not receive said gem
+ */
+public class BoosterItemGiveEvent extends Event implements Cancellable
+{
+	private Player _player;
+	private boolean _cancelled;
+
+	public BoosterItemGiveEvent(Player player)
+	{
+		this._player = player;
+	}
+
+	public Player getPlayer()
+	{
+		return this._player;
+	}
+
+	public boolean isCancelled()
+	{
+		return this._cancelled;
+	}
+
+	public void setCancelled(boolean cancelled)
+	{
+		this._cancelled = cancelled;
+	}
+
+	private static final HandlerList _handlers = new HandlerList();
+
+	private static HandlerList getHandlerList()
+	{
+		return _handlers;
+	}
+
+	@Override
+	public HandlerList getHandlers()
+	{
+		return getHandlerList();
+	}
+}

GOD DAMN COSMETICS/boosters/event/BoosterUpdateEvent.java

@@ -0,0 +1,41 @@
+package mineplex.core.boosters.event;
+
+import mineplex.core.boosters.Booster;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Called when {@link mineplex.core.boosters.redis.BoosterUpdateListener} receives updated Boosters over redis pubsub.
+ *
+ * @author Shaun Bennett
+ */
+public class BoosterUpdateEvent extends Event
+{
+	private Map<String, List<Booster>> _boosterMap;
+
+	public BoosterUpdateEvent(Map<String, List<Booster>> boosterMap)
+	{
+		_boosterMap = boosterMap;
+	}
+
+	public Map<String, List<Booster>> getBoosterMap()
+	{
+		return _boosterMap;
+	}
+
+	private static final HandlerList _handlers = new HandlerList();
+	private static HandlerList getHandlerList()
+	{
+		return _handlers;
+	}
+
+	@Override
+	public HandlerList getHandlers()
+	{
+		return getHandlerList();
+	}
+
+}

GOD DAMN COSMETICS/boosters/gui/ActivateBoosterButton.java

@@ -0,0 +1,55 @@
+//package mineplex.core.boosters.gui;
+//
+//import mineplex.core.boosters.BoosterApiResponse;
+//import mineplex.core.boosters.BoosterManager;
+//import mineplex.core.common.util.C;
+//import mineplex.core.common.util.Callback;
+//import mineplex.core.common.util.F;
+//import mineplex.core.common.util.UtilTime;
+//import mineplex.core.shop.item.IButton;
+//import org.bukkit.entity.Player;
+//import org.bukkit.event.inventory.ClickType;
+//
+///**
+// * @author Shaun Bennett
+// */
+//@Deprecated
+//public class ActivateBoosterButton implements IButton
+//{
+//	private BoosterShop _boosterShop;
+//	private BoosterManager _boosterManager;
+//
+//	public ActivateBoosterButton(BoosterShop boosterShop, BoosterManager boosterManager)
+//	{
+//		_boosterShop = boosterShop;
+//		_boosterManager = boosterManager;
+//	}
+//
+//	@Override
+//	public void onClick(Player player, ClickType clickType)
+//	{
+//		player.closeInventory();
+//
+//		_boosterManager.chargeBooster(player, data -> {
+//			if (data)
+//			{
+//				_boosterManager.activateBooster(player, response -> {
+//					if (response.isSuccess())
+//					{
+//						long timeToStart = response.getStartTime().getTime() - System.currentTimeMillis();
+//						if (timeToStart <= 0) player.sendMessage(F.main("Amplifier", "Amplifier Activated!"));
+//						else                  player.sendMessage(F.main("Amplifier", "Game Amplifier Added. It will start in " + F.elem(UtilTime.convertString(timeToStart, 2, UtilTime.TimeUnit.FIT))));
+//					}
+//					else
+//					{
+//						player.sendMessage(C.cRed + "There was an error trying to enable your Amplifier :(");
+//					}
+//				});
+//			}
+//			else
+//			{
+//				player.sendMessage(F.main("Amplifier", "There was an error charging your account. Try again later!"));
+//			}
+//		});
+//	}
+//}

GOD DAMN COSMETICS/boosters/gui/BoosterPage.java

@@ -0,0 +1,228 @@
+//package mineplex.core.boosters.gui;
+//
+//import mineplex.core.account.CoreClientManager;
+//import mineplex.core.boosters.Booster;
+//import mineplex.core.boosters.BoosterManager;
+//import mineplex.core.boosters.BoosterProcessor;
+//import mineplex.core.common.util.C;
+//import mineplex.core.common.util.UtilTime;
+//import mineplex.core.donation.DonationManager;
+//import mineplex.core.shop.confirmation.ConfirmationPage;
+//import mineplex.core.shop.item.ShopItem;
+//import mineplex.core.shop.page.ShopPageBase;
+//import org.apache.commons.lang3.tuple.Triple;
+//import org.bukkit.Material;
+//import org.bukkit.entity.Player;
+//import org.bukkit.event.inventory.ClickType;
+//
+//import java.util.ArrayList;
+//import java.util.List;
+//import java.util.Map;
+//
+///**
+// * @author Shaun Bennett
+// */
+//public class BoosterPage extends ShopPageBase<BoosterManager, BoosterShop>
+//{
+//	public BoosterPage(BoosterManager plugin, BoosterShop shop, CoreClientManager clientManager, DonationManager donationManager, Player player)
+//	{
+//		super(plugin, shop, clientManager, donationManager, "Game Amplifiers", player, 45);
+//
+//		buildPage();
+//	}
+//
+//	@Override
+//	protected void buildPage()
+//	{
+//		ArrayList<String> lore = new ArrayList<>();
+//
+//		int amplifierCount = getPlugin().getAvailableBoosterCount(getPlayer());
+//		lore.add(" ");
+//		lore.add(C.cWhite + "You own " + C.cGreen + amplifierCount + C.cWhite +  " Game Amplifiers");
+//		if (getPlugin().canActivateBoosters() && amplifierCount > 0)
+//		{
+//			List<Booster> boosters = getPlugin().getBoosters();
+//
+//			long waitTime = getPlugin().getBoostTime();
+//			if (waitTime == 0)
+//			{
+//				lore.add(C.cWhite + "Amplifier would activate " + C.cGreen + "now");
+//				lore.add(" ");
+//				lore.add(C.cGray + "Once this Amplifier is activated");
+//				lore.add(C.cGray + "or queued you are not able to");
+//				lore.add(C.cGray + "cancel or refund it. You will still");
+//				lore.add(C.cGray + "earn rewards if you are offline.");
+//				lore.add(" ");
+//				lore.add(C.cWhite + "Click to Activate Amplifier");
+//			}
+//			else
+//			{
+//				lore.add(" ");
+//				lore.add(C.cWhite + "Amplifier would activate in " + C.cGreen + UtilTime.convertColonString(waitTime, UtilTime.TimeUnit.HOURS, UtilTime.TimeUnit.SECONDS));
+//				if (boosters.size() - 1 == 1)
+//				{
+//					lore.add(C.cWhite + "There is " + C.cGreen + 1 + C.cWhite + " Amplifier queued");
+//				}
+//				else if (boosters.size() - 1 > 0)
+//				{
+//					lore.add(C.cWhite + "There are " + C.cGreen + (boosters.size() - 1) + C.cWhite + " Amplifiers queued");
+//				}
+//				lore.add(" ");
+//				lore.add(C.cGray + "Once this Amplifier is activated");
+//				lore.add(C.cGray + "or queued you are not able to");
+//				lore.add(C.cGray + "cancel or refund it. You will still");
+//				lore.add(C.cGray + "earn rewards if you are offline.");
+//				lore.add(" ");
+//				lore.add(C.cWhite + "Click to Queue Amplifier");
+//			}
+//		}
+//		else
+//		{
+//			lore.add(" ");
+//			lore.add(C.cGray + "Game Amplifiers allow you to");
+//			lore.add(C.cGray + "increase the shards");
+//			lore.add(C.cGray + "earned in that game for 1 hour.");
+//			lore.add(C.cGray + "You will also earn bonus rewards");
+//			lore.add(C.cGray + "from players thanking you while");
+//			lore.add(C.cGray + "your amplifier is active.");
+//			lore.add(" ");
+//			lore.add(C.cWhite + "Get Amplifiers at " + C.cGreen + "mineplex.com/shop");
+//		}
+//
+//		ShopItem booster = new ShopItem(Material.SUGAR, "Game Amplifier", lore.toArray(new String[0]), 0, false, false);
+//		if (getPlugin().canActivateBoosters() && amplifierCount > 0)
+//		{
+//			addButton(13, booster, this::openConfirmation);
+//		}
+//		else
+//		{
+//			setItem(13, booster);
+//		}
+//
+//		addBoosterQueue();
+////		addOtherBoosters();
+//	}
+//
+//	private void openConfirmation(Player player, ClickType type)
+//	{
+//		ArrayList<String> lore = new ArrayList<>();
+//		lore.add(" ");
+//		lore.add(C.cGray + "Once this Amplifier is activated");
+//		lore.add(C.cGray + "or queued you are not able to");
+//		lore.add(C.cGray + "cancel or refund it. You will still");
+//		lore.add(C.cGray + "earn rewards if you are offline.");
+//		ShopItem booster = new ShopItem(Material.SUGAR, "Game Amplifier", lore.toArray(new String[0]), 0, false, false);
+//
+//		BoosterProcessor processor = new BoosterProcessor(getPlugin(), getPlayer());
+//		ConfirmationPage<BoosterManager, BoosterShop> page = new ConfirmationPage<>(getPlayer(), this, processor, booster);
+//		getShop().openPageForPlayer(getPlayer(), page);
+//	}
+//
+//	private void addBoosterQueue()
+//	{
+//		if (getPlugin().getBoosters() == null)
+//			return;
+//
+//		List<Booster> boosters = getPlugin().getBoosters();
+//		int startIndex = Math.max(0, (9 - boosters.size()) / 2);
+//		for (int i = 0; i < boosters.size() && i < 18; i++)
+//		{
+//			int slot = startIndex + 27 + i;
+//			Booster booster = boosters.get(i);
+//			boolean active = booster.isActive();
+//			int queueIndex = Math.max(1, i);
+//			boolean owns = getPlayer().getUniqueId().equals(booster.getUuid());
+//
+//			long timeActivatedDif = System.currentTimeMillis() - booster.getActivationTime().getTime();
+//			String activationTime = UtilTime.convertString(timeActivatedDif, 0, UtilTime.TimeUnit.FIT);
+//
+//			List<String> lore = new ArrayList<>();
+//			if (active)
+//			{
+//				lore.add(C.cWhite + "Active");
+//				lore.add(" ");
+//				String expireTime = UtilTime.convertColonString(booster.getTimeRemaining(), UtilTime.TimeUnit.MINUTES, UtilTime.TimeUnit.SECONDS);
+//				lore.add(C.cWhite + "Added by " + C.cGreen + booster.getPlayerName());
+//				lore.add(C.cWhite + "Expires in " + C.cGreen + expireTime);
+//			}
+//			else
+//			{
+//				long timeToActive = booster.getStartTime().getTime() - System.currentTimeMillis();
+//				String activeString = UtilTime.convertColonString(timeToActive, UtilTime.TimeUnit.HOURS, UtilTime.TimeUnit.SECONDS);
+//
+//				lore.add(" ");
+//				lore.add(C.cWhite + "Added by " + C.cGreen + booster.getPlayerName());
+//				lore.add(C.cWhite + "Starts in " + C.cGreen + activeString);
+////				lore.add(C.cWhite + "Position " + C.cGreen + queueIndex + C.cWhite + " in queue");
+//			}
+//
+//			lore.add(" ");
+//			lore.add(C.cGray + "Added " + activationTime + " ago");
+//
+//			ShopItem shopItem = new ShopItem(booster.isActive() ? Material.EMERALD_BLOCK : Material.REDSTONE_BLOCK,
+//					"Game Amplifier", lore.toArray(new String[0]), queueIndex, !active, false);
+//			setItem(slot, shopItem);
+//
+//			// Add glow if the booster belongs to you
+//			if (owns)
+//			{
+//				addGlow(slot);
+//			}
+//		}
+//	}
+//
+//	private void addOtherBoosters()
+//	{
+//		Map<String, List<Booster>> boosterMap = getPlugin().getBoosterCache();
+//		List<Triple<Integer, String, Booster>> tripleList = new ArrayList<>();
+//		for (Map.Entry<String, List<Booster>> entry : boosterMap.entrySet())
+//		{
+//			String boosterGroup = entry.getKey();
+//			// dont display boosters for the current booster group
+//			if (boosterGroup.equals(getPlugin().getBoosterGroup()))
+//				continue;
+//
+//			List<Booster> boosters = entry.getValue();
+//			for (int i = 0; i < boosters.size(); i++)
+//			{
+//				Booster booster = boosters.get(i);
+//				if (booster.getUuid().equals(getPlayer().getUniqueId()))
+//				{
+//					tripleList.add(Triple.of(i, boosterGroup, booster));
+//				}
+//			}
+//		}
+//
+//
+//		int startIndex = Math.max(0, (9 - tripleList.size()) / 2);
+//		for (int i = 0; i < 9 && i < tripleList.size(); i++)
+//		{
+//			Triple<Integer, String, Booster> triple = tripleList.get(i);
+//			int deliveryAmount = Math.max(1, triple.getLeft());
+//			String boosterGroup = triple.getMiddle();
+//			Booster booster = triple.getRight();
+//			long timeActivatedDif = System.currentTimeMillis() - booster.getActivationTime().getTime();
+//			String activationTime = UtilTime.convertString(timeActivatedDif, 2, UtilTime.TimeUnit.FIT);
+//
+//			List<String> lore = new ArrayList<String>();
+//			lore.add(" ");
+//			lore.add(C.cWhite + "Server: " + C.cGreen + boosterGroup);
+//			if (booster.isActive())
+//			{
+//				lore.add(C.cWhite + "Expires in " + C.cGreen + UtilTime.convertColonString(booster.getTimeRemaining(), UtilTime.TimeUnit.MINUTES, UtilTime.TimeUnit.SECONDS));
+//			}
+//			else
+//			{
+//				long timeToActive = booster.getStartTime().getTime() - System.currentTimeMillis();
+//				lore.add(C.cWhite + "Starts in " + C.cGreen + UtilTime.convertColonString(timeToActive, UtilTime.TimeUnit.HOURS, UtilTime.TimeUnit.SECONDS));
+//			}
+//
+//			lore.add(" ");
+//			lore.add(C.cGray + "Added " + activationTime + " ago");
+//
+//			ShopItem shopItem = new ShopItem(Material.GOLD_BLOCK,
+//					"Game Amplifier", lore.toArray(new String[0]), 1, false, false);
+//			setItem(startIndex + i + 27, shopItem);
+//		}
+//	}
+//}

GOD DAMN COSMETICS/boosters/gui/BoosterShop.java

@@ -0,0 +1,37 @@
+//package mineplex.core.boosters.gui;
+//
+//import mineplex.core.account.CoreClientManager;
+//import mineplex.core.boosters.BoosterManager;
+//import mineplex.core.donation.DonationManager;
+//import mineplex.core.shop.ShopBase;
+//import mineplex.core.shop.page.ShopPageBase;
+//import mineplex.core.updater.UpdateType;
+//import mineplex.core.updater.event.UpdateEvent;
+//import org.bukkit.entity.Player;
+//import org.bukkit.event.EventHandler;
+//
+///**
+// * @author Shaun Bennett
+// */
+//public class BoosterShop extends ShopBase<BoosterManager>
+//{
+//	public BoosterShop(BoosterManager plugin, CoreClientManager clientManager, DonationManager donationManager)
+//	{
+//		super(plugin, clientManager, donationManager, "Game Amplifiers");
+//	}
+//
+//	@Override
+//	protected ShopPageBase<BoosterManager, ? extends ShopBase<BoosterManager>> buildPagesFor(Player player)
+//	{
+//		return new BoosterPage(getPlugin(), this, getClientManager(), getDonationManager(), player);
+//	}
+//
+//	@EventHandler
+//	public void update(UpdateEvent event)
+//	{
+//		if (event.getType() != UpdateType.SEC)
+//			return;
+//
+//		getPlayerPageMap().values().stream().filter(value -> value instanceof BoosterPage).forEach(ShopPageBase::refresh);
+//	}
+//}

GOD DAMN COSMETICS/boosters/redis/BoosterUpdateListener.java

@@ -0,0 +1,44 @@
+package mineplex.core.boosters.redis;
+
+import com.mineplex.shaded.google.reflect.TypeToken;
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import mineplex.core.boosters.Booster;
+import mineplex.core.boosters.event.BoosterUpdateEvent;
+import mineplex.core.common.api.ApiFieldNamingStrategy;
+import org.bukkit.Bukkit;
+import org.bukkit.plugin.java.JavaPlugin;
+import redis.clients.jedis.JedisPubSub;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author Shaun Bennett
+ */
+public class BoosterUpdateListener extends JedisPubSub
+{
+	private Gson _gson = new GsonBuilder().setFieldNamingStrategy(new ApiFieldNamingStrategy())
+			.setDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSX").create();
+	private JavaPlugin _plugin;
+
+	public BoosterUpdateListener(JavaPlugin plugin)
+	{
+		_plugin = plugin;
+	}
+
+	@Override
+	public void onMessage(String channel, String message)
+	{
+		try
+		{
+			Map<String, List<Booster>> boosterMap = _gson.fromJson(message, new TypeToken<Map<String, List<Booster>>>() {}.getType());
+			_plugin.getServer().getScheduler().runTask(_plugin, () -> Bukkit.getPluginManager().callEvent(new BoosterUpdateEvent(boosterMap)));
+		}
+		catch (Exception e)
+		{
+			System.out.println("Failed to load booster update");
+			e.printStackTrace();
+		}
+	}
+}

GOD DAMN COSMETICS/boosters/redis/BoosterUpdateRepository.java

@@ -0,0 +1,39 @@
+package mineplex.core.boosters.redis;
+
+import mineplex.serverdata.Region;
+import mineplex.serverdata.redis.RedisRepository;
+import org.bukkit.plugin.java.JavaPlugin;
+import redis.clients.jedis.Jedis;
+
+/**
+ * @author Shaun Bennett
+ */
+public class BoosterUpdateRepository extends RedisRepository
+{
+	private JavaPlugin _plugin;
+
+	public BoosterUpdateRepository(JavaPlugin plugin)
+	{
+		super(Region.ALL);
+
+		_plugin = plugin;
+		init();
+	}
+
+	private void init()
+	{
+		Thread thread = new Thread("Booster Subscriber")
+		{
+			@Override
+			public void run()
+			{
+				try (Jedis jedis = getResource(false))
+				{
+					jedis.subscribe(new BoosterUpdateListener(_plugin), "minecraft.boosters");
+				}
+			}
+		};
+
+		thread.start();
+	}
+}

GOD DAMN COSMETICS/boosters/tips/BoosterThankManager.java

@@ -0,0 +1,93 @@
+package mineplex.core.boosters.tips;
+
+import mineplex.core.MiniPlugin;
+import mineplex.core.account.CoreClientManager;
+import mineplex.core.boosters.Booster;
+import mineplex.core.common.util.Callback;
+import mineplex.core.common.util.F;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.recharge.Recharge;
+import mineplex.core.thank.ThankManager;
+import mineplex.core.thank.ThankResult;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.java.JavaPlugin;
+
+/**
+ * This class handles "thanking" Amplifiers. This is a way of rewarding players for activating Amplifiers.
+ *
+ * @author Shaun Bennett
+ */
+public class BoosterThankManager extends MiniPlugin
+{
+	public static final int TIP_FOR_SPONSOR = 5;
+	public static final int TIP_FOR_TIPPER = 5;
+
+	private BoosterThankRepository _repository;
+	private CoreClientManager _clientManager;
+	private ThankManager _thankManager;
+
+	public BoosterThankManager(JavaPlugin plugin, CoreClientManager clientManager, ThankManager thankManager)
+	{
+		super("Amplifier Thanks", plugin);
+
+		_clientManager = clientManager;
+		_repository = new BoosterThankRepository(plugin);
+		_thankManager = thankManager;
+	}
+
+	/**
+	 * Attempt to "Thank" an Amplifier. This checks with {@link BoosterThankRepository} if a player hasn't already
+	 * thanked that Amplifier. If they havent, we proceed to use {@link ThankManager} to send a thank you to the player
+	 * who activated that Amplifier.
+	 *
+	 * @param player The player sending the thanks
+	 * @param booster The Amplifier to be thanked
+	 * @param callback Callback with the result of sending the thanks
+	 */
+	public void addTip(Player player, Booster booster, Callback<TipAddResult> callback)
+	{
+		if (!Recharge.Instance.use(player, "Amplifier Thanks", 1000 * 5, false, false))
+		{
+			UtilPlayer.message(player, F.main("Amplifier", "Please wait before trying that again"));
+			callback.run(TipAddResult.ON_COOLDOWN);
+			return;
+		}
+
+		int accountId = _clientManager.getAccountId(player);
+
+		// Break out if client manager has a bad account id
+		if (accountId == -1)
+		{
+			callback.run(TipAddResult.INVALID_ACCOUNT_ID);
+			return;
+		}
+
+		// You can't tip yourself, silly!
+		if (accountId == booster.getAccountId())
+		{
+			callback.run(TipAddResult.CANNOT_TIP_SELF);
+			return;
+		}
+
+		runAsync(() ->
+		{
+			if (_repository.checkAmplifierThank(accountId, booster.getId()))
+			{
+				// We can thank that amplifier!
+				_thankManager.thankPlayer(booster.getPlayerName(), booster.getAccountId(), player,
+						TIP_FOR_SPONSOR, TIP_FOR_TIPPER, "Amplifier", true, thankResult ->
+								runSync(() -> callback.run(fromThankResult(thankResult))));
+			}
+			else
+			{
+				runSync(() -> callback.run(TipAddResult.ALREADY_TIPPED_BOOSTER));
+			}
+		});
+	}
+
+
+	private TipAddResult fromThankResult(ThankResult result)
+	{
+		return result == ThankResult.SUCCESS ? TipAddResult.SUCCESS : TipAddResult.UNKNOWN_ERROR;
+	}
+}

GOD DAMN COSMETICS/boosters/tips/BoosterThankRepository.java

@@ -0,0 +1,35 @@
+package mineplex.core.boosters.tips;
+
+import mineplex.database.routines.CheckAmplifierThank;
+import mineplex.serverdata.database.DBPool;
+import mineplex.serverdata.database.RepositoryBase;
+import org.bukkit.plugin.java.JavaPlugin;
+
+/**
+ * @author Shaun Bennett
+ */
+public class BoosterThankRepository extends RepositoryBase
+{
+	public BoosterThankRepository(JavaPlugin plugin)
+	{
+		super(DBPool.getAccount());
+	}
+
+	/**
+	 * Checks the database if an accountId is allowed to thank a specific Amplifier.
+	 * This will return true and update the database if the thank is okay, or false
+	 * if that account ID has already thanked that Amplifier ID.
+	 *
+	 * @param accountId Account ID of the player trying to thank the Amplifier
+	 * @param amplifierId The ID of the Amplifier the player is trying to thank
+	 * @return True if the account id can thank the amplifier id, false otherwise
+	 */
+	public boolean checkAmplifierThank(int accountId, int amplifierId)
+	{
+		CheckAmplifierThank checkAmplifierThank = new CheckAmplifierThank();
+		checkAmplifierThank.setInAccountId(accountId);
+		checkAmplifierThank.setInAmplifierId(amplifierId);
+		checkAmplifierThank.execute(jooq().configuration());
+		return checkAmplifierThank.getCanThank() == 1;
+	}
+}

GOD DAMN COSMETICS/boosters/tips/PlayerTipData.java

@@ -0,0 +1,24 @@
+package mineplex.core.boosters.tips;
+
+/**
+ * @author Shaun Bennett
+ */
+public class PlayerTipData
+{
+	private int _tips;
+
+	public PlayerTipData()
+	{
+		_tips = 0;
+	}
+
+	public int getTips()
+	{
+		return _tips;
+	}
+
+	public void setTips(int tips)
+	{
+		_tips = tips;
+	}
+}

GOD DAMN COSMETICS/boosters/tips/TipAddResult.java

@@ -0,0 +1,26 @@
+package mineplex.core.boosters.tips;
+
+/**
+ * @author Shaun Bennett
+ */
+public enum TipAddResult
+{
+	ALREADY_TIPPED_BOOSTER("You have already thanked this Amplifier!"),
+	INVALID_ACCOUNT_ID("Uh oh, something went wrong. Try relogging"),
+	UNKNOWN_ERROR("An error occurred. Try again later"),
+	CANNOT_TIP_SELF("You can't thank yourself, silly!"),
+	ON_COOLDOWN(null),
+	SUCCESS(null);
+
+	private String _friendlyMessage;
+
+	TipAddResult(String friendlyMessage)
+	{
+		_friendlyMessage = friendlyMessage;
+	}
+
+	public String getFriendlyMessage()
+	{
+		return _friendlyMessage;
+	}
+}

GOD DAMN COSMETICS/cosmetic/CosmeticManager.java

@@ -0,0 +1,256 @@
+package mineplex.core.cosmetic;
+
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+import org.bukkit.block.BlockFace;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.player.PlayerDropItemEvent;
+import org.bukkit.event.player.PlayerInteractAtEntityEvent;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import mineplex.core.Managers;
+import mineplex.core.MiniPlugin;
+import mineplex.core.account.CoreClientManager;
+//import mineplex.core.boosters.BoosterManager;
+import mineplex.core.common.util.C;
+import mineplex.core.common.util.UtilGear;
+import mineplex.core.common.util.UtilInv;
+import mineplex.core.common.util.UtilServer;
+import mineplex.core.cosmetic.ui.CosmeticShop;
+import mineplex.core.donation.DonationManager;
+import mineplex.core.gadget.GadgetManager;
+import mineplex.core.gadget.gadgets.morph.MorphDinnerbone;
+import mineplex.core.gadget.gadgets.outfit.OutfitTeam;
+import mineplex.core.gadget.types.Gadget;
+import mineplex.core.gadget.types.GadgetType;
+import mineplex.core.inventory.InventoryManager;
+import mineplex.core.itemstack.ItemStackFactory;
+import mineplex.core.pet.PetManager;
+import mineplex.core.punish.Punish;
+import mineplex.core.treasure.TreasureManager;
+import mineplex.core.twofactor.TwoFactorAuth;
+
+public class CosmeticManager extends MiniPlugin
+{
+	private final TwoFactorAuth _twofactor = Managers.require(TwoFactorAuth.class);
+	private final InventoryManager _inventoryManager;
+	private final GadgetManager _gadgetManager;
+	private final PetManager _petManager;
+	private final TreasureManager _treasureManager;
+//	private final BoosterManager _boosterManager;
+	private final Punish _punish;
+
+	private CosmeticShop _shop;
+
+	private boolean _showInterface = true;
+	private int _interfaceSlot = 4;
+
+	public CosmeticManager(JavaPlugin plugin, CoreClientManager clientManager, DonationManager donationManager,
+						   InventoryManager inventoryManager, GadgetManager gadgetManager, PetManager petManager,
+						   TreasureManager treasureManager /*BoosterManager boosterManager*/, Punish punish)
+	{
+		super("Cosmetic Manager", plugin);
+
+		_inventoryManager = inventoryManager;
+		_gadgetManager = gadgetManager;
+		_petManager = petManager;
+		_treasureManager = treasureManager;
+//		_boosterManager = boosterManager;
+		_punish = punish;
+
+		_shop = new CosmeticShop(this, clientManager, donationManager, _moduleName);
+	}
+
+	public void showInterface(boolean showInterface)
+	{
+		boolean changed = _showInterface == showInterface;
+
+		_showInterface = showInterface;
+
+		if (changed)
+		{
+			for (Player player : Bukkit.getOnlinePlayers())
+			{
+				if (_showInterface)
+					player.getInventory().setItem(_interfaceSlot, ItemStackFactory.Instance.CreateStack(Material.CHEST, (byte)0, 1, ChatColor.RESET + C.cGreen + "Cosmetic Menu"));
+				else
+					player.getInventory().setItem(_interfaceSlot, null);
+			}
+		}
+	}
+
+	@EventHandler
+	public void onPlayerJoin(PlayerJoinEvent event)
+	{
+		if (!_showInterface)
+			return;
+
+		giveInterfaceItem(event.getPlayer());
+	}
+
+	public void giveInterfaceItem(Player player)
+	{
+		if (!UtilGear.isMat(player.getInventory().getItem(_interfaceSlot), Material.CHEST))
+		{
+			player.getInventory().setItem(_interfaceSlot, ItemStackFactory.Instance.CreateStack(Material.CHEST, (byte)0, 1, ChatColor.RESET + C.cGreen + "Cosmetic Menu"));
+
+			_gadgetManager.redisplayActiveItem(player);
+
+			UtilInv.Update(player);
+		}
+	}
+
+	@EventHandler
+	public void orderThatChest(final PlayerDropItemEvent event)
+	{
+		if (!_showInterface)
+			return;
+
+		if (event.getItemDrop().getItemStack().getType() == Material.CHEST)
+		{
+			Bukkit.getScheduler().scheduleSyncDelayedTask(getPlugin(), new Runnable()
+			{
+				public void run()
+				{
+					if (event.getPlayer().isOnline())
+					{
+						event.getPlayer().getInventory().remove(Material.CHEST);
+						event.getPlayer().getInventory().setItem(_interfaceSlot, ItemStackFactory.Instance.CreateStack(Material.CHEST, (byte)0, 1, ChatColor.RESET + C.cGreen + "Cosmetic Menu"));
+						event.getPlayer().updateInventory();
+					}
+				}
+			});
+		}
+	}
+
+	@EventHandler
+	public void openShop(PlayerInteractEvent event)
+	{
+		if (_twofactor.isAuthenticating(event.getPlayer()) || !_showInterface)
+			return;
+
+		if (event.hasItem() && event.getItem().getType() == Material.CHEST)
+		{
+			event.setCancelled(true);
+
+			_shop.attemptShopOpen(event.getPlayer());
+		}
+	}
+
+	// Allows player to open cosmetic shop while carrying armor stand
+	// Also calls PlayerInteractEvent to open other menus
+	@EventHandler
+	public void openShop(PlayerInteractAtEntityEvent event)
+	{
+		if (!_showInterface)
+			return;
+
+		Player player = event.getPlayer();
+
+		if (!(_gadgetManager.getActive(player, GadgetType.MORPH) instanceof MorphDinnerbone))
+			return;
+
+		if (!event.getRightClicked().getType().equals(EntityType.ARMOR_STAND))
+			return;
+
+		Block block = event.getRightClicked().getLocation().getBlock();
+		Action action = Action.RIGHT_CLICK_AIR;
+		BlockFace blockFace = BlockFace.SOUTH;
+		ItemStack item = player.getItemInHand();
+		PlayerInteractEvent playerInteractEvent = new PlayerInteractEvent(player, action, item, block, blockFace);
+		Bukkit.getPluginManager().callEvent(playerInteractEvent);
+	}
+
+	public GadgetManager getGadgetManager()
+	{
+		return _gadgetManager;
+	}
+
+	public PetManager getPetManager()
+	{
+		return _petManager;
+	}
+
+	public InventoryManager getInventoryManager()
+	{
+		return _inventoryManager;
+	}
+
+	public void setInterfaceSlot(int i)
+	{
+		_interfaceSlot = i;
+
+		_gadgetManager.setActiveItemSlot(i-1);
+	}
+
+	public void setActive(boolean showInterface)
+	{
+		_showInterface = showInterface;
+
+		if (!showInterface)
+		{
+			for (Player player : UtilServer.getPlayers())
+			{
+				if (player.getOpenInventory().getTopInventory().getHolder() != player)
+				{
+					player.closeInventory();
+				}
+			}
+		}
+	}
+
+	public void disableItemsForGame()
+	{
+		_gadgetManager.disableAll();
+		_petManager.disableAll();
+	}
+
+	public void setHideParticles(boolean b)
+	{
+		_gadgetManager.setHideParticles(b);
+	}
+
+	public boolean isShowingInterface()
+	{
+		return _showInterface;
+	}
+
+	public TreasureManager getTreasureManager()
+	{
+		return _treasureManager;
+	}
+
+//	public BoosterManager getBoosterManager()
+//	{
+//		return _boosterManager;
+//	}
+
+	public Punish getPunishManager()
+	{
+		return _punish;
+	}
+
+	public CosmeticShop getShop()
+	{
+		return _shop;
+	}
+
+	public void disableTeamArmor()
+	{
+		for (Gadget gadget : getGadgetManager().getGadgets(GadgetType.COSTUME))
+		{
+			if (gadget instanceof OutfitTeam)
+			{
+				((OutfitTeam)gadget).setEnabled(false);
+			}
+		}
+	}
+}

GOD DAMN COSMETICS/cosmetic/ui/CosmeticShop.java

@@ -0,0 +1,54 @@
+package mineplex.core.cosmetic.ui;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.plugin.messaging.PluginMessageListener;
+
+import mineplex.core.account.CoreClientManager;
+import mineplex.core.cosmetic.CosmeticManager;
+import mineplex.core.cosmetic.ui.page.ItemGadgetPage;
+import mineplex.core.cosmetic.ui.page.Menu;
+import mineplex.core.cosmetic.ui.page.PetTagPage;
+import mineplex.core.donation.DonationManager;
+import mineplex.core.gadget.event.ItemGadgetOutOfAmmoEvent;
+import mineplex.core.shop.ShopBase;
+import mineplex.core.shop.page.ShopPageBase;
+
+public class CosmeticShop extends ShopBase<CosmeticManager> implements PluginMessageListener
+{
+	public CosmeticShop(CosmeticManager plugin, CoreClientManager clientManager, DonationManager donationManager, String name)
+	{
+		super(plugin, clientManager, donationManager, name);
+		
+		plugin.getPlugin().getServer().getMessenger().registerIncomingPluginChannel(plugin.getPlugin(), "MC|ItemName", this);
+	}
+
+	@Override
+	protected ShopPageBase<CosmeticManager, ? extends ShopBase<CosmeticManager>> buildPagesFor(Player player)
+	{
+		return new Menu(getPlugin(), this, getClientManager(), getDonationManager(), player);
+	}
+	
+	@Override
+	public void onPluginMessageReceived(String channel, Player player, byte[] message)
+	{
+        if (!channel.equalsIgnoreCase("MC|ItemName"))
+            return;
+        
+        if (getPlayerPageMap().containsKey(player.getUniqueId()) && getPlayerPageMap().get(player.getUniqueId()) instanceof PetTagPage)
+        {
+	        if (message != null && message.length >= 1)
+	        {
+	            String tagName = new String(message);
+	            
+	            ((PetTagPage) getPlayerPageMap().get(player.getUniqueId())).SetTagName(tagName);
+	        }
+	    }
+	}
+
+	@EventHandler
+	public void itemGadgetEmptyAmmo(ItemGadgetOutOfAmmoEvent event)
+	{
+		new ItemGadgetPage(getPlugin(), this, getClientManager(), getDonationManager(), "Item Gadgets", event.getPlayer()).purchaseGadget(event.getPlayer(), event.getGadget());
+	}
+}

GOD DAMN COSMETICS/cosmetic/ui/button/CloseButton.java

@@ -0,0 +1,14 @@
+package mineplex.core.cosmetic.ui.button;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.inventory.ClickType;
+
+import mineplex.core.shop.item.IButton;
+
+public class CloseButton implements IButton
+{
+	public void onClick(Player player, ClickType clickType)
+	{
+		player.closeInventory();
+	}
+}

GOD DAMN COSMETICS/cosmetic/ui/button/GadgetButton.java

@@ -0,0 +1,26 @@
+package mineplex.core.cosmetic.ui.button;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.inventory.ClickType;
+
+import mineplex.core.cosmetic.ui.page.GadgetPage;
+import mineplex.core.gadget.types.Gadget;
+import mineplex.core.shop.item.IButton;
+
+public class GadgetButton implements IButton
+{
+	private Gadget _gadget;
+	private GadgetPage _page;
+	
+	public GadgetButton(Gadget gadget, GadgetPage page)
+	{
+		_gadget = gadget;
+		_page = page;
+	}
+
+	@Override
+	public void onClick(Player player, ClickType clickType)
+	{
+		_page.purchaseGadget(player, _gadget);
+	}
+}

GOD DAMN COSMETICS/cosmetic/ui/button/PetButton.java

@@ -0,0 +1,25 @@
+package mineplex.core.cosmetic.ui.button;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.inventory.ClickType;
+
+import mineplex.core.cosmetic.ui.page.PetPage;
+import mineplex.core.pet.PetType;
+import mineplex.core.shop.item.IButton;
+
+public class PetButton implements IButton
+{
+	private PetType _petType;
+	private PetPage _page;
+	
+	public PetButton(PetType pet, PetPage page)
+	{
+		_petType = pet;
+		_page = page;
+	}
+
+	public void onClick(Player player, ClickType clickType)
+	{
+		_page.purchasePet(player, _petType);
+	}
+}

GOD DAMN COSMETICS/cosmetic/ui/button/RenamePetButton.java

@@ -0,0 +1,26 @@
+package mineplex.core.cosmetic.ui.button;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.inventory.ClickType;
+
+import mineplex.core.cosmetic.ui.page.PetPage;
+import mineplex.core.pet.PetType;
+import mineplex.core.shop.item.IButton;
+
+public class RenamePetButton implements IButton
+{
+	private PetPage _page;
+	
+	public RenamePetButton(PetPage page)
+	{
+		_page = page;
+	}
+
+	@Override
+	public void onClick(Player player, ClickType clickType)
+	{
+		_page.playAcceptSound(player);
+		PetType currentType = _page.getPlugin().getPetManager().getActivePetType(player.getName());
+		_page.renamePet(player, currentType, false);
+	}
+}

GOD DAMN COSMETICS/cosmetic/ui/button/SelectTagButton.java

@@ -0,0 +1,22 @@
+package mineplex.core.cosmetic.ui.button;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.inventory.ClickType;
+
+import mineplex.core.cosmetic.ui.page.PetTagPage;
+import mineplex.core.shop.item.IButton;
+
+public class SelectTagButton implements IButton
+{
+	private PetTagPage _page;
+	
+	public SelectTagButton(PetTagPage page)
+	{
+		_page = page;
+	}
+
+	public void onClick(Player player, ClickType clickType)
+	{
+		_page.SelectTag();
+	}
+}

GOD DAMN COSMETICS/cosmetic/ui/button/activate/ActivatePetButton.java

@@ -0,0 +1,29 @@
+package mineplex.core.cosmetic.ui.button.activate;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.inventory.ClickType;
+
+import mineplex.core.cosmetic.ui.page.Menu;
+import mineplex.core.cosmetic.ui.page.PetPage;
+import mineplex.core.pet.PetType;
+import mineplex.core.shop.item.IButton;
+
+public class ActivatePetButton implements IButton
+{
+	private PetType _pet;
+	private PetPage _page;
+	
+	public ActivatePetButton(PetType pet, PetPage page)
+	{
+		_pet = pet;
+		_page = page;
+	}
+	
+	@Override
+	public void onClick(Player player, ClickType clickType)
+	{
+		_page.playAcceptSound(player);
+		_page.getPlugin().getPetManager().addPetOwner(player, _pet, player.getLocation());
+		_page.getShop().openPageForPlayer(player, new Menu(_page.getPlugin(), _page.getShop(), _page.getClientManager(), _page.getDonationManager(), player));
+	}
+}

GOD DAMN COSMETICS/cosmetic/ui/button/deactivate/DeactivatePetButton.java

@@ -0,0 +1,27 @@
+package mineplex.core.cosmetic.ui.button.deactivate;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.inventory.ClickType;
+
+import mineplex.core.pet.PetManager;
+import mineplex.core.shop.item.IButton;
+import mineplex.core.shop.page.ShopPageBase;
+
+public class DeactivatePetButton implements IButton
+{
+	private ShopPageBase<?,?> _page;
+	private PetManager _petManager;
+	
+	public DeactivatePetButton(ShopPageBase<?,?> page, PetManager petManager)
+	{
+		_page = page;
+		_petManager = petManager;
+	}
+	
+	public void onClick(Player player, ClickType clickType)
+	{
+		_page.playAcceptSound(player);
+		_petManager.removePet(player, true);
+		_page.refresh();
+	}
+}

GOD DAMN COSMETICS/cosmetic/ui/button/open/OpenCostumes.java

@@ -0,0 +1,20 @@
+package mineplex.core.cosmetic.ui.button.open;
+
+import org.bukkit.entity.Player;
+
+import mineplex.core.cosmetic.ui.page.Menu;
+import mineplex.core.gadget.types.Gadget;
+
+public class OpenCostumes extends OpenPageButton
+{
+	public OpenCostumes(Menu menu, Gadget active)
+	{
+		super(menu, active);
+	}
+
+	@Override
+	protected void leftClick(Player player)
+	{
+		getMenu().openCostumes(player);
+	}
+}

GOD DAMN COSMETICS/cosmetic/ui/button/open/OpenGameModifiers.java

@@ -0,0 +1,22 @@
+package mineplex.core.cosmetic.ui.button.open;
+
+import org.bukkit.entity.Player;
+
+import mineplex.core.cosmetic.ui.page.Menu;
+import mineplex.core.cosmetic.ui.page.gamemodifiers.GameCosmeticsPage;
+import mineplex.core.gadget.types.Gadget;
+
+public class OpenGameModifiers extends OpenPageButton
+{
+
+	public OpenGameModifiers(Menu menu, Gadget active)
+	{
+		super(menu, active);
+	}
+
+	@Override
+	protected void leftClick(Player player)
+	{
+		getMenu().getShop().openPageForPlayer(player, new GameCosmeticsPage(getMenu().getPlugin(), getMenu().getShop(), getMenu().getClientManager(), getMenu().getDonationManager(),player));
+	}
+}

GOD DAMN COSMETICS/cosmetic/ui/button/open/OpenItems.java

@@ -0,0 +1,20 @@
+package mineplex.core.cosmetic.ui.button.open;
+
+import org.bukkit.entity.Player;
+
+import mineplex.core.cosmetic.ui.page.Menu;
+import mineplex.core.gadget.types.Gadget;
+
+public class OpenItems extends OpenPageButton
+{
+	public OpenItems(Menu menu, Gadget active)
+	{
+		super(menu, active);
+	}
+
+	@Override
+	protected void leftClick(Player player)
+	{
+		getMenu().openItems(player);
+	}
+}

GOD DAMN COSMETICS/cosmetic/ui/button/open/OpenPageButton.java

@@ -0,0 +1,48 @@
+package mineplex.core.cosmetic.ui.button.open;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.inventory.ClickType;
+
+import mineplex.core.cosmetic.ui.page.Menu;
+import mineplex.core.gadget.types.Gadget;
+import mineplex.core.shop.item.IButton;
+
+public abstract class OpenPageButton implements IButton
+{
+	private Menu _menu;
+	private Gadget _active;
+
+	public OpenPageButton(Menu menu, Gadget active)
+	{
+		_active = active;
+		_menu = menu;
+	}
+
+	@Override
+	public void onClick(Player player, ClickType clickType)
+	{
+		if (clickType.isLeftClick())
+				leftClick(player);
+		else
+		{
+			if (_active != null)
+			{
+				_menu.playAcceptSound(player);
+				_active.disable(player);
+				_menu.refresh();
+			}
+		}
+	}
+
+	protected Menu getMenu()
+	{
+		return _menu;
+	}
+
+	protected Gadget getActive()
+	{
+		return _active;
+	}
+
+	protected abstract void leftClick(Player player);
+}

GOD DAMN COSMETICS/cosmetic/ui/button/open/OpenPets.java

@@ -0,0 +1,31 @@
+package mineplex.core.cosmetic.ui.button.open;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.inventory.ClickType;
+
+import mineplex.core.cosmetic.ui.page.Menu;
+import mineplex.core.cosmetic.ui.page.PetPage;
+import mineplex.core.shop.item.IButton;
+
+public class OpenPets implements IButton
+{
+	private Menu _menu;
+
+	public OpenPets(Menu menu)
+	{
+		_menu = menu;
+	}
+
+	@Override
+	public void onClick(Player player, ClickType clickType)
+	{
+		if (clickType.isLeftClick())
+			_menu.getShop().openPageForPlayer(player, new PetPage(_menu.getPlugin(), _menu.getShop(), _menu.getClientManager(), _menu.getDonationManager(), "Pets", player));
+		else
+		{
+			_menu.playAcceptSound(player);
+			_menu.getPlugin().getPetManager().removePet(player, true);
+			_menu.refresh();
+		}
+	}
+}

GOD DAMN COSMETICS/cosmetic/ui/button/open/OpenWeaponNames.java

@@ -0,0 +1,22 @@
+package mineplex.core.cosmetic.ui.button.open;
+
+import org.bukkit.entity.Player;
+
+import mineplex.core.cosmetic.ui.page.Menu;
+import mineplex.core.cosmetic.ui.page.WeaponNamePage;
+import mineplex.core.gadget.types.Gadget;
+
+public class OpenWeaponNames extends OpenPageButton
+{
+
+	public OpenWeaponNames(Menu menu, Gadget active)
+	{
+		super(menu, active);
+	}
+
+	@Override
+	protected void leftClick(Player player)
+	{
+		getMenu().getShop().openPageForPlayer(player, new WeaponNamePage(getMenu().getPlugin(), getMenu().getShop(), getMenu().getClientManager(), getMenu().getDonationManager(), player));
+	}
+}

GOD DAMN COSMETICS/cosmetic/ui/page/CostumePage.java

@@ -0,0 +1,97 @@
+package mineplex.core.cosmetic.ui.page;
+
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.entity.Player;
+
+import mineplex.core.account.CoreClientManager;
+import mineplex.core.common.util.C;
+import mineplex.core.common.util.UtilServer;
+import mineplex.core.cosmetic.CosmeticManager;
+import mineplex.core.cosmetic.ui.CosmeticShop;
+import mineplex.core.donation.DonationManager;
+import mineplex.core.gadget.event.GadgetChangeEvent;
+import mineplex.core.gadget.event.GadgetChangeEvent.GadgetState;
+import mineplex.core.gadget.types.Gadget;
+import mineplex.core.gadget.types.GadgetType;
+import mineplex.core.gadget.types.OutfitGadget;
+import mineplex.core.shop.item.ShopItem;
+
+public class CostumePage extends GadgetPage
+{
+
+	CostumePage(CosmeticManager plugin, CosmeticShop shop, CoreClientManager clientManager, DonationManager donationManager, String name, Player player)
+	{
+		super(plugin, shop, clientManager, donationManager, name, player);
+
+		buildPage();
+	}
+
+	protected void buildPage()
+	{
+		int slot;
+		int offset = 0;
+		Class<? extends OutfitGadget> lastGadgetClass = null;
+
+		for (Gadget gadget : getPlugin().getGadgetManager().getGadgets(GadgetType.COSTUME))
+		{
+			if (gadget.isHidden())
+			{
+				continue;
+			}
+
+			OutfitGadget outfitGadget = ((OutfitGadget) gadget);
+
+			if (lastGadgetClass == null || !(gadget.getClass().getSuperclass().isAssignableFrom(lastGadgetClass.getSuperclass())))
+			{
+				lastGadgetClass = outfitGadget.getClass();
+				offset++;
+			}
+
+			slot = offset + 18; // 18 = 2 lines down
+
+			switch (outfitGadget.getSlot())
+			{
+				case CHEST:
+					slot += 9;
+					break;
+				case LEGS:
+					slot += 18;
+					break;
+				case BOOTS:
+					slot += 27;
+					break;
+			}
+
+			addGadget(gadget, slot);
+
+			if (gadget.isActive(getPlayer()))
+			{
+				addGlow(slot);
+			}
+		}
+
+		addButton(8, new ShopItem(Material.TNT, C.cRedB + "Remove all Clothing", new String[0], 1, false), (player, clickType) ->
+		{
+			boolean gadgetDisabled = false;
+
+			for (Gadget gadget : getPlugin().getGadgetManager().getGadgets(GadgetType.COSTUME))
+			{
+				if (gadget.isActive(player))
+				{
+					gadgetDisabled = true;
+					gadget.disable(player);
+					UtilServer.CallEvent(new GadgetChangeEvent(player, gadget, GadgetState.DISABLED));
+				}
+			}
+
+			if (gadgetDisabled)
+			{
+				buildPage();
+				player.playSound(player.getEyeLocation(), Sound. SPLASH, 1, 1);
+			}
+		});
+
+		addBackButton();
+	}
+}

GOD DAMN COSMETICS/cosmetic/ui/page/GadgetPage.java

@@ -0,0 +1,481 @@
+package mineplex.core.cosmetic.ui.page;
+
+import java.time.Month;
+import java.time.YearMonth;
+import java.time.format.TextStyle;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Locale;
+
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+
+import mineplex.core.account.CoreClientManager;
+import mineplex.core.common.currency.GlobalCurrency;
+import mineplex.core.common.util.C;
+import mineplex.core.common.util.LineFormat;
+import mineplex.core.common.util.UtilServer;
+import mineplex.core.common.util.UtilText;
+import mineplex.core.cosmetic.CosmeticManager;
+import mineplex.core.cosmetic.ui.CosmeticShop;
+import mineplex.core.cosmetic.ui.button.GadgetButton;
+import mineplex.core.donation.DonationManager;
+import mineplex.core.gadget.event.GadgetChangeEvent;
+import mineplex.core.gadget.event.GadgetChangeEvent.GadgetState;
+import mineplex.core.gadget.types.Gadget;
+import mineplex.core.gadget.types.GadgetSet;
+import mineplex.core.gadget.types.GadgetType;
+import mineplex.core.gadget.util.CostConstants;
+import mineplex.core.shop.confirmation.ConfirmationPage;
+import mineplex.core.shop.item.SalesPackageProcessor;
+import mineplex.core.shop.item.ShopItem;
+import mineplex.core.shop.page.ShopPageBase;
+
+public class GadgetPage extends ShopPageBase<CosmeticManager, CosmeticShop>
+{
+
+	private static final int ELEMENTS_PER_PAGE = 28;
+
+	private final GadgetType _gadgetType;
+
+	private int _page;
+
+	public GadgetPage(CosmeticManager plugin, CosmeticShop shop, CoreClientManager clientManager, DonationManager donationManager, String name, Player player)
+	{
+		this(plugin, shop, clientManager, donationManager, name, player, null);
+	}
+
+	public GadgetPage(CosmeticManager plugin, CosmeticShop shop, CoreClientManager clientManager, DonationManager donationManager, String name, Player player, GadgetType gadgetType)
+	{
+		super(plugin, shop, clientManager, donationManager, name, player);
+
+		_gadgetType = gadgetType;
+	}
+
+	@Override
+	protected void buildPage()
+	{
+		List<Gadget> gadgets = getGadgetsToDisplay();
+
+		if (gadgets == null)
+		{
+			return;
+		}
+
+		int slot = 10;
+		int startIndex = _page * ELEMENTS_PER_PAGE;
+		int endIndex = startIndex + ELEMENTS_PER_PAGE;
+
+		gadgets = gadgets.subList(startIndex, Math.min(endIndex, gadgets.size()));
+
+		for (Gadget gadget : gadgets)
+		{
+			if (gadget.isHidden())
+			{
+				continue;
+			}
+
+			addGadget(gadget, slot);
+
+			if (gadget.isActive(getPlayer()))
+			{
+				addGlow(slot);
+			}
+
+			if (++slot % 9 == 8)
+			{
+				slot += 2;
+			}
+		}
+
+		if (_page != 0)
+		{
+			addButton(45, new ShopItem(Material.ARROW, C.cGreen + "Previous Page", new String[0], 1, false), (player, clickType) ->
+			{
+				_page--;
+				refresh();
+			});
+		}
+		if (endIndex <= gadgets.size())
+		{
+			addButton(53, new ShopItem(Material.ARROW, C.cGreen + "Next Page", new String[0], 1, false), (player, clickType) ->
+			{
+				_page++;
+				refresh();
+			});
+		}
+
+		addBackButton();
+	}
+
+	protected List<Gadget> getGadgetsToDisplay()
+	{
+		return getPlugin().getGadgetManager().getGadgets(_gadgetType);
+	}
+
+	protected void addBackButton()
+	{
+		addBackButton(4);
+	}
+
+	protected void addBackButton(int slot)
+	{
+		addButton(slot, new ShopItem(Material.BED, C.cGreen + "Go Back", new String[0], 1, false), (player, clickType) -> getShop().openPageForPlayer(getPlayer(), new Menu(getPlugin(), getShop(), getClientManager(), getDonationManager(), player)));
+	}
+
+	protected void addGadget(Gadget gadget, int slot)
+	{
+		boolean owns = gadget.ownsGadget(getPlayer());
+		int shardCost = gadget.getCost(GlobalCurrency.TREASURE_SHARD);
+		List<String> itemLore = new ArrayList<>();
+
+		itemLore.add(C.cBlack);
+		itemLore.addAll(Arrays.asList(gadget.getDescription()));
+
+		GadgetSet set = gadget.getSet();
+		if (set != null)
+		{
+			itemLore.add(C.cBlack);
+			itemLore.add(C.cWhite + set.getName() + " Set");
+
+			//Elements
+			for (Gadget cur : gadget.getSet().getGadgets())
+			{
+				itemLore.add("   " + (cur.ownsGadget(getPlayer()) ? C.cDGreen : C.cDRed) + "▪ " + (cur.isActive(getPlayer()) ? C.cGreen : C.cGray) + cur.getName());
+			}
+
+			itemLore.add(C.cBlack);
+
+			//Bonus
+			itemLore.add(C.cWhite + set.getName() + " Set Bonus");
+			for (String bonus : set.getBonus())
+			{
+				itemLore.add("   " + (set.isActive(getPlayer()) ? C.cGreen : C.cGray) + bonus);
+			}
+		}
+
+		if (!owns)
+		{
+			int displayedShardCost = shardCost;
+
+			if (displayedShardCost > 0)
+			{
+				displayedShardCost = CostConstants.FOUND_IN_TREASURE_CHESTS;
+			}
+
+			switch (displayedShardCost)
+			{
+
+				// Nothing
+				case CostConstants.NO_LORE:
+					break;
+
+				// Chests
+				case CostConstants.FOUND_IN_TREASURE_CHESTS:
+					itemLore.add(C.cBlack);
+					itemLore.add(C.cBlue + "Found in Treasure Chests");
+					break;
+
+				case CostConstants.FOUND_IN_WINTER_CHESTS:
+					itemLore.add(C.cBlack);
+					itemLore.add(C.cBlue + "Found in Winter Holiday Treasure");
+					break;
+
+				case CostConstants.FOUND_IN_HALLOWEEN_PUMPKIN_CHESTS:
+					itemLore.add(C.cBlack);
+					itemLore.add(C.cBlue + "Found in Halloween Pumpkin Treasure");
+					break;
+
+				case CostConstants.FOUND_IN_EASTER_CHESTS:
+					itemLore.add(C.cBlack);
+					itemLore.add(C.cBlue + "Found in Easter Holiday Treasure");
+					break;
+
+				case CostConstants.FOUND_IN_VALENTINES_GIFTS:
+					itemLore.add(C.cBlack);
+					itemLore.add(C.cBlue + "Found in Valentines Gifts");
+					break;
+
+				case CostConstants.FOUND_IN_FREEDOM_CHESTS:
+					itemLore.add(C.cBlack);
+					itemLore.add(C.cBlue + "Found in Freedom Chests");
+					break;
+
+				case CostConstants.FOUND_IN_HAUNTED_CHESTS:
+					itemLore.add(C.cBlack);
+					itemLore.add(C.cBlue + "Found in Haunted Chests");
+					break;
+
+				case CostConstants.FOUND_IN_GINGERBREAD_CHESTS:
+					itemLore.add(C.cBlack);
+					itemLore.add(C.cBlue + "Found in Gingerbread Chests");
+					break;
+
+				case CostConstants.FOUND_IN_LOVE_CHESTS:
+					itemLore.add(C.cBlack);
+					itemLore.add(C.cBlue + "Found in Love Chests");
+					break;
+
+				case CostConstants.FOUND_IN_ST_PATRICKS_CHESTS:
+					itemLore.add(C.cBlack);
+					itemLore.add(C.cBlue + "Found in St Patrick's Chests");
+					break;
+
+				case CostConstants.FOUND_IN_SPRING_CHESTS:
+					itemLore.add(C.cBlack);
+					itemLore.add(C.cBlue + "Found in Spring Chests");
+					break;
+
+				case CostConstants.FOUND_IN_MOBA_CHESTS:
+					itemLore.add(C.cBlack);
+					itemLore.add(C.cBlue + "Found in HOG Chests");
+					break;
+
+				case CostConstants.FOUND_IN_THANKFUL_CHESTS:
+					itemLore.add(C.cBlack);
+					itemLore.add(C.cBlue + "Found in Thankful Treasure");
+					break;
+
+				case CostConstants.FOUND_IN_TRICK_OR_TREAT:
+					itemLore.add(C.cBlack);
+					itemLore.add(C.cBlue + "Found in Trick or Treat Treasure");
+					break;
+
+				case CostConstants.FOUND_IN_MINESTRIKE_CHESTS:
+					itemLore.add(C.cBlack);
+					itemLore.add(C.cBlue + "Found in MineStrike Chests");
+					break;
+
+
+				// Ranks
+				case CostConstants.UNLOCKED_WITH_ULTRA:
+					itemLore.add(C.cBlack);
+					itemLore.add(C.cAqua + "Unlocked with Ultra Rank");
+					break;
+
+				case CostConstants.UNLOCKED_WITH_HERO:
+					itemLore.add(C.cBlack);
+					itemLore.add(C.cPurple + "Unlocked with Hero Rank");
+					break;
+
+				case CostConstants.UNLOCKED_WITH_LEGEND:
+					itemLore.add(C.cBlack);
+					itemLore.add(C.cGreen + "Unlocked with Legend Rank");
+					break;
+
+				case CostConstants.UNLOCKED_WITH_TITAN:
+					itemLore.add(C.cBlack);
+					itemLore.add(C.cRed + "Unlocked with Titan Rank");
+					break;
+
+				case CostConstants.UNLOCKED_WITH_ETERNAL:
+					itemLore.add(C.cBlack);
+					itemLore.add(C.cDAqua + "Unlocked with Eternal Rank");
+					break;
+
+				// Special
+				case CostConstants.POWERPLAY_BONUS:
+					itemLore.add(C.cBlack);
+
+					YearMonth yearMonth = gadget.getYearMonth();
+					if (yearMonth != null)
+					{
+						int year = yearMonth.getYear();
+						Month month = yearMonth.getMonth();
+						String monthName = month.getDisplayName(TextStyle.FULL, Locale.US);
+						itemLore.addAll(UtilText.splitLine(C.cBlue + "Monthly Power Play Club Reward for " + monthName + " " + year, LineFormat.LORE));
+					}
+					else
+					{
+						itemLore.add(C.cBlue + "Bonus Item Unlocked with Power Play Club");
+					}
+
+					break;
+
+				case CostConstants.PURCHASED_FROM_STORE:
+					itemLore.add(C.cBlack);
+					itemLore.add(C.cBlue + "Purchased from mineplex.com/shop");
+					break;
+
+				case CostConstants.LEVEL_REWARDS:
+					itemLore.add(C.cBlack);
+					itemLore.add(C.cBlue + "Unlocked in Level Rewards");
+					break;
+
+				default:
+					break;
+			}
+		}
+
+		addCustomLore(gadget, itemLore);
+
+		if (owns)
+		{
+			ItemStack gadgetItemStack;
+
+			if (gadget.hasDisplayItem())
+			{
+				gadgetItemStack = gadget.getDisplayItem();
+			}
+			else
+			{
+				gadgetItemStack = new ItemStack(gadget.getDisplayMaterial(), 1, gadget.getDisplayData());
+			}
+
+			ItemMeta meta = gadgetItemStack.getItemMeta();
+			meta.setDisplayName(C.cGreenB + gadget.getName());
+			itemLore.add(C.cBlack);
+
+			if (gadget.isActive(getPlayer()))
+			{
+				itemLore.add(C.cGreen + "Left-Click to Disable");
+			}
+			else
+			{
+				itemLore.add(C.cGreen + "Left-Click to Enable");
+			}
+
+			if (set != null)
+			{
+				if (set.isActive(getPlayer()))
+				{
+					itemLore.add(C.cGreen + "Shift-Click to Disable Set");
+				}
+				else
+				{
+					itemLore.add(C.cGreen + "Shift-Click to Enable Set");
+				}
+			}
+
+			meta.setLore(itemLore);
+			gadgetItemStack.setItemMeta(meta);
+
+			addButton(slot, new ShopItem(gadgetItemStack, false, false).hideInfo(), (player, clickType) ->
+			{
+				if (clickType.isShiftClick())
+				{
+					toggleSet(player, gadget);
+				}
+				else
+				{
+					toggleGadget(player, gadget);
+				}
+			});
+		}
+		else
+		{
+			if (shardCost > 0)
+			{
+				itemLore.add(C.cBlack);
+				itemLore.add(C.cWhiteB + "Cost: " + C.cAqua + gadget.getCost(GlobalCurrency.TREASURE_SHARD) + " Treasure Shards");
+
+				if (getDonationManager().Get(getPlayer()).getBalance(GlobalCurrency.TREASURE_SHARD) >= shardCost)
+				{
+					itemLore.add(C.cBlack);
+					itemLore.add(C.cGreen + "Click to Purchase");
+
+					addButton(slot, new ShopItem(Material.INK_SACK, (byte) 8, gadget.getName(), itemLore.toArray(new String[itemLore.size()]), 1, true, false).hideInfo(), new GadgetButton(gadget, this));
+				}
+				else
+				{
+					itemLore.add(C.cBlack);
+					itemLore.add(C.cRed + "Not enough Treasure Shards.");
+
+					setItem(slot, new ShopItem(Material.INK_SACK, (byte) 8, gadget.getName(), itemLore.toArray(new String[itemLore.size()]), 1, true, false).hideInfo());
+				}
+			}
+			else
+			{
+				setItem(slot, new ShopItem(Material.INK_SACK, (byte) 8, gadget.getName(), itemLore.toArray(new String[itemLore.size()]), 1, true, false).hideInfo());
+			}
+		}
+	}
+
+	protected void addCustomLore(Gadget gadget, List<String> lore)
+	{
+	}
+
+	public void purchaseGadget(final Player player, final Gadget gadget)
+	{
+		getShop().openPageForPlayer(
+				getPlayer(),
+				new ConfirmationPage<>(
+						player,
+						this,
+						new SalesPackageProcessor(
+								player,
+								GlobalCurrency.TREASURE_SHARD,
+								gadget,
+								getDonationManager(),
+								() ->
+								{
+									getPlugin().getInventoryManager().addItemToInventory(getPlayer(), gadget.getName(), gadget.getQuantity());
+									refresh();
+								}
+						),
+						gadget.buildIcon()
+				)
+		);
+	}
+
+	protected void toggleGadget(Player player, Gadget gadget)
+	{
+		playAcceptSound(player);
+
+		if (gadget.isActive(player))
+		{
+			deactivateGadget(player, gadget);
+		}
+		else
+		{
+			activateGadget(player, gadget);
+		}
+	}
+
+	protected void toggleSet(Player player, Gadget gadget)
+	{
+		GadgetSet set = gadget.getSet();
+
+		if (set == null)
+		{
+			return;
+		}
+
+		if (set.isActive(player))
+		{
+			for (Gadget setGadget : set.getGadgets())
+			{
+				deactivateGadget(player, setGadget);
+			}
+
+			playAcceptSound(player);
+		}
+		else
+		{
+			for (Gadget setGadget : set.getGadgets())
+			{
+				if (setGadget.ownsGadget(player))
+				{
+					activateGadget(player, setGadget);
+				}
+			}
+		}
+	}
+
+	private void activateGadget(Player player, Gadget gadget)
+	{
+		gadget.enable(player);
+		UtilServer.CallEvent(new GadgetChangeEvent(player, gadget, GadgetState.ENABLED));
+		refresh();
+	}
+
+	private void deactivateGadget(Player player, Gadget gadget)
+	{
+		gadget.disable(player);
+		UtilServer.CallEvent(new GadgetChangeEvent(player, gadget, GadgetState.DISABLED));
+		refresh();
+	}
+}

GOD DAMN COSMETICS/cosmetic/ui/page/ItemGadgetPage.java

@@ -0,0 +1,69 @@
+package mineplex.core.cosmetic.ui.page;
+
+import java.util.List;
+
+import org.bukkit.entity.Player;
+
+import mineplex.core.account.CoreClientManager;
+import mineplex.core.common.currency.GlobalCurrency;
+import mineplex.core.common.util.C;
+import mineplex.core.cosmetic.CosmeticManager;
+import mineplex.core.cosmetic.ui.CosmeticShop;
+import mineplex.core.donation.DonationManager;
+import mineplex.core.gadget.types.Gadget;
+import mineplex.core.gadget.types.GadgetType;
+import mineplex.core.gadget.types.ItemGadget;
+import mineplex.core.shop.confirmation.ConfirmationPage;
+import mineplex.core.shop.item.SalesPackageProcessor;
+
+public class ItemGadgetPage extends GadgetPage
+{
+
+	public ItemGadgetPage(CosmeticManager plugin, CosmeticShop shop, CoreClientManager clientManager, DonationManager donationManager, String name, Player player)
+	{
+		super(plugin, shop, clientManager, donationManager, name, player, GadgetType.ITEM);
+
+		buildPage();
+	}
+
+	@Override
+	protected void addCustomLore(Gadget gadget, List<String> lore)
+	{
+		if (gadget instanceof ItemGadget && ((ItemGadget) gadget).isUsingAmmo())
+		{
+			lore.add(C.blankLine);
+			lore.add(C.cWhite + "You own " + C.cGreen + getPlugin().getInventoryManager().Get(getPlayer()).getItemCount(gadget.getName()));
+		}
+	}
+
+	@Override
+	public void purchaseGadget(Player player, Gadget gadget)
+	{
+		ItemGadget itemGadget = (ItemGadget) gadget;
+
+		if (itemGadget.isUsingAmmo() && itemGadget.getAmmo().getCost(GlobalCurrency.TREASURE_SHARD) <= 0)
+		{
+			return;
+		}
+
+		getShop().openPageForPlayer(
+				getPlayer(),
+				new ConfirmationPage<>(
+						player,
+						this,
+						new SalesPackageProcessor(
+								player,
+								GlobalCurrency.TREASURE_SHARD,
+								itemGadget.getAmmo(),
+								getDonationManager(),
+								() ->
+								{
+									getPlugin().getInventoryManager().addItemToInventory(getPlayer(), itemGadget.getAmmo().getName(), itemGadget.getAmmo().getQuantity());
+									refresh();
+								}
+						),
+						gadget.buildIcon()
+				)
+		);
+	}
+}

GOD DAMN COSMETICS/cosmetic/ui/page/ListGadgetPage.java

@@ -0,0 +1,31 @@
+package mineplex.core.cosmetic.ui.page;
+
+import java.util.List;
+
+import org.bukkit.entity.Player;
+
+import mineplex.core.account.CoreClientManager;
+import mineplex.core.cosmetic.CosmeticManager;
+import mineplex.core.cosmetic.ui.CosmeticShop;
+import mineplex.core.donation.DonationManager;
+import mineplex.core.gadget.types.Gadget;
+
+public class ListGadgetPage extends GadgetPage
+{
+
+	private final List<Gadget> _gadgetList;
+
+	ListGadgetPage(CosmeticManager plugin, CosmeticShop shop, CoreClientManager clientManager, DonationManager donationManager, String name, Player player, List<Gadget> gadgetList)
+	{
+		super(plugin, shop, clientManager, donationManager, name, player);
+
+		_gadgetList = gadgetList;
+		buildPage();
+	}
+
+	@Override
+	protected List<Gadget> getGadgetsToDisplay()
+	{
+		return _gadgetList;
+	}
+}

GOD DAMN COSMETICS/cosmetic/ui/page/Menu.java

@@ -0,0 +1,350 @@
+package mineplex.core.cosmetic.ui.page;
+
+import java.util.EnumMap;
+import java.util.List;
+import java.util.Map;
+
+import org.bukkit.Material;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemFlag;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.BannerMeta;
+
+import mineplex.core.account.CoreClientManager;
+import mineplex.core.common.currency.GlobalCurrency;
+import mineplex.core.common.util.C;
+import mineplex.core.common.util.LineFormat;
+import mineplex.core.common.util.UtilServer;
+import mineplex.core.common.util.UtilText;
+import mineplex.core.common.util.banner.CountryFlag;
+import mineplex.core.cosmetic.CosmeticManager;
+import mineplex.core.cosmetic.ui.CosmeticShop;
+import mineplex.core.cosmetic.ui.button.open.OpenCostumes;
+import mineplex.core.cosmetic.ui.button.open.OpenGameModifiers;
+import mineplex.core.cosmetic.ui.button.open.OpenItems;
+import mineplex.core.cosmetic.ui.button.open.OpenPets;
+import mineplex.core.cosmetic.ui.button.open.OpenWeaponNames;
+import mineplex.core.donation.DonationManager;
+import mineplex.core.gadget.event.GadgetChangeEvent;
+import mineplex.core.gadget.event.GadgetChangeEvent.GadgetState;
+import mineplex.core.gadget.types.Gadget;
+import mineplex.core.gadget.types.GadgetType;
+import mineplex.core.itemstack.ItemBuilder;
+import mineplex.core.pet.PetType;
+import mineplex.core.shop.item.IButton;
+import mineplex.core.shop.item.ShopItem;
+import mineplex.core.shop.page.ShopPageBase;
+
+public class Menu extends ShopPageBase<CosmeticManager, CosmeticShop>
+{
+
+	private static final String VISIBILITY_HUB = "Usable in Lobbies";
+	private static final String VISIBILITY_EVERYWHERE = "Visible Everywhere";
+	private static final String VISIBILITY_GAMES = "Visible in Games";
+	private static final String VISIBILITY_GAME_HUB = "Visible in Game Lobbies";
+
+	public Menu(CosmeticManager plugin, CosmeticShop shop, CoreClientManager clientManager, DonationManager donationManager, Player player)
+	{
+		super(plugin, shop, clientManager, donationManager, "Cosmetics", player);
+
+		buildPage();
+	}
+
+	@Override
+	protected void buildPage()
+	{
+		int deathSlot        = 19;
+		int jumpSlot         = 28;
+		int particleSlot     =  1;
+		int winEffectSlot    = 13;
+		int arrowSlot        = 10;
+		int tauntSlot        = 31;
+		int gameModifierSlot = 21;
+		int kitSelectorSlot  = 23;
+		int musicSlot        = 48;
+		int mountSlot        = 50;
+		int balloonsSlot     = 47;
+		int petSlot          = 51;
+		int gadgetSlot       = 49;
+		int hatSlot          =  7;
+		int flagSlot         = 34;
+		int morphSlot        = 25;
+		int costumeSlot      = 16;
+		int weaponNameSlot   = 4;
+		int powerPlaySlot 	 = 22;
+		int chatColourSlot 	 = 40;
+
+		EnumMap<GadgetType, Integer> ownedCount = new EnumMap<>(GadgetType.class);
+		EnumMap<GadgetType, Integer> maxCount = new EnumMap<>(GadgetType.class);
+		EnumMap<GadgetType, Gadget> enabled = new EnumMap<>(GadgetType.class);
+
+		for(GadgetType type : GadgetType.values())
+		{
+			ownedCount.put(type, 0);
+			maxCount.put(type, 0);
+
+			List<Gadget> gadgets = getPlugin().getGadgetManager().getGadgets(type);
+			if (gadgets != null)
+			{
+				for (Gadget gadget : gadgets)
+				{
+					if (gadget.ownsGadget(getPlayer()))
+					{
+						ownedCount.put(type, ownedCount.get(type) + 1);
+					}
+
+					maxCount.put(type, maxCount.get(type) + 1);
+				}
+			}
+
+			final Gadget gadget = getPlugin().getGadgetManager().getActive(getPlayer(), type);
+			if(gadget != null) enabled.put(type, gadget);
+		}
+
+		int petOwned = 0;
+		int petMax = 0;
+		for (PetType type : PetType.values())
+		{
+			Map<PetType, String> pets = getPlugin().getPetManager().Get(getPlayer()).getPets();
+			if (pets != null && pets.containsKey(type))
+			{
+				petOwned++;
+			}
+
+			petMax++;
+		}
+		Entity petActive = getPlugin().getPetManager().getPet(getPlayer());
+
+		GadgetType type = GadgetType.PARTICLE;
+		String[] lore = getLore(ownedCount.get(type), maxCount.get(type), "Show everyone how cool you are with swirly particles that follow you when you walk!", VISIBILITY_EVERYWHERE, enabled.get(type));
+		addButton(particleSlot, new ShopItem(Material.NETHER_STAR, "Particle Effects", lore, 1, false), generateButton(type, enabled.get(type)));
+		if (enabled.containsKey(type)) addGlow(particleSlot);
+
+		type = GadgetType.ARROW_TRAIL;
+		lore = getLore(ownedCount.get(type), maxCount.get(type), "Your arrows will now leave particle trails as they soar through the air.", VISIBILITY_GAMES, enabled.get(type));
+		addButton(arrowSlot, new ShopItem(Material.ARROW, "Arrow Effects", lore, 1, false), generateButton(type, enabled.get(type)));
+		if (enabled.containsKey(type)) addGlow(arrowSlot);
+
+		type = GadgetType.DOUBLE_JUMP;
+		lore = getLore(ownedCount.get(type), maxCount.get(type), "Demonstrate your parkour prowess with sweet particles when you double jump.", VISIBILITY_EVERYWHERE, enabled.get(type));
+		addButton(jumpSlot, new ShopItem(Material.GOLD_BOOTS, "Double Jump Effects", lore, 1, false), generateButton(type, enabled.get(type)));
+		if (enabled.containsKey(type)) addGlow(jumpSlot);
+
+		type = GadgetType.DEATH;
+		lore = getLore(ownedCount.get(type), maxCount.get(type), "Your death will now be mourned with a wonderful particle tribute.", VISIBILITY_GAMES, enabled.get(type));
+		addButton(deathSlot, new ShopItem(Material.SKULL_ITEM, "Death Animations", lore, 1, false), generateButton(type, enabled.get(type)));
+		if (enabled.containsKey(type)) addGlow(deathSlot);
+
+		type = GadgetType.ITEM;
+		lore = getLore(ownedCount.get(type), maxCount.get(type), "All sorts of zany contraptions to use on your friends and foes.", VISIBILITY_HUB, enabled.get(type));
+		addButton(gadgetSlot, new ShopItem(Material.MELON_BLOCK, "Gadgets", lore, 1, false), new OpenItems(this, enabled.get(type)));
+		if (enabled.containsKey(type)) addGlow(gadgetSlot);
+
+		type = GadgetType.MORPH;
+		lore = getLore(ownedCount.get(type), maxCount.get(type), "Have you ever wanted to be a tiger? Well, you can't be a tiger! That's silly! But you can be many other things!", VISIBILITY_HUB, enabled.get(type));
+		addButton(morphSlot, new ShopItem(Material.LEATHER, "Morphs", lore, 1, false), generateButton(type, enabled.get(type)));
+		if (enabled.containsKey(type)) addGlow(morphSlot);
+
+		type = GadgetType.MOUNT;
+		lore = getLore(ownedCount.get(type), maxCount.get(type), "Why walk when you can ride? Summon fancy mounts to help you move in style.", VISIBILITY_HUB, enabled.get(type));
+		addButton(mountSlot, new ShopItem(Material.IRON_BARDING, "Mounts", lore, 1, false), generateButton(type, enabled.get(type)));
+		if (enabled.containsKey(type)) addGlow(mountSlot);
+
+		lore = getLore(petOwned, petMax, "Life on a server can get lonely sometimes. Summon an adorable pet to follow you around and cheer you up!", VISIBILITY_HUB, petActive == null ? null : petActive.getCustomName(), false);
+		addButton(petSlot, new ShopItem(Material.BONE, "Pets", lore, 1, false), new OpenPets(this));
+		if (petActive != null) addGlow(petSlot);
+
+		type = GadgetType.HAT;
+		lore = getLore(ownedCount.get(type), maxCount.get(type), "Hats are in this year. Wear them on your head to impress the others.", VISIBILITY_HUB, enabled.get(type));
+		addButton(hatSlot, new ShopItem(Material.GOLD_HELMET, "Hats", lore, 1, false), generateButton(type, enabled.get(type)));
+		if (enabled.containsKey(type)) addGlow(hatSlot);
+
+		type = GadgetType.COSTUME;
+        // -4 Fixes more than the real costumes being counted (Happens because of the hub games costumes
+		lore = getLore(ownedCount.get(type), maxCount.get(type) - 4, "Sometimes going out calls for special clothes! Gain bonus effects for matching outfit.", VISIBILITY_HUB, enabled.get(type));
+		addButton(costumeSlot, new ShopItem(Material.DIAMOND_CHESTPLATE, "Costumes", lore, 1, false), new OpenCostumes(this, enabled.get(type)));
+		if (enabled.containsKey(type)) addGlow(costumeSlot);
+
+		type = GadgetType.MUSIC_DISC;
+		lore = getLore(ownedCount.get(type), maxCount.get(type), "I JUST WANT TO DANCE WITH YOU!", VISIBILITY_HUB, enabled.get(type));
+		addButton(musicSlot, new ShopItem(Material.GREEN_RECORD, "Music", lore, 1, false), generateButton(type, enabled.get(type)));
+		if (enabled.containsKey(type)) addGlow(musicSlot);
+
+		type = GadgetType.TAUNT;
+		lore = getLore(ownedCount.get(type), maxCount.get(type), "Taunt your enemies or just show off. Use /taunt to have a good time!", VISIBILITY_GAMES, enabled.get(type));
+		addButton(tauntSlot, new ShopItem(Material.NAME_TAG, "Taunts", lore, 1, false), generateButton(type, enabled.get(type)));
+		if (enabled.containsKey(type)) addGlow(tauntSlot);
+
+		type = GadgetType.WIN_EFFECT;
+		lore = getLore(ownedCount.get(type), maxCount.get(type), "Winning a game with your friends all good and dandy, but then being able to also show off awesome effects is even more fun!", VISIBILITY_GAMES, enabled.get(type));
+		addButton(winEffectSlot, new ShopItem(Material.CAKE, "Win Effects", lore, 1, false), generateButton(type, enabled.get(type)));
+		if (enabled.containsKey(type)) addGlow(winEffectSlot);
+
+		type = GadgetType.GAME_MODIFIER;
+		lore = getLore(ownedCount.get(type), maxCount.get(type), "Cosmetics which are exclusive to the game you are playing!", VISIBILITY_GAMES, null);
+		addButton(gameModifierSlot, new ShopItem(Material.TORCH, "Game Cosmetics", lore, 1, false), new OpenGameModifiers(this, null));
+		if (enabled.containsKey(type)) addGlow(gameModifierSlot);
+
+		type = GadgetType.BALLOON;
+		lore = getLore(ownedCount.get(type), maxCount.get(type), "Balloons are collectibles that you can float above your head as you wander the lobby. You can have up to 3 balloons in your hand at one time.", VISIBILITY_HUB, enabled.get(type));
+		addButton(balloonsSlot, new ShopItem(Material.LEASH, "Balloons", lore, 1, false), generateButton(type, enabled.get(type)));
+		if (enabled.containsKey(type)) addGlow(balloonsSlot);
+
+		type = GadgetType.KIT_SELECTOR;
+		lore = getLore(ownedCount.get(type), maxCount.get(type), "Click here to select different particles to indicate which kit you have selected!", VISIBILITY_GAME_HUB, enabled.get(type));
+		addButton(kitSelectorSlot, new ShopItem(Material.LEVER, "Kit Selector Particles", lore, 1, false), generateButton(type, enabled.get(type)));
+		if (enabled.containsKey(type)) addGlow(kitSelectorSlot);
+
+		type = GadgetType.FLAG;
+		lore = getLore(ownedCount.get(type), maxCount.get(type), "Show off your country's flag!", VISIBILITY_HUB, enabled.get(type));
+		addButton(flagSlot, new ShopItem(Material.BANNER, "Flags", lore, 1, false), generateButton(type, enabled.get(type)));
+		if (enabled.containsKey(type)) addGlow(flagSlot);
+
+		type = GadgetType.WEAPON_NAME;
+		lore = getLore(ownedCount.get(type), maxCount.get(type), "\"Automagically\" changes your sword names to really show off how cool you are.", VISIBILITY_GAMES, null);
+		addButton(weaponNameSlot, new ShopItem(Material.DIAMOND_SWORD, "Weapon Names", lore, 1, false), new OpenWeaponNames(this, null));
+		if (enabled.containsKey(type)) addGlow(weaponNameSlot);
+
+		type = GadgetType.LEVEL_PREFIX;
+		lore = getLore(ownedCount.get(type), maxCount.get(type), "Changes the color of your level in chat!", VISIBILITY_HUB, enabled.get(type));
+		addButton(chatColourSlot, new ShopItem(Material.PAPER, "Level Colors", lore, 1, false), generateButton(type, enabled.get(type)));
+		if (enabled.containsKey(type)) addGlow(weaponNameSlot);
+
+		// Copy over banner design
+		BannerMeta banner = (BannerMeta) CountryFlag.MINEPLEX.getBanner().getItemMeta();
+		BannerMeta meta = ((BannerMeta) getItem(flagSlot).getItemMeta());
+		meta.setBaseColor(banner.getBaseColor());
+		meta.setPatterns(banner.getPatterns());
+		meta.addItemFlags(ItemFlag.HIDE_POTION_EFFECTS);
+		getItem(flagSlot).setItemMeta(meta);
+
+		List<Gadget> powerPlayGadgets = getPlugin().getGadgetManager().getPowerPlayGadgets();
+		int ownedPowerPlay = 0;
+		int maxPowerPlay = powerPlayGadgets.size();
+		for (Gadget gadget : powerPlayGadgets)
+		{
+			if (gadget.ownsGadget(getPlayer()))
+			{
+				ownedPowerPlay++;
+			}
+		}
+
+		lore = getLore(ownedPowerPlay, maxPowerPlay, "View all of the Power Play Club Rewards!", VISIBILITY_EVERYWHERE, null);
+		addButton(powerPlaySlot, new ShopItem(Material.DIAMOND, "Power Play Club Rewards", lore, 1, false), (player, clickType) ->
+		{
+			if (clickType.isLeftClick())
+			{
+				GadgetPage page = new PowerPlayClubPage(getPlugin(), getShop(), getClientManager(), getDonationManager(), getPlayer());
+				getShop().openPageForPlayer(player, page);
+			}
+		});
+
+		ItemStack pane = new ItemBuilder(Material.STAINED_GLASS_PANE, (byte) 3)
+				.setTitle(C.cAqua + _donationManager.Get(getPlayer()).getBalance(GlobalCurrency.TREASURE_SHARD) + " Shards")
+				.build();
+
+		for (int i = 0; i < getSize(); i++)
+		{
+			if (getItem(i) == null)
+			{
+				setItem(i, pane);
+			}
+		}
+	}
+
+	private String[] getLore(int ownedCount, int maxCount, String info, String visibility, Gadget enabled)
+	{
+		boolean balloon = false;
+		if (enabled != null)
+		{
+			if (enabled.getGadgetType() == GadgetType.BALLOON)
+				balloon = true;
+		}
+		return getLore(ownedCount, maxCount, info, visibility, enabled == null ? null : enabled.getName(), balloon);
+	}
+
+	private String[] getLore(int ownedCount, int maxCount,String info, String visibility, String enabled, boolean balloons)
+	{
+		if (!balloons)
+		{
+			if (enabled != null)
+			{
+				return UtilText.splitLinesToArray(new String[]{
+						C.blankLine,
+						C.cGray + info,
+						C.cDGray + visibility,
+						C.blankLine,
+						C.cWhite + "You own " + ownedCount + "/" + maxCount,
+						C.blankLine,
+						C.cWhite + "Active: " + C.cYellow + enabled,
+						C.cGreen + "Right-Click to Disable",
+						C.blankLine,
+						C.cGreen + "Left-Click to View Category"
+				}, LineFormat.LORE);
+			} else
+			{
+				return UtilText.splitLinesToArray(new String[]{
+						C.blankLine,
+						C.cGray + info,
+						C.cDGray + visibility,
+						C.blankLine,
+						C.cWhite + "You own " + ownedCount + "/" + maxCount,
+						C.blankLine,
+						C.cGreen + "Left-Click to View Category"
+				}, LineFormat.LORE);
+			}
+		}
+		else
+		{
+			return UtilText.splitLinesToArray(new String[]{
+					C.blankLine,
+					C.cGray + info,
+					C.cDGray + visibility,
+					C.blankLine,
+					C.cWhite + "You own " + ownedCount + "/" + maxCount,
+					C.blankLine,
+					C.cGreen + "Left-Click to View Category"
+			}, LineFormat.LORE);
+		}
+	}
+
+	private IButton generateButton(GadgetType type, Gadget active)
+	{
+		return (player, clickType) ->
+		{
+			if (active != null && clickType.isRightClick())
+			{
+				playAcceptSound(player);
+				active.disable(player);
+				GadgetChangeEvent gadgetChangeEvent = new GadgetChangeEvent(player, active, GadgetState.DISABLED);
+				UtilServer.CallEvent(gadgetChangeEvent);
+				refresh();
+				return;
+			}
+
+			GadgetPage page = new GadgetPage(
+					getPlugin(),
+					getShop(),
+					getClientManager(),
+					getDonationManager(),
+					type.getCategoryType(),
+					player,
+					type
+			);
+			page.buildPage();
+
+			getShop().openPageForPlayer(player, page);
+		};
+	}
+
+	public void openCostumes(Player player)
+	{
+		getShop().openPageForPlayer(player, new CostumePage(getPlugin(), getShop(), getClientManager(), getDonationManager(), "Costumes", player));
+	}
+
+	public void openItems(Player player)
+	{
+		getShop().openPageForPlayer(player, new ItemGadgetPage(getPlugin(), getShop(), getClientManager(), getDonationManager(), "Item Gadgets", player));
+	}
+}

GOD DAMN COSMETICS/cosmetic/ui/page/PetPage.java

@@ -0,0 +1,304 @@
+package mineplex.core.cosmetic.ui.page;
+
+import java.time.Month;
+import java.time.YearMonth;
+import java.time.format.TextStyle;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Locale;
+
+import net.minecraft.server.v1_8_R3.Blocks;
+import net.minecraft.server.v1_8_R3.ChatMessage;
+import net.minecraft.server.v1_8_R3.EntityPlayer;
+import net.minecraft.server.v1_8_R3.Items;
+import net.minecraft.server.v1_8_R3.PacketPlayOutOpenWindow;
+import net.minecraft.server.v1_8_R3.PacketPlayOutSetSlot;
+
+import org.bukkit.Material;
+import org.bukkit.craftbukkit.v1_8_R3.entity.CraftPlayer;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+
+import mineplex.core.account.CoreClientManager;
+import mineplex.core.common.currency.GlobalCurrency;
+import mineplex.core.common.util.C;
+import mineplex.core.common.util.LineFormat;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.common.util.UtilText;
+import mineplex.core.cosmetic.CosmeticManager;
+import mineplex.core.cosmetic.ui.CosmeticShop;
+import mineplex.core.cosmetic.ui.button.PetButton;
+import mineplex.core.cosmetic.ui.button.RenamePetButton;
+import mineplex.core.cosmetic.ui.button.activate.ActivatePetButton;
+import mineplex.core.cosmetic.ui.button.deactivate.DeactivatePetButton;
+import mineplex.core.donation.DonationManager;
+import mineplex.core.pet.PetExtra;
+import mineplex.core.pet.PetType;
+import mineplex.core.shop.item.ShopItem;
+import mineplex.core.shop.page.AnvilContainer;
+import mineplex.core.shop.page.ShopPageBase;
+
+public class PetPage extends ShopPageBase<CosmeticManager, CosmeticShop>
+{
+    public PetPage(CosmeticManager plugin, CosmeticShop shop, CoreClientManager clientManager, DonationManager donationManager, String name, Player player)
+    {
+        super(plugin, shop, clientManager, donationManager, name, player, 54);
+        
+        buildPage();
+    }
+    
+    protected void buildPage()
+    {
+        int slot = 10;
+
+		PetType[] pets = PetType.values();
+		Arrays.sort(pets, Comparator.comparing(type -> type.getEntityType().getTypeId()));
+
+        for (PetType pet : pets)
+        {
+        	List<String> itemLore = new ArrayList<>();
+        	
+        	itemLore.add(C.cBlack);
+			if (pet.getLore().isPresent())
+			{
+				Collections.addAll(itemLore, UtilText.splitLineToArray(C.cGray + pet.getLore().get(), LineFormat.LORE));
+			}
+			else
+			{
+				itemLore.add(C.cGray + "Your very own " + pet.getName() + "!");
+			}
+        	//Chest Unlocks
+        	if (!getPlugin().getPetManager().Get(getPlayer()).getPets().containsKey(pet))
+        	{
+        		if (pet.getPrice() == -1)
+            	{
+            		//Nothing
+            	}
+
+        		else if (pet.getPrice() == -2 || pet.getPrice() > 0)
+            	{
+            		itemLore.add(C.cBlack);
+            		itemLore.add(C.cBlue + "Found in Treasure Chests");
+            	}
+            	else if (pet.getPrice() == -3)
+            	{
+            		itemLore.add(C.cBlack);
+            		itemLore.add(C.cBlue + "Found in Winter Holiday Treasure");
+            	}
+            	else if (pet.getPrice() == -4)
+            	{
+            		itemLore.add(C.cBlack);
+					itemLore.add(C.cBlue + "Earned by defeating the Pumpkin King");
+					itemLore.add(C.cBlue + "in the 2014 Christmas Chaos Event.");
+            	}
+            	else if (pet.getPrice() == -5)
+            	{
+            		itemLore.add(C.cBlack);
+            		itemLore.add(C.cBlue + "Found in Easter Holiday Treasure");
+            	}
+				else if (pet.getPrice() == -8)
+				{
+					itemLore.add(C.cBlack);
+					itemLore.add(C.cBlue + "Found in Pumpkin's Revenge");
+				}
+				else if (pet.getPrice() == -9)
+				{
+					itemLore.add(C.cBlack);
+					itemLore.add(C.cBlue + "Found in Haunted Chests");
+				}
+				else if (pet.getPrice() == -18)
+				{
+					itemLore.add(C.cBlack);
+					itemLore.add(C.cBlue + "Found in St Patrick's Chests");
+				}
+				else if (pet.getPrice() == -19)
+				{
+					itemLore.add(C.cBlack);
+					itemLore.add(C.cBlue + "Found in Spring Chests");
+				}
+				else if (pet.getPrice() == -14)
+				{
+					itemLore.add(C.cBlack);
+					YearMonth yearMonth = pet.getYearMonth();
+					if (yearMonth != null)
+					{
+						int year = yearMonth.getYear();
+						Month month = yearMonth.getMonth();
+						String monthName = month.getDisplayName(TextStyle.FULL, Locale.US);
+						itemLore.addAll(UtilText.splitLine(C.cBlue + "Monthly Power Play Club Reward for " + monthName + " " + year, LineFormat.LORE));
+					}
+					else
+					{
+						itemLore.add(C.cBlue + "Bonus Item Unlocked with Power Play Club");
+					}
+				}
+
+        		//Rank Unlocks
+            	else if (pet.getPrice() == -10)
+            	{
+            		itemLore.add(C.cBlack);
+            		itemLore.add(C.cAqua + "Unlocked with Ultra Rank");
+            	}
+            	else if (pet.getPrice() == -11)
+            	{
+            		itemLore.add(C.cBlack);
+            		itemLore.add(C.cPurple + "Unlocked with Hero Rank");
+            	}
+            	else if (pet.getPrice() == -12)
+            	{
+            		itemLore.add(C.cBlack);
+            		itemLore.add(C.cGreen + "Unlocked with Legend Rank");
+            	}
+            	else if (pet.getPrice() == -13)
+            	{
+            		itemLore.add(C.cBlack);
+            		itemLore.add(C.cRed + "Unlocked with Titan Rank");
+            	}
+        	}	
+        	
+        	//Owned
+        	if (getPlugin().getPetManager().Get(getPlayer()).getPets().containsKey(pet))
+        	{
+        	    String petName = getPlugin().getPetManager().Get(getPlayer()).getPets().get(pet);
+        	    if (petName == null)
+        	    {
+        	        petName = pet.getName();
+        	    }
+        	    
+        		if (getPlugin().getPetManager().hasActivePet(getPlayer().getName()) && getPlugin().getPetManager().getActivePetType(getPlayer().getName()) == pet)
+        		{
+        			itemLore.add(C.cBlack);
+            		itemLore.add(C.cGreen + "Click to Disable");
+
+					ItemStack item = pet.getDisplayItem();
+					ItemMeta itemMeta = item.getItemMeta();
+					itemMeta.setDisplayName(C.cGreen + C.Bold + pet.getName() + C.cGreen + " (" + C.cWhite + petName + C.cGreen + ")");
+					itemMeta.setLore(itemLore);
+					item.setItemMeta(itemMeta);
+
+        			addButton(slot, new ShopItem(item, false, false).hideInfo(), new DeactivatePetButton(this, getPlugin().getPetManager()));
+
+                	addGlow(slot);
+        		}
+        		else
+        		{
+        			itemLore.add(C.cBlack);
+            		itemLore.add(C.cGreen + "Click to Enable");
+
+					ItemStack item = pet.getDisplayItem();
+					ItemMeta itemMeta = item.getItemMeta();
+					itemMeta.setDisplayName(C.cGreen + C.Bold + pet.getName() + C.cGreen + " (" + C.cWhite + petName + C.cGreen + ")");
+					itemMeta.setLore(itemLore);
+					item.setItemMeta(itemMeta);
+
+        			addButton(slot, new ShopItem(item, false, false).hideInfo(), new ActivatePetButton(pet, this));
+        			//addButton(slot, new ShopItem(petItem, false, false), iButton);
+        		}
+        	}
+        	//Not Owned
+        	else
+        	{
+        		if (pet.getPrice() > 0)
+    			{
+        			itemLore.add(C.cBlack);
+        			itemLore.add(C.cWhiteB + "Cost: " + C.cAqua + pet.getPrice() + " Treasure Shards");
+    			}
+
+        		if (pet.getPrice() > 0 && getDonationManager().Get(getPlayer()).getBalance(GlobalCurrency.TREASURE_SHARD) >= pet.getPrice())
+        		{
+        			itemLore.add(C.cBlack);
+        			itemLore.add(C.cGreen + "Click to Purchase");
+        			
+        			addButton(slot, new ShopItem(Material.INK_SACK, (byte) 8, pet.getName(), itemLore.toArray(new String[itemLore.size()]), 1, true, false), new PetButton(pet, this));
+        		}
+        		else if (pet.getPrice() > 0)
+        		{
+        			itemLore.add(C.cBlack);
+        			itemLore.add(C.cRed + "Not enough Treasure Shards.");
+        			
+        			setItem(slot, new ShopItem(Material.INK_SACK, (byte)8, pet.getName(), itemLore.toArray(new String[itemLore.size()]), 1, true, false));
+        		}
+        		else
+        		{
+        			setItem(slot, new ShopItem(Material.INK_SACK, (byte)8, pet.getName(), itemLore.toArray(new String[itemLore.size()]), 1, true, false));
+        		}
+        	}            
+        	
+        	slot++;
+
+			if (slot % 9 == 8)
+			{
+				slot += 2;
+			}
+        }
+        
+        slot = 49;
+        for (PetExtra petExtra : PetExtra.values())
+        {
+        	List<String> itemLore = new ArrayList<String>();
+
+			if (getPlugin().getPunishManager().GetClient(_player.getName()).IsMuted())
+			{
+				itemLore.add(C.cRed + "You may not rename pets while muted!");
+				getInventory().setItem(slot, new ShopItem(petExtra.getMaterial(), (byte)0, C.cRed + petExtra.getName(), itemLore.toArray(new String[itemLore.size()]), 1, true, false).getHandle());
+			}
+        	else if (!getPlugin().getPetManager().hasActivePet(getPlayer().getName()))
+        	{
+                itemLore.add(C.cWhite + "You must have an active pet to use this!");
+                getInventory().setItem(slot, new ShopItem(petExtra.getMaterial(), (byte)0, C.cRed + petExtra.getName(), itemLore.toArray(new String[itemLore.size()]), 1, true, false).getHandle());
+        	}
+			// Silverfish = Wither disguised
+			// Villager = Elf
+			// Zombie = Pumpkin
+        	else if (getPlugin().getPetManager().getActivePet(getPlayer().getName()).getType() != EntityType.SILVERFISH
+					|| getPlugin().getPetManager().getActivePet(getPlayer().getName()).getType() != EntityType.VILLAGER
+					|| getPlugin().getPetManager().getActivePet(getPlayer().getName()).getType() != EntityType.ZOMBIE)
+        	{
+        		addButton(slot, new ShopItem(petExtra.getMaterial(), (byte) 0, "Rename " + getPlugin().getPetManager().getActivePet(getPlayer().getName()).getCustomName() + " for " + C.cYellow + petExtra.getPrice(), itemLore.toArray(new String[itemLore.size()]), 1, false, false), new RenamePetButton(this));
+        	}
+            
+        	slot++;
+        }
+
+        // Custom pet
+		/*addButton(50, new ShopItem(Material.GLASS, C.cGreen + "Custom", new String[]{}, 1, false), (player, clickType) ->
+				getShop().openPageForPlayer(getPlayer(), new CustomPetBasePage(getPlugin(), getShop(), getClientManager(), getDonationManager(), "Custom Pet", player)));*/
+
+        
+		addButton(4, new ShopItem(Material.BED, C.cGray + " \u21FD Go Back", new String[]{}, 1, false), (player, clickType) ->
+				getShop().openPageForPlayer(getPlayer(), new Menu(getPlugin(), getShop(), getClientManager(), getDonationManager(), player)));
+    }
+    
+	public void purchasePet(final Player player, final PetType petType)
+	{
+		renamePet(player, petType, true);
+	}
+	
+	public void renamePet(Player player, PetType pet, boolean petPurchase)
+	{
+		playAcceptSound(player);
+		
+		PetTagPage petTagPage = new PetTagPage(getPlugin(), getShop(), getClientManager(), getDonationManager(), "Repairing", getPlayer(), pet, petPurchase);
+        EntityPlayer entityPlayer = ((CraftPlayer) getPlayer()).getHandle();
+        int containerCounter = entityPlayer.nextContainerCounter();
+       	UtilPlayer.sendPacket(player, new PacketPlayOutOpenWindow(containerCounter, "minecraft:anvil", new ChatMessage(Blocks.ANVIL.a() + ".name", new Object[0])));
+        entityPlayer.activeContainer = new AnvilContainer(entityPlayer.inventory, petTagPage.getInventory());
+        entityPlayer.activeContainer.windowId = containerCounter;
+        entityPlayer.activeContainer.addSlotListener(entityPlayer);
+        UtilPlayer.sendPacket(player, new PacketPlayOutSetSlot(containerCounter, 0, new net.minecraft.server.v1_8_R3.ItemStack(Items.NAME_TAG)));
+        
+        getShop().setCurrentPageForPlayer(getPlayer(), petTagPage);
+	}
+
+	public void deactivatePet(Player player)
+	{
+		playAcceptSound(player);
+		getPlugin().getPetManager().removePet(player, true);
+		refresh();
+	}
+}

GOD DAMN COSMETICS/cosmetic/ui/page/PetTagPage.java

@@ -0,0 +1,143 @@
+package mineplex.core.cosmetic.ui.page;
+
+import net.minecraft.server.v1_8_R3.ItemStack;
+import net.minecraft.server.v1_8_R3.Items;
+
+import org.bukkit.ChatColor;
+import org.bukkit.entity.Player;
+
+import mineplex.cache.player.PlayerCache;
+import mineplex.core.account.CoreClientManager;
+import mineplex.core.common.currency.GlobalCurrency;
+import mineplex.core.common.util.F;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.cosmetic.CosmeticManager;
+import mineplex.core.cosmetic.ui.CosmeticShop;
+import mineplex.core.cosmetic.ui.button.CloseButton;
+import mineplex.core.cosmetic.ui.button.SelectTagButton;
+import mineplex.core.donation.DonationManager;
+import mineplex.core.pet.PetExtra;
+import mineplex.core.pet.PetType;
+import mineplex.core.pet.repository.token.PetChangeToken;
+import mineplex.core.pet.repository.token.PetToken;
+import mineplex.core.shop.confirmation.ConfirmationPage;
+import mineplex.core.shop.item.SalesPackageBase;
+import mineplex.core.shop.item.SalesPackageProcessor;
+import mineplex.core.shop.page.ShopPageBase;
+
+public class PetTagPage extends ShopPageBase<CosmeticManager, CosmeticShop>
+{
+	private String _tagName = "Pet Tag";
+	private PetType _petType;
+	private boolean _petPurchase;
+	
+    public PetTagPage(CosmeticManager plugin, CosmeticShop shop, CoreClientManager clientManager, DonationManager donationManager, String name, Player player, PetType petType, boolean petPurchase)
+    {
+        super(plugin, shop, clientManager, donationManager, name, player, 3);
+        
+        _petType = petType;
+        _petPurchase = petPurchase;
+        
+        buildPage();
+        
+        getPlayer().setLevel(5);
+    }
+
+	@Override
+	protected void buildPage()
+	{
+		inventory.setItem(0, new ItemStack(Items.NAME_TAG));
+		
+		getButtonMap().put(0, new CloseButton());
+		getButtonMap().put(1, new CloseButton());
+		getButtonMap().put(2, new SelectTagButton(this));
+	}
+	
+	@Override
+	public void playerClosed()
+	{
+		super.playerClosed();
+		
+		getPlayer().setLevel(0);
+	}
+
+	public void SelectTag()
+	{
+		_tagName = ChatColor.stripColor(_tagName);
+		_tagName = _tagName.replaceAll("[^A-Za-z0-9]", "");
+		System.out.println("Pet name: " + _tagName + ".");
+		if (_tagName.length() == 0)
+		{
+			UtilPlayer.message(getPlayer(), F.main(getPlugin().getName(), ChatColor.RED + "Supplied pet name contains invalid characters."));
+			playDenySound(getPlayer());
+			
+			getShop().openPageForPlayer(getPlayer(), new PetPage(getPlugin(), getShop(), getClientManager(), getDonationManager(), "Pets", getPlayer()));
+			return;
+		}
+		
+		if (_tagName.length() > 16)
+		{
+			UtilPlayer.message(getPlayer(), F.main(getPlugin().getName(), ChatColor.RED + "Pet name cannot be longer than 16 characters."));
+			playDenySound(getPlayer());
+			
+			getShop().openPageForPlayer(getPlayer(), new PetPage(getPlugin(), getShop(), getClientManager(), getDonationManager(), "Pets", getPlayer()));
+			return;
+		}
+
+		if (_tagName.toLowerCase().contains("ultra"))
+		{
+			UtilPlayer.message(getPlayer(), F.main(getPlugin().getName(), ChatColor.RED + _tagName + " is a restricted name."));
+			playDenySound(getPlayer());
+
+			getShop().openPageForPlayer(getPlayer(), new PetPage(getPlugin(), getShop(), getClientManager(), getDonationManager(), "Pets", getPlayer()));
+			return;
+		}
+
+		final SalesPackageBase salesPackage;
+		if (_petPurchase)
+		{
+			salesPackage = _petType.toSalesPackage(_tagName);
+
+		} else
+		{
+			salesPackage = PetExtra.NAME_TAG.toSalesPackage("Rename " + _petType.getName() + " to " + _tagName);
+		}
+
+		getShop().openPageForPlayer(getPlayer(), new ConfirmationPage<>(_player, this, new SalesPackageProcessor(_player, GlobalCurrency.TREASURE_SHARD, salesPackage, _donationManager, () ->
+		{
+			PetChangeToken token = new PetChangeToken();
+
+			if (getClientManager().Get(getPlayer()) != null)
+				token.AccountId = getClientManager().Get(getPlayer()).getAccountId();
+			else
+				token.AccountId = PlayerCache.getInstance().getAccountId(getPlayer().getUniqueId());
+
+			token.Name = getPlayer().getName();
+			token.PetType = _petType.toString();
+			token.PetName = _tagName;
+
+			PetToken petToken = new PetToken();
+			petToken.PetType = token.PetType;
+
+			if (_petPurchase)
+			{
+				getPlugin().getPetManager().getRepository().AddPet(token);
+				getPlugin().getPetManager().addPetOwnerToQueue(getPlayer().getName(), _petType);
+			}
+			else
+			{
+				getPlugin().getPetManager().getRepository().UpdatePet(token);
+				getPlugin().getPetManager().addRenamePetToQueue(getPlayer().getName(), token.PetName);
+			}
+
+			getPlugin().getPetManager().Get(getPlayer()).getPets().put(_petType, token.PetName);
+
+			getShop().openPageForPlayer(getPlayer(), new Menu(getPlugin(), getShop(), getClientManager(), getDonationManager(), getPlayer()));
+		}), salesPackage.buildIcon()));
+	}
+
+	public void SetTagName(String tagName)
+	{
+		_tagName = tagName;
+	}
+}

GOD DAMN COSMETICS/cosmetic/ui/page/PowerPlayClubPage.java

@@ -0,0 +1,43 @@
+package mineplex.core.cosmetic.ui.page;
+
+import java.util.List;
+
+import org.bukkit.entity.Player;
+
+import mineplex.core.account.CoreClientManager;
+import mineplex.core.cosmetic.CosmeticManager;
+import mineplex.core.cosmetic.ui.CosmeticShop;
+import mineplex.core.donation.DonationManager;
+import mineplex.core.gadget.types.Gadget;
+import mineplex.core.gadget.types.OutfitGadget;
+
+public class PowerPlayClubPage extends GadgetPage
+{
+
+	PowerPlayClubPage(CosmeticManager plugin, CosmeticShop shop, CoreClientManager clientManager, DonationManager donationManager, Player player)
+	{
+		super(plugin, shop, clientManager, donationManager, "Power Play Club Rewards", player);
+
+		buildPage();
+	}
+
+	@Override
+	protected void toggleGadget(Player player, Gadget gadget)
+	{
+		// This allows us to have one item for the entire suit in the PowerPlayClubPage
+		if (gadget instanceof OutfitGadget)
+		{
+			toggleSet(player, gadget);
+		}
+		else
+		{
+			super.toggleGadget(player, gadget);
+		}
+	}
+
+	@Override
+	protected List<Gadget> getGadgetsToDisplay()
+	{
+		return getPlugin().getGadgetManager().getPowerPlayGadgets();
+	}
+}

GOD DAMN COSMETICS/cosmetic/ui/page/TreasurePage.java

@@ -0,0 +1,175 @@
+package mineplex.core.cosmetic.ui.page;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Random;
+
+import org.bukkit.ChatColor;
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.entity.Player;
+import org.bukkit.event.inventory.ClickType;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+
+import mineplex.core.account.CoreClientManager;
+import mineplex.core.cosmetic.CosmeticManager;
+import mineplex.core.cosmetic.ui.CosmeticShop;
+import mineplex.core.shop.item.IButton;
+import mineplex.core.shop.item.ShopItem;
+import mineplex.core.shop.page.ShopPageBase;
+
+public class TreasurePage extends ShopPageBase<CosmeticManager, CosmeticShop>
+{
+	/**
+	 * This is unfinished, and unused.
+	 * TODO
+	 */
+
+	private static final int[] ROTATION_SLOTS = new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 17, 26, 35, 34, 33, 32, 31, 30, 29, 28, 27, 18, 9 };
+	private static final List<Integer> CHEST_SLOTS = Arrays.asList(new Integer[] {3 + 9 + 9, 6 + 9 + 9, 2 + 9 + 9, 4 + 9 + 9, 5 + 9 + 9});
+	private static final List<ChatColor> CHEST_COLORS = Arrays.asList(new ChatColor[] {ChatColor.RED, ChatColor.GREEN, ChatColor.YELLOW, ChatColor.BLUE, ChatColor.AQUA, ChatColor.GOLD});
+
+	// Used to animate the gui
+	private int _ticks;
+	private Random _random;
+
+	// Used for blocks that rotate around the gui
+	private short _rotationColorOne = 0;
+	private short _rotationColorTwo = 0;
+	private boolean _rotationForwardOne = true;
+	private boolean _rotationForwardTwo = false;
+	private int _currentIndexOne = 4;
+	private int _currentIndexTwo = 4;
+
+	// Is the animation done, can the player select a chest?
+	public boolean _canSelectChest = false;
+
+	// Queues for Chest Colors and Slots
+	private LinkedList<ChatColor> _colors;
+	private LinkedList<Integer> _chestSlots;
+
+	public TreasurePage(CosmeticManager plugin, CosmeticShop shop, CoreClientManager clientManager, mineplex.core.donation.DonationManager donationManager, String name, Player player)
+	{
+		super(plugin, shop, clientManager, donationManager, name, player, 9 * 4);
+		_random = new Random();
+
+		// Shuffle random _colors and chest positions
+		_colors = new LinkedList<ChatColor>(CHEST_COLORS);
+		_chestSlots = new LinkedList<Integer>(CHEST_SLOTS);
+		Collections.shuffle(_colors, _random);
+		Collections.shuffle(_chestSlots, _random);
+	}
+
+	@Override
+	protected void buildPage()
+	{
+		int treasureCount = getPlugin().getInventoryManager().Get(getPlayer()).getItemCount("Treasure Chest");
+
+		_rotationColorOne = _ticks % 2 == 0 ? ((short) _random.nextInt(15)) : _rotationColorOne;
+		_rotationColorTwo = _ticks % 20 == 0 ? ((short) _random.nextInt(15)) : _rotationColorTwo;
+		ItemStack borderPane = new ItemStack(Material.STAINED_GLASS_PANE, 1, _canSelectChest ? (short) 7 : (short) 15);
+
+		// Set all the border panes
+		for (int row = 0; row < 4; row++)
+		{
+			if (row == 0 || row == 3)
+			{
+				for (int column = 0; column < 9; column++)
+				{
+					setItem(column, row, borderPane);
+				}
+			}
+			else
+			{
+				setItem(0, row, borderPane);
+				setItem(8, row, borderPane);
+			}
+		}
+
+		if (_ticks <= 21)
+		{
+			rotateBorderPanes();
+		}
+
+		if (_ticks == 0)
+		{
+			getPlayer().playSound(getPlayer().getEyeLocation(), Sound.ANVIL_USE, 4, 1);
+		}
+		else if (_ticks == 20)
+		{
+			getPlayer().playSound(getPlayer().getEyeLocation(), Sound.CHEST_OPEN, 4, 1);
+		}
+		else if (_ticks >= 30 && _ticks <= 120 && _ticks % 20 == 0)
+		{
+			ChatColor color = _colors.poll();
+			String colorName = color.name().toLowerCase();
+			colorName = colorName.substring(0, 1).toUpperCase() + colorName.substring(1);
+			String chestName = color + colorName + " Chest";
+			String[] lore = new String[] { ChatColor.RESET.toString() + ChatColor.WHITE + "Click to Open" };
+
+
+			getPlayer().playSound(getPlayer().getEyeLocation(), Sound.NOTE_PLING, 4, 1);
+			final int slot = _chestSlots.poll();
+			addButton(slot, new ShopItem(Material.CHEST, chestName, lore, 1, false), new IButton()
+			{
+				public void onClick(Player player, ClickType clickType)
+				{
+					if (_canSelectChest)
+					{
+						player.playSound(player.getLocation(), Sound.CHEST_OPEN, 1, 1);
+					}
+				}
+			});
+
+		}
+		else if (_ticks == 140)
+		{
+			getPlayer().playSound(getPlayer().getEyeLocation(), Sound.LEVEL_UP, 4, 1F);
+			ItemStack is = new ItemStack(Material.BOOK);
+			ItemMeta meta = is.getItemMeta();
+			meta.setDisplayName(ChatColor.RESET.toString() + "Select a Chest");
+			is.setItemMeta(meta);
+
+			setItem(9 + 4, is);
+			addGlow(9 + 4);
+
+			_canSelectChest = true;
+		}
+
+		_ticks++;
+	}
+
+	public void rotateBorderPanes()
+	{
+		ItemStack whitePane = new ItemStack(Material.STAINED_GLASS_PANE, 1, (short) 0);
+		ItemStack paneOne = new ItemStack(Material.STAINED_GLASS_PANE, 1, _rotationColorOne);
+		ItemStack paneTwo = new ItemStack(Material.STAINED_GLASS_PANE, 1, _rotationColorTwo);
+
+		_currentIndexOne = (_currentIndexOne + (_rotationForwardOne ? 1 : -1)) % ROTATION_SLOTS.length;
+		if (_currentIndexOne < 0)
+			_currentIndexOne = _currentIndexOne + ROTATION_SLOTS.length;
+
+		_currentIndexTwo = (_currentIndexTwo + (_rotationForwardTwo ? 1 : -1)) % ROTATION_SLOTS.length;
+		if (_currentIndexTwo < 0)
+			_currentIndexTwo = _currentIndexTwo + ROTATION_SLOTS.length;
+
+		if (_currentIndexOne == _currentIndexTwo)
+		{
+			setItem(ROTATION_SLOTS[_currentIndexOne], whitePane);
+		}
+		else
+		{
+			setItem(ROTATION_SLOTS[_currentIndexOne], paneOne);
+			setItem(ROTATION_SLOTS[_currentIndexTwo], paneTwo);
+		}
+	}
+
+	public void update()
+	{
+		buildPage();
+	}
+
+}

GOD DAMN COSMETICS/cosmetic/ui/page/WeaponNamePage.java

@@ -0,0 +1,76 @@
+package mineplex.core.cosmetic.ui.page;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.bukkit.entity.Player;
+
+import mineplex.core.account.CoreClientManager;
+import mineplex.core.common.util.C;
+import mineplex.core.common.util.UtilUI;
+import mineplex.core.cosmetic.CosmeticManager;
+import mineplex.core.cosmetic.ui.CosmeticShop;
+import mineplex.core.donation.DonationManager;
+import mineplex.core.gadget.types.Gadget;
+import mineplex.core.gadget.types.GadgetType;
+import mineplex.core.gadget.types.WeaponNameGadget;
+import mineplex.core.gadget.types.WeaponNameGadget.WeaponType;
+import mineplex.core.itemstack.ItemBuilder;
+import mineplex.core.itemstack.ItemStackFactory;
+
+public class WeaponNamePage extends GadgetPage
+{
+
+	public WeaponNamePage(CosmeticManager plugin, CosmeticShop shop, CoreClientManager clientManager, DonationManager donationManager, Player player)
+	{
+		super(plugin, shop, clientManager, donationManager, "Weapon Names", player);
+
+		buildPage();
+	}
+
+	@Override
+	protected void buildPage()
+	{
+		WeaponType[] types = WeaponType.values();
+		int[] slots = UtilUI.getIndicesFor(types.length, 2);
+		int index = 0;
+		Map<WeaponType, List<Gadget>> gadgets = new HashMap<>(types.length);
+
+		for (Gadget gadget : _plugin.getGadgetManager().getGadgets(GadgetType.WEAPON_NAME))
+		{
+			gadgets.computeIfAbsent(((WeaponNameGadget) gadget).getWeaponNameType().getWeaponType(), k -> new ArrayList<>()).add(gadget);
+		}
+
+		for (WeaponType type : types)
+		{
+			int own = 0, total = 0;
+			List<Gadget> gadgetList = gadgets.get(type);
+
+			for (Gadget gadget : gadgetList)
+			{
+				if (gadget.ownsGadget(getPlayer()))
+				{
+					own++;
+				}
+				total++;
+			}
+
+			ItemBuilder builder = new ItemBuilder(type.getMaterial());
+			String name = ItemStackFactory.Instance.GetName(builder.getType(), (byte) 0, false);
+
+			builder.setTitle(C.cGreenB + name);
+			builder.addLore(
+					"",
+					C.cWhite + "You own " + own + "/" + total,
+					"",
+					C.cGreen + "Left-Click to view " + name + " cosmetics"
+			);
+
+			addButton(slots[index++], builder.build(), (player, clickType) -> getShop().openPageForPlayer(player, new ListGadgetPage(getPlugin(), getShop(), getClientManager(), getDonationManager(), name, player, gadgetList)));
+		}
+
+		addBackButton();
+	}
+}

GOD DAMN COSMETICS/cosmetic/ui/page/gamemodifiers/GameCosmeticCategoryPage.java

@@ -0,0 +1,77 @@
+package mineplex.core.cosmetic.ui.page.gamemodifiers;
+
+import java.util.List;
+
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+
+import mineplex.core.account.CoreClientManager;
+import mineplex.core.common.util.C;
+import mineplex.core.common.util.UtilUI;
+import mineplex.core.cosmetic.CosmeticManager;
+import mineplex.core.cosmetic.ui.CosmeticShop;
+import mineplex.core.cosmetic.ui.page.GadgetPage;
+import mineplex.core.donation.DonationManager;
+import mineplex.core.gadget.gadgets.gamemodifiers.GameCosmeticCategory;
+import mineplex.core.gadget.gadgets.gamemodifiers.GameCosmeticType;
+import mineplex.core.gadget.types.GameModifierGadget;
+import mineplex.core.itemstack.ItemBuilder;
+import mineplex.core.shop.item.ShopItem;
+
+public class GameCosmeticCategoryPage extends GadgetPage
+{
+
+	private final List<GameCosmeticCategory> _categories;
+
+	public GameCosmeticCategoryPage(CosmeticManager plugin, CosmeticShop shop, CoreClientManager clientManager, DonationManager donationManager, Player player, GameCosmeticType type, List<GameCosmeticCategory> categories)
+	{
+		super(plugin, shop, clientManager, donationManager, type.getName(), player, null);
+
+		_categories = categories;
+
+		buildPage();
+	}
+
+	@Override
+	protected void buildPage()
+	{
+		int[] slots = UtilUI.getIndicesFor(_categories.size(), 2);
+		int index = 0;
+
+		for (GameCosmeticCategory category : _categories)
+		{
+			int own = 0;
+			int total = 0;
+			for (GameModifierGadget gadget : category.getGadgets())
+			{
+				if (gadget.ownsGadget(getPlayer()))
+				{
+					own++;
+				}
+				total++;
+			}
+
+			ItemBuilder builder = new ItemBuilder(category.getItemStack());
+
+			builder.setTitle(C.cGreenB + category.getCategoryName());
+			builder.addLore(
+					"",
+					C.cWhite + "You own " + own + "/" + total,
+					"",
+					C.cGreen + "Left-Click to view " + category.getCategoryName() + " cosmetics"
+			);
+
+			GadgetPage page = category.getGadgetPage(this);
+
+			addButton(slots[index++], builder.build(), (player, clickType) ->
+			{
+				if (page != null)
+				{
+					getShop().openPageForPlayer(player, page);
+				}
+			});
+		}
+
+		addButton(4, new ShopItem(Material.BED, C.cGreen + "Go Back", new String[0], 1, false), (player, clickType) -> getShop().openPageForPlayer(getPlayer(), new GameCosmeticsPage(getPlugin(), getShop(), getClientManager(), getDonationManager(), player)));
+	}
+}

GOD DAMN COSMETICS/cosmetic/ui/page/gamemodifiers/GameCosmeticGadgetPage.java

@@ -0,0 +1,55 @@
+package mineplex.core.cosmetic.ui.page.gamemodifiers;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+
+import mineplex.core.account.CoreClientManager;
+import mineplex.core.common.util.C;
+import mineplex.core.cosmetic.CosmeticManager;
+import mineplex.core.cosmetic.ui.CosmeticShop;
+import mineplex.core.cosmetic.ui.page.GadgetPage;
+import mineplex.core.donation.DonationManager;
+import mineplex.core.gadget.gadgets.gamemodifiers.GameCosmeticCategory;
+import mineplex.core.gadget.types.Gadget;
+import mineplex.core.shop.item.ShopItem;
+
+public class GameCosmeticGadgetPage extends GadgetPage
+{
+
+	private final GameCosmeticCategoryPage _previousMenu;
+	private final GameCosmeticCategory _category;
+
+	public GameCosmeticGadgetPage(CosmeticManager plugin, CosmeticShop shop, CoreClientManager clientManager, DonationManager donationManager, String name, Player player, GameCosmeticCategoryPage previousMenu, GameCosmeticCategory category)
+	{
+		super(plugin, shop, clientManager, donationManager, name, player);
+
+		_previousMenu = previousMenu;
+		_category = category;
+
+		buildPage();
+	}
+
+	@Override
+	protected void buildPage()
+	{
+		super.buildPage();
+
+		if (_previousMenu != null)
+		{
+			addButton(4, new ShopItem(Material.BED, C.cGreen + "Go Back", new String[0], 1, false), (player, clickType) -> getShop().openPageForPlayer(getPlayer(), _previousMenu));
+		}
+		else
+		{
+			removeButton(4);
+		}
+	}
+
+	@Override
+	protected List<Gadget> getGadgetsToDisplay()
+	{
+		return new ArrayList<>(_category.getGadgets());
+	}
+}

GOD DAMN COSMETICS/cosmetic/ui/page/gamemodifiers/GameCosmeticsPage.java

@@ -0,0 +1,75 @@
+package mineplex.core.cosmetic.ui.page.gamemodifiers;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import org.bukkit.entity.Player;
+
+import mineplex.core.account.CoreClientManager;
+import mineplex.core.common.util.C;
+import mineplex.core.common.util.UtilUI;
+import mineplex.core.cosmetic.CosmeticManager;
+import mineplex.core.cosmetic.ui.CosmeticShop;
+import mineplex.core.cosmetic.ui.page.GadgetPage;
+import mineplex.core.donation.DonationManager;
+import mineplex.core.gadget.gadgets.gamemodifiers.GameCosmeticCategory;
+import mineplex.core.gadget.gadgets.gamemodifiers.GameCosmeticManager;
+import mineplex.core.gadget.gadgets.gamemodifiers.GameCosmeticType;
+import mineplex.core.gadget.types.GameModifierGadget;
+import mineplex.core.game.GameDisplay;
+import mineplex.core.itemstack.ItemBuilder;
+
+public class GameCosmeticsPage extends GadgetPage
+{
+
+	public GameCosmeticsPage(CosmeticManager plugin, CosmeticShop shop, CoreClientManager clientManager, DonationManager donationManager, Player player)
+	{
+		super(plugin, shop, clientManager, donationManager, "Game Cosmetics", player);
+
+		buildPage();
+	}
+
+	@Override
+	protected void buildPage()
+	{
+		GameCosmeticManager manager = getPlugin().getGadgetManager().getGameCosmeticManager();
+		Map<GameCosmeticType, List<GameCosmeticCategory>> cosmetics = manager.getTypes();
+		int[] slots = UtilUI.getIndicesFor(cosmetics.size(), 2);
+		int index = 0;
+
+		for (Entry<GameCosmeticType, List<GameCosmeticCategory>> entry : cosmetics.entrySet())
+		{
+			int own = 0;
+			int total = 0;
+
+			for (GameCosmeticCategory category : entry.getValue())
+			{
+				for (GameModifierGadget gadget : category.getGadgets())
+				{
+					if (gadget.ownsGadget(getPlayer()))
+					{
+						own++;
+					}
+					total++;
+				}
+			}
+
+			GameDisplay display = entry.getKey().getGame();
+			ItemBuilder builder = new ItemBuilder(display.getMaterial(), display.getMaterialData());
+
+			builder.setTitle(C.cGreenB + display.getName());
+			builder.addLore(
+					"",
+					C.cWhite + "You own " + own + "/" + total,
+					"",
+					C.cGreen + "Left-Click to view " + display.getName() + "'s cosmetics"
+			);
+
+			addButton(slots[index++], builder.build(), (player, clickType) -> getShop().openPageForPlayer(player, new GameCosmeticCategoryPage(getPlugin(), getShop(), getClientManager(), getDonationManager(), player, entry.getKey(), entry.getValue())));
+		}
+
+		addBackButton();
+	}
+
+}

GOD DAMN COSMETICS/cosmetic/ui/page/gamemodifiers/moba/HeroSkinCategoryPage.java

@@ -0,0 +1,104 @@
+package mineplex.core.cosmetic.ui.page.gamemodifiers.moba;
+
+import java.lang.reflect.Field;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+
+import mineplex.core.account.CoreClientManager;
+import mineplex.core.common.skin.SkinData;
+import mineplex.core.common.util.C;
+import mineplex.core.common.util.UtilUI;
+import mineplex.core.cosmetic.CosmeticManager;
+import mineplex.core.cosmetic.ui.CosmeticShop;
+import mineplex.core.cosmetic.ui.page.GadgetPage;
+import mineplex.core.cosmetic.ui.page.gamemodifiers.GameCosmeticCategoryPage;
+import mineplex.core.donation.DonationManager;
+import mineplex.core.gadget.gadgets.gamemodifiers.moba.skins.HeroSkinGadget;
+import mineplex.core.gadget.gadgets.gamemodifiers.moba.skins.HeroSkinGadgetData;
+import mineplex.core.shop.item.ShopItem;
+
+public class HeroSkinCategoryPage extends GadgetPage
+{
+
+	private static final Map<String, SkinData> SKIN_DATA = new HashMap<>();
+
+	private static SkinData getSkinItem(String name)
+	{
+		if (SKIN_DATA.containsKey(name))
+		{
+			return SKIN_DATA.get(name);
+		}
+
+		try
+		{
+			Field field = SkinData.class.getDeclaredField(name.toUpperCase());
+			SkinData data = (SkinData) field.get(null);
+			SKIN_DATA.put(name, data);
+			return data;
+		}
+		catch (Exception e)
+		{
+			return null;
+		}
+	}
+
+	private final GameCosmeticCategoryPage _previousMenu;
+
+	public HeroSkinCategoryPage(CosmeticManager plugin, CosmeticShop shop, CoreClientManager clientManager, DonationManager donationManager, String name, Player player, GameCosmeticCategoryPage previousMenu)
+	{
+		super(plugin, shop, clientManager, donationManager, name, player);
+
+		_previousMenu = previousMenu;
+
+		buildPage();
+	}
+
+	@Override
+	protected void buildPage()
+	{
+		Map<String, List<HeroSkinGadgetData>> skinData = HeroSkinGadget.getSkins();
+		int[] slots = UtilUI.getIndicesFor(skinData.size(), 2);
+		int index = 0;
+
+		for (Entry<String, List<HeroSkinGadgetData>> entry : skinData.entrySet())
+		{
+			String name = entry.getKey();
+			List<HeroSkinGadgetData> gadgetDataList = entry.getValue();
+			SkinData data = getSkinItem(name);
+
+			if (data == null)
+			{
+				continue;
+			}
+
+			int own = 0;
+			int total = 0;
+			for (HeroSkinGadgetData gadgetData : gadgetDataList)
+			{
+				if (gadgetData.getGadget().ownsGadget(getPlayer()))
+				{
+					own++;
+				}
+				total++;
+			}
+
+			ItemStack itemStack = data.getSkull(C.cGreenB + name, Arrays.asList(
+					"",
+					C.cWhite + "You own " + own + "/" + total,
+					"",
+					C.cGreen + "Left-Click to view " + name + "'s skins"
+			));
+
+			addButton(slots[index++], itemStack, (player, clickType) -> getShop().openPageForPlayer(player, new HeroSkinGadgetPage(getPlugin(), getShop(), getClientManager(), getDonationManager(), name, getPlayer(), this, gadgetDataList)));
+		}
+
+		addButton(4, new ShopItem(Material.BED, C.cGreen + "Go Back", new String[0], 1, false), (player, clickType) -> getShop().openPageForPlayer(getPlayer(), _previousMenu));
+	}
+}

GOD DAMN COSMETICS/cosmetic/ui/page/gamemodifiers/moba/HeroSkinGadgetPage.java

@@ -0,0 +1,50 @@
+package mineplex.core.cosmetic.ui.page.gamemodifiers.moba;
+
+import java.util.List;
+
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+
+import mineplex.core.account.CoreClientManager;
+import mineplex.core.common.util.C;
+import mineplex.core.cosmetic.CosmeticManager;
+import mineplex.core.cosmetic.ui.CosmeticShop;
+import mineplex.core.cosmetic.ui.page.GadgetPage;
+import mineplex.core.donation.DonationManager;
+import mineplex.core.gadget.gadgets.gamemodifiers.moba.skins.HeroSkinGadgetData;
+import mineplex.core.shop.item.ShopItem;
+
+public class HeroSkinGadgetPage extends GadgetPage
+{
+
+	private final GadgetPage _previousMenu;
+	private final List<HeroSkinGadgetData> _gadgetData;
+
+	HeroSkinGadgetPage(CosmeticManager plugin, CosmeticShop shop, CoreClientManager clientManager, DonationManager donationManager, String name, Player player, GadgetPage previousMenu, List<HeroSkinGadgetData> gadgetData)
+	{
+		super(plugin, shop, clientManager, donationManager, name, player);
+
+		_previousMenu = previousMenu;
+		_gadgetData = gadgetData;
+
+		buildPage();
+	}
+
+	@Override
+	protected void buildPage()
+	{
+		int slot = 10;
+
+		for (HeroSkinGadgetData gadgetData : _gadgetData)
+		{
+			addGadget(gadgetData.getGadget(), slot);
+
+			if (++slot % 9 == 8)
+			{
+				slot += 2;
+			}
+		}
+
+		addButton(4, new ShopItem(Material.BED, C.cGreen + "Go Back", new String[0], 1, false), (player, clickType) -> getShop().openPageForPlayer(getPlayer(), _previousMenu));
+	}
+}

GOD DAMN COSMETICS/gadget/commands/AmmoCommand.java

@@ -0,0 +1,109 @@
+package mineplex.core.gadget.commands;
+
+import org.bukkit.entity.Player;
+
+import mineplex.core.command.CommandBase;
+import mineplex.core.common.util.F;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.gadget.GadgetManager;
+import mineplex.core.gadget.types.Gadget;
+import mineplex.core.gadget.types.GadgetType;
+
+public class AmmoCommand extends CommandBase<GadgetManager>
+{
+    private GadgetManager _plugin;
+
+    public AmmoCommand(GadgetManager plugin)
+    {
+        super(plugin, GadgetManager.Perm.AMMO_COMMAND, "ammo");
+        
+        _plugin = plugin;
+    }
+
+    @Override
+    public void Execute(Player caller, String[] args)
+    {
+        if (args.length == 2)
+        {
+            String gadgetName = args[0];
+            String amount = args[1];
+            Gadget gadget = getGadgetByName(gadgetName);
+            if (gadget == null)
+            {
+                UtilPlayer.message(caller, F.main("Ammo", "Could not find gadget " + F.skill(gadgetName)));
+            }
+            else
+            {
+                addAmmo(caller, caller, gadget, amount);
+            }
+        }
+        else if (args.length == 3)
+        {
+            String gadgetName = args[0];
+            String amount = args[1];
+            String targetName = args[2];
+            Player target = UtilPlayer.searchExact(targetName);
+
+            Gadget gadget = getGadgetByName(gadgetName);
+            if (gadget == null)
+            {
+                UtilPlayer.message(caller, F.main("Ammo", "Could not find gadget " + F.skill(gadgetName)));
+            }
+            else
+            {
+                if (target == null)
+                {
+                    _plugin.getClientManager().loadClientByName(targetName, loadedProfile ->
+                    {
+                        if (loadedProfile != null)
+                        {
+                            addAmmo(caller, loadedProfile.GetPlayer(), gadget, amount);
+                        }
+                        else
+                        {
+                            UtilPlayer.message(caller, F.main("Ammo", "Could not find player " + F.name(targetName)));
+                        }
+                    });
+                }
+                else
+                {
+                    addAmmo(caller, target, gadget, amount);
+                }
+            }
+        }
+        else
+        {
+            UtilPlayer.message(caller, F.main("Ammo", "Usage: /ammo <gadget> <ammo> [player]"));
+        }
+    }
+
+    private void addAmmo(Player caller, Player target, Gadget gadget, String amount)
+    {
+        try
+        {
+            int ammo = Integer.parseInt(amount);
+            _plugin.getInventoryManager().addItemToInventory(target, gadget.getName(), ammo);
+            UtilPlayer.message(caller, F.main("Ammo", "You gave " + F.elem(ammo + " Ammo") + " for the gadget " + F.skill(gadget.getName()) + " to " + F.name(target.getName()) + "."));
+            if (target != null)
+            {
+                UtilPlayer.message(target, F.main("Ammo", F.name(caller.getName()) + " gave you " + F.elem(ammo + " Ammo") + " for the gadget " + F.skill(gadget.getName()) + "."));
+            }
+        }
+        catch (Exception e)
+        {
+            UtilPlayer.message(caller, F.main("Ammo", "Invalid Ammo Amount"));
+        }
+    }
+
+    private Gadget getGadgetByName(String gadgetName)
+    {
+        for (Gadget gadget : _plugin.getGadgets(GadgetType.ITEM))
+        {
+            if (gadget.getName().equalsIgnoreCase(gadgetName.replaceAll("_", " ")))
+            {
+                return gadget;
+            }
+        }
+        return null;
+    }
+}

GOD DAMN COSMETICS/gadget/commands/LockCosmeticsCommand.java

@@ -0,0 +1,92 @@
+package mineplex.core.gadget.commands;
+
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+
+import mineplex.core.command.CommandBase;
+import mineplex.core.common.util.F;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.common.util.UtilText;
+import mineplex.core.donation.Donor;
+import mineplex.core.gadget.GadgetManager;
+import mineplex.core.gadget.types.Gadget;
+import mineplex.core.gadget.types.GadgetType;
+import mineplex.core.pet.PetType;
+
+public class LockCosmeticsCommand extends CommandBase<GadgetManager>
+{
+
+    public LockCosmeticsCommand(GadgetManager plugin)
+    {
+        super(plugin, GadgetManager.Perm.LOCK_COSMETICS_COMMAND, "lockCosmetics");
+	}
+
+	@Override
+	public void Execute(Player caller, String[] args)
+	{
+		// Adds all cosmetic types
+		if (args.length == 0)
+		{
+			removeCosmetics(null, caller);
+		}
+		else if (args.length == 1)
+		{
+			Player player = Bukkit.getPlayer(args[0]);
+			if (player != null)
+			{
+				removeCosmetics(null, player);
+				UtilPlayer.message(caller, F.main(Plugin.getName(), "Removed all the cosmetics to " + F.name(player.getName()) + "!"));
+			}
+		}
+	}
+
+	private void removeCosmetics(GadgetType gadgetType, Player caller)
+	{
+		if (gadgetType == null)
+		{
+			for (GadgetType type : GadgetType.values())
+			{
+				removeCosmetics(type, caller);
+			}
+			removePets(caller);
+			return;
+		}
+		Donor donor = Plugin.getDonationManager().Get(caller);
+		int removed = 0;
+		for (Gadget gadget : Plugin.getGadgets(gadgetType))
+		{
+			if (gadget != null)
+			{
+				int i;
+				String[] names = new String[gadget.getAlternativePackageNames().length + 1];
+				for (i = 0; i < gadget.getAlternativePackageNames().length; i++)
+				{
+					names[i] = gadget.getAlternativePackageNames()[i];
+				}
+				names[i++] = gadget.getName();
+				for (String name : names)
+				{
+					if (donor.ownsUnknownSalesPackage(name))
+					{
+						donor.removeAllOwnedUnknownSalesPackages(name);
+						removed++;
+					}
+				}
+			}
+		}
+		UtilPlayer.message(caller, F.main(Plugin.getName(), "Removed " + removed + F.elem(" " + gadgetType.getCategoryType()) + UtilText.plural(" item", removed) + "!"));
+	}
+
+	private void removePets(Player caller)
+	{
+		int removed = 0;
+		for (PetType pet : PetType.values())
+		{
+			if (Plugin.getPetManager().Get(caller).getPets().remove(pet) != null)
+			{
+				removed++;
+			}
+		}
+		UtilPlayer.message(caller, F.main(Plugin.getName(), "Removed " + removed + UtilText.plural(" pet", removed) + "!"));
+	}
+}

GOD DAMN COSMETICS/gadget/commands/TestTauntCommand.java

@@ -0,0 +1,48 @@
+package mineplex.core.gadget.commands;
+
+import java.util.Arrays;
+import java.util.stream.Collectors;
+
+import org.bukkit.entity.Player;
+
+import mineplex.core.command.CommandBase;
+import mineplex.core.common.util.F;
+import mineplex.core.gadget.GadgetManager;
+import mineplex.core.gadget.GadgetManager.Perm;
+import mineplex.core.gadget.types.GadgetType;
+import mineplex.core.gadget.types.TauntGadget;
+
+public class TestTauntCommand extends CommandBase<GadgetManager>
+{
+
+	public TestTauntCommand(GadgetManager plugin)
+	{
+		super(plugin, Perm.TEST_TAUNT_COMMAND, "testtaunt");
+	}
+
+	@Override
+	public void Execute(Player caller, String[] args)
+	{
+		if (args.length < 1)
+		{
+			caller.sendMessage(F.main(Plugin.getName(), "/" + _aliasUsed + " <name>"));
+			return;
+		}
+
+		String name = Arrays.stream(args).collect(Collectors.joining(" "));
+		TauntGadget gadget = (TauntGadget) Plugin.getGadget(name, GadgetType.TAUNT);
+
+		if (gadget == null)
+		{
+			caller.sendMessage(F.main(Plugin.getName(), "There is no taunt named " + F.name(name) + "."));
+			return;
+		}
+
+		if (!gadget.isActive(caller))
+		{
+			gadget.enable(caller);
+		}
+
+		gadget.start(caller);
+	}
+}

GOD DAMN COSMETICS/gadget/commands/UnlockCosmeticCommand.java

@@ -0,0 +1,79 @@
+package mineplex.core.gadget.commands;
+
+import org.bukkit.entity.Player;
+
+import mineplex.core.command.CommandBase;
+import mineplex.core.common.currency.GlobalCurrency;
+import mineplex.core.common.util.F;
+import mineplex.core.gadget.GadgetManager;
+import mineplex.core.gadget.types.Gadget;
+import mineplex.core.server.util.TransactionResponse;
+
+public class UnlockCosmeticCommand extends CommandBase<GadgetManager>
+{
+
+	public UnlockCosmeticCommand(GadgetManager plugin)
+	{
+		super(plugin, GadgetManager.Perm.UNLOCK_COSMETIC_COMMAND, "unlockCosmetic");
+	}
+
+	@Override
+	public void Execute(Player caller, String[] args)
+	{
+		if (args.length < 2)
+		{
+			caller.sendMessage(F.main(Plugin.getName(), "/" + _aliasUsed + " <player> <cosmetic>"));
+			return;
+		}
+
+		Plugin.getClientManager().getOrLoadClient(args[0], client ->
+		{
+			if (client == null)
+			{
+				caller.sendMessage(F.main(Plugin.getName(), F.name(args[0]) + " does not exist."));
+				return;
+			}
+
+			StringBuilder cosmetic = new StringBuilder();
+
+			for (int i = 1; i < args.length; i++)
+			{
+				cosmetic.append(args[i]).append(" ");
+			}
+
+			String cosmeticString = cosmetic.toString().trim();
+
+			for (Gadget gadget : Plugin.getAllGadgets())
+			{
+				boolean thisGadget = gadget.getName().equals(cosmeticString);
+
+				for (String alternative : gadget.getAlternativePackageNames())
+				{
+					if (alternative.equals(cosmeticString))
+					{
+						thisGadget = true;
+						break;
+					}
+				}
+
+				if (thisGadget)
+				{
+					Plugin.getDonationManager().purchaseUnknownSalesPackage(client, cosmeticString, GlobalCurrency.TREASURE_SHARD, 0, true, response ->
+					{
+						if (response != TransactionResponse.Success)
+						{
+							caller.sendMessage(F.main(Plugin.getName(), "Failed to unlock " + F.name(cosmeticString) + " for " + F.name(client.getName()) + "."));
+						}
+						else
+						{
+							caller.sendMessage(F.main(Plugin.getName(), "Unlocked " + F.name(cosmeticString) + " for " + F.name(client.getName()) + "."));
+						}
+					});
+					return;
+				}
+			}
+
+			caller.sendMessage(F.main(Plugin.getName(), "The cosmetic " + F.name(cosmeticString) + " does not exist."));
+		});
+	}
+}

GOD DAMN COSMETICS/gadget/commands/UnlockCosmeticsCommand.java

@@ -0,0 +1,118 @@
+package mineplex.core.gadget.commands;
+
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+
+import mineplex.core.command.CommandBase;
+import mineplex.core.common.util.F;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.common.util.UtilServer;
+import mineplex.core.common.util.UtilText;
+import mineplex.core.donation.Donor;
+import mineplex.core.gadget.GadgetManager;
+import mineplex.core.gadget.types.Gadget;
+import mineplex.core.gadget.types.GadgetType;
+import mineplex.core.pet.PetType;
+
+public class UnlockCosmeticsCommand extends CommandBase<GadgetManager>
+{
+	
+	public UnlockCosmeticsCommand(GadgetManager plugin)
+	{
+		super(plugin, GadgetManager.Perm.UNLOCK_COSMETICS_COMMAND, "unlockcosmetics", "ulcs");
+	}
+
+    @Override
+    public void Execute(Player caller, String[] args)
+    {
+		// Adds all cosmetic types
+        if (args.length == 0)
+        {
+            addCosmetics(null, caller);
+        }
+        else
+		{
+			if (args[0].equalsIgnoreCase("all"))
+			{
+				for (Player player : UtilServer.getPlayers())
+				{
+					if (player != null)
+					{
+						addCosmetics(null, player);
+						UtilPlayer.message(caller, F.main(Plugin.getName(), "Added all the cosmetics to " + F.name(player.getName()) + "!"));
+					}
+				}
+			}
+			else
+			{
+				for (String arg : args)
+				{
+					Player player = Bukkit.getPlayer(arg);
+					if (player != null)
+					{
+						addCosmetics(null, player);
+						UtilPlayer.message(caller, F.main(Plugin.getName(), "Added all the cosmetics to " + F.name(player.getName()) + "!"));
+					}
+				}
+			}
+		}
+	}
+
+	private void addCosmetics(GadgetType gadgetType, Player caller)
+	{
+		if (gadgetType == null)
+		{
+			for (GadgetType type : GadgetType.values())
+			{
+				addCosmetics(type, caller);
+			}
+			addPets(caller);
+			return;
+		}
+		Donor donor = Plugin.getDonationManager().Get(caller);
+		int added = 0;
+		for (Gadget gadget : Plugin.getGadgets(gadgetType))
+		{
+			if (gadget.isHidden())
+			{
+				continue;
+			}
+
+			boolean hasGadget = false;
+			int i;
+			String[] names = new String[gadget.getAlternativePackageNames().length + 1];
+			for (i = 0; i < gadget.getAlternativePackageNames().length; i++)
+			{
+				names[i] = gadget.getAlternativePackageNames()[i];
+			}
+			names[i] = gadget.getName();
+			for (String name : names)
+			{
+				if (donor.ownsUnknownSalesPackage(name))
+				{
+					hasGadget = true;
+				}
+			}
+			if (!hasGadget)
+			{
+				donor.addOwnedUnknownSalesPackage(gadget.getName());
+				added++;
+			}
+		}
+		UtilPlayer.message(caller, F.main(Plugin.getName(), "Added " + added + F.elem(" " + gadgetType.getCategoryType()) + UtilText.plural(" item", added) + "!"));
+	}
+
+	private void addPets(Player caller)
+	{
+		int added = 0;
+		for (PetType pet : PetType.values())
+		{
+			if (!Plugin.getPetManager().Get(caller).getPets().containsKey(pet))
+			{
+				Plugin.getPetManager().Get(caller).getPets().put(pet, pet.getName());
+				added++;
+			}
+		}
+		UtilPlayer.message(caller, F.main(Plugin.getName(), "Added " + added + UtilText.plural(" pet", added) + "!"));
+	}
+}

GOD DAMN COSMETICS/gadget/event/GadgetAppliedEvent.java

@@ -0,0 +1,42 @@
+package mineplex.core.gadget.event;
+
+import mineplex.core.gadget.types.Gadget;
+import org.bukkit.entity.Player;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+
+public class GadgetAppliedEvent extends Event
+{
+
+	private static final HandlerList handlers = new HandlerList();
+
+	private Player _player;
+	private Gadget _gadget;
+
+	public GadgetAppliedEvent(Player player, Gadget gadget)
+	{
+		_player = player;
+		_gadget = gadget;
+	}
+
+	public HandlerList getHandlers()
+	{
+		return handlers;
+	}
+
+	public static HandlerList getHandlerList()
+	{
+		return handlers;
+	}
+
+	public Gadget getGadget()
+	{
+		return _gadget;
+	}
+
+	public Player getPlayer()
+	{
+		return _player;
+	}
+
+}

GOD DAMN COSMETICS/gadget/event/GadgetBlockEvent.java

@@ -0,0 +1,59 @@
+package mineplex.core.gadget.event;
+
+import java.util.Collection;
+
+import org.bukkit.block.Block;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+
+import mineplex.core.gadget.types.Gadget;
+
+public class GadgetBlockEvent extends Event implements Cancellable
+{
+
+    private static final HandlerList HANDLER_LIST = new HandlerList();
+    
+    private final Gadget _gadget;
+    private final Collection<Block> _blocks;
+    
+    private boolean _cancelled;
+
+    public GadgetBlockEvent(Gadget gadget, Collection<Block> blocks)
+    {
+    	_gadget = gadget;
+    	_blocks = blocks;
+    }
+  
+    public HandlerList getHandlers() 
+    {
+        return HANDLER_LIST;
+    }
+ 
+    public static HandlerList getHandlerList() 
+    {
+        return HANDLER_LIST;
+    }
+
+	public Gadget getGadget() 
+	{
+		return _gadget;
+	}
+
+	public Collection<Block> getBlocks()
+	{
+		return _blocks;
+	}
+
+	@Override
+	public void setCancelled(boolean cancel)
+	{
+		_cancelled = cancel;
+	}
+
+	@Override
+	public boolean isCancelled()
+	{
+		return _cancelled;
+	}
+}

GOD DAMN COSMETICS/gadget/event/GadgetChangeEvent.java

@@ -0,0 +1,60 @@
+package mineplex.core.gadget.event;
+
+import mineplex.core.gadget.types.Gadget;
+import org.bukkit.entity.Player;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+
+/**
+ * Called when a player enables or disables a gadget manually,
+ * allowing it to be saved when the player changes a gadget, instead of
+ * when they quit or join a server
+ */
+public class GadgetChangeEvent extends Event
+{
+
+	public enum GadgetState
+	{
+		ENABLED,
+		DISABLED
+	}
+
+	private static final HandlerList handlers = new HandlerList();
+
+	private final Player _player;
+	private final Gadget _gadget;
+	private final GadgetState _gadgetState;
+
+	public GadgetChangeEvent(Player player, Gadget gadget, GadgetState gadgetState)
+	{
+		_player = player;
+		_gadget = gadget;
+		_gadgetState = gadgetState;
+	}
+
+	public Player getPlayer()
+	{
+		return _player;
+	}
+
+	public Gadget getGadget()
+	{
+		return _gadget;
+	}
+
+	public GadgetState getGadgetState()
+	{
+		return _gadgetState;
+	}
+
+	public HandlerList getHandlers()
+	{
+		return handlers;
+	}
+
+	public static HandlerList getHandlerList()
+	{
+		return handlers;
+	}
+
+}

GOD DAMN COSMETICS/gadget/event/GadgetCollideEntityEvent.java

@@ -0,0 +1,49 @@
+package mineplex.core.gadget.event;
+
+import org.bukkit.entity.Entity;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.HandlerList;
+import org.bukkit.event.entity.EntityEvent;
+
+import mineplex.core.gadget.types.Gadget;
+
+public class GadgetCollideEntityEvent extends EntityEvent implements Cancellable
+{
+
+	private static final HandlerList HANDLER_LIST = new HandlerList();
+
+	private final Gadget _gadget;
+	private boolean _cancelled;
+
+	public GadgetCollideEntityEvent(Gadget gadget, Entity collided)
+	{
+		super(collided);
+
+		_gadget = gadget;
+	}
+
+	public HandlerList getHandlers()
+	{
+		return HANDLER_LIST;
+	}
+
+	public static HandlerList getHandlerList()
+	{
+		return HANDLER_LIST;
+	}
+
+	public Gadget getGadget()
+	{
+		return _gadget;
+	}
+
+	public void setCancelled(boolean cancel)
+	{
+		_cancelled = cancel;
+	}
+
+	public boolean isCancelled()
+	{
+		return _cancelled;
+	}
+}

GOD DAMN COSMETICS/gadget/event/GadgetDisableEvent.java

@@ -0,0 +1,43 @@
+package mineplex.core.gadget.event;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+
+import mineplex.core.gadget.types.Gadget;
+
+public class GadgetDisableEvent extends Event
+{
+	
+	private static final HandlerList handlers = new HandlerList();
+	
+	private Player _player;
+	private Gadget _gadget;
+
+	public GadgetDisableEvent(Player player, Gadget gadget)
+	{
+		_player = player;
+		_gadget = gadget;
+	}
+	
+	public Player getPlayer()
+	{
+		return _player;
+	}
+	
+	public Gadget getGadget()
+	{
+		return _gadget;
+	}
+
+	public static HandlerList getHandlerList() 
+    {
+        return handlers;
+    }
+	
+	public HandlerList getHandlers() 
+    {
+        return handlers;
+    }
+
+}

GOD DAMN COSMETICS/gadget/event/GadgetEnableEvent.java

@@ -0,0 +1,63 @@
+package mineplex.core.gadget.event;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.HandlerList;
+import org.bukkit.event.player.PlayerEvent;
+
+import mineplex.core.gadget.types.Gadget;
+
+public class GadgetEnableEvent extends PlayerEvent implements Cancellable
+{
+
+    private static final HandlerList handlers = new HandlerList();
+    
+    private final Gadget _gadget;
+	private boolean _showMessage = true;
+    
+    private boolean _cancelled = false;
+    
+    public GadgetEnableEvent(Player player, Gadget gadget) 
+    {
+    	super(player);
+
+    	_gadget = gadget;
+    }
+  
+    public HandlerList getHandlers() 
+    {
+        return handlers;
+    }
+ 
+    public static HandlerList getHandlerList() 
+    {
+        return handlers;
+    }
+
+	public Gadget getGadget() 
+	{
+		return _gadget;
+	}
+
+	@Override
+	public void setCancelled(boolean cancel)
+	{
+		_cancelled = cancel;
+	}
+
+	@Override
+	public boolean isCancelled()
+	{
+		return _cancelled;
+	}
+
+	public void setShowMessage(boolean showMessage)
+	{
+		_showMessage = showMessage;
+	}
+
+	public boolean canShowMessage()
+	{
+		return _showMessage;
+	}
+}

GOD DAMN COSMETICS/gadget/event/GadgetSelectLocationEvent.java

@@ -0,0 +1,56 @@
+package mineplex.core.gadget.event;
+
+import org.bukkit.Location;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+
+import mineplex.core.gadget.types.Gadget;
+
+public class GadgetSelectLocationEvent extends Event implements Cancellable
+{
+
+	private static final HandlerList HANDLER_LIST = new HandlerList();
+
+	private final Gadget _gadget;
+	private final Location _location;
+	private boolean _cancelled;
+
+	public GadgetSelectLocationEvent(Gadget gadget, Location location)
+	{
+		_gadget = gadget;
+		_location = location;
+	}
+
+	public HandlerList getHandlers()
+	{
+		return HANDLER_LIST;
+	}
+
+	public static HandlerList getHandlerList()
+	{
+		return HANDLER_LIST;
+	}
+
+	public Gadget getGadget()
+	{
+		return _gadget;
+	}
+
+	public Location getLocation()
+	{
+		return _location;
+	}
+
+	@Override
+	public void setCancelled(boolean cancel)
+	{
+		_cancelled = cancel;
+	}
+
+	@Override
+	public boolean isCancelled()
+	{
+		return _cancelled;
+	}
+}

GOD DAMN COSMETICS/gadget/event/ItemGadgetOutOfAmmoEvent.java

@@ -0,0 +1,41 @@
+package mineplex.core.gadget.event;
+
+import mineplex.core.gadget.types.ItemGadget;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+
+public class ItemGadgetOutOfAmmoEvent extends Event 
+{
+    private static final HandlerList handlers = new HandlerList();
+    
+    private Player _player;
+    private ItemGadget _gadget;
+    
+    public ItemGadgetOutOfAmmoEvent(Player player, ItemGadget gadget) 
+    {
+    	_player = player;
+    	_gadget = gadget;
+    }
+  
+    public HandlerList getHandlers() 
+    {
+        return handlers;
+    }
+ 
+    public static HandlerList getHandlerList() 
+    {
+        return handlers;
+    }
+	
+	public ItemGadget getGadget() 
+	{
+		return _gadget;
+	}
+
+	public Player getPlayer()
+	{
+		return _player;
+	}
+}

GOD DAMN COSMETICS/gadget/event/ItemGadgetUseEvent.java

@@ -0,0 +1,73 @@
+package mineplex.core.gadget.event;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+
+import mineplex.core.gadget.types.ItemGadget;
+
+public class ItemGadgetUseEvent extends Event implements Cancellable
+{
+    private static final HandlerList handlers = new HandlerList();
+    
+    private Player _player;
+    private ItemGadget _gadget;
+    private int _count;
+    private boolean _cancelled;
+    private String _cancelledMessage = "";
+    
+    public ItemGadgetUseEvent(Player player, ItemGadget gadget, int count) 
+    {
+    	_player = player;
+    	_gadget = gadget;
+    	_count = count;
+    }
+  
+    public HandlerList getHandlers() 
+    {
+        return handlers;
+    }
+ 
+    public static HandlerList getHandlerList() 
+    {
+        return handlers;
+    }
+
+	public int getCount() 
+	{
+		return _count;
+	}
+	
+	public ItemGadget getGadget() 
+	{
+		return _gadget;
+	}
+
+	public Player getPlayer()
+	{
+		return _player;
+	}
+
+	@Override
+	public boolean isCancelled()
+	{
+		return _cancelled;
+	}
+
+	@Override
+	public void setCancelled(boolean cancelled)
+	{
+		_cancelled = cancelled;
+	}
+
+	public String getCancelledMessage()
+	{
+		return _cancelledMessage;
+	}
+
+	public void setCancelledMessage(String cancelledMessage)
+	{
+		_cancelledMessage = cancelledMessage;
+	}
+}

GOD DAMN COSMETICS/gadget/event/PlayerConsumeMelonEvent.java

@@ -0,0 +1,25 @@
+package mineplex.core.gadget.event;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.HandlerList;
+import org.bukkit.event.player.PlayerEvent;
+
+public class PlayerConsumeMelonEvent extends PlayerEvent
+{
+	private static final HandlerList handlers = new HandlerList();
+
+	public PlayerConsumeMelonEvent(Player player)
+	{
+		super(player);
+	}
+
+	public HandlerList getHandlers()
+	{
+		return handlers;
+	}
+
+	public static HandlerList getHandlerList()
+	{
+		return handlers;
+	}
+}