Update version number to 6.4

VotingPlugin/Resources/Config.yml

@@ -231,6 +231,9 @@ Format:
         Title: '&6&lVoting Player Help'
         # Format for help message in /v help
         Line: '&6%Command% - &6%HelpMessage%'
+        # Hover color for help message
+        # Hex format: #HEXCOLOR
+        HoverColor: AQUA
         # Require permission to see command in /v help or /av help
         RequirePermission: true
         
@@ -600,7 +603,7 @@ ExtraBackgroundUpdate: false
 
 # This will prevent spam clicking GUI's to prevent exploits
 # Number is time in between clicking in milliseconds
-SpamClickTime: 350
+SpamClickTime: 150
 # Message to send when inventory forced closed when spam clicking
 # Uncomment to use
 #SpamClickMessage: '&cDetected spam clicking GUI, closing to prevent exploits'

VotingPlugin/Resources/SpecialRewards.yml

@@ -1,13 +1,16 @@
-# To disable reward set value to []
+# To disable reward set value to {}
 # or remove entirely
 # Eg:
-# FirstVote: [] (All in one line)
-# Rewards will be given if there is a reward to give
+# FirstVote: {} (All in one line)
+# Rewards will be given if there is a reward to give, otherwise they will be ignored
 
 # First vote rewards
 FirstVote: 
   Messages:
     Player: '&aYou voted for your first time!'
+    
+# First vote of the day reward
+FirstVoteToday: {}
 
 # All vote rewards
 # Reward for voting on all sites in one day

VotingPlugin/Resources/plugin.yml

@@ -6,6 +6,8 @@ website: https://www.spigotmc.org/resources/votingplugin.15358/
 author: BenCodez
 softdepend: [MVdWPlaceholders, Votifier, VotifierPlus, NuVotifier, CMI, Vault, PlaceholderAPI, ProtocolLib, MVdWPlaceholderAPI, AuthMe]
 api-version: 1.13
+libraries:
+  - org.openjdk.nashorn:nashorn-core:15.2
 commands:
   vote:
     description: Vote command

VotingPlugin/pom.xml

@@ -4,7 +4,7 @@
 	<modelVersion>4.0.0</modelVersion>
 	<groupId>com.bencodez</groupId>
 	<artifactId>VotingPlugin</artifactId>
-	<version>6.3.1</version>
+	<version>6.4</version>
 	<packaging>jar</packaging>
 	<name>VotingPlugin</name>
 	<properties>
@@ -102,6 +102,14 @@
 				<configuration>
 					<shadedArtifactAttached>false</shadedArtifactAttached>
 					<minimizeJar>true</minimizeJar>
+					<filters>
+						<filter>
+							<artifact>mysql-connector-java</artifact>
+							<includes>
+								<include>**</include>
+							</includes>
+						</filter>
+					</filters>
 					<relocations>
 						<!-- Lets relocate the shaded API so we dont cause any conflicts with 
 							other plugins -->
@@ -131,6 +139,11 @@
 							<pattern>xyz.upperlevel.spigot.book</pattern>
 							<shadedPattern>${project.groupId}.votingplugin.upperlevel.book</shadedPattern>
 						</relocation>
+						<relocation>
+							<pattern>org.bstats</pattern>
+							<!-- Replace this with your package! -->
+							<shadedPattern>${project.groupId}.votingplugin.bstats</shadedPattern>
+						</relocation>
 					</relocations>
 				</configuration>
 				<executions>
@@ -148,6 +161,16 @@
 								</excludes>
 							</artifactSet>
 							<createDependencyReducedPom>false</createDependencyReducedPom>
