Added stats manager.

Added lots of missing files.

Plugins/Mineplex.Bungee.Mineplexer/src/mineplex/bungee/FileUpdater.java

@@ -0,0 +1,171 @@
+package mineplex.bungee;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FilenameFilter;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.concurrent.TimeUnit;
+
+import net.md_5.bungee.BungeeCord;
+import net.md_5.bungee.api.ChatColor;
+import net.md_5.bungee.api.plugin.Plugin;
+
+import org.apache.commons.codec.digest.DigestUtils;
+
+public class FileUpdater implements Runnable
+{
+	private Plugin _plugin;
+	private HashMap<String, String> _jarMd5Map = new HashMap<String, String>();
+	
+	private boolean _needUpdate;
+	private boolean _enabled = true;
+	private int _timeTilRestart = 10;
+	
+	public FileUpdater(Plugin plugin)
+	{
+		_plugin = plugin;
+		
+		getPluginMd5s();
+		
+		if (new File("IgnoreUpdates.dat").exists())
+			_enabled = false;
+		
+		_plugin.getProxy().getScheduler().schedule(_plugin, this, 2L, 2L, TimeUnit.MINUTES);
+	}
+	
+	public void checkForNewFiles()
+	{
+		if (_needUpdate || !_enabled)
+			return;
+		
+		boolean windows = System.getProperty("os.name").startsWith("Windows");
+		
+		File updateDir = new File((windows ? "C:" : File.separator + "home" + File.separator + "mineplex") + File.separator + "update");
+		
+		updateDir.mkdirs();
+	    
+	    FilenameFilter statsFilter = new FilenameFilter() 
+	    {
+            public boolean accept(File paramFile, String paramString) 
+            {
+                if (paramString.endsWith("jar"))
+                {
+                    return true;
+                }
+                
+                return false;
+            }
+	    };
+	    
+	    for (File f : updateDir.listFiles(statsFilter))
+	    {
+	    	FileInputStream fis = null;
+	    	
+	    	try
+	    	{
+	    		if (_jarMd5Map.containsKey(f.getName()))
+	    		{
+	    			fis = new FileInputStream(f);
+	    			String md5 = DigestUtils.md5Hex(fis);
+	    			
+	    			if (!md5.equals(_jarMd5Map.get(f.getName())))
+	    			{
+	    				System.out.println(f.getName() + " old jar : " + _jarMd5Map.get(f.getName()));
+	    				System.out.println(f.getName() + " new jar : " + md5);
+	    				_needUpdate = true;
+	    			}
+	    		}
+	    	}
+	    	catch (Exception ex)
+	    	{
+	    		ex.printStackTrace();
+	    	}
+	    	finally
+	    	{
+	    		if (fis != null)
+	    		{
+					try
+					{
+						fis.close();
+					} 
+					catch (IOException e)
+					{
+						e.printStackTrace();
+					}		
+	    		}
+	    	}
+	    }
+	}
+	
+	private void getPluginMd5s()
+	{
+		File pluginDir = new File("plugins");
+		
+		pluginDir.mkdirs();
+	    
+	    FilenameFilter statsFilter = new FilenameFilter() 
+	    {
+            public boolean accept(File paramFile, String paramString) 
+            {
+                if (paramString.endsWith("jar"))
+                {
+                    return true;
+                }
+                
+                return false;
+            }
+	    };
+	    
+	    for (File f : pluginDir.listFiles(statsFilter))
+	    {
+	    	FileInputStream fis = null;
+	    	
+	    	try
+	    	{
+	    		fis = new FileInputStream(f);
+	    		_jarMd5Map.put(f.getName(), DigestUtils.md5Hex(fis));
+	    	}
+	    	catch (Exception ex)
+	    	{
+	    		ex.printStackTrace();
+	    	}
+	    	finally
+	    	{
+	    		if (fis != null)
+	    		{
+					try
+					{
+						fis.close();
+					} 
+					catch (IOException e)
+					{
+						e.printStackTrace();
+					}		
+	    		}
+	    	}
+	    }
+	}
+
+	@Override
+	public void run() 
+	{
+		checkForNewFiles();
+		
+		if (_needUpdate)
+		{
+			BungeeCord.getInstance().broadcast(ChatColor.RED + "Connection Node" + ChatColor.DARK_GRAY + ">" + ChatColor.YELLOW + "This connection node will be restarting in " + _timeTilRestart + " minutes.");
+		}
+		else
+		{
+			return;
+		}
+		
+		_timeTilRestart -= 2;
+		
+		if (_timeTilRestart < 0 || !_enabled)
+		{
+			BungeeCord.getInstance().stop();
+		}
+	}
+}