+							<filters>
+								<filter>
+									<artifact>*:*</artifact>
+									<excludes>
+										<exclude>META-INF/*.SF</exclude>
+										<exclude>META-INF/*.DSA</exclude>
+										<exclude>META-INF/*.RSA</exclude>
+									</excludes>
+								</filter>
+							</filters>
 						</configuration>
 					</execution>
 				</executions>
@@ -241,16 +264,12 @@
 			<id>velocity</id>
 			<url>https://nexus.velocitypowered.com/repository/maven-public/</url>
 		</repository>
-		<repository>
-			<id>bintray-repo</id>
-			<url>https://dl.bintray.com/ichbinjoe/public/</url>
-		</repository>
 	</repositories>
 	<dependencies>
 		<dependency>
 			<groupId>org.spigotmc</groupId>
 			<artifactId>spigot-api</artifactId>
-			<version>1.16.5-R0.1-SNAPSHOT</version>
+			<version>1.17-R0.1-SNAPSHOT</version>
 			<scope>provided</scope>
 		</dependency>
 		<dependency>
@@ -268,20 +287,15 @@
 		<dependency>
 			<groupId>com.vexsoftware</groupId>
 			<artifactId>nuvotifier-universal</artifactId>
-			<version>2.6.0</version>
-			<scope>provided</scope>
+			<version>2.7.2</version>
+			<scope>system</scope>
+			<systemPath>${project.basedir}/Jars/nuvotifier.jar</systemPath>
 		</dependency>
 		<dependency>
 			<groupId>com.tchristofferson</groupId>
 			<artifactId>ConfigUpdater</artifactId>
 			<version>1.1-SNAPSHOT</version>
 		</dependency>
-		<dependency>
-			<groupId>org.apache.httpcomponents</groupId>
-			<artifactId>httpclient</artifactId>
-			<version>4.5.6</version>
-			<scope>test</scope>
-		</dependency>
 		<dependency>
 			<groupId>be.maximvdw</groupId>
 			<artifactId>MVdWPlaceholderAPI</artifactId>
@@ -289,6 +303,18 @@
 			<scope>system</scope>
 			<systemPath>${project.basedir}/Jars/MVdWPlaceholderAPI.jar</systemPath>
 		</dependency>
+		<dependency>
+			<groupId>com.velocitypowered</groupId>
+			<artifactId>velocity-api</artifactId>
+			<version>1.1.5</version>
+			<scope>provided</scope>
+		</dependency>
+		<dependency>
+			<groupId>org.bstats</groupId>
+			<artifactId>bstats-velocity</artifactId>
+			<version>2.2.1</version>
+			<scope>compile</scope>
+		</dependency>
 	</dependencies>
 	<profiles>
 		<profile>

VotingPlugin/src/com/bencodez/votingplugin/VotingPluginMain.java

@@ -524,6 +524,29 @@ public class VotingPluginMain extends AdvancedCorePlugin {
 				getSpecialRewardsConfig().setValue(path, value);
 			}
 		});
+		
+		addDirectlyDefinedRewards(new DirectlyDefinedReward("FirstVoteToday") {
+
+			@Override
+			public void createSection(String key) {
+				getSpecialRewardsConfig().createSection(key);
+			}
+
+			@Override
+			public ConfigurationSection getFileData() {
+				return getSpecialRewardsConfig().getData();
+			}
+
+			@Override
+			public void save() {
+				getSpecialRewardsConfig().saveData();
+			}
+
+			@Override
+			public void setData(String path, Object value) {
+				getSpecialRewardsConfig().setValue(path, value);
+			}
+		});
 
 		addDirectlyDefinedRewards(new DirectlyDefinedReward("VoteReminding.Rewards") {
 
@@ -1159,7 +1182,7 @@ public class VotingPluginMain extends AdvancedCorePlugin {
 		}
 
 		plugin.getLogger().info("Enabled VotingPlugin " + plugin.getDescription().getVersion());
-		if (getProfile().equals("dev")) {
+		if (getProfile().contains("dev")) {
 			plugin.getLogger().warning("Using dev build, this is not a stable build, use at your own risk");
 		}
 
@@ -1370,11 +1393,9 @@ public class VotingPluginMain extends AdvancedCorePlugin {
 
 		specialRewardsConfig = new SpecialRewardsConfig(this);
 		specialRewardsConfig.setup();
-		// specialRewardsConfig.loadValues();
 
 		bungeeSettings = new BungeeSettings(this);
 		bungeeSettings.setup();
-		// bungeeSettings.loadValues();
 
 		gui = new GUI(this);
 		gui.setup();

VotingPlugin/src/com/bencodez/votingplugin/VotingPluginMetrics.java

@@ -239,5 +239,59 @@ public class VotingPluginMetrics {
 				}
 			}
 		});
+		if (plugin.getBungeeSettings().isUseBungeecoord()) {
+			metrics.addCustomChart(new BStatsMetrics.SimplePie("bungeebroadcast") {
+
+				@Override
+				public String getValue() {
+					return "" + plugin.getBungeeSettings().isBungeeBroadcast();
+				}
+			});
+			metrics.addCustomChart(new BStatsMetrics.SimplePie("bungeebroadcastalways") {
+
+				@Override
+				public String getValue() {
+					return "" + plugin.getBungeeSettings().isBungeeBroadcastAlways();
+				}
+			});
+
+			metrics.addCustomChart(new BStatsMetrics.SimplePie("perserverrewards") {
+
+				@Override
+				public String getValue() {
+					return "" + plugin.getBungeeSettings().isPerServerRewards();
+				}
+			});
+			metrics.addCustomChart(new BStatsMetrics.SimplePie("perserverpoints") {
+
+				@Override
+				public String getValue() {
+					return "" + plugin.getBungeeSettings().isPerServerPoints();
+				}
+			});
+			metrics.addCustomChart(new BStatsMetrics.SimplePie("triggervotifierevent") {
+
+				@Override
+				public String getValue() {
+					return "" + plugin.getBungeeSettings().isTriggerVotifierEvent();
+				}
+			});
+		}
+
+		metrics.addCustomChart(new BStatsMetrics.SimplePie("geyserprefixsupport") {
+
+			@Override
+			public String getValue() {
+				return "" + plugin.getOptions().isGeyserPrefixSupport();
+			}
+		});
+
+		metrics.addCustomChart(new BStatsMetrics.SimplePie("using_dev_build") {
+
+			@Override
+			public String getValue() {
+				return "" + plugin.getProfile().contains("dev");
+			}
+		});
 	}
 }

VotingPlugin/src/com/bencodez/votingplugin/bungee/BungeeMySQL.java

@@ -40,7 +40,7 @@ public class BungeeMySQL {
 
 	private Set<String> uuids = Collections.synchronizedSet(new HashSet<String>());
 
-	public BungeeMySQL(String tableName, Configuration section) {
+	public BungeeMySQL(VotingPluginBungee bungee, String tableName, Configuration section) {
 		String tablePrefix = section.getString("Prefix");
 		String hostName = section.getString("Host");
 		int port = section.getInt("Port");
@@ -63,7 +63,20 @@ public class BungeeMySQL {
 		if (tablePrefix != null) {
 			name = tablePrefix + tableName;
 		}
-		mysql = new com.bencodez.advancedcore.api.user.userstorage.mysql.api.MySQL(maxThreads);
+		mysql = new com.bencodez.advancedcore.api.user.userstorage.mysql.api.MySQL(maxThreads) {
+
+			@Override
+			public void severe(String string) {
+				bungee.getLogger().severe(string);
+			}
+
+			@Override
+			public void debug(SQLException e) {
+				if (bungee.getConfig().getDebug()) {
+					e.printStackTrace();
+				}
+			}
+		};
 		if (!mysql.connect(hostName, "" + port, user, pass, database, useSSL, lifeTime, str, publicKeyRetrieval)) {
 
 		}

VotingPlugin/src/com/bencodez/votingplugin/bungee/VotingPluginBungee.java

@@ -235,6 +235,36 @@ public class VotingPluginBungee extends Plugin {
 		}
 	}
 
+	private void loadMysql() {
+		mysql = new BungeeMySQL(this, "VotingPlugin_Users", config.getData());
+
+		// column types
+		getMysql().alterColumnType("TopVoterIgnore", "VARCHAR(5)");
+		getMysql().alterColumnType("CheckWorld", "VARCHAR(5)");
+		getMysql().alterColumnType("Reminded", "VARCHAR(5)");
+		getMysql().alterColumnType("DisableBroadcast", "VARCHAR(5)");
+		getMysql().alterColumnType("LastOnline", "VARCHAR(20)");
+		getMysql().alterColumnType("PlayerName", "VARCHAR(30)");
+		getMysql().alterColumnType("DailyTotal", "INT DEFAULT '0'");
+		getMysql().alterColumnType("WeeklyTotal", "INT DEFAULT '0'");
+		getMysql().alterColumnType("DayVoteStreak", "INT DEFAULT '0'");
+		getMysql().alterColumnType("BestDayVoteStreak", "INT DEFAULT '0'");
+		getMysql().alterColumnType("WeekVoteStreak", "INT DEFAULT '0'");
+		getMysql().alterColumnType("BestWeekVoteStreak", "INT DEFAULT '0'");
+		getMysql().alterColumnType("VotePartyVotes", "INT DEFAULT '0'");
+		getMysql().alterColumnType("MonthVoteStreak", "INT DEFAULT '0'");
+		getMysql().alterColumnType("Points", "INT DEFAULT '0'");
+		getMysql().alterColumnType("HighestDailyTotal", "INT DEFAULT '0'");
+		getMysql().alterColumnType("AllTimeTotal", "INT DEFAULT '0'");
+		getMysql().alterColumnType("HighestMonthlyTotal", "INT DEFAULT '0'");
+		getMysql().alterColumnType("MilestoneCount", "INT DEFAULT '0'");
+		getMysql().alterColumnType("MonthTotal", "INT DEFAULT '0'");
+		getMysql().alterColumnType("HighestWeeklyTotal", "INT DEFAULT '0'");
+		getMysql().alterColumnType("LastMonthTotal", "INT DEFAULT '0'");
+		getMysql().alterColumnType("OfflineRewards", "MEDIUMTEXT");
+		getMysql().alterColumnType("DayVoteStreakLastUpdate", "MEDIUMTEXT");
+	}
+
 	@Override
 	public void onEnable() {
 		try {
@@ -252,40 +282,21 @@ public class VotingPluginBungee extends Plugin {
 		config = new Config(this);
 		config.load();
 
-		try {
-			mysql = new BungeeMySQL("VotingPlugin_Users", config.getData());
+		getProxy().getPluginManager().registerCommand(this, new VotingPluginBungeeCommand(this));
 
-			// column types
-			getMysql().alterColumnType("TopVoterIgnore", "VARCHAR(5)");
-			getMysql().alterColumnType("CheckWorld", "VARCHAR(5)");
-			getMysql().alterColumnType("Reminded", "VARCHAR(5)");
-			getMysql().alterColumnType("DisableBroadcast", "VARCHAR(5)");
-			getMysql().alterColumnType("LastOnline", "VARCHAR(20)");
-			getMysql().alterColumnType("PlayerName", "VARCHAR(30)");
-			getMysql().alterColumnType("DailyTotal", "INT DEFAULT '0'");
-			getMysql().alterColumnType("WeeklyTotal", "INT DEFAULT '0'");
-			getMysql().alterColumnType("DayVoteStreak", "INT DEFAULT '0'");
-			getMysql().alterColumnType("BestDayVoteStreak", "INT DEFAULT '0'");
-			getMysql().alterColumnType("WeekVoteStreak", "INT DEFAULT '0'");
-			getMysql().alterColumnType("BestWeekVoteStreak", "INT DEFAULT '0'");
-			getMysql().alterColumnType("VotePartyVotes", "INT DEFAULT '0'");
-			getMysql().alterColumnType("MonthVoteStreak", "INT DEFAULT '0'");
-			getMysql().alterColumnType("Points", "INT DEFAULT '0'");
-			getMysql().alterColumnType("HighestDailyTotal", "INT DEFAULT '0'");
-			getMysql().alterColumnType("AllTimeTotal", "INT DEFAULT '0'");
-			getMysql().alterColumnType("HighestMonthlyTotal", "INT DEFAULT '0'");
-			getMysql().alterColumnType("MilestoneCount", "INT DEFAULT '0'");
-			getMysql().alterColumnType("MonthTotal", "INT DEFAULT '0'");
-			getMysql().alterColumnType("HighestWeeklyTotal", "INT DEFAULT '0'");
-			getMysql().alterColumnType("LastMonthTotal", "INT DEFAULT '0'");
-			getMysql().alterColumnType("OfflineRewards", "MEDIUMTEXT");
-			getMysql().alterColumnType("DayVoteStreakLastUpdate", "MEDIUMTEXT");
+		boolean mysqlLoaded = true;
+		try {
+			if (!config.getData().getString("Host", "").isEmpty()) {
+				loadMysql();
+			} else {
+				mysqlLoaded = false;
+				getLogger().severe("MySQL settings not set in bungeeconfig.yml");
+			}
 		} catch (Exception e) {
+			mysqlLoaded = false;
 			e.printStackTrace();
 		}
 
-		getProxy().getPluginManager().registerCommand(this, new VotingPluginBungeeCommand(this));
-
 		method = BungeeMethod.getByName(config.getBungeeMethod());
 		if (method == null) {
 			method = BungeeMethod.PLUGINMESSAGING;
@@ -293,114 +304,116 @@ public class VotingPluginBungee extends Plugin {
 
 		this.getProxy().registerChannel("vp:vp");
 
-		if (method.equals(BungeeMethod.MYSQL)) {
-			// this.getProxy().registerChannel("vp:vp");
+		if (mysqlLoaded) {
+			if (method.equals(BungeeMethod.MYSQL)) {
+				// this.getProxy().registerChannel("vp:vp");
 
-		} else if (method.equals(BungeeMethod.PLUGINMESSAGING)) {
-			voteCacheFile = new VoteCache(this);
-			voteCacheFile.load();
+			} else if (method.equals(BungeeMethod.PLUGINMESSAGING)) {
+				voteCacheFile = new VoteCache(this);
+				voteCacheFile.load();
 
-			nonVotedPlayersCache = new NonVotedPlayersCache(this);
-			nonVotedPlayersCache.load();
+				nonVotedPlayersCache = new NonVotedPlayersCache(this);
+				nonVotedPlayersCache.load();
 
-			try {
-				for (String server : voteCacheFile.getServers()) {
-					ArrayList<OfflineBungeeVote> vote = new ArrayList<OfflineBungeeVote>();
-					for (String num : voteCacheFile.getServerVotes(server)) {
-						Configuration data = voteCacheFile.getServerVotes(server, num);
-						vote.add(new OfflineBungeeVote(data.getString("Name"), data.getString("UUID"),
-								data.getString("Service"), data.getLong("Time"), data.getBoolean("Real"),
-								data.getString("Text")));
+				try {
+					for (String server : voteCacheFile.getServers()) {
+						ArrayList<OfflineBungeeVote> vote = new ArrayList<OfflineBungeeVote>();
+						for (String num : voteCacheFile.getServerVotes(server)) {
+							Configuration data = voteCacheFile.getServerVotes(server, num);
+							vote.add(new OfflineBungeeVote(data.getString("Name"), data.getString("UUID"),
+									data.getString("Service"), data.getLong("Time"), data.getBoolean("Real"),
+									data.getString("Text")));
+						}
+						cachedVotes.put(server, vote);
 					}
-					cachedVotes.put(server, vote);
+				} catch (Exception e) {
+					e.printStackTrace();
 				}
-			} catch (Exception e) {
-				e.printStackTrace();
-			}
 
-			try {
-				for (String player : voteCacheFile.getPlayers()) {
-					ArrayList<OfflineBungeeVote> vote = new ArrayList<OfflineBungeeVote>();
-					for (String num : voteCacheFile.getOnlineVotes(player)) {
-						Configuration data = voteCacheFile.getOnlineVotes(player, num);
-						vote.add(new OfflineBungeeVote(data.getString("Name"), data.getString("UUID"),
-								data.getString("Service"), data.getLong("Time"), data.getBoolean("Real"),
-								data.getString("Text")));
+				try {
+					for (String player : voteCacheFile.getPlayers()) {
+						ArrayList<OfflineBungeeVote> vote = new ArrayList<OfflineBungeeVote>();
+						for (String num : voteCacheFile.getOnlineVotes(player)) {
+							Configuration data = voteCacheFile.getOnlineVotes(player, num);
+							vote.add(new OfflineBungeeVote(data.getString("Name"), data.getString("UUID"),
+									data.getString("Service"), data.getLong("Time"), data.getBoolean("Real"),
+									data.getString("Text")));
+						}
+						cachedOnlineVotes.put(player, vote);
 					}
-					cachedOnlineVotes.put(player, vote);
+				} catch (Exception e) {
+					e.printStackTrace();
 				}
-			} catch (Exception e) {
-				e.printStackTrace();
-			}
 
-			voteCacheFile.clearData();
+				voteCacheFile.clearData();
 
-			getProxy().getScheduler().schedule(this, new Runnable() {
+				getProxy().getScheduler().schedule(this, new Runnable() {
 
-				@Override
-				public void run() {
-					for (String server : cachedVotes.keySet()) {
-						checkCachedVotes(server);
+					@Override
+					public void run() {
+						for (String server : cachedVotes.keySet()) {
+							checkCachedVotes(server);
+						}
+
+						for (String player : cachedOnlineVotes.keySet()) {
+							checkOnlineVotes(getProxy().getPlayer(UUID.fromString(player)), player, null);
+						}
 					}
+				}, 15l, 30l, TimeUnit.SECONDS);
 
-					for (String player : cachedOnlineVotes.keySet()) {
-						checkOnlineVotes(getProxy().getPlayer(UUID.fromString(player)), player, null);
+				getProxy().getScheduler().schedule(this, new Runnable() {
+
+					@Override
+					public void run() {
+						if (nonVotedPlayersCache != null) {
+							debug("Checking nonvotedplayers.yml...");
+							nonVotedPlayersCache.check();
+						}
 					}
-				}
-			}, 15l, 30l, TimeUnit.SECONDS);
+				}, 1l, 60l, TimeUnit.MINUTES);
+			} else if (method.equals(BungeeMethod.SOCKETS)) {
+				encryptionHandler = new EncryptionHandler(new File(getDataFolder(), "secretkey.key"));
 
-			getProxy().getScheduler().schedule(this, new Runnable() {
+				socketHandler = new SocketHandler(getDescription().getVersion(), config.getBungeeHost(),
+						config.getBungeePort(), encryptionHandler, config.getDebug());
 
-				@Override
-				public void run() {
-					if (nonVotedPlayersCache != null) {
-						debug("Checking nonvotedplayers.yml...");
-						nonVotedPlayersCache.check();
-					}
-				}
-			}, 1l, 60l, TimeUnit.MINUTES);
-		} else if (method.equals(BungeeMethod.SOCKETS)) {
-			encryptionHandler = new EncryptionHandler(new File(getDataFolder(), "secretkey.key"));
+				socketHandler.add(new SocketReceiver() {
 
-			socketHandler = new SocketHandler(getDescription().getVersion(), config.getBungeeHost(),
-					config.getBungeePort(), encryptionHandler, config.getDebug());
-
-			socketHandler.add(new SocketReceiver() {
-
-				@Override
-				public void onReceive(String[] data) {
-					if (data.length > 1) {
-						if (data.length > 2) {
-							if (data[0].equalsIgnoreCase("Broadcast")) {
-								sendServerMessage(data);
+					@Override
+					public void onReceive(String[] data) {
+						if (data.length > 1) {
+							if (data.length > 2) {
+								if (data[0].equalsIgnoreCase("Broadcast")) {
+									sendServerMessage(data);
+								}
 							}
 						}
+
 					}
+				});
 
-				}
-			});
+				socketHandler.add(new SocketReceiver() {
 
-			socketHandler.add(new SocketReceiver() {
-
-				@Override
-				public void onReceive(String[] data) {
-					if (data.length > 1) {
-						if (data[0].equalsIgnoreCase("StatusOkay")) {
-							String server = data[1];
-							getLogger().info("Voting communicaton okay with " + server);
+					@Override
+					public void onReceive(String[] data) {
+						if (data.length > 1) {
+							if (data[0].equalsIgnoreCase("StatusOkay")) {
+								String server = data[1];
+								getLogger().info("Voting communicaton okay with " + server);
+							}
 						}
+
 					}
+				});
 
-				}
-			});
-
-			clientHandles = new HashMap<String, ClientHandler>();
-			List<String> l = config.getBlockedServers();
-			for (String s : config.getSpigotServers()) {
-				if (!l.contains(s)) {
-					Configuration d = config.getSpigotServerConfiguration(s);
-					clientHandles.put(s, new ClientHandler(d.getString("Host", ""), d.getInt("Port", 1298),
-							encryptionHandler, config.getDebug()));
+				clientHandles = new HashMap<String, ClientHandler>();
+				List<String> l = config.getBlockedServers();
+				for (String s : config.getSpigotServers()) {
+					if (!l.contains(s)) {
+						Configuration d = config.getSpigotServerConfiguration(s);
+						clientHandles.put(s, new ClientHandler(d.getString("Host", ""), d.getInt("Port", 1298),
+								encryptionHandler, config.getDebug()));
+					}
 				}
 			}
 		}
@@ -413,6 +426,18 @@ public class VotingPluginBungee extends Plugin {
 		metrics.addCustomChart(new BStatsMetricsBungee.SimplePie("sendtoallservers",
 				() -> "" + getConfig().getSendVotesToAllServers()));
 
+		metrics.addCustomChart(
+				new BStatsMetricsBungee.SimplePie("allowunjoined", () -> "" + getConfig().getAllowUnJoined()));
+
+		metrics.addCustomChart(
+				new BStatsMetricsBungee.SimplePie("pointsonvote", () -> "" + getConfig().getPointsOnVote()));
+
+		metrics.addCustomChart(new BStatsMetricsBungee.SimplePie("bungeemanagetotals",
+				() -> "" + getConfig().getBungeeManageTotals()));
+
+		metrics.addCustomChart(
+				new BStatsMetricsBungee.SimplePie("waitforuseronline", () -> "" + getConfig().getWaitForUserOnline()));
+
 		getLogger().info("VotingPlugin loaded, using method: " + method.toString());
 	}
 
@@ -507,8 +532,19 @@ public class VotingPluginBungee extends Plugin {
 		return new UUID(mostSigBits, leastSigBits);
 	}
 
-	public void reload() {
+	public void reload(boolean loadMysql) {
 		config.load();
+		if (loadMysql) {
+			try {
+				if (!config.getData().getString("Host", "").isEmpty()) {
+					loadMysql();
+				} else {
+					getLogger().severe("MySQL settings not set in bungeeconfig.yml");
+				}
+			} catch (Exception e) {
+				e.printStackTrace();
+			}
+		}
 	}
 
 	public void sendPluginMessageServer(String server, String channel, String... messageData) {

VotingPlugin/src/com/bencodez/votingplugin/bungee/VotingPluginBungeeCommand.java

@@ -17,41 +17,46 @@ public class VotingPluginBungeeCommand extends Command {
 		if (sender.hasPermission("votingplugin.admin")) {
 			if (args.length > 0) {
 				if (args[0].equalsIgnoreCase("reload")) {
-					bungee.reload();
-					sender.sendMessage(new TextComponent("Reloading VotingPluginBungee"));
+					bungee.reload(false);
+					sender.sendMessage(new TextComponent("&aReloading VotingPluginBungee"));
+				}
+				if (args[0].equalsIgnoreCase("reloadmysql")) {
+					bungee.reload(true);
+					sender.sendMessage(new TextComponent("&aReloading VotingPluginBungee with MySQL"));
 				}
 				if (args[0].equalsIgnoreCase("vote")) {
 					if (args.length >= 2) {
 						String user = args[1];
 						String site = args[2];
 						bungee.vote(user, site, false);
-						sender.sendMessage(new TextComponent("Sending vote"));
+						sender.sendMessage(new TextComponent("&aSending vote"));
 					}
 				}
 				if (args[0].equalsIgnoreCase("status")) {
 					if (bungee.getMethod().equals(BungeeMethod.SOCKETS)) {
 						sender.sendMessage(new TextComponent(
-								"Checking status, waiting for response, check console, method: sockets"));
+								"&aChecking status, waiting for response, check console, method: sockets"));
 						bungee.status(sender);
 					} else if (bungee.getMethod().equals(BungeeMethod.PLUGINMESSAGING)) {
 						sender.sendMessage(new TextComponent(
-								"Checking status, waiting for response, check console, method: plugin messaging"));
+								"&aChecking status, waiting for response, check console, method: plugin messaging"));
 						bungee.status(sender);
 					} else {
 						sender.sendMessage(
-								new TextComponent("Not using socket/pluginmessage method, command unavailable"));
+								new TextComponent("&aNot using socket/pluginmessage method, command unavailable"));
 					}
 				}
 				if (args[0].equalsIgnoreCase("help")) {
-					TextComponent[] msg = new TextComponent[3];
+					TextComponent[] msg = new TextComponent[4];
 					msg[0] = new TextComponent("&avotingpluginbungee reload - Reload plugin");
-					msg[1] = new TextComponent("&avotingpluginbungee vote (player) (servicesite) - Send bungee vote");
-					msg[2] = new TextComponent("&avotingplugin status - Check socket connection status");
+					msg[1] = new TextComponent("&avotingpluginbungee reloadmysql - Reload plugin including mysql");
+					msg[2] = new TextComponent("&avotingpluginbungee vote (player) (servicesite) - Send bungee vote");
+					msg[3] = new TextComponent("&avotingpluginbungee status - Check socket connection status");
 					sender.sendMessage(msg);
 				}
 			}
 		} else {
-			sender.sendMessage(new TextComponent("You do not have permission to do this!"));
+			sender.sendMessage(new TextComponent("&cYou do not have permission to do this!"));
 		}
 	}
 }

VotingPlugin/src/com/bencodez/votingplugin/bungee/velocity/BungeeMySQL.java

@@ -0,0 +1,483 @@
+package com.bencodez.votingplugin.bungee.velocity;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import com.bencodez.advancedcore.api.user.userstorage.mysql.api.queries.Query;
+import com.bencodez.advancedcore.api.user.userstorage.sql.Column;
+import com.bencodez.advancedcore.api.user.userstorage.sql.DataType;
+
+public class BungeeMySQL {
+	private List<String> columns = Collections.synchronizedList(new ArrayList<String>());
+
+	private List<String> intColumns = new ArrayList<String>();
+
+	// private HashMap<String, ArrayList<Column>> table;
+
+	// ConcurrentMap<String, ArrayList<Column>> table = new
+	// ConcurrentHashMap<String, ArrayList<Column>>();
+
+	private com.bencodez.advancedcore.api.user.userstorage.mysql.api.MySQL mysql;
+
+	private String name;
+
+	private Object object2 = new Object();
+
+	private Object object3 = new Object();
+
+	private Object object4 = new Object();
+
+	private Set<String> uuids = Collections.synchronizedSet(new HashSet<String>());
+
+	public BungeeMySQL(VotingPluginVelocity plugin, String tableName, Config config) {
+		String tablePrefix = config.getString(config.getNode("Prefix"), "");
+		String hostName = config.getString(config.getNode("Host"), "");
+		int port = config.getInt(config.getNode("Port"), 0);
+		String user = config.getString(config.getNode("Username"), "");
+		String pass = config.getString(config.getNode("Password"), "");
+		String database = config.getString(config.getNode("Database"), "");
+		long lifeTime = config.getLong(config.getNode("MaxLifeTime"), -1);
+		int maxThreads = config.getInt(config.getNode("MaxConnections"), 1);
+		String str = config.getString(config.getNode("Line"), "");
+		if (maxThreads < 1) {
+			maxThreads = 1;
+		}
+		boolean useSSL = config.getBoolean(config.getNode("UseSSL"), false);
+		boolean publicKeyRetrieval = config.getBoolean(config.getNode("PublicKeyRetrieval"), false);
+		name = config.getString(config.getNode("Name"), "");
+		if (!name.isEmpty()) {
+			name = tableName;
+		}
+
+		if (tablePrefix != null) {
+			name = tablePrefix + tableName;
+		}
+		mysql = new com.bencodez.advancedcore.api.user.userstorage.mysql.api.MySQL(maxThreads) {
+
+			@Override
+			public void severe(String string) {
+				plugin.getLogger().error(string);
+			}
+
+			@Override
+			public void debug(SQLException e) {
+				if (plugin.getConfig().getDebug()) {
+					e.printStackTrace();
+				}
+			}
+		};
+		if (!mysql.connect(hostName, "" + port, user, pass, database, useSSL, lifeTime, str, publicKeyRetrieval)) {
+
+		}
+		try {
+			Query q = new Query(mysql, "USE " + database + ";");
+			q.executeUpdateAsync();
+		} catch (SQLException e) {
+			e.printStackTrace();
+		}
+		String sql = "CREATE TABLE IF NOT EXISTS " + getName() + " (";
+		sql += "uuid VARCHAR(37),";
+		sql += "PRIMARY KEY ( uuid )";
+		sql += ");";
+		Query query;
+		try {
+			query = new Query(mysql, sql);
+
+			query.executeUpdateAsync();
+		} catch (SQLException e) {
+			e.printStackTrace();
+		}
+
+		loadData();
+
+		// tempoary to improve performance from old tables
+		// addToQue("ALTER TABLE " + getName() + " MODIFY uuid VARCHAR(37);");
+		alterColumnType("uuid", "VARCHAR(37)");
+	}
+
+	public void addColumn(String column, DataType dataType) {
+		synchronized (object3) {
+			String sql = "ALTER TABLE " + getName() + " ADD COLUMN " + column + " text" + ";";
+			try {
+				Query query = new Query(mysql, sql);
+				query.executeUpdate();
+
+				getColumns().add(column);
+			} catch (SQLException e) {
+				e.printStackTrace();
+			}
+
+		}
+	}
+
+	public void alterColumnType(String column, String newType) {
+		checkColumn(column, DataType.STRING);
+		if (newType.contains("INT")) {
+			try {
+				new Query(mysql, "UPDATE " + getName() + " SET " + column + " = '0' where trim(coalesce(" + column
+						+ ", '')) = '';").executeUpdateAsync();
+			} catch (SQLException e) {
+				// TODO Auto-generated catch block
+				e.printStackTrace();
+			}
+			;
+			if (!intColumns.contains(column)) {
+				intColumns.add(column);
+			}
+		}
+		try {
+			new Query(mysql, "ALTER TABLE " + getName() + " MODIFY " + column + " " + newType + ";")
+					.executeUpdateAsync();
+		} catch (SQLException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+	}
+
+	public void checkColumn(String column, DataType dataType) {
+		synchronized (object4) {
+			if (!getColumns().contains(column)) {
+				if (!getColumnsQueury().contains(column)) {
+					addColumn(column, dataType);
+				}
+			}
+		}
+	}
+
+	public void clearCache() {
+		clearCacheBasic();
+	}
+
+	public void clearCacheBasic() {
+		columns.clear();
+		columns.addAll(getColumnsQueury());
+		uuids.clear();
+		uuids.addAll(getUuidsQuery());
+	}
+
+	public void close() {
+		mysql.disconnect();
+	}
+
+	public boolean containsKeyQuery(String index) {
+		String sqlStr = "SELECT uuid FROM " + getName() + ";";
+		try (Connection conn = mysql.getConnectionManager().getConnection();
+				PreparedStatement sql = conn.prepareStatement(sqlStr)) {
+			ResultSet rs = sql.executeQuery();
+			/*
+			 * Query query = new Query(mysql, sql); ResultSet rs = query.executeQuery();
+			 */
+			while (rs.next()) {
+				if (rs.getString("uuid").equals(index)) {
+					rs.close();
+					return true;
+				}
+			}
+			rs.close();
+		} catch (SQLException ex) {
+			ex.printStackTrace();
+		}
+		return false;
+	}
+
+	public List<String> getColumns() {
+		if (columns == null || columns.size() == 0) {
+			loadData();
+		}
+		return columns;
+	}
+
+	public ArrayList<String> getColumnsQueury() {
+		ArrayList<String> columns = new ArrayList<String>();
+		try (Connection conn = mysql.getConnectionManager().getConnection();
+				PreparedStatement sql = conn.prepareStatement("SELECT * FROM " + getName() + ";")) {
+			ResultSet rs = sql.executeQuery();
+			/*
+			 * Query query = new Query(mysql, "SELECT * FROM " + getName() + ";"); ResultSet
+			 * rs = query.executeQuery();
+			 */
+
+			ResultSetMetaData metadata = rs.getMetaData();
+			int columnCount = 0;
+			if (metadata != null) {
+				columnCount = metadata.getColumnCount();
+
+				for (int i = 1; i <= columnCount; i++) {
+					String columnName = metadata.getColumnName(i);
+					columns.add(columnName);
+				}
+				rs.close();
+				return columns;
+			}
+			rs.close();
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		return columns;
+
+	}
+
+	public ArrayList<Column> getExactQuery(Column column) {
+		ArrayList<Column> result = new ArrayList<>();
+		String query = "SELECT * FROM " + getName() + " WHERE `" + column.getName() + "`='"
+				+ column.getValue().toString() + "';";
+
+		try (Connection conn = mysql.getConnectionManager().getConnection();
+				PreparedStatement sql = conn.prepareStatement(query)) {
+			ResultSet rs = sql.executeQuery();
+
+			/*
+			 * Query sql = new Query(mysql, query); sql.setParameter(1,
+			 * column.getValue().toString()); ResultSet rs = sql.executeQuery();
+			 */
+			if (rs.next()) {
+				for (int i = 1; i <= rs.getMetaData().getColumnCount(); i++) {
+					String columnName = rs.getMetaData().getColumnLabel(i);
+					Column rCol = null;
+					if (intColumns.contains(columnName)) {
+						rCol = new Column(columnName, DataType.INTEGER);
+					} else {
+						rCol = new Column(columnName, DataType.STRING);
+					}
+					// System.out.println(i + " " +
+					// rs.getMetaData().getColumnLabel(i));
+					rCol.setValue(rs.getString(i));
+					// System.out.println(rCol.getValue());
+					result.add(rCol);
+				}
+			}
+			rs.close();
+			return result;
+		} catch (SQLException e) {
+			e.printStackTrace();
+		} catch (ArrayIndexOutOfBoundsException e) {
+		}
+
+		for (String col : getColumns()) {
+			result.add(new Column(col, DataType.STRING));
+		}
+		return result;
+	}
+
+	public String getName() {
+		return name;
+	}
+
+	public ArrayList<String> getNamesQuery() {
+		ArrayList<String> uuids = new ArrayList<String>();
+
+		checkColumn("PlayerName", DataType.STRING);
+		ArrayList<Column> rows = getRowsNameQuery();
+		if (rows != null) {
+			for (Column c : rows) {
+				uuids.add((String) c.getValue());
+			}
+		}
+
+		return uuids;
+	}
+
+	public ArrayList<Column> getRowsNameQuery() {
+		ArrayList<Column> result = new ArrayList<Column>();
+		String sqlStr = "SELECT PlayerName FROM " + getName() + ";";
+
+		try (Connection conn = mysql.getConnectionManager().getConnection();
+				PreparedStatement sql = conn.prepareStatement(sqlStr)) {
+			ResultSet rs = sql.executeQuery();
+			/*
+			 * Query query = new Query(mysql, sql); ResultSet rs = query.executeQuery();
+			 */
+
+			while (rs.next()) {
+				Column rCol = new Column("PlayerName", rs.getString("PlayerName"), DataType.STRING);
+				result.add(rCol);
+			}
+			sql.close();
+			conn.close();
+		} catch (SQLException e) {
+		}
+
+		return result;
+	}
+
+	public ArrayList<Column> getRowsQuery() {
+		ArrayList<Column> result = new ArrayList<Column>();
+		String sqlStr = "SELECT uuid FROM " + getName() + ";";
+
+		try (Connection conn = mysql.getConnectionManager().getConnection();
+				PreparedStatement sql = conn.prepareStatement(sqlStr)) {
+			ResultSet rs = sql.executeQuery();
+			/*
+			 * Query query = new Query(mysql, sql); ResultSet rs = query.executeQuery();
+			 */
+
+			while (rs.next()) {
+				Column rCol = new Column("uuid", rs.getString("uuid"), DataType.STRING);
+				result.add(rCol);
+			}
+			rs.close();
+		} catch (SQLException e) {
+			return null;
+		}
+
+		return result;
+	}
+
+	public String getUUID(String playerName) {
+		String query = "SELECT uuid FROM " + getName() + " WHERE " + "PlayerName" + "='" + playerName + "';";
+		try (Connection conn = mysql.getConnectionManager().getConnection();
+				PreparedStatement sql = conn.prepareStatement(query)) {
+			ResultSet rs = sql.executeQuery();
+			/*
+			 * Query sql = new Query(mysql, query); ResultSet rs = sql.executeQuery();
+			 */
+			if (rs.next()) {
+				String uuid = rs.getString("uuid");
+				if (uuid != null && !uuid.isEmpty()) {
+					rs.close();
+					return uuid;
+				}
+			}
+			rs.close();
+		} catch (SQLException e) {
+			e.printStackTrace();
+		} catch (ArrayIndexOutOfBoundsException e) {
+		}
+		return null;
+	}
+
+	public Set<String> getUuids() {
+		if (uuids == null || uuids.size() == 0) {
+			uuids.clear();
+			uuids.addAll(getUuidsQuery());
+			return uuids;
+		}
+		return uuids;
+	}
+
+	public ArrayList<String> getUuidsQuery() {
+		ArrayList<String> uuids = new ArrayList<String>();
+
+		ArrayList<Column> rows = getRowsQuery();
+		for (Column c : rows) {
+			uuids.add((String) c.getValue());
+		}
+
+		return uuids;
+	}
+
+	public void insert(String index, String column, Object value, DataType dataType) {
+		insertQuery(index, Arrays.asList(new Column(column, value, dataType)));
+	}
+
+	public void insertQuery(String index, List<Column> cols) {
+		String query = "INSERT " + getName() + " ";
+
+		query += "set uuid='" + index + "', ";
+
+		for (int i = 0; i < cols.size(); i++) {
+			Column col = cols.get(i);
+			if (i == cols.size() - 1) {
+				query += col.getName() + "='" + col.getValue().toString() + "';";
+			} else {
+				query += col.getName() + "='" + col.getValue().toString() + "', ";
+			}
+
+		}
+
+		try {
+			uuids.add(index);
+			new Query(mysql, query).executeUpdateAsync();
+		} catch (SQLException e) {
+			e.printStackTrace();
+		}
+
+	}
+
+	public boolean isIntColumn(String key) {
+		return intColumns.contains(key);
+	}
+
+	public void loadData() {
+		columns = getColumnsQueury();
+	}
+
+	public void update(String index, List<Column> cols, boolean queue) {
+		for (Column col : cols) {
+			checkColumn(col.getName(), col.getDataType());
+		}
+		if (getUuids().contains(index)) {
+			synchronized (object2) {
+
+				String query = "UPDATE " + getName() + " SET ";
+
+				for (int i = 0; i < cols.size(); i++) {
+					Column col = cols.get(i);
+					if (i == cols.size() - 1) {
+						if (col.getDataType().equals(DataType.STRING)) {
+							query += col.getName() + "='" + col.getValue().toString() + "';";
+						} else {
+							query += col.getName() + "=" + col.getValue().toString() + ";";
+						}
+					} else {
+						if (col.getDataType().equals(DataType.STRING)) {
+							query += col.getName() + "='" + col.getValue().toString() + "', ";
+						} else {
+							query += col.getName() + "=" + col.getValue().toString() + ", ";
+						}
+
+					}
+				}
+				query += " WHERE `uuid`=";
+				query += "'" + index + "';";
+
+				try {
+					Query q = new Query(mysql, query);
+					q.executeUpdateAsync();
+				} catch (SQLException e) {
+					e.printStackTrace();
+				}
+			}
+		} else {
+			insertQuery(index, cols);
+		}
+	}
+
+	public void update(String index, String column, Object value, DataType dataType) {
+		checkColumn(column, dataType);
+		if (getUuids().contains(index)) {
+			synchronized (object2) {
+				String query = "UPDATE " + getName() + " SET ";
+
+				if (dataType == DataType.STRING) {
+					query += column + "='" + value.toString() + "'";
+				} else {
+					query += column + "=" + value;
+
+				}
+				query += " WHERE `uuid`=";
+				query += "'" + index + "';";
+
+				try {
+					Query q = new Query(mysql, query);
+					q.executeUpdate();
+				} catch (SQLException e) {
+					e.printStackTrace();
+				}
+			}
+
+		} else {
+			insert(index, column, value, dataType);
+		}
+
+	}
+}