Plugins/Mineplex.Core/src/mineplex/core/account/CoreClientManager.java

@@ -1,11 +1,12 @@
 package mineplex.core.account;
 
-import java.sql.Connection;
+import java.sql.*;
 import java.util.HashSet;
 
 import mineplex.core.account.event.AsyncClientLoadEvent;
 import mineplex.core.account.event.ClientUnloadEvent;
 import mineplex.core.account.event.ClientWebResponseEvent;
+import mineplex.core.account.event.RetrieveClientInformationEvent;
 //import mineplex.core.account.event.RetrieveClientInformationEvent;
 import mineplex.core.account.repository.AccountRepository;
 import mineplex.core.account.repository.token.ClientToken;
@@ -26,6 +27,10 @@ import org.bukkit.event.player.PlayerLoginEvent;
 import org.bukkit.event.player.PlayerQuitEvent;
 import org.bukkit.plugin.java.JavaPlugin;
 
+import sun.jdbc.odbc.ee.ConnectionPoolFactory;
+
+import java.util.Properties;
+
 public class CoreClientManager implements Listener
 {
 	private static CoreClientManager _instance;
@@ -144,33 +149,14 @@ public class CoreClientManager implements Listener
 		client.SetAccountId(token.AccountId);
 		client.SetRank(Rank.valueOf(token.Rank));
 		
+		// JSON sql response
 		Bukkit.getServer().getPluginManager().callEvent(new ClientWebResponseEvent(response));
+		
+		// Load client in miniplugins
 		Bukkit.getServer().getPluginManager().callEvent(new AsyncClientLoadEvent(token, client));
 		
-		Connection connection = null;
+		// Mysql
-		
+		Bukkit.getServer().getPluginManager().callEvent(new RetrieveClientInformationEvent(client.GetPlayerName()));
-		try
-		{
-			//Bukkit.getServer().getPluginManager().callEvent(new RetrieveClientInformationEvent(connection));
-		}
-		catch (Exception exception)
-		{
-			exception.printStackTrace();
-		}
-		finally
-		{
-			if (connection != null)
-			{
-				try
-				{
-					connection.close();
-				}
-				catch (Exception exception)
-				{
-					exception.printStackTrace();
-				}
-			}
-		}
 	}
 
 	@EventHandler(priority = EventPriority.LOWEST)

Plugins/Mineplex.Core/src/mineplex/core/account/event/RetrieveClientInformationEvent.java

@@ -1,6 +1,7 @@
 package mineplex.core.account.event;
 
 import java.sql.Connection;
+import java.sql.DriverManager;
 
 import org.bukkit.event.Event;
 import org.bukkit.event.HandlerList;
@@ -9,12 +10,27 @@ public class RetrieveClientInformationEvent extends Event
 {
     private static final HandlerList handlers = new HandlerList();
     
-    private Connection _connection;
+    private static Connection _connection;
- 
+	private String _connectionString = "jdbc:mysql://sql.mineplex.com:3306/Stats?autoReconnect=true&failOverReadOnly=false&maxReconnects=10";
-    public RetrieveClientInformationEvent(Connection connection)
+	private String _userName = "root";
+	private String _password = "tAbechAk3wR7tuTh";
+
+	private String _clientName;
+	
+    public RetrieveClientInformationEvent(String playerName)
     {
-    	_connection = connection;
+    	_clientName = playerName;
-    }
+    	
+		try
+		{
+			if (_connection == null || _connection.isClosed())
+				_connection = DriverManager.getConnection(_connectionString, _userName, _password);
+		}
+		catch (Exception exception)
+		{
+			System.out.println("Erorr in REtrieveClientINformationEvent constructor");
+		}
+	}
     
     public Connection getConnection()
     {
@@ -30,4 +46,9 @@ public class RetrieveClientInformationEvent extends Event
     {
         return handlers;
     }
+
+	public String getClientName() 
+	{
+		return _clientName;
+	}
 }

Plugins/Mineplex.Core/src/mineplex/core/stats/PlayerStats.java