VotingPlugin/src/com/bencodez/votingplugin/bungee/velocity/Config.java

@@ -0,0 +1,83 @@
+package com.bencodez.votingplugin.bungee.velocity;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+import ninja.leaping.configurate.ConfigurationNode;
+
+public class Config extends VelocityYMLFile {
+
+	public Config(File file) {
+		super(file);
+	}
+
+	public List<String> getBlockedServers() {
+		return getStringList(getNode("BlockedServers"), new ArrayList<String>());
+	}
+
+	public boolean getBroadcast() {
+		return getBoolean(getNode("Broadcast"), false);
+	}
+
+	public boolean getWaitForUserOnline() {
+		return getBoolean(getNode("WaitForUserOnline"), false);
+	}
+
+	public boolean getBungeeManageTotals() {
+		return getBoolean(getNode("BungeeManageTotals"), true);
+	}
+
+	public boolean getAllowUnJoined() {
+		return getBoolean(getNode("AllowUnJoined"), false);
+	}
+
+	public String getBungeeHost() {
+		return getString(getNode("BungeeServer", "Host"), "");
+	}
+
+	public String getBungeeMethod() {
+		return getString(getNode("BungeeMethod"), "PLUGINMESSAGING");
+	}
+
+	public int getBungeePort() {
+		return getInt(getNode("BungeeServer", "Port"), 1297);
+	}
+
+	public boolean getDebug() {
+		return getBoolean(getNode("Debug"), false);
+	}
+
+	public String getFallBack() {
+		return getString(getNode("FallBackServer"), "");
+	}
+
+	public boolean getSendVotesToAllServers() {
+		return getBoolean(getNode("SendVotesToAllServers"), true);
+	}
+
+	public ConfigurationNode getSpigotServerConfiguration(String s) {
+		return getNode("SpigotServers", s);
+	}
+
+	public int getPointsOnVote() {
+		return getInt(getNode("PointsOnVote"), 1);
+	}
+
+	public Collection<String> getSpigotServers() {
+		ArrayList<String> list = new ArrayList<String>();
+		for (ConfigurationNode conf : getNode("SpigotServers").getChildrenList()) {
+			list.add(conf.getKey().toString());
+		}
+		return list;
+	}
+
+	public ConfigurationNode getMysqlNode() {
+		return getNode("MySQL");
+	}
+
+	public long getLong(ConfigurationNode node, long def) {
+		return node.getLong(def);
+	}
+}

VotingPlugin/src/com/bencodez/votingplugin/bungee/velocity/NonVotedPlayersCache.java

@@ -0,0 +1,62 @@
+package com.bencodez.votingplugin.bungee.velocity;
+
+import java.io.File;
+
+import com.velocitypowered.api.proxy.Player;
+
+public class NonVotedPlayersCache extends VelocityYMLFile {
+
+	private VotingPluginVelocity plugin;
+
+	public NonVotedPlayersCache(File file, VotingPluginVelocity plugin) {
+		super(file);
+		this.plugin = plugin;
+	}
+
+	public void addPlayer(Player player) {
+		if (!plugin.getMysql().containsKeyQuery(player.getUniqueId().toString())) {
+			addPlayer(player.getUniqueId().toString(), player.getUsername());
+		}
+	}
+
+	private void addPlayer(String uuid, String playerName) {
+		getNode("NonVotedPlayers", playerName, "UUID").setValue(uuid);
+		getNode("NonVotedPlayers", playerName, "LastTime").setValue(System.currentTimeMillis());
+		save();
+	}
+
+	public void check() {
+		for (String player : getKeys(getNode("NonVotedPlayers"))) {
+			long time = getNode("NonVotedPlayers", player, "LastTime").getLong(0);
+			if ((System.currentTimeMillis() - time) > 1000 * 60 * 60 * 24 * 5) {
+				remove(player);
+			} else {
+				String uuid = getNode("NonVotedPlayers", player, "UUID").getString("");
+				if (!uuid.isEmpty()) {
+					if (plugin.getMysql().containsKeyQuery(uuid)) {
+						remove(player);
+					}
+				} else {
+					remove(player);
+				}
+			}
+		}
+		save();
+	}
+
+	public String playerExists(String playerName) {
+		if (!getNode("NonVotedPlayers", playerName).isEmpty()) {
+			return getNode("NonVotedPlayers", playerName, "UUID").getString("");
+		}
+		return "";
+	}
+
+	private void remove(String player) {
+		plugin.debug("Removing nonvotedplayer: " + player);
+
+		getNode("NonVotedPlayers", player).setValue(null);
+
+		save();
+	}
+
+}

VotingPlugin/src/com/bencodez/votingplugin/bungee/velocity/VelocityYMLFile.java