@@ -0,0 +1,30 @@
+package mineplex.core.stats;
+
+import java.util.Set;
+
+import mineplex.core.common.util.NautHashMap;
+
+public class PlayerStats 
+{
+	private NautHashMap<String, Integer> _statHash = new NautHashMap<String, Integer>();
+	
+	public void addStat(String statName, int value)
+	{
+		if (!_statHash.containsKey(statName))
+		{
+			_statHash.put(statName, 0);
+		}
+		
+		_statHash.put(statName, _statHash.get(statName) + value);
+	}
+
+	public int getStat(String statName) 
+	{
+		return _statHash.containsKey(statName) ? _statHash.get(statName) : 0;
+	}
+
+	public Set<String> getStatsNames() 
+	{	
+		return _statHash.keySet();
+	}
+}

Plugins/Mineplex.Core/src/mineplex/core/stats/StatsManager.java

@@ -0,0 +1,272 @@
+package mineplex.core.stats;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.Iterator;
+import java.util.Map.Entry;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.player.PlayerQuitEvent;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import mineplex.core.MiniPlugin;
+import mineplex.core.account.event.RetrieveClientInformationEvent;
+import mineplex.core.common.util.NautHashMap;
+
+public class StatsManager extends MiniPlugin
+{
+	private static Object _statSync = new Object();
+	private static Connection _connection;
+	
+	private NautHashMap<String, NautHashMap<String, PlayerStats>> _statUploadQueue = new NautHashMap<String, NautHashMap<String, PlayerStats>>();
+	private Runnable _saveRunnable;
+	
+	private String _connectionString = "jdbc:mysql://sql.mineplex.com:3306/Stats?autoReconnect=true&failOverReadOnly=false&maxReconnects=10";
+	private String _userName = "root";
+	private String _password = "tAbechAk3wR7tuTh";
+	
+	private NautHashMap<String, String> _retrieveStatements = new NautHashMap<String, String>();
+	private NautHashMap<String, String> _updateStatements = new NautHashMap<String, String>();
+	
+	private NautHashMap<String, NautHashMap<String, PlayerStats>> _playerStatList = new NautHashMap<String, NautHashMap<String, PlayerStats>>();
+	
+	public StatsManager(JavaPlugin plugin) 
+	{
+		super("StatsManager", plugin);
+				
+		if (_saveRunnable == null)
+		{
+			_saveRunnable = new Runnable()
+			{
+				public void run()
+				{
+					saveStats();
+				}
+			};
+			
+			plugin.getServer().getScheduler().runTaskTimerAsynchronously(plugin, _saveRunnable, 200L, 200L);
+		}
+	}
+	
+	public StatsManager addTable(String tableName)
+	{
+		if (!_retrieveStatements.containsKey(tableName))
+		{
+			_retrieveStatements.put(tableName, "Select statName, statValue FROM " + tableName + " WHERE playerName = ?");
+		}
+		
+		if (!_updateStatements.containsKey(tableName))
+		{
+			_updateStatements.put(tableName, "INSERT INTO " + tableName + " (playerName, statName, statValue) VALUES (?, ?, ?) ON DUPLICATE KEY UPDATE statName = VALUES(statName), statValue = VALUES(statValue);");
+		}
+		
+		if (!_playerStatList.containsKey(tableName))
+		{
+			_playerStatList.put(tableName, new NautHashMap<String, PlayerStats>());
+		}
+		
+		if (!_playerStatList.containsKey(tableName))
+		{
+			_playerStatList.put(tableName, new NautHashMap<String, PlayerStats>());
+		}
+
+		PreparedStatement createStatement = null;
+		
+		try
+		{
+			if (_connection == null || _connection.isClosed())
+				_connection = DriverManager.getConnection(_connectionString, _userName, _password);
+			
+			createStatement = _connection.prepareStatement("CREATE TABLE IF NOT EXISTS " + tableName + " (playerName VARCHAR(25), statName VARCHAR(256), statValue INT, PRIMARY KEY (playerName, statName), INDEX (playerName));");
+			
+			createStatement.execute();
+		}
+		catch (Exception exception)
+		{
+			System.out.println("Error creating table " + tableName + ".");
+			exception.printStackTrace();
+		}
+		finally
+		{
+			if (createStatement != null)
+			{
+				try
+				{
+					createStatement.close();
+				} 
+				catch (SQLException e)
+				{
+					e.printStackTrace();
+				}
+			}
+		}
+		
+		return this;
+	}
+
+	public void addStat(Player player, String table, String statName, int value)
+	{
+		addStat(player.getName(), table, statName, value);
+	}
+	
+	public void addStat(String playerName, String table, String statName, int value)
+	{
+		if (!_playerStatList.containsKey(table))
+		{
+			System.out.println("Error adding stats for " + playerName + " on table " + table + " (" + statName + ", " + value + ") : TABLE DOES NOT EXIST!");
+			return;
+		}
+		
+		if (!_playerStatList.get(table).containsKey(playerName))
+		{
+			_playerStatList.get(table).put(playerName, new PlayerStats());
+		}
+		
+		_playerStatList.get(table).get(playerName).addStat(statName, value);
+		
+		synchronized (_statSync)
+		{
+			if (!_statUploadQueue.containsKey(table))
+			{
+				_statUploadQueue.put(table, new NautHashMap<String, PlayerStats>());
+			}
+			
+			_statUploadQueue.get(table).put(playerName, _playerStatList.get(table).get(playerName));
+		}
+	}
+	
+	@EventHandler
+	public void clearPlayerStatsOnLeave(PlayerQuitEvent event)
+	{
+		for (String table : _playerStatList.keySet())
+			_playerStatList.get(table).remove(event.getPlayer().getName());
+	}
+	
+	@EventHandler
+	public void loadPlayerStats(RetrieveClientInformationEvent event)
+	{
+		ResultSet resultSet = null;
+		PreparedStatement preparedStatement = null;
+		
+		for (String tableName : _retrieveStatements.keySet())
+		{
+			try
+			{
+				preparedStatement = event.getConnection().prepareStatement(_retrieveStatements.get(tableName));
+				preparedStatement.setString(1, event.getClientName());
+				
+				resultSet = preparedStatement.executeQuery();
+				PlayerStats playerStats = new PlayerStats();
+				
+				while (resultSet.next())
+				{	
+					playerStats.addStat(resultSet.getString(1), resultSet.getInt(2));	
+				}
+				
+				_playerStatList.get(tableName).put(event.getClientName(), playerStats);
+			}
+			catch (Exception exception)
+			{
+				exception.printStackTrace();
+			}
+			finally
+			{
+				if (preparedStatement != null)
+				{
+					try
+					{
+						preparedStatement.close();
+					} 
+					catch (SQLException e)
+					{
+						e.printStackTrace();
+					}
+				}
+				
+				if (resultSet != null)
+				{
+					try
+					{
+						resultSet.close();
+					} 
+					catch (SQLException e)
+					{
+						e.printStackTrace();
+					}
+				}
+			}
+		}
+	}
+	
+	protected void saveStats() 
+	{
+		PreparedStatement preparedStatement = null;
+		
+		try
+		{
+			NautHashMap<String, NautHashMap<String, PlayerStats>> uploadQueue = new NautHashMap<String, NautHashMap<String, PlayerStats>>();
+			
+			synchronized (_statSync)
+			{
+				for (String key : _statUploadQueue.keySet())
+				{
+					uploadQueue.put(key, new NautHashMap<String, PlayerStats>());
+					
+					for (String stat : _statUploadQueue.get(key).keySet())
+					{
+						uploadQueue.get(key).put(stat, _statUploadQueue.get(key).get(stat));
+					}
+				}
+				
+				_statUploadQueue.clear();
+			}
+
+			for (String tableName : uploadQueue.keySet())
+			{
+				for (Iterator<Entry<String, PlayerStats>> iterator = uploadQueue.get(tableName).entrySet().iterator(); iterator.hasNext();)
+				{
+					Entry<String, PlayerStats> entry = iterator.next();
+					
+					for (String statName : entry.getValue().getStatsNames())
+					{
+						if (_connection == null || _connection.isClosed())
+							_connection = DriverManager.getConnection(_connectionString, _userName, _password);
+						
+						preparedStatement = _connection.prepareStatement(_updateStatements.get(tableName), Statement.RETURN_GENERATED_KEYS);
+						
+						preparedStatement.setString(1, entry.getKey());
+						preparedStatement.setString(2, statName);
+						preparedStatement.setInt(3, entry.getValue().getStat(statName));
+						
+						preparedStatement.executeUpdate();
+					}
+					
+					iterator.remove();
+				}
+			}
+		}
+		catch (Exception exception)
+		{
+			exception.printStackTrace();
+		}
+		finally
+		{
+			if (preparedStatement != null)
+			{
+				try
+				{
+					preparedStatement.close();
+				}
+				catch (SQLException e)
+				{
+					e.printStackTrace();
+				}
+			}
+		}	
+	}
+}

Plugins/Mineplex.Hub/src/mineplex/hub/server/ui/SelectBHButton.java

@@ -0,0 +1,21 @@
+package mineplex.hub.server.ui;
+
+import org.bukkit.entity.Player;
+
+import mineplex.core.shop.item.IButton;
+
+public class SelectBHButton implements IButton
+{
+	private ServerGameMenu _menu;
+
+	public SelectBHButton(ServerGameMenu menu)
+	{
+		_menu = menu;
+	}
+	
+	@Override
+	public void Clicked(Player player)
+	{
+		_menu.OpenBH(player);
+	}
+}

Plugins/Mineplex.Hub/src/mineplex/hub/server/ui/SelectSGButton.java

@@ -0,0 +1,21 @@
+package mineplex.hub.server.ui;
+
+import org.bukkit.entity.Player;
+
+import mineplex.core.shop.item.IButton;
+
+public class SelectSGButton implements IButton
+{
+	private ServerGameMenu _menu;
+
+	public SelectSGButton(ServerGameMenu menu)
+	{
+		_menu = menu;
+	}
+	
+	@Override
+	public void Clicked(Player player)
+	{
+		_menu.OpenSG(player);
+	}
+}

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

@@ -62,6 +62,7 @@ import mineplex.core.packethandler.PacketHandler;
 import mineplex.core.explosion.Explosion;
 import mineplex.core.portal.Portal;
 import mineplex.core.projectile.ProjectileManager;