@@ -0,0 +1,98 @@
+package com.bencodez.votingplugin.bungee.velocity;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+import com.google.common.reflect.TypeToken;
+
+import lombok.Getter;
+import ninja.leaping.configurate.ConfigurationNode;
+import ninja.leaping.configurate.objectmapping.ObjectMappingException;
+import ninja.leaping.configurate.yaml.YAMLConfigurationLoader;
+
+public class VelocityYMLFile {
+	@Getter
+	private File file;
+	@Getter
+	private ConfigurationNode conf;
+	private YAMLConfigurationLoader loader;
+
+	public VelocityYMLFile(File file) {
+
+		this.file = file;
+		if (!file.exists()) {
+			try {
+				file.getParentFile().mkdirs();
+				file.createNewFile();
+			} catch (IOException e) {
+				// TODO Auto-generated catch block
+				e.printStackTrace();
+			}
+		}
+		loader = YAMLConfigurationLoader.builder().setPath(file.toPath()).build();
+
+		try {
+			conf = loader.load();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+
+	}
+
+	public ConfigurationNode getData() {
+		return conf;
+	}
+
+	public ConfigurationNode getNode(Object... path) {
+		return getData().getNode(path);
+	}
+
+	public List<String> getStringList(ConfigurationNode node, ArrayList<String> def) {
+		try {
+			return node.getList(TypeToken.of(String.class), def);
+		} catch (ObjectMappingException e) {
+			e.printStackTrace();
+			return def;
+		}
+	}
+
+	public String getString(ConfigurationNode node, String def) {
+		return node.getString(def);
+	}
+
+	public boolean getBoolean(ConfigurationNode node, boolean def) {
+		return node.getBoolean(def);
+	}
+
+	public int getInt(ConfigurationNode node, int def) {
+		return node.getInt(def);
+	}
+
+	public ArrayList<String> getKeys(ConfigurationNode node) {
+		ArrayList<String> keys = new ArrayList<String>();
+		for (ConfigurationNode key : node.getChildrenList()) {
+			keys.add(key.getKey().toString());
+		}
+		return keys;
+	}
+	
+	public void reload() {
+		loader = YAMLConfigurationLoader.builder().setPath(file.toPath()).build();
+
+		try {
+			conf = loader.load();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+
+	public void save() {
+		try {
+			loader.save(conf);
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+}

VotingPlugin/src/com/bencodez/votingplugin/bungee/velocity/VoteCache.java

@@ -0,0 +1,72 @@
+package com.bencodez.votingplugin.bungee.velocity;
+
+import java.io.File;
+import java.util.Collection;
+
+import com.bencodez.votingplugin.bungee.OfflineBungeeVote;
+
+import ninja.leaping.configurate.ConfigurationNode;
+
+public class VoteCache extends VelocityYMLFile {
+
+	public VoteCache(File file) {
+		super(file);
+	}
+
+	public void addVote(String server, int num, OfflineBungeeVote voteData) {
+		String[] path = new String[] { "VoteCache", server, "" + num };
+
+		getNode(path, "Name").setValue(voteData.getPlayerName());
+		getNode(path, "Service").setValue(voteData.getService());
+		getNode(path, "UUID").setValue(voteData.getUuid());
+		getNode(path, "Time").setValue(voteData.getTime());
+		getNode(path, "Real").setValue(voteData.isRealVote());
+		getNode(path, "Text").setValue(voteData.getText());
+
+		save();
+	}
+
+	public void addVoteOnline(String player, int num, OfflineBungeeVote voteData) {
+		String[] path = new String[] { "OnlineCache", player, "" + num };
+
+		getNode(path, "Name").setValue(voteData.getPlayerName());
+		getNode(path, "Service").setValue(voteData.getService());
+		getNode(path, "UUID").setValue(voteData.getUuid());
+		getNode(path, "Time").setValue(voteData.getTime());
+		getNode(path, "Real").setValue(voteData.isRealVote());
+		getNode(path, "Text").setValue(voteData.getText());
+
+		save();
+	}
+
+	public void clearData() {
+		getNode("VoteCache").setValue(null);
+		getNode("OnlineCache").setValue(null);
+		save();
+	}
+
+	public Collection<String> getOnlineVotes(String name) {
+		return getKeys(getNode("OnlineCache", name));
+	}
+
+	public ConfigurationNode getOnlineVotes(String name, String num) {
+		return getNode("OnlineCache", name, num);
+	}
+
+	public Collection<String> getPlayers() {
+		return getKeys(getNode("OnlineCache"));
+	}
+
+	public Collection<String> getServers() {
+		return getKeys(getNode("VoteCache"));
+	}
+
+	public Collection<String> getServerVotes(String server) {
+		return getKeys(getNode("OnlineCache", server));
+	}
+
+	public ConfigurationNode getServerVotes(String server, String num) {
+		return getNode("VoteCache", server, num);
+	}
+
+}

VotingPlugin/src/com/bencodez/votingplugin/bungee/velocity/VotingPluginChannelIdentifier.java

@@ -0,0 +1,14 @@
+package com.bencodez.votingplugin.bungee.velocity;
+
+import com.velocitypowered.api.proxy.messages.ChannelIdentifier;
+
+public class VotingPluginChannelIdentifier implements ChannelIdentifier {
+	public VotingPluginChannelIdentifier() {
+	}
+
+	@Override
+	public String getId() {
+		return "vp:vp";
+	}
+
+}

VotingPlugin/src/com/bencodez/votingplugin/bungee/velocity/VotingPluginVelocity.java

@@ -0,0 +1,758 @@
+package com.bencodez.votingplugin.bungee.velocity;
+
+import java.io.BufferedReader;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.nio.file.Path;
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map.Entry;
+import java.util.UUID;
+import java.util.concurrent.TimeUnit;
+
+import org.bstats.charts.SimplePie;
+import org.bstats.velocity.Metrics;
+import org.slf4j.Logger;
+
+import com.bencodez.advancedcore.api.misc.ArrayUtils;
+import com.bencodez.advancedcore.api.misc.encryption.EncryptionHandler;
+import com.bencodez.advancedcore.api.user.userstorage.sql.Column;
+import com.bencodez.advancedcore.api.user.userstorage.sql.DataType;
+import com.bencodez.advancedcore.bungeeapi.sockets.ClientHandler;
+import com.bencodez.advancedcore.bungeeapi.sockets.SocketHandler;
+import com.bencodez.advancedcore.bungeeapi.sockets.SocketReceiver;
+import com.bencodez.votingplugin.bungee.BungeeMessageData;
+import com.bencodez.votingplugin.bungee.BungeeMethod;
+import com.bencodez.votingplugin.bungee.BungeeVersion;
+import com.bencodez.votingplugin.bungee.OfflineBungeeVote;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import com.google.inject.Inject;
+import com.velocitypowered.api.command.CommandMeta;
+import com.velocitypowered.api.event.Subscribe;
+import com.velocitypowered.api.event.connection.PluginMessageEvent;
+import com.velocitypowered.api.event.player.ServerConnectedEvent;
+import com.velocitypowered.api.event.proxy.ProxyInitializeEvent;
+import com.velocitypowered.api.event.proxy.ProxyShutdownEvent;
+import com.velocitypowered.api.plugin.Dependency;
+import com.velocitypowered.api.plugin.Plugin;
+import com.velocitypowered.api.plugin.annotation.DataDirectory;
+import com.velocitypowered.api.proxy.Player;
+import com.velocitypowered.api.proxy.ProxyServer;
+import com.velocitypowered.api.proxy.messages.ChannelIdentifier;
+import com.velocitypowered.api.proxy.messages.MinecraftChannelIdentifier;
+import com.velocitypowered.api.proxy.server.RegisteredServer;
+import com.vexsoftware.votifier.model.Vote;
+import com.vexsoftware.votifier.velocity.event.VotifierEvent;
+
+import lombok.Getter;
+import ninja.leaping.configurate.ConfigurationNode;
+
+@Plugin(id = "votingplugin", name = "VotingPlugin", version = "1.0", url = "https://www.spigotmc.org/resources/votingplugin.15358/", description = "VotingPlugin Velocity Version", authors = {
+		"BenCodez" }, dependencies = { @Dependency(id = "nuvotifier", optional = true) })
+public class VotingPluginVelocity {
+
+	private final ProxyServer server;
+	@Getter
+	private final Logger logger;
+	private final Path dataDirectory;
+
+	private final Metrics.Factory metricsFactory;
+
+	@Getter
+	private Config config;
+	private static final ChannelIdentifier CHANNEL = MinecraftChannelIdentifier.create("vp", "vp");
+	@Getter
+	private BungeeMethod method;
+	@Getter
+	private BungeeMySQL mysql;
+
+	private HashMap<String, ArrayList<OfflineBungeeVote>> cachedOnlineVotes = new HashMap<String, ArrayList<OfflineBungeeVote>>();
+
+	private HashMap<RegisteredServer, ArrayList<OfflineBungeeVote>> cachedVotes = new HashMap<RegisteredServer, ArrayList<OfflineBungeeVote>>();
+
+	private HashMap<String, ClientHandler> clientHandles;
+
+	private EncryptionHandler encryptionHandler;
+
+	private NonVotedPlayersCache nonVotedPlayersCache;
+
+	private SocketHandler socketHandler;
+
+	private VoteCache voteCacheFile;
+
+	public void checkCachedVotes(RegisteredServer serverToCheck) {
+		if (!serverToCheck.getPlayersConnected().isEmpty()) {
+			if (cachedVotes.containsKey(serverToCheck)
+					&& !config.getBlockedServers().contains(serverToCheck.getServerInfo().getName())) {
+				ArrayList<OfflineBungeeVote> c = cachedVotes.get(serverToCheck);
+				ArrayList<OfflineBungeeVote> newSet = new ArrayList<OfflineBungeeVote>();
+				if (!c.isEmpty()) {
+					for (OfflineBungeeVote cache : c) {
+						boolean toSend = true;
+						if (getConfig().getWaitForUserOnline()) {
+							Player p = server.getPlayer(UUID.fromString(cache.getUuid())).get();
+							if (p == null || !p.isActive()) {
+								toSend = false;
+							} else if (p != null && p.isActive() && !p.getCurrentServer().get().getServerInfo()
+									.getName().equals(serverToCheck.getServerInfo().getName())) {
+								toSend = false;
+							}
+
+						}
+						if (toSend) {
+							sendPluginMessageServer(serverToCheck, "Vote", cache.getPlayerName(), cache.getUuid(),
+									cache.getService(), "" + cache.getTime(), Boolean.FALSE.toString(),
+									"" + cache.isRealVote(), cache.getText(), "" + getConfig().getBungeeManageTotals(),
+									"" + BungeeVersion.getPluginMessageVersion());
+						} else {
+							debug("Not sending vote because user isn't on server " + serverToCheck + ": "
+									+ cache.toString());
+							newSet.add(cache);
+						}
+					}
+					cachedVotes.put(serverToCheck, newSet);
+				}
+			}
+		}
+
+	}
+
+	public void checkOnlineVotes(Player player, String uuid, RegisteredServer serverToCheck) {
+		if (player != null && player.isActive() && cachedOnlineVotes.containsKey(uuid)) {
+			ArrayList<OfflineBungeeVote> c = cachedOnlineVotes.get(uuid);
+			if (!c.isEmpty()) {
+				if (serverToCheck == null) {
+					serverToCheck = player.getCurrentServer().get().getServer();
+				}
+				if (!config.getBlockedServers().contains(serverToCheck.getServerInfo().getName())) {
+					for (OfflineBungeeVote cache : c) {
+						sendPluginMessageServer(serverToCheck, "VoteOnline", cache.getPlayerName(), cache.getUuid(),
+								cache.getService(), "" + cache.getTime(), Boolean.FALSE.toString(),
+								"" + cache.isRealVote(), cache.getText(), "" + getConfig().getBungeeManageTotals(),
+								"" + BungeeVersion.getPluginMessageVersion());
+					}
+					cachedOnlineVotes.put(uuid, new ArrayList<OfflineBungeeVote>());
+				}
+			}
+		}
+	}
+
+	@Inject
+	public VotingPluginVelocity(ProxyServer server, Logger logger, Metrics.Factory metricsFactory,
+			@DataDirectory Path dataDirectory) {
+		this.server = server;
+		this.logger = logger;
+		this.dataDirectory = dataDirectory;
+		this.metricsFactory = metricsFactory;
+	}
+
+	private void loadMysql() {
+		mysql = new BungeeMySQL(this, "VotingPlugin_Users", config);
+		// column types
+		getMysql().alterColumnType("TopVoterIgnore", "VARCHAR(5)");
+		getMysql().alterColumnType("CheckWorld", "VARCHAR(5)");
+		getMysql().alterColumnType("Reminded", "VARCHAR(5)");
+		getMysql().alterColumnType("DisableBroadcast", "VARCHAR(5)");
+		getMysql().alterColumnType("LastOnline", "VARCHAR(20)");
+		getMysql().alterColumnType("PlayerName", "VARCHAR(30)");
+		getMysql().alterColumnType("DailyTotal", "INT DEFAULT '0'");
+		getMysql().alterColumnType("WeeklyTotal", "INT DEFAULT '0'");
+		getMysql().alterColumnType("DayVoteStreak", "INT DEFAULT '0'");
+		getMysql().alterColumnType("BestDayVoteStreak", "INT DEFAULT '0'");
+		getMysql().alterColumnType("WeekVoteStreak", "INT DEFAULT '0'");
+		getMysql().alterColumnType("BestWeekVoteStreak", "INT DEFAULT '0'");
+		getMysql().alterColumnType("VotePartyVotes", "INT DEFAULT '0'");
+		getMysql().alterColumnType("MonthVoteStreak", "INT DEFAULT '0'");
+		getMysql().alterColumnType("Points", "INT DEFAULT '0'");
+		getMysql().alterColumnType("HighestDailyTotal", "INT DEFAULT '0'");
+		getMysql().alterColumnType("AllTimeTotal", "INT DEFAULT '0'");
+		getMysql().alterColumnType("HighestMonthlyTotal", "INT DEFAULT '0'");
+		getMysql().alterColumnType("MilestoneCount", "INT DEFAULT '0'");
+		getMysql().alterColumnType("MonthTotal", "INT DEFAULT '0'");
+		getMysql().alterColumnType("HighestWeeklyTotal", "INT DEFAULT '0'");
+		getMysql().alterColumnType("LastMonthTotal", "INT DEFAULT '0'");
+		getMysql().alterColumnType("OfflineRewards", "MEDIUMTEXT");
+		getMysql().alterColumnType("DayVoteStreakLastUpdate", "MEDIUMTEXT");
+	}
+
+	public void reload(boolean loadMySQL) {
+		config.reload();
+		if (loadMySQL) {
+			if (!config.getString(config.getNode("Host"), "").isEmpty()) {
+				loadMysql();
+			} else {
+				logger.error("MySQL settings not set in bungeeconfig.yml");
+			}
+		}
+	}
+
+	public void status() {
+		if (method.equals(BungeeMethod.SOCKETS)) {
+			sendServerMessage("status");
+		} else if (method.equals(BungeeMethod.PLUGINMESSAGING)) {
+			for (RegisteredServer s : server.getAllServers()) {
+				if (!config.getBlockedServers().contains(s.getServerInfo().getName())) {
+					if (s.getPlayersConnected().size() == 0) {
+						getLogger().info("No players on server " + s + " to send test status message");
+					} else {
+						// send
+						getLogger().info("Sending request for status message on " + s);
+						sendPluginMessageServer(s, "Status", s.getServerInfo().getName());
+					}
+				} else {
+					getLogger().info("Ignoring blocked server " + s);
+				}
+			}
+		}
+	}
+
+	@Subscribe
+	public void onProxyInitialization(ProxyInitializeEvent event) {
+		File configFile = new File(dataDirectory.toFile(), "bungeeconfig.yml");
+		configFile.getParentFile().mkdirs();
+		if (!configFile.exists()) {
+			try {
+				configFile.createNewFile();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+
+			InputStream toCopyStream = VotingPluginVelocity.class.getClassLoader()
+					.getResourceAsStream("bungeeconfig.yml");
+
+			try (FileOutputStream fos = new FileOutputStream(configFile)) {
+				byte[] buf = new byte[2048];
+				int r;
+				while (-1 != (r = toCopyStream.read(buf))) {
+					fos.write(buf, 0, r);
+				}
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+		}
+		config = new Config(configFile);
+		server.getChannelRegistrar().register(CHANNEL);
+		method = BungeeMethod.getByName(config.getBungeeMethod());
+		boolean mysqlLoaded = true;
+		try {
+			if (!config.getString(config.getNode("Host"), "").isEmpty()) {
+				loadMysql();
+			} else {
+				mysqlLoaded = false;
+				logger.error("MySQL settings not set in bungeeconfig.yml");
+			}
+		} catch (Exception e) {
+			mysqlLoaded = false;
+			e.printStackTrace();
+		}
+
+		CommandMeta meta = server.getCommandManager().metaBuilder("votingpluginbungee")
+				// Specify other aliases (optional)
+				.aliases("vpb").build();
+
+		server.getCommandManager().register(meta, new VotingPluginVelocityCommand(this));
+
+		if (mysqlLoaded) {
+			if (method.equals(BungeeMethod.MYSQL)) {
+				// this.getProxy().registerChannel("vp:vp");
+
+			} else if (method.equals(BungeeMethod.PLUGINMESSAGING)) {
+				voteCacheFile = new VoteCache(new File(dataDirectory.toFile(), "votecache.yml"));
+				nonVotedPlayersCache = new NonVotedPlayersCache(
+						new File(dataDirectory.toFile(), "nonvotedplayerscache.yml"), this);
+
+				try {
+					for (String serverToCheck : voteCacheFile.getServers()) {
+						ArrayList<OfflineBungeeVote> vote = new ArrayList<OfflineBungeeVote>();
+						for (String num : voteCacheFile.getServerVotes(serverToCheck)) {
+							ConfigurationNode data = voteCacheFile.getServerVotes(serverToCheck, num);
+
+							vote.add(new OfflineBungeeVote(data.getNode("Name").getString(),
+									data.getNode("UUID").getString(), data.getNode("Service").getString(),
+									data.getNode("Time").getLong(), data.getNode("Real").getBoolean(),
+									data.getNode("TEXT").getString()));
+						}
+						cachedVotes.put(server.getServer(serverToCheck).get(), vote);
+					}
+				} catch (Exception e) {
+					e.printStackTrace();
+				}
+
+				try {
+					for (String player : voteCacheFile.getPlayers()) {
+						ArrayList<OfflineBungeeVote> vote = new ArrayList<OfflineBungeeVote>();
+						for (String num : voteCacheFile.getOnlineVotes(player)) {
+							ConfigurationNode data = voteCacheFile.getOnlineVotes(player, num);
+							vote.add(new OfflineBungeeVote(data.getNode("Name").getString(),
+									data.getNode("UUID").getString(), data.getNode("Service").getString(),
+									data.getNode("Time").getLong(), data.getNode("Real").getBoolean(),
+									data.getNode("TEXT").getString()));
+						}
+						cachedOnlineVotes.put(player, vote);
+					}
+				} catch (Exception e) {
+					e.printStackTrace();
+				}
+
+				voteCacheFile.clearData();
+
+				server.getScheduler().buildTask(this, () -> {
+					for (RegisteredServer server : cachedVotes.keySet()) {
+						checkCachedVotes(server);
+					}
+
+					for (String player : cachedOnlineVotes.keySet()) {
+						checkOnlineVotes(server.getPlayer(UUID.fromString(player)).get(), player, null);
+					}
+				}).delay(15L, TimeUnit.SECONDS).repeat(30l, TimeUnit.SECONDS).schedule();
+
+				server.getScheduler().buildTask(this, () -> {
+					if (nonVotedPlayersCache != null) {
+						debug("Checking nonvotedplayerscache.yml...");
+						nonVotedPlayersCache.check();
+					}
+				}).delay(1L, TimeUnit.MINUTES).repeat(60l, TimeUnit.MINUTES).schedule();
+			} else if (method.equals(BungeeMethod.SOCKETS)) {
+				encryptionHandler = new EncryptionHandler(new File(dataDirectory.toFile(), "secretkey.key"));
+
+				socketHandler = new SocketHandler(
+						server.getPluginManager().getPlugin("votingplugin").get().getDescription().getVersion().get(),
+						config.getBungeeHost(), config.getBungeePort(), encryptionHandler, config.getDebug());
+
+				socketHandler.add(new SocketReceiver() {
+
+					@Override
+					public void onReceive(String[] data) {
+						if (data.length > 1) {
+							if (data.length > 2) {
+								if (data[0].equalsIgnoreCase("Broadcast")) {
+									sendServerMessage(data);
+								}
+							}
+						}
+
+					}
+				});
+
+				socketHandler.add(new SocketReceiver() {
+
+					@Override
+					public void onReceive(String[] data) {
+						if (data.length > 1) {
+							if (data[0].equalsIgnoreCase("StatusOkay")) {
+								String server = data[1];
+								logger.info("Voting communicaton okay with " + server);
+							}
+						}
+
+					}
+				});
+
+				clientHandles = new HashMap<String, ClientHandler>();
+				List<String> l = config.getBlockedServers();
+				for (String s : config.getSpigotServers()) {
+					if (!l.contains(s)) {
+						ConfigurationNode d = config.getSpigotServerConfiguration(s);
+						clientHandles.put(s, new ClientHandler(d.getNode("Host").getString(""),
+								d.getNode("Port").getInt(1298), encryptionHandler, config.getDebug()));
+					}
+				}
+			}
+		}
+
+		Metrics metrics = metricsFactory.make(this, 11547);
+
+		metrics.addCustomChart(new SimplePie("bungee_method", () -> getConfig().getBungeeMethod().toString()));
+
+		metrics.addCustomChart(new SimplePie("sendtoallservers", () -> "" + getConfig().getSendVotesToAllServers()));
+
+		metrics.addCustomChart(new SimplePie("allowunjoined", () -> "" + getConfig().getAllowUnJoined()));
+
+		metrics.addCustomChart(new SimplePie("pointsonvote", () -> "" + getConfig().getPointsOnVote()));
+
+		metrics.addCustomChart(new SimplePie("bungeemanagetotals", () -> "" + getConfig().getBungeeManageTotals()));
+
+		metrics.addCustomChart(new SimplePie("waitforuseronline", () -> "" + getConfig().getWaitForUserOnline()));
+
+		logger.info("VotingPlugin velocity loaded, method: " + method.toString());
+	}
+
+	@Subscribe
+	public void onProxyDisable(ProxyShutdownEvent event) {
+		if (method.equals(BungeeMethod.PLUGINMESSAGING)) {
+			for (Entry<RegisteredServer, ArrayList<OfflineBungeeVote>> entry : cachedVotes.entrySet()) {
+				RegisteredServer server = entry.getKey();
+				int num = 0;
+				for (OfflineBungeeVote voteData : entry.getValue()) {
+					voteCacheFile.addVote(server.getServerInfo().getName(), num, voteData);
+					num++;
+				}
+			}
+			for (Entry<String, ArrayList<OfflineBungeeVote>> entry : cachedOnlineVotes.entrySet()) {
+				String name = entry.getKey();
+				int num = 0;
+				for (OfflineBungeeVote voteData : entry.getValue()) {
+					voteCacheFile.addVoteOnline(name, num, voteData);
+					num++;
+				}
+			}
+			nonVotedPlayersCache.save();
+		}
+	}
+
+	@Subscribe
+	public void playerServerConnected(ServerConnectedEvent event) {
+		checkCachedVotes(event.getServer());
+		checkOnlineVotes(event.getPlayer(), event.getPlayer().getUniqueId().toString(), event.getServer());
+	}
+
+	@Subscribe
+	public void onPluginMessagingReceived(PluginMessageEvent event) {
+		if (event.getIdentifier().getId().equals(CHANNEL.getId())) {
+			ByteArrayInputStream instream = new ByteArrayInputStream(event.getData());
+			DataInputStream in = new DataInputStream(instream);
+			try {
+				ByteArrayOutputStream outstream = new ByteArrayOutputStream();
+				DataOutputStream out = new DataOutputStream(outstream);
+				String subchannel = in.readUTF();
+				int size = in.readInt();
+
+				// check for status message returns
+				if (subchannel.equalsIgnoreCase("statusokay")) {
+					String server = in.readUTF();
+					logger.info("Status okay for " + server);
+					return;
+				} else if (subchannel.equalsIgnoreCase("login")) {
+					String player = in.readUTF();
+					Player p = server.getPlayer(player).get();
+					checkCachedVotes(p.getCurrentServer().get().getServer());
+					checkOnlineVotes(p, p.getUniqueId().toString(), p.getCurrentServer().get().getServer());
+					return;
+				} else {
+
+					// reforward message
+					out.writeUTF(subchannel);
+					out.writeInt(size);
+					for (int i = 0; i < size; i++) {
+						out.writeUTF(in.readUTF());
+					}
+					for (RegisteredServer send : server.getAllServers()) {
+
+						if (send.getPlayersConnected().size() > 0) {
+							send.sendPluginMessage(CHANNEL, outstream.toByteArray());
+						}
+					}
+				}
+			} catch (Exception e) {
+				e.printStackTrace();
+			}
+		}
+	}
+
+	public String getUUID(String playerName) {
+		Player p = server.getPlayer(playerName).get();
+		if (p != null && p.isActive()) {
+			return p.getUniqueId().toString();
+		}
+		if (mysql != null) {
+			String str = mysql.getUUID(playerName);
+			if (str != null) {
+				return str;
+			}
+		}
+		if (nonVotedPlayersCache != null) {
+			return nonVotedPlayersCache.playerExists(playerName);
+		}
+		return "";
+	}
+
+	public UUID fetchUUID(String playerName) throws Exception {
+		// Get response from Mojang API
+		URL url = new URL("https://api.mojang.com/users/profiles/minecraft/" + playerName);
+		HttpURLConnection connection = (HttpURLConnection) url.openConnection();
+		connection.connect();
+
+		if (connection.getResponseCode() == 400) {
+			logger.info("There is no player with the name \"" + playerName + "\"!");
+			return null;
+		}
+
+		InputStream inputStream = connection.getInputStream();
+		BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
+
+		// Parse JSON response and get UUID
+		JsonElement element = new JsonParser().parse(bufferedReader);
+		JsonObject object = element.getAsJsonObject();
+		String uuidAsString = object.get("id").getAsString();
+
+		// Return UUID
+		return parseUUIDFromString(uuidAsString);
+	}
+
+	private UUID parseUUIDFromString(String uuidAsString) {
+		String[] parts = { "0x" + uuidAsString.substring(0, 8), "0x" + uuidAsString.substring(8, 12),
+				"0x" + uuidAsString.substring(12, 16), "0x" + uuidAsString.substring(16, 20),
+				"0x" + uuidAsString.substring(20, 32) };
+
+		long mostSigBits = Long.decode(parts[0]).longValue();
+		mostSigBits <<= 16;
+		mostSigBits |= Long.decode(parts[1]).longValue();
+		mostSigBits <<= 16;
+		mostSigBits |= Long.decode(parts[2]).longValue();
+
+		long leastSigBits = Long.decode(parts[3]).longValue();
+		leastSigBits <<= 48;
+		leastSigBits |= Long.decode(parts[4]).longValue();
+
+		return new UUID(mostSigBits, leastSigBits);
+	}
+
+	public void debug(String msg) {
+		if (config.getDebug()) {
+			logger.info("Debug: " + msg);
+		}
+	}
+
+	private int getValue(ArrayList<Column> cols, String column) {
+		for (Column d : cols) {
+			if (d.getName().equalsIgnoreCase(column)) {
+
+				Object value = d.getValue();
+				int num = 0;
+				if (value instanceof Integer) {
+					try {
+						num = (int) value;
+					} catch (ClassCastException | NullPointerException ex) {
+					}
+				} else if (value instanceof String) {
+					try {
+						num = Integer.parseInt((String) value);
+					} catch (Exception e) {
+					}
+				}
+				return num;
+			}
+		}
+		return 0;
+	}
+
+	private int mysqlUpdate(ArrayList<Column> cols, String uuid, String column, int toAdd) {
+		int num = getValue(cols, column) + toAdd;
+		debug("Setting " + column + " to " + num + " for " + uuid);
+		mysql.update(uuid, column, num, DataType.INTEGER);
+		return num;
+	}
+
+	@Subscribe
+	public void onVotifierEvent(VotifierEvent event) {
+		Vote vote = event.getVote();
+		vote(vote.getUsername(), vote.getServiceName(), true);
+	}
+
+	public String getProperName(String uuid, String currentName) {
+		Player p = server.getPlayer(UUID.fromString(uuid)).get();
+		if (p != null && p.isActive()) {
+			return p.getUsername();
+		}
+		return currentName;
+	}
+
+	public void sendPluginMessageServer(RegisteredServer s, String channel, String... messageData) {
+		ByteArrayOutputStream byteOutStream = new ByteArrayOutputStream();
+		DataOutputStream out = new DataOutputStream(byteOutStream);
+		try {
+			out.writeUTF(channel);
+			out.writeInt(messageData.length);
+			for (String message : messageData) {
+				out.writeUTF(message);
+			}
+			if (s.getPlayersConnected().size() > 0) {
+				s.sendPluginMessage(CHANNEL, byteOutStream.toByteArray());
+			}
+			out.close();
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		debug("Sending plugin message " + s.getServerInfo().getName() + " " + channel + " "
+				+ ArrayUtils.getInstance().makeStringList(ArrayUtils.getInstance().convert(messageData)));
+
+	}
+
+	public void vote(String player, String service, boolean realVote) {
+		try {
+			if (player == null || player.isEmpty()) {
+				logger.info("No name from vote on " + service);
+				return;
+			}
+
+			String uuid = getUUID(player);
+			if (uuid.isEmpty()) {
+				if (config.getAllowUnJoined()) {
+					UUID u = null;
+					try {
+						u = fetchUUID(player);
+					} catch (Exception e) {
+						if (getConfig().getDebug()) {
+							e.printStackTrace();
+						}
+					}
+					if (u == null) {
+						debug("Failed to get uuid for " + player);
+						return;
+					}
+					uuid = u.toString();
+				} else {
+					logger.info("Ignoring vote from " + player);
+					return;
+				}
+			}
+
+			player = getProperName(uuid, player);
+
+			BungeeMessageData text = null;
+
+			if (getConfig().getBungeeManageTotals()) {
+
+				if (!mysql.getUuids().contains(uuid)) {
+					mysql.update(uuid, "PlayerName", player, DataType.STRING);
+				}
+
+				ArrayList<Column> data = mysql.getExactQuery(new Column("uuid", uuid, DataType.STRING));
+
+				text = new BungeeMessageData(mysqlUpdate(data, uuid, "AllTimeTotal", 1),
+						mysqlUpdate(data, uuid, "MonthTotal", 1), mysqlUpdate(data, uuid, "WeeklyTotal", 1),
+						mysqlUpdate(data, uuid, "DailyTotal", 1),
+						mysqlUpdate(data, uuid, "Points", getConfig().getPointsOnVote()),
+						mysqlUpdate(data, uuid, "MilestoneCount", 1));
+			} else {
+				text = new BungeeMessageData(0, 0, 0, 0, 0, 0);
+			}
+
+			/*
+			 * String text = mysqlUpdate(data, uuid, "AllTimeTotal", 1) + "//" +
+			 * mysqlUpdate(data, uuid, "MonthTotal", 1) + "//" + mysqlUpdate(data, uuid,
+			 * "WeeklyTotal", 1) + "//" + mysqlUpdate(data, uuid, "DailyTotal", 1) + "//" +
+			 * mysqlUpdate(data, uuid, "Points", 1) + "//" + mysqlUpdate(data, uuid,
+			 * "MilestoneCount", 1);
+			 */
+
+			long time = LocalDateTime.now().atZone(ZoneId.systemDefault()).toInstant().toEpochMilli();
+
+			if (method.equals(BungeeMethod.PLUGINMESSAGING)) {
+
+				if (config.getSendVotesToAllServers()) {
+					for (RegisteredServer s : server.getAllServers()) {
+						if (!config.getBlockedServers().contains(s.getServerInfo().getName())) {
+							boolean forceCache = false;
+							Player p = server.getPlayer(UUID.fromString(uuid)).get();
+							if ((p == null || !p.isActive()) && getConfig().getWaitForUserOnline()) {
+								forceCache = true;
+								debug("Forcing vote to cache");
+							}
+							if (s.getPlayersConnected().isEmpty() || forceCache) {
+								// cache
+								if (!cachedVotes.containsKey(s)) {
+									cachedVotes.put(s, new ArrayList<OfflineBungeeVote>());
+								}
+								ArrayList<OfflineBungeeVote> list = cachedVotes.get(s);
+								list.add(new OfflineBungeeVote(player, uuid, service, time, realVote, text.toString()));
+								cachedVotes.put(s, list);
+
+								debug("Caching vote for " + player + " on " + service + " for " + s);
+
+							} else {
+								// send
+								sendPluginMessageServer(s, "Vote", player, uuid, service, "" + time,
+										Boolean.TRUE.toString(), "" + realVote, text.toString(),
+										"" + getConfig().getBungeeManageTotals(),
+										"" + BungeeVersion.getPluginMessageVersion());
+							}
+						}
+					}
+				} else {
+					Player p = server.getPlayer(UUID.fromString(uuid)).get();
+					if (p != null && p.isActive() && !config.getBlockedServers()
+							.contains(p.getCurrentServer().get().getServerInfo().getName())) {
+						sendPluginMessageServer(p.getCurrentServer().get().getServer(), "VoteOnline", player, uuid,
+								service, "" + time, Boolean.TRUE.toString(), "" + realVote, text.toString(),
+								"" + getConfig().getBungeeManageTotals(), "" + BungeeVersion.getPluginMessageVersion());
+					} else {
+						if (!cachedOnlineVotes.containsKey(uuid)) {
+							cachedOnlineVotes.put(uuid, new ArrayList<OfflineBungeeVote>());
+						}
+						ArrayList<OfflineBungeeVote> list = cachedOnlineVotes.get(uuid);
+						if (list == null) {
+							list = new ArrayList<OfflineBungeeVote>();
+						}
+						list.add(new OfflineBungeeVote(player, uuid, service, time, realVote, text.toString()));
+						cachedOnlineVotes.put(uuid, list);
+						debug("Caching online vote for " + player + " on " + service);
+					}
+				}
+			} else if (method.equals(BungeeMethod.SOCKETS)) {
+				sendSocketVote(player, service, text);
+			}
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+
+	public void sendSocketVote(String name, String service, BungeeMessageData text) {
+		String uuid = getUUID(name);
+
+		if (config.getSendVotesToAllServers()) {
+			sendServerMessage("bungeevote", uuid, name, service, text.toString(),
+					"" + getConfig().getBungeeManageTotals());
+			if (config.getBroadcast()) {
+				sendServerMessage("BungeeBroadcast", service, uuid, name);
+			}
+		} else {
+			// online server only
+			Player p = server.getPlayer(name).get();
+
+			String server = "";
+			if (p != null && p.isActive()) {
+				server = p.getCurrentServer().get().getServerInfo().getName();
+			} else {
+				server = config.getFallBack();
+			}
+			if (config.getBlockedServers().contains(server)) {
+				server = config.getFallBack();
+			}
+
+			sendServerMessageServer(server, "bungeevoteonline", uuid, name, service, text.toString(),
+					"" + getConfig().getBungeeManageTotals());
+			if (config.getBroadcast()) {
+				sendServerMessage("BungeeBroadcast", service, uuid, name);
+			}
+			sendServerMessage("BungeeUpdate");
+		}
+
+	}
+
+	public void sendServerMessage(String... messageData) {
+		for (ClientHandler h : clientHandles.values()) {
+			h.sendMessage(messageData);
+		}
+	}
+
+	public void sendServerMessageServer(String server, String... messageData) {
+		if (clientHandles.containsKey(server)) {
+			clientHandles.get(server).sendMessage(messageData);
+		}
+	}
+}

VotingPlugin/src/com/bencodez/votingplugin/bungee/velocity/VotingPluginVelocityCommand.java

@@ -0,0 +1,74 @@
+package com.bencodez.votingplugin.bungee.velocity;
+
+import com.bencodez.votingplugin.bungee.BungeeMethod;
+import com.velocitypowered.api.command.CommandSource;
+import com.velocitypowered.api.command.SimpleCommand;
+
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+
+public class VotingPluginVelocityCommand implements SimpleCommand {
+	private VotingPluginVelocity plugin;
+
+	public VotingPluginVelocityCommand(VotingPluginVelocity plugin) {
+		this.plugin = plugin;
+	}
+
+	@Override
+	public void execute(final Invocation invocation) {
+		CommandSource source = invocation.source();
+		// Get the arguments after the command alias
+		String[] args = invocation.arguments();
+
+		if (args.length > 0) {
+			if (args[0].equalsIgnoreCase("reload")) {
+				plugin.reload(false);
+				source.sendMessage(Component.text("Reloading VotingPluginBungee").color(NamedTextColor.AQUA));
+			}
+			if (args[0].equalsIgnoreCase("reloadmysql")) {
+				plugin.reload(true);
+				source.sendMessage(Component.text("Reloading VotingPluginBungee MySQL").color(NamedTextColor.AQUA));
+			}
+			if (args[0].equalsIgnoreCase("vote")) {
+				if (args.length >= 2) {
+					String user = args[1];
+					String site = args[2];
+					plugin.vote(user, site, false);
+					source.sendMessage(Component.text("Sending vote").color(NamedTextColor.AQUA));
+				}
+			}
+			if (args[0].equalsIgnoreCase("status")) {
+				if (plugin.getMethod().equals(BungeeMethod.SOCKETS)) {
+					source.sendMessage(
+							Component.text("Checking status, waiting for response, check console, method: sockets")
+									.color(NamedTextColor.AQUA));
+					plugin.status();
+				} else if (plugin.getMethod().equals(BungeeMethod.PLUGINMESSAGING)) {
+					source.sendMessage(Component
+							.text("Checking status, waiting for response, check console, method: pluginmessaging")
+							.color(NamedTextColor.AQUA));
+					plugin.status();
+				} else {
+					source.sendMessage(Component.text("Not using socket/pluginmessage method, command unavailable")
+							.color(NamedTextColor.AQUA));
+				}
+			}
+			if (args[0].equalsIgnoreCase("help")) {
+				String[] msg = new String[4];
+				msg[0] = "votingpluginbungee reload - Reload plugin";
+				msg[1] = "votingpluginbungee reloadmysql - Reload plugin including mysql";
+				msg[2] = "votingpluginbungee vote (player) (servicesite) - Send bungee vote";
+				msg[3] = "votingpluginbungee status - Check socket connection status";
+				for (String m : msg) {
+					source.sendMessage(Component.text(m).color(NamedTextColor.AQUA));
+				}
+
+			}
+		}
+	}
+
+	@Override
+	public boolean hasPermission(final Invocation invocation) {
+		return invocation.source().hasPermission("votingpluginbungee.admin");
+	}
+}

VotingPlugin/src/com/bencodez/votingplugin/commands/CommandLoader.java

@@ -797,6 +797,7 @@ public class CommandLoader {
 					public void execute(CommandSender sender, String[] args) {
 						VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(args[1]);
 						user.setMilestoneCount(user.getMilestoneCount() + Integer.parseInt(args[3]));
+						plugin.getSpecialRewards().checkMilestone(user, null, false);
 						sender.sendMessage(
 								StringParser.getInstance().colorize("&cAdded milestonecount for " + args[1]));
 					}
@@ -1334,6 +1335,18 @@ public class CommandLoader {
 			}
 		});
 
+		plugin.getAdminVoteCommand().add(new CommandHandler(new String[] { "User", "(player)", "ForceFirstVoteToday" },
+				"VotingPlugin.Commands.AdminVote.ForceFirstVoteToday|" + adminPerm, "Force a firstvotetoday reward") {
+
+			@Override
+			public void execute(CommandSender sender, String[] args) {
+				VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(args[1]);
+				plugin.getSpecialRewards().giveFirstVoteTodayRewards(user, user.isOnline(),
+						plugin.getBungeeSettings().isUseBungeecoord());
+				sendMessage(sender, "&cFirstVoteToday forced");
+			}
+		});
+
 		plugin.getAdminVoteCommand()
 				.add(new CommandHandler(new String[] { "Placeholders", "(player)" },
 						"VotingPlugin.Commands.AdminVote.Placeholders.Players|" + adminPerm,

VotingPlugin/src/com/bencodez/votingplugin/commands/gui/AdminGUI.java

@@ -113,6 +113,14 @@ public class AdminGUI {
 						RewardHandler.getInstance().getDirectlyDefined("FirstVote"));
 			}
 		});
+		buttons.add(new BInventoryButton(new ItemBuilder(Material.STONE, 1).setName("&cEdit FirstVoteToday reward")) {
+
+			@Override
+			public void onClick(ClickEvent clickEvent) {
+				RewardEditGUI.getInstance().openRewardGUI(clickEvent.getPlayer(),
+						RewardHandler.getInstance().getDirectlyDefined("FirstVoteToday"));
+			}
+		});
 
 		buttons.add(new BInventoryButton(new ItemBuilder(Material.STONE, 1).setName("&cEdit AllSites reward")) {
 
@@ -141,7 +149,7 @@ public class AdminGUI {
 			}
 		});
 
-		buttons.add(new BInventoryButton(new ItemBuilder(Material.GRASS_BLOCK).setName("&cEdit BungeeSettings.yml")) {
+		buttons.add(new BInventoryButton(new ItemBuilder("GRASS_BLOCK").setName("&cEdit BungeeSettings.yml")) {
 
 			@Override
 			public void onClick(ClickEvent clickEvent) {

VotingPlugin/src/com/bencodez/votingplugin/commands/gui/player/VoteHelp.java

@@ -13,6 +13,7 @@ import com.bencodez.advancedcore.api.gui.GUIMethod;
 import com.bencodez.advancedcore.api.messages.StringParser;
 import com.bencodez.votingplugin.VotingPluginMain;
 
+import net.md_5.bungee.api.ChatColor;
 import net.md_5.bungee.api.chat.TextComponent;
 
 public class VoteHelp extends GUIHandler {
@@ -37,10 +38,19 @@ public class VoteHelp extends GUIHandler {
 
 		boolean requirePerms = plugin.getConfigFile().getFormatCommandsVoteHelpRequirePermission();
 
+		String colorStr = plugin.getConfigFile().getFormatCommandsVoteHelpHoverColor();
+		ChatColor hoverColor = null;
+		try {
+			hoverColor = ChatColor.of(colorStr);
+		} catch (Exception e) {
+			plugin.getLogger().warning("Failed to get color for hover help message");
+			e.printStackTrace();
+			hoverColor = ChatColor.AQUA;
+		}
 		for (CommandHandler cmdHandle : plugin.getVoteCommand()) {
 			if (!requirePerms || cmdHandle.hasPerm(sender)) {
-				unsorted.put(cmdHandle.getHelpLineCommand("/vote"),
-						cmdHandle.getHelpLine("/vote", plugin.getConfigFile().getFormatCommandsVoteHelpLine()));
+				unsorted.put(cmdHandle.getHelpLineCommand("/vote"), cmdHandle.getHelpLine("/vote",
+						plugin.getConfigFile().getFormatCommandsVoteHelpLine(), hoverColor));
 			}
 		}
 		ArrayList<String> unsortedList = new ArrayList<String>();

VotingPlugin/src/com/bencodez/votingplugin/config/BungeeSettings.java

@@ -52,6 +52,10 @@ public class BungeeSettings extends YMLFile {
 	@ConfigDataString(path = "Server")
 	@Getter
 	private String server = "PleaseSet";
+	
+	public String getServerNameStorage() {
+		return getServer().replace("-", "_");
+	}
 
 	@ConfigDataString(path = "SpigotServer.Host")
 	@Getter

VotingPlugin/src/com/bencodez/votingplugin/config/Config.java

@@ -87,7 +87,7 @@ public class Config extends YMLFile {
 
 	@ConfigDataInt(path = "ConvertAmount")
 	@Getter
-	private int convertAmount = 250;
+	private int convertAmount = 150;
 
 	@ConfigDataInt(path = "ConvertDelay", defaultValue = 30000)
 	@Getter
@@ -349,6 +349,10 @@ public class Config extends YMLFile {
 	public String getFormatCommandsVoteHelpLine() {
 		return getData().getString("Format.Commands.Vote.Help.Line", "&6%Command% - &6%HelpMessage%");
 	}
+	
+	public String getFormatCommandsVoteHelpHoverColor() {
+		return getData().getString("Format.Commands.Vote.Help.HoverColor", "AQUA");
+	}
 
 	/**
 	 * Gets the commands vote help require permission.

VotingPlugin/src/com/bencodez/votingplugin/config/SpecialRewardsConfig.java

@@ -36,6 +36,9 @@ public class SpecialRewardsConfig extends YMLFile {
 
 	@Getter
 	private String firstVoteRewardsPath = "FirstVote";
+	
+	@Getter
+	private String firstVoteTodayRewardsPath = "FirstVoteToday";
 
 	/** The plugin. */
 	private VotingPluginMain plugin;
@@ -133,7 +136,7 @@ public class SpecialRewardsConfig extends YMLFile {
 				return TopVoter.Daily.toString();
 			}
 		}
-		return TopVoter.AllTime.toString();
+		return str;
 	}
 
 	public String getDailyAwardRewardsPath(String path) {

VotingPlugin/src/com/bencodez/votingplugin/events/SpecialRewardType.java

@@ -3,7 +3,7 @@ package com.bencodez.votingplugin.events;
 import lombok.Getter;
 
 public enum SpecialRewardType {
-	ALLSITE, CUMMULATIVE, FIRSTVOTE, MILESTONE, VOTESTREAK;
+	ALLSITE, CUMMULATIVE, FIRSTVOTE, MILESTONE, VOTESTREAK, FIRSTVOTETODAY;
 
 	@Getter
 	private int amount = -1;

VotingPlugin/src/com/bencodez/votingplugin/listeners/PlayerJoinEvent.java

@@ -10,6 +10,7 @@ import org.bukkit.event.player.PlayerQuitEvent;
 import com.bencodez.advancedcore.api.user.UserStorage;
 import com.bencodez.advancedcore.listeners.AdvancedCoreLoginEvent;
 import com.bencodez.votingplugin.VotingPluginMain;
+import com.bencodez.votingplugin.bungee.BungeeMethod;
 import com.bencodez.votingplugin.user.UserManager;
 import com.bencodez.votingplugin.user.VotingPluginUser;
 
@@ -47,6 +48,11 @@ public class PlayerJoinEvent implements Listener {
 		}
 
 		user.loginRewards();
+
+		if (plugin.getBungeeSettings().isUseBungeecoord()
+				&& plugin.getBungeeHandler().getMethod().equals(BungeeMethod.PLUGINMESSAGING)) {
+			plugin.getPluginMessaging().sendPluginMessage("Login", user.getPlayerName(), user.getUUID());
+		}
 	}
 
 	/**

VotingPlugin/src/com/bencodez/votingplugin/listeners/PlayerVoteListener.java

@@ -142,6 +142,7 @@ public class PlayerVoteListener implements Listener {
 
 			// check first vote rewards
 			plugin.getSpecialRewards().checkFirstVote(user, event.isForceBungee());
+			plugin.getSpecialRewards().checkFirstVoteToday(user, event.isForceBungee());
 
 			if (user.isReminded()) {
 				user.setReminded(false);

VotingPlugin/src/com/bencodez/votingplugin/placeholders/PlaceHolders.java

@@ -54,6 +54,10 @@ public class PlaceHolders {
 		VotingPluginUser user = UserManager.getInstance().getVotingPluginUser(p);
 		if (Bukkit.isPrimaryThread() || plugin.getConfigFile().isAlwaysWaitForCachePlaceholders()) {
 			user.setWaitForCache(false);
+			if (!user.isCached()) {
+				user.loadCache();
+				return "";
+			}
 		}
 		if (plugin.getConfigFile().isUsePrimaryAccountForPlaceholders() && user.hasPrimaryAccount()) {
 			user = UserManager.getInstance().getVotingPluginUser(user.getPrimaryAccount());

VotingPlugin/src/com/bencodez/votingplugin/signs/SignHandler.java

@@ -251,6 +251,7 @@ public class SignHandler {
 					}
 
 				} catch (Exception ex) {
+					plugin.debug("Failed to update sign at " + getLocation().toString());
 					VotingPluginMain.plugin.debug(ex);
 				}
 			}

VotingPlugin/src/com/bencodez/votingplugin/specialrewards/SpecialRewards.java

@@ -123,6 +123,18 @@ public class SpecialRewards {
 		return false;
 	}
 
+	public boolean checkFirstVoteToday(VotingPluginUser user, boolean forceBungee) {
+		if (RewardHandler.getInstance().hasRewards(plugin.getSpecialRewardsConfig().getData(),
+				plugin.getSpecialRewardsConfig().getFirstVoteRewardsPath())) {
+			if (!user.hasGottenFirstVoteToday()) {
+				giveFirstVoteTodayRewards(user, user.isOnline(), forceBungee);
+				return true;
+			}
+
+		}
+		return false;
+	}
+
 	public boolean checkMilestone(VotingPluginUser user, BungeeMessageData bungeeMessageData, boolean forceBungee) {
 		int milestoneCount = user.getMilestoneCount();
 		if (bungeeMessageData != null) {
@@ -274,6 +286,18 @@ public class SpecialRewards {
 				new RewardOptions().setServer(forceBungee).setOnline(online));
 	}
 
+	public void giveFirstVoteTodayRewards(VotingPluginUser user, boolean online, boolean forceBungee) {
+		PlayerSpecialRewardEvent event = new PlayerSpecialRewardEvent(user, SpecialRewardType.FIRSTVOTETODAY);
+		Bukkit.getPluginManager().callEvent(event);
+
+		if (event.isCancelled()) {
+			return;
+		}
+		RewardHandler.getInstance().giveReward(user, plugin.getSpecialRewardsConfig().getData(),
+				plugin.getSpecialRewardsConfig().getFirstVoteTodayRewardsPath(),
+				new RewardOptions().setServer(forceBungee).setOnline(online));
+	}
+
 	public void giveMilestoneVoteReward(VotingPluginUser user, boolean online, int milestone, boolean forceBungee) {
 		PlayerSpecialRewardEvent event = new PlayerSpecialRewardEvent(user,
 				SpecialRewardType.MILESTONE.setAmount(milestone));

VotingPlugin/src/com/bencodez/votingplugin/user/VotingPluginUser.java

@@ -397,7 +397,7 @@ public class VotingPluginUser extends com.bencodez.advancedcore.api.user.Advance
 
 	public int getGottenAllSitesDay() {
 		if (plugin.getBungeeSettings().isUseBungeecoord()) {
-			return getData().getInt("AllSitesLast_" + plugin.getBungeeSettings().getServer(), 0, true);
+			return getData().getInt("AllSitesLast_" + plugin.getBungeeSettings().getServerNameStorage(), 0, true);
 		} else {
 			return getData().getInt("AllSitesLast", 0, true);
 		}
@@ -528,7 +528,7 @@ public class VotingPluginUser extends com.bencodez.advancedcore.api.user.Advance
 
 	public String getPointsPath() {
 		if (plugin.getBungeeSettings().isPerServerPoints()) {
-			return plugin.getBungeeSettings().getServer() + "_Points";
+			return plugin.getBungeeSettings().getServerNameStorage() + "_Points";
 		} else {
 			return "Points";
 		}
@@ -654,6 +654,14 @@ public class VotingPluginUser extends com.bencodez.advancedcore.api.user.Advance
 		return getTotal(TopVoter.AllTime) != 0;
 	}
 
+	public boolean hasGottenFirstVoteToday() {
+		if (plugin.getBungeeSettings().isUseBungeecoord()
+				&& plugin.getBungeeHandler().getMethod().equals(BungeeMethod.PLUGINMESSAGING)) {
+			return getTotal(TopVoter.Daily) > 1;
+		}
+		return getTotal(TopVoter.Daily) != 0;
+	}
+
 	/**
 	 * Checks for gotten milestone.
 	 *
@@ -821,7 +829,7 @@ public class VotingPluginUser extends com.bencodez.advancedcore.api.user.Advance
 
 	public void setGottenAllSitesDay(int day) {
 		if (plugin.getBungeeSettings().isUseBungeecoord()) {
-			getData().setInt("AllSitesLast_" + plugin.getBungeeSettings().getServer(), day);
+			getData().setInt("AllSitesLast_" + plugin.getBungeeSettings().getServerNameStorage(), day);
 		} else {
 			getData().setInt("AllSitesLast", day);
 		}