+import mineplex.core.stats.StatsManager;
 
 public class ArcadeManager extends MiniPlugin implements IRelation
 {
@@ -91,7 +92,8 @@ public class ArcadeManager extends MiniPlugin implements IRelation
 	private GameManager _gameManager;
 	private GameLobbyManager _gameLobbyManager;
 	private GameWorldManager _gameWorldManager;
-
+	
+	private StatsManager _statsManager;
 	private ClassManager _classManager;
 	private SkillFactory _skillFactory;
 	private ClassShopManager _classShopManager;
@@ -147,6 +149,8 @@ public class ArcadeManager extends MiniPlugin implements IRelation
 		_classCustomBuildShop = new ClassCombatCustomBuildShop(_classShopManager, clientManager, donationManager, webAddress);
 		 */
 
+		_statsManager = new StatsManager(plugin);
+		
 		_portal = portal;
 
 		//Shop
@@ -300,6 +304,11 @@ public class ArcadeManager extends MiniPlugin implements IRelation
 		return _gameWorldManager;
 	}
 
+	public StatsManager GetStatsManager()
+	{
+		return _statsManager;
+	}
+	
 	public ChatColor GetColor(Player player)
 	{
 		if (_game == null)

Plugins/Nautilus.Game.Arcade/src/nautilus/game/arcade/game/games/hungergames/HungerGames.java

@@ -1498,6 +1498,25 @@ public class HungerGames extends SoloGame
 		}
 	}
 
+	@EventHandler
+    public void TourneyKills(CombatDeathEvent event)
+    {
+	    if (!(event.GetEvent().getEntity() instanceof Player))
+            return;
+	   
+	    Player killed = (Player)event.GetEvent().getEntity();
+	
+	    if (event.GetLog().GetKiller() != null)
+	    {
+            Player killer = UtilPlayer.searchExact(event.GetLog().GetKiller().GetName());
+
+            if (killer != null && !killer.equals(killed))
+            {
+            	Manager.GetStatsManager().addStat(killer, "Pvp", "Kills", 1);
+	        }
+	    }
+    }
+	
 	@EventHandler
 	public void BlockBreak(BlockBreakEvent event)
 	{

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

@@ -47,6 +47,7 @@ public class GamePlayerManager implements Listener
 		Manager = manager;
 		
 		Manager.GetPluginManager().registerEvents(this, Manager.GetPlugin());
+		Manager.GetStatsManager().addTable("Pvp");
 	}
 	
 	@EventHandler(priority = EventPriority.HIGH)
@@ -80,7 +81,7 @@ public class GamePlayerManager implements Listener
 	public void PlayerJoin(PlayerJoinEvent event)
 	{
 		final Player player = event.getPlayer();
-
+		
 		//Lobby Name
 		Manager.GetLobby().AddPlayerToScoreboards(player, null);