protocolVersionByIP = new HashMap<>();
+
+ public static Protocol INSTANCE;
+ @Instance
+ public static ProtocolAPI classInstance;
+
+ public ProtocolAPI() {
+ if(Bukkit.getPluginManager().isPluginEnabled("ViaVersion")) {
+ INSTANCE = new ViaVersionAPI();
+ } else if(Bukkit.getPluginManager().isPluginEnabled("ProtocolSupport")) {
+ INSTANCE = new ProtocolSupport();
+ } else INSTANCE = new NoAPI();
+ }
+}
diff --git a/AtlasParent/Atlas/src/main/java/cc/funkemunky/api/handlers/protocolsupport/impl/NoAPI.java b/AtlasParent/Atlas/src/main/java/cc/funkemunky/api/handlers/protocolsupport/impl/NoAPI.java
new file mode 100644
index 00000000..a80c5124
--- /dev/null
+++ b/AtlasParent/Atlas/src/main/java/cc/funkemunky/api/handlers/protocolsupport/impl/NoAPI.java
@@ -0,0 +1,26 @@
+package cc.funkemunky.api.handlers.protocolsupport.impl;
+
+import cc.funkemunky.api.Atlas;
+import cc.funkemunky.api.bungee.BungeeAPI;
+import cc.funkemunky.api.handlers.protocolsupport.Protocol;
+import cc.funkemunky.api.handlers.protocolsupport.ProtocolAPI;
+import cc.funkemunky.api.tinyprotocol.api.ProtocolVersion;
+import cc.funkemunky.api.tinyprotocol.api.TinyProtocolHandler;
+import org.bukkit.entity.Player;
+
+public class NoAPI implements Protocol {
+
+ @Override
+ public int getPlayerVersion(Player player) {
+ return ProtocolAPI.classInstance.protocolVersionByIP.computeIfAbsent(player.getAddress().getAddress()
+ .getHostAddress().substring(1), shit -> {
+ if(Atlas.getInstance().getBungeeManager().isBungee()) {
+ int version = TinyProtocolHandler.bungeeVersionCache
+ .computeIfAbsent(player.getUniqueId(), key -> BungeeAPI.getPlayerVersion(player));
+
+ if(version != -1) return ProtocolVersion.getVersion(version).getVersion();
+ }
+ return TinyProtocolHandler.getInstance().getProtocolVersion(player);
+ });
+ }
+}
diff --git a/AtlasParent/Atlas/src/main/java/cc/funkemunky/api/handlers/protocolsupport/impl/ProtocolSupport.java b/AtlasParent/Atlas/src/main/java/cc/funkemunky/api/handlers/protocolsupport/impl/ProtocolSupport.java
new file mode 100644
index 00000000..7af800b0
--- /dev/null
+++ b/AtlasParent/Atlas/src/main/java/cc/funkemunky/api/handlers/protocolsupport/impl/ProtocolSupport.java
@@ -0,0 +1,13 @@
+package cc.funkemunky.api.handlers.protocolsupport.impl;
+
+import cc.funkemunky.api.handlers.protocolsupport.Protocol;
+import org.bukkit.entity.Player;
+import protocolsupport.api.ProtocolSupportAPI;
+
+public class ProtocolSupport implements Protocol {
+
+ @Override
+ public int getPlayerVersion(Player player) {
+ return ProtocolSupportAPI.getProtocolVersion(player).getId();
+ }
+}
diff --git a/AtlasParent/Atlas/src/main/java/cc/funkemunky/api/handlers/protocolsupport/impl/ViaVersionAPI.java b/AtlasParent/Atlas/src/main/java/cc/funkemunky/api/handlers/protocolsupport/impl/ViaVersionAPI.java
new file mode 100644
index 00000000..7c6dd55f
--- /dev/null
+++ b/AtlasParent/Atlas/src/main/java/cc/funkemunky/api/handlers/protocolsupport/impl/ViaVersionAPI.java
@@ -0,0 +1,13 @@
+package cc.funkemunky.api.handlers.protocolsupport.impl;
+
+import cc.funkemunky.api.handlers.protocolsupport.Protocol;
+import org.bukkit.entity.Player;
+import us.myles.ViaVersion.api.Via;
+
+public class ViaVersionAPI implements Protocol {
+
+ @Override
+ public int getPlayerVersion(Player player) {
+ return Via.getAPI().getPlayerVersion(player.getUniqueId());
+ }
+}
diff --git a/AtlasParent/Atlas/src/main/java/cc/funkemunky/api/handlers/tab/TabHandler.java b/AtlasParent/Atlas/src/main/java/cc/funkemunky/api/handlers/tab/TabHandler.java
new file mode 100644
index 00000000..9fd06abd
--- /dev/null
+++ b/AtlasParent/Atlas/src/main/java/cc/funkemunky/api/handlers/tab/TabHandler.java
@@ -0,0 +1,4 @@
+package cc.funkemunky.api.handlers.tab;
+
+public class TabHandler {
+}
diff --git a/AtlasParent/Atlas/src/main/java/cc/funkemunky/api/listeners/AtlasConnectionListeners.java b/AtlasParent/Atlas/src/main/java/cc/funkemunky/api/listeners/AtlasConnectionListeners.java
new file mode 100644
index 00000000..a1fc97b3
--- /dev/null
+++ b/AtlasParent/Atlas/src/main/java/cc/funkemunky/api/listeners/AtlasConnectionListeners.java
@@ -0,0 +1,44 @@
+package cc.funkemunky.api.listeners;
+
+import cc.funkemunky.api.events.AtlasListener;
+import cc.funkemunky.api.events.Listen;
+import cc.funkemunky.api.events.impl.PacketLoginEvent;
+import cc.funkemunky.api.handlers.protocolsupport.ProtocolAPI;
+import cc.funkemunky.api.reflections.impl.BukkitReflection;
+import cc.funkemunky.api.tinyprotocol.api.Packet;
+import cc.funkemunky.api.tinyprotocol.packet.login.WrappedHandshakingInSetProtocol;
+import cc.funkemunky.api.tinyprotocol.packet.types.enums.WrappedEnumProtocol;
+import cc.funkemunky.api.utils.Init;
+
+@Init
+public class AtlasConnectionListeners implements AtlasListener {
+
+ private boolean bungeeMode;
+
+ public AtlasConnectionListeners() {
+ bungeeMode = BukkitReflection.isBungeeMode();
+ }
+
+ @Listen
+ public void onEvent(PacketLoginEvent event) {
+ if(event.getPacketType().equals(Packet.Login.HANDSHAKE)) {
+ WrappedHandshakingInSetProtocol packet = new WrappedHandshakingInSetProtocol(event.getPacket());
+
+ if(event.getAddress().toString().contains("127.0.0.1") && bungeeMode
+ && packet.enumProtocol.equals(WrappedEnumProtocol.LOGIN)) {
+ String[] split = packet.hostname.split("\00");
+
+ if (split.length >= 3) {
+ ProtocolAPI.classInstance.protocolVersionByIP.put(split[1], packet.a);
+ }
+ } else {
+ String address = event.getAddress().toString();
+
+ if(address.contains(":")) address = address.split(":")[0];
+ address = address.substring(1);
+
+ ProtocolAPI.classInstance.protocolVersionByIP.put(address, packet.a);
+ }
+ }
+ }
+}
diff --git a/AtlasParent/Atlas/src/main/java/cc/funkemunky/api/listeners/ConnectionListeners.java b/AtlasParent/Atlas/src/main/java/cc/funkemunky/api/listeners/ConnectionListeners.java
new file mode 100644
index 00000000..077924d5
--- /dev/null
+++ b/AtlasParent/Atlas/src/main/java/cc/funkemunky/api/listeners/ConnectionListeners.java
@@ -0,0 +1,39 @@
+package cc.funkemunky.api.listeners;
+
+import cc.funkemunky.api.Atlas;
+import cc.funkemunky.api.tinyprotocol.api.TinyProtocolHandler;
+import cc.funkemunky.api.utils.Init;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.ObjectOutputStream;
+
+@Init
+public class ConnectionListeners implements Listener {
+
+ @EventHandler
+ public void onQuit(PlayerQuitEvent event) {
+ TinyProtocolHandler.bungeeVersionCache.remove(event.getPlayer().getUniqueId());
+ }
+
+ @EventHandler
+ public void onJoin(PlayerJoinEvent event) {
+ if(Atlas.getInstance().getBungeeManager().isBungee()) {
+ try {
+ ByteArrayOutputStream bstream = new ByteArrayOutputStream();
+ ObjectOutputStream ostream = new ObjectOutputStream(bstream);
+
+ ostream.writeObject("version");
+ ostream.writeObject(event.getPlayer().getUniqueId());
+
+ event.getPlayer().sendPluginMessage(Atlas.getInstance(), "atlas:out", bstream.toByteArray());
+ } catch(IOException e) {
+ e.printStackTrace();
+ }
+ }
+ }
+}
diff --git a/AtlasParent/Atlas/src/main/java/cc/funkemunky/api/listeners/PluginShutdownListeners.java b/AtlasParent/Atlas/src/main/java/cc/funkemunky/api/listeners/PluginShutdownListeners.java
new file mode 100644
index 00000000..af616c6b
--- /dev/null
+++ b/AtlasParent/Atlas/src/main/java/cc/funkemunky/api/listeners/PluginShutdownListeners.java
@@ -0,0 +1,23 @@
+package cc.funkemunky.api.listeners;
+
+import cc.funkemunky.api.Atlas;
+import cc.funkemunky.api.utils.MiscUtils;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.server.PluginDisableEvent;
+
+//@Init
+public class PluginShutdownListeners implements Listener {
+
+ @EventHandler(priority = EventPriority.HIGHEST)
+ public void onEvent(PluginDisableEvent event) {
+ if(event.getPlugin().getDescription().getDepend().contains("Atlas")) {
+ MiscUtils.printToConsole("&c" + event.getPlugin().getName() + " &7is being shutdown. Removing its hooks and listeners...");
+ Atlas.getInstance().getEventManager().unregisterAll(event.getPlugin());
+ Atlas.getInstance().getSchedular().shutdownNow();
+ Atlas.getInstance().getFunkeCommandManager().removeAll(event.getPlugin());
+ MiscUtils.printToConsole("&aCompleted!");
+ }
+ }
+}
diff --git a/AtlasParent/Atlas/src/main/java/cc/funkemunky/api/metrics/Metrics.java b/AtlasParent/Atlas/src/main/java/cc/funkemunky/api/metrics/Metrics.java
new file mode 100644
index 00000000..dff27c03
--- /dev/null
+++ b/AtlasParent/Atlas/src/main/java/cc/funkemunky/api/metrics/Metrics.java
@@ -0,0 +1,695 @@
+package cc.funkemunky.api.metrics;
+
+import org.bukkit.Bukkit;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.plugin.RegisteredServiceProvider;
+import org.bukkit.plugin.ServicePriority;
+import org.json.simple.JSONArray;
+import org.json.simple.JSONObject;
+
+import javax.net.ssl.HttpsURLConnection;
+import java.io.*;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.nio.charset.StandardCharsets;
+import java.util.*;
+import java.util.concurrent.Callable;
+import java.util.logging.Level;
+import java.util.zip.GZIPOutputStream;
+
+/**
+ * bStats collects some data for plugin authors.
+ *
+ * Check out https://bStats.org/ to learn more about bStats!
+ */
+@SuppressWarnings({"WeakerAccess", "unused"})
+public class Metrics {
+
+ static {
+ // You can use the property to disable the check in your test environment
+ if (System.getProperty("bstats.relocatecheck") == null || !System.getProperty("bstats.relocatecheck").equals("false")) {
+ // Maven's Relocate is clever and changes strings, too. So we have to use this little "trick" ... :D
+ final String defaultPackage = new String(
+ new byte[]{'o', 'r', 'g', '.', 'b', 's', 't', 'a', 't', 's', '.', 'b', 'u', 'k', 'k', 'i', 't'});
+ final String examplePackage = new String(new byte[]{'y', 'o', 'u', 'r', '.', 'p', 'a', 'c', 'k', 'a', 'g', 'e'});
+ // We want to make sure nobody just copy & pastes the example and use the wrong package names
+ if (Metrics.class.getPackage().getName().equals(defaultPackage) || Metrics.class.getPackage().getName().equals(examplePackage)) {
+ throw new IllegalStateException("bStats Metrics class has not been relocated correctly!");
+ }
+ }
+ }
+
+ // The version of this bStats class
+ public static final int B_STATS_VERSION = 1;
+
+ // The url to which the data is sent
+ private static final String URL = "https://bStats.org/submitData/bukkit";
+
+ // Is bStats enabled on this server?
+ private boolean enabled;
+
+ // Should failed requests be logged?
+ private static boolean logFailedRequests;
+
+ // Should the sent data be logged?
+ private static boolean logSentData;
+
+ // Should the response text be logged?
+ private static boolean logResponseStatusText;
+
+ // The uuid of the server
+ private static String serverUUID;
+
+ // The plugin
+ private final Plugin plugin;
+
+ // A list with all custom charts
+ private final List charts = new ArrayList<>();
+
+ /**
+ * Class constructor.
+ *
+ * @param plugin The plugin which stats should be submitted.
+ */
+ public Metrics(Plugin plugin) {
+ if (plugin == null) {
+ throw new IllegalArgumentException("Plugin cannot be null!");
+ }
+ this.plugin = plugin;
+
+ // Get the atlasConfig file
+ File bStatsFolder = new File(plugin.getDataFolder().getParentFile(), "bStats");
+ File configFile = new File(bStatsFolder, "config.yml");
+ YamlConfiguration config = YamlConfiguration.loadConfiguration(configFile);
+
+ // Check if the atlasConfig file exists
+ if (!config.isSet("serverUuid")) {
+
+ // Add default values
+ config.addDefault("enabled", true);
+ // Every server gets it's unique random id.
+ config.addDefault("serverUuid", UUID.randomUUID().toString());
+ // Should failed request be logged?
+ config.addDefault("logFailedRequests", false);
+ // Should the sent data be logged?
+ config.addDefault("logSentData", false);
+ // Should the response text be logged?
+ config.addDefault("logResponseStatusText", false);
+
+ // Inform the server owners about bStats
+ config.options().header(
+ "bStats collects some data for plugin authors like how many servers are using their plugins.\n" +
+ "To honor their work, you should not disable it.\n" +
+ "This has nearly no effect on the server performance!\n" +
+ "Check out https://bStats.org/ to learn more :)"
+ ).copyDefaults(true);
+ try {
+ config.save(configFile);
+ } catch (IOException ignored) { }
+ }
+
+ // Load the data
+ enabled = config.getBoolean("enabled", true);
+ serverUUID = config.getString("serverUuid");
+ logFailedRequests = config.getBoolean("logFailedRequests", false);
+ logSentData = config.getBoolean("logSentData", false);
+ logResponseStatusText = config.getBoolean("logResponseStatusText", false);
+
+ if (enabled) {
+ boolean found = false;
+ // Search for all other bStats Metrics classes to see if we are the first one
+ for (Class service : Bukkit.getServicesManager().getKnownServices()) {
+ try {
+ service.getField("B_STATS_VERSION"); // Our identifier :)
+ found = true; // We aren't the first
+ break;
+ } catch (NoSuchFieldException ignored) { }
+ }
+ // Register our service
+ Bukkit.getServicesManager().register(Metrics.class, this, plugin, ServicePriority.Normal);
+ if (!found) {
+ // We are the first!
+ startSubmitting();
+ }
+ }
+ }
+
+ /**
+ * Checks if bStats is enabled.
+ *
+ * @return Whether bStats is enabled or not.
+ */
+ public boolean isEnabled() {
+ return enabled;
+ }
+
+ /**
+ * Adds a custom chart.
+ *
+ * @param chart The chart to add.
+ */
+ public void addCustomChart(CustomChart chart) {
+ if (chart == null) {
+ throw new IllegalArgumentException("Chart cannot be null!");
+ }
+ charts.add(chart);
+ }
+
+ /**
+ * Starts the Scheduler which submits our data every 30 minutes.
+ */
+ private void startSubmitting() {
+ final Timer timer = new Timer(true); // We use a timer cause the Bukkit scheduler is affected by server lags
+ timer.scheduleAtFixedRate(new TimerTask() {
+ @Override
+ public void run() {
+ if (!plugin.isEnabled()) { // Plugin was disabled
+ timer.cancel();
+ return;
+ }
+ // Nevertheless we want our code to run in the Bukkit main thread, so we have to use the Bukkit scheduler
+ // Don't be afraid! The connection to the bStats server is still async, only the stats collection is sync ;)
+ Bukkit.getScheduler().runTask(plugin, () -> submitData());
+ }
+ }, 1000 * 60 * 5, 1000 * 60 * 30);
+ // Submit the data every 30 minutes, first time after 5 minutes to give other plugins enough time to start
+ // WARNING: Changing the frequency has no effect but your plugin WILL be blocked/deleted!
+ // WARNING: Just don't do it!
+ }
+
+ /**
+ * Gets the plugin specific data.
+ * This method is called using Reflection.
+ *
+ * @return The plugin specific data.
+ */
+ public JSONObject getPluginData() {
+ JSONObject data = new JSONObject();
+
+ String pluginName = plugin.getDescription().getName();
+ String pluginVersion = plugin.getDescription().getVersion();
+
+ data.put("pluginName", pluginName); // Append the name of the plugin
+ data.put("pluginVersion", pluginVersion); // Append the version of the plugin
+ JSONArray customCharts = new JSONArray();
+ for (CustomChart customChart : charts) {
+ // Add the data of the custom charts
+ JSONObject chart = customChart.getRequestJsonObject();
+ if (chart == null) { // If the chart is null, we skip it
+ continue;
+ }
+ customCharts.add(chart);
+ }
+ data.put("customCharts", customCharts);
+
+ return data;
+ }
+
+ /**
+ * Gets the server specific data.
+ *
+ * @return The server specific data.
+ */
+ private JSONObject getServerData() {
+ // Minecraft specific data
+ int playerAmount;
+ try {
+ // Around MC 1.8 the return type was changed to a collection from an array,
+ // This fixes java.lang.NoSuchMethodError: org.bukkit.Bukkit.getOnlinePlayers()Ljava/util/Collection;
+ Method onlinePlayersMethod = Class.forName("org.bukkit.Server").getMethod("getOnlinePlayers");
+ playerAmount = onlinePlayersMethod.getReturnType().equals(Collection.class)
+ ? ((Collection) onlinePlayersMethod.invoke(Bukkit.getServer())).size()
+ : ((Player[]) onlinePlayersMethod.invoke(Bukkit.getServer())).length;
+ } catch (Exception e) {
+ playerAmount = Bukkit.getOnlinePlayers().size(); // Just use the new method if the Reflection failed
+ }
+ int onlineMode = Bukkit.getOnlineMode() ? 1 : 0;
+ String bukkitVersion = Bukkit.getVersion();
+
+ // OS/Java specific data
+ String javaVersion = System.getProperty("java.version");
+ String osName = System.getProperty("os.name");
+ String osArch = System.getProperty("os.arch");
+ String osVersion = System.getProperty("os.version");
+ int coreCount = Runtime.getRuntime().availableProcessors();
+
+ JSONObject data = new JSONObject();
+
+ data.put("serverUUID", serverUUID);
+
+ data.put("playerAmount", playerAmount);
+ data.put("onlineMode", onlineMode);
+ data.put("bukkitVersion", bukkitVersion);
+
+ data.put("javaVersion", javaVersion);
+ data.put("osName", osName);
+ data.put("osArch", osArch);
+ data.put("osVersion", osVersion);
+ data.put("coreCount", coreCount);
+
+ return data;
+ }
+
+ /**
+ * Collects the data and sends it afterwards.
+ */
+ private void submitData() {
+ final JSONObject data = getServerData();
+
+ JSONArray pluginData = new JSONArray();
+ // Search for all other bStats Metrics classes to get their plugin data
+ for (Class service : Bukkit.getServicesManager().getKnownServices()) {
+ try {
+ service.getField("B_STATS_VERSION"); // Our identifier :)
+
+ for (RegisteredServiceProvider provider : Bukkit.getServicesManager().getRegistrations(service)) {
+ try {
+ pluginData.add(provider.getService().getMethod("getPluginData").invoke(provider.getProvider()));
+ } catch (NullPointerException | NoSuchMethodException | IllegalAccessException | InvocationTargetException ignored) { }
+ }
+ } catch (NoSuchFieldException ignored) { }
+ }
+
+ data.put("plugins", pluginData);
+
+ // Create a new thread for the connection to the bStats server
+ new Thread(new Runnable() {
+ @Override
+ public void run() {
+ try {
+ // Send the data
+ sendData(plugin, data);
+ } catch (Exception e) {
+ // Something went wrong! :(
+ if (logFailedRequests) {
+ plugin.getLogger().log(Level.WARNING, "Could not submit plugin stats of " + plugin.getName(), e);
+ }
+ }
+ }
+ }).start();
+ }
+
+ /**
+ * Sends the data to the bStats server.
+ *
+ * @param plugin Any plugin. It's just used to get a logger instance.
+ * @param data The data to send.
+ * @throws Exception If the request failed.
+ */
+ private static void sendData(Plugin plugin, JSONObject data) throws Exception {
+ if (data == null) {
+ throw new IllegalArgumentException("Data cannot be null!");
+ }
+ if (Bukkit.isPrimaryThread()) {
+ throw new IllegalAccessException("This method must not be called from the main thread!");
+ }
+ if (logSentData) {
+ plugin.getLogger().info("Sending data to bStats: " + data.toString());
+ }
+ HttpsURLConnection connection = (HttpsURLConnection) new URL(URL).openConnection();
+
+ // Compress the data to save bandwidth
+ byte[] compressedData = compress(data.toString());
+
+ // Add headers
+ connection.setRequestMethod("POST");
+ connection.addRequestProperty("Accept", "application/json");
+ connection.addRequestProperty("Connection", "close");
+ connection.addRequestProperty("Content-Encoding", "gzip"); // We gzip our request
+ connection.addRequestProperty("Content-Length", String.valueOf(compressedData.length));
+ connection.setRequestProperty("Content-Type", "application/json"); // We send our data in JSON format
+ connection.setRequestProperty("User-Agent", "MC-Server/" + B_STATS_VERSION);
+
+ // Send data
+ connection.setDoOutput(true);
+ DataOutputStream outputStream = new DataOutputStream(connection.getOutputStream());
+ outputStream.write(compressedData);
+ outputStream.flush();
+ outputStream.close();
+
+ InputStream inputStream = connection.getInputStream();
+ BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
+
+ StringBuilder builder = new StringBuilder();
+ String line;
+ while ((line = bufferedReader.readLine()) != null) {
+ builder.append(line);
+ }
+ bufferedReader.close();
+ if (logResponseStatusText) {
+ plugin.getLogger().info("Sent data to bStats and received response: " + builder.toString());
+ }
+ }
+
+ /**
+ * Gzips the given String.
+ *
+ * @param str The string to gzip.
+ * @return The gzipped String.
+ * @throws IOException If the compression failed.
+ */
+ private static byte[] compress(final String str) throws IOException {
+ if (str == null) {
+ return null;
+ }
+ ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+ GZIPOutputStream gzip = new GZIPOutputStream(outputStream);
+ gzip.write(str.getBytes(StandardCharsets.UTF_8));
+ gzip.close();
+ return outputStream.toByteArray();
+ }
+
+ /**
+ * Represents a custom chart.
+ */
+ public static abstract class CustomChart {
+
+ // The id of the chart
+ final String chartId;
+
+ /**
+ * Class constructor.
+ *
+ * @param chartId The id of the chart.
+ */
+ CustomChart(String chartId) {
+ if (chartId == null || chartId.isEmpty()) {
+ throw new IllegalArgumentException("ChartId cannot be null or empty!");
+ }
+ this.chartId = chartId;
+ }
+
+ private JSONObject getRequestJsonObject() {
+ JSONObject chart = new JSONObject();
+ chart.put("chartId", chartId);
+ try {
+ JSONObject data = getChartData();
+ if (data == null) {
+ // If the data is null we don't send the chart.
+ return null;
+ }
+ chart.put("data", data);
+ } catch (Throwable t) {
+ if (logFailedRequests) {
+ Bukkit.getLogger().log(Level.WARNING, "Failed to get data for custom chart with id " + chartId, t);
+ }
+ return null;
+ }
+ return chart;
+ }
+
+ protected abstract JSONObject getChartData() throws Exception;
+
+ }
+
+ /**
+ * Represents a custom simple pie.
+ */
+ public static class SimplePie extends CustomChart {
+
+ private final Callable callable;
+
+ /**
+ * Class constructor.
+ *
+ * @param chartId The id of the chart.
+ * @param callable The callable which is used to request the chart data.
+ */
+ public SimplePie(String chartId, Callable callable) {
+ super(chartId);
+ this.callable = callable;
+ }
+
+ @Override
+ protected JSONObject getChartData() throws Exception {
+ JSONObject data = new JSONObject();
+ String value = callable.call();
+ if (value == null || value.isEmpty()) {
+ // Null = skip the chart
+ return null;
+ }
+ data.put("value", value);
+ return data;
+ }
+ }
+
+ /**
+ * Represents a custom advanced pie.
+ */
+ public static class AdvancedPie extends CustomChart {
+
+ private final Callable> callable;
+
+ /**
+ * Class constructor.
+ *
+ * @param chartId The id of the chart.
+ * @param callable The callable which is used to request the chart data.
+ */
+ public AdvancedPie(String chartId, Callable> callable) {
+ super(chartId);
+ this.callable = callable;
+ }
+
+ @Override
+ protected JSONObject getChartData() throws Exception {
+ JSONObject data = new JSONObject();
+ JSONObject values = new JSONObject();
+ Map map = callable.call();
+ if (map == null || map.isEmpty()) {
+ // Null = skip the chart
+ return null;
+ }
+ boolean allSkipped = true;
+ for (Map.Entry entry : map.entrySet()) {
+ if (entry.getValue() == 0) {
+ continue; // Skip this invalid
+ }
+ allSkipped = false;
+ values.put(entry.getKey(), entry.getValue());
+ }
+ if (allSkipped) {
+ // Null = skip the chart
+ return null;
+ }
+ data.put("values", values);
+ return data;
+ }
+ }
+
+ /**
+ * Represents a custom drilldown pie.
+ */
+ public static class DrilldownPie extends CustomChart {
+
+ private final Callable>> callable;
+
+ /**
+ * Class constructor.
+ *
+ * @param chartId The id of the chart.
+ * @param callable The callable which is used to request the chart data.
+ */
+ public DrilldownPie(String chartId, Callable>> callable) {
+ super(chartId);
+ this.callable = callable;
+ }
+
+ @Override
+ public JSONObject getChartData() throws Exception {
+ JSONObject data = new JSONObject();
+ JSONObject values = new JSONObject();
+ Map> map = callable.call();
+ if (map == null || map.isEmpty()) {
+ // Null = skip the chart
+ return null;
+ }
+ boolean reallyAllSkipped = true;
+ for (Map.Entry> entryValues : map.entrySet()) {
+ JSONObject value = new JSONObject();
+ boolean allSkipped = true;
+ for (Map.Entry valueEntry : map.get(entryValues.getKey()).entrySet()) {
+ value.put(valueEntry.getKey(), valueEntry.getValue());
+ allSkipped = false;
+ }
+ if (!allSkipped) {
+ reallyAllSkipped = false;
+ values.put(entryValues.getKey(), value);
+ }
+ }
+ if (reallyAllSkipped) {
+ // Null = skip the chart
+ return null;
+ }
+ data.put("values", values);
+ return data;
+ }
+ }
+
+ /**
+ * Represents a custom single line chart.
+ */
+ public static class SingleLineChart extends CustomChart {
+
+ private final Callable callable;
+
+ /**
+ * Class constructor.
+ *
+ * @param chartId The id of the chart.
+ * @param callable The callable which is used to request the chart data.
+ */
+ public SingleLineChart(String chartId, Callable callable) {
+ super(chartId);
+ this.callable = callable;
+ }
+
+ @Override
+ protected JSONObject getChartData() throws Exception {
+ JSONObject data = new JSONObject();
+ int value = callable.call();
+ if (value == 0) {
+ // Null = skip the chart
+ return null;
+ }
+ data.put("value", value);
+ return data;
+ }
+
+ }
+
+ /**
+ * Represents a custom multi line chart.
+ */
+ public static class MultiLineChart extends CustomChart {
+
+ private final Callable> callable;
+
+ /**
+ * Class constructor.
+ *
+ * @param chartId The id of the chart.
+ * @param callable The callable which is used to request the chart data.
+ */
+ public MultiLineChart(String chartId, Callable> callable) {
+ super(chartId);
+ this.callable = callable;
+ }
+
+ @Override
+ protected JSONObject getChartData() throws Exception {
+ JSONObject data = new JSONObject();
+ JSONObject values = new JSONObject();
+ Map map = callable.call();
+ if (map == null || map.isEmpty()) {
+ // Null = skip the chart
+ return null;
+ }
+ boolean allSkipped = true;
+ for (Map.Entry entry : map.entrySet()) {
+ if (entry.getValue() == 0) {
+ continue; // Skip this invalid
+ }
+ allSkipped = false;
+ values.put(entry.getKey(), entry.getValue());
+ }
+ if (allSkipped) {
+ // Null = skip the chart
+ return null;
+ }
+ data.put("values", values);
+ return data;
+ }
+
+ }
+
+ /**
+ * Represents a custom simple bar chart.
+ */
+ public static class SimpleBarChart extends CustomChart {
+
+ private final Callable> callable;
+
+ /**
+ * Class constructor.
+ *
+ * @param chartId The id of the chart.
+ * @param callable The callable which is used to request the chart data.
+ */
+ public SimpleBarChart(String chartId, Callable> callable) {
+ super(chartId);
+ this.callable = callable;
+ }
+
+ @Override
+ protected JSONObject getChartData() throws Exception {
+ JSONObject data = new JSONObject();
+ JSONObject values = new JSONObject();
+ Map map = callable.call();
+ if (map == null || map.isEmpty()) {
+ // Null = skip the chart
+ return null;
+ }
+ for (Map.Entry entry : map.entrySet()) {
+ JSONArray categoryValues = new JSONArray();
+ categoryValues.add(entry.getValue());
+ values.put(entry.getKey(), categoryValues);
+ }
+ data.put("values", values);
+ return data;
+ }
+
+ }
+
+ /**
+ * Represents a custom advanced bar chart.
+ */
+ public static class AdvancedBarChart extends CustomChart {
+
+ private final Callable> callable;
+
+ /**
+ * Class constructor.
+ *
+ * @param chartId The id of the chart.
+ * @param callable The callable which is used to request the chart data.
+ */
+ public AdvancedBarChart(String chartId, Callable> callable) {
+ super(chartId);
+ this.callable = callable;
+ }
+
+ @Override
+ protected JSONObject getChartData() throws Exception {
+ JSONObject data = new JSONObject();
+ JSONObject values = new JSONObject();
+ Map map = callable.call();
+ if (map == null || map.isEmpty()) {
+ // Null = skip the chart
+ return null;
+ }
+ boolean allSkipped = true;
+ for (Map.Entry entry : map.entrySet()) {
+ if (entry.getValue().length == 0) {
+ continue; // Skip this invalid
+ }
+ allSkipped = false;
+ JSONArray categoryValues = new JSONArray();
+ for (int categoryValue : entry.getValue()) {
+ categoryValues.add(categoryValue);
+ }
+ values.put(entry.getKey(), categoryValues);
+ }
+ if (allSkipped) {
+ // Null = skip the chart
+ return null;
+ }
+ data.put("values", values);
+ return data;
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/AtlasParent/Atlas/src/main/java/cc/funkemunky/api/profiling/BaseProfiler.java b/AtlasParent/Atlas/src/main/java/cc/funkemunky/api/profiling/BaseProfiler.java
new file mode 100644
index 00000000..af00b1a0
--- /dev/null
+++ b/AtlasParent/Atlas/src/main/java/cc/funkemunky/api/profiling/BaseProfiler.java
@@ -0,0 +1,128 @@
+package cc.funkemunky.api.profiling;
+
+import cc.funkemunky.api.utils.Tuple;
+import lombok.Getter;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class BaseProfiler implements Profiler {
+ @Getter
+ private Map timingsMap = new HashMap<>();
+ public long lastSample = 0, lastReset;
+ public int totalCalls = 0;
+ public long start = 0;
+
+ public BaseProfiler() {
+ }
+
+ @Override
+ public void start() {
+ StackTraceElement stack = Thread.currentThread().getStackTrace()[2];
+ start(stack.getMethodName());
+
+ if(start == 0) start = System.currentTimeMillis();
+ }
+
+ @Override
+ public void start(String name) {
+ Timing timing = getTiming(name);
+ timing.lastCall = System.nanoTime();
+
+ if(start == 0) start = System.currentTimeMillis();
+ }
+
+ @Override
+ public void stop() {
+ if(System.currentTimeMillis() - lastReset < 100L) return;
+ long extense = System.nanoTime();
+ StackTraceElement stack = Thread.currentThread().getStackTrace()[2];
+ stop(stack.getMethodName(), extense);
+ totalCalls++;
+ }
+
+ @Override
+ public void reset() {
+ lastSample = totalCalls = 0;
+ timingsMap.clear();
+ start = lastReset = System.currentTimeMillis();
+ }
+
+ //Returns Tuple
+ @Override
+ public Map> results(ResultsType type) {
+ Map> toReturn = new HashMap<>();
+ switch(type) {
+ case TOTAL: {
+ for (String key : timingsMap.keySet()) {
+ Timing timing = timingsMap.get(key);
+
+ toReturn.put(key, new Tuple<>(timing.calls, timing.average.getAverage()
+ * (timing.calls / (double)totalCalls)));
+ }
+ break;
+ }
+ case AVERAGE: {
+ for(String key : timingsMap.keySet()) {
+ Timing timing = timingsMap.get(key);
+
+ toReturn.put(key, new Tuple<>(timing.calls, timing.average.getAverage()));
+ }
+ break;
+ }
+ case SAMPLES: {
+ for(String key : timingsMap.keySet()) {
+ Timing timing = timingsMap.get(key);
+
+ toReturn.put(key, new Tuple<>(timing.calls, (double)timing.call));
+ }
+ break;
+ }
+ default: {
+ for (String key : timingsMap.keySet()) {
+ Timing timing = timingsMap.get(key);
+
+ toReturn.put(key, new Tuple<>(timing.calls, timing.total / (double)timing.calls));
+ }
+ break;
+ }
+ }
+ return toReturn;
+ }
+
+ @Override
+ public void stop(String name) {
+ long ts = System.currentTimeMillis();
+ if(ts - lastReset < 100L) return;
+ long extense = System.nanoTime();
+ Timing timing = getTiming(name);
+ long time = (System.nanoTime() - timing.lastCall) - (System.nanoTime() - extense);
+ timing.average.add(time);
+ timing.stdDev = Math.abs(time - timing.average.getAverage());
+ timing.total+= time;
+ timing.call = time;
+ timing.calls++;
+ totalCalls++;
+ lastSample = ts;
+ }
+
+ @Override
+ public void stop(String name, long extense) {
+ long ts = System.currentTimeMillis();
+ if(ts - lastReset < 100L) return;
+ Timing timing = getTiming(name);
+ long time = (System.nanoTime() - timing.lastCall) - (System.nanoTime() - extense);
+
+ timing.average.add(time);
+ timing.stdDev = Math.abs(time - timing.average.getAverage());
+ timing.total+= time;
+ timing.call = time;
+ timing.calls++;
+ totalCalls++;
+ lastSample = ts;
+ }
+
+ private Timing getTiming(String name) {
+ return timingsMap.computeIfAbsent(name, Timing::new);
+ }
+}
\ No newline at end of file
diff --git a/AtlasParent/Atlas/src/main/java/cc/funkemunky/api/profiling/Profiler.java b/AtlasParent/Atlas/src/main/java/cc/funkemunky/api/profiling/Profiler.java
new file mode 100644
index 00000000..3ba45424
--- /dev/null
+++ b/AtlasParent/Atlas/src/main/java/cc/funkemunky/api/profiling/Profiler.java
@@ -0,0 +1,21 @@
+package cc.funkemunky.api.profiling;
+
+import cc.funkemunky.api.utils.Tuple;
+
+import java.util.Map;
+
+public interface Profiler {
+ void start(String name);
+
+ void start();
+
+ void stop(String name, long extense);
+
+ void stop(String name);
+
+ void stop();
+
+ void reset();
+
+ Map> results(ResultsType type);
+}
diff --git a/AtlasParent/Atlas/src/main/java/cc/funkemunky/api/profiling/ResultsType.java b/AtlasParent/Atlas/src/main/java/cc/funkemunky/api/profiling/ResultsType.java
new file mode 100644
index 00000000..ae5b0787
--- /dev/null
+++ b/AtlasParent/Atlas/src/main/java/cc/funkemunky/api/profiling/ResultsType.java
@@ -0,0 +1,5 @@
+package cc.funkemunky.api.profiling;
+
+public enum ResultsType {
+ SAMPLES, TOTAL, AVERAGE, TICK, MEDIAN;
+}
diff --git a/AtlasParent/Atlas/src/main/java/cc/funkemunky/api/profiling/Timing.java b/AtlasParent/Atlas/src/main/java/cc/funkemunky/api/profiling/Timing.java
new file mode 100644
index 00000000..4075ca29
--- /dev/null
+++ b/AtlasParent/Atlas/src/main/java/cc/funkemunky/api/profiling/Timing.java
@@ -0,0 +1,13 @@
+package cc.funkemunky.api.profiling;
+
+import cc.funkemunky.api.utils.math.RollingAverageDouble;
+import lombok.RequiredArgsConstructor;
+
+@RequiredArgsConstructor
+public class Timing {
+ public final String name;
+ public int calls;
+ public long call, total, lastCall;
+ public double stdDev;
+ public RollingAverageDouble average = new RollingAverageDouble(40, 0);
+}
diff --git a/AtlasParent/Atlas/src/main/java/cc/funkemunky/api/profiling/ToggleableProfiler.java b/AtlasParent/Atlas/src/main/java/cc/funkemunky/api/profiling/ToggleableProfiler.java
new file mode 100644
index 00000000..d944f22b
--- /dev/null
+++ b/AtlasParent/Atlas/src/main/java/cc/funkemunky/api/profiling/ToggleableProfiler.java
@@ -0,0 +1,40 @@
+package cc.funkemunky.api.profiling;
+
+public class ToggleableProfiler extends BaseProfiler {
+ private boolean enabled;
+
+ @Override
+ public void start() {
+ if(!enabled) return;
+ super.start();
+ }
+
+ @Override
+ public void start(String name) {
+ if(!enabled) return;
+ super.start(name);
+ }
+
+ @Override
+ public void stop() {
+ if(!enabled) return;
+ super.stop();
+ }
+
+ @Override
+ public void stop(String name) {
+ if(!enabled) return;
+ super.stop(name);
+ }
+
+ @Override
+ public void stop(String name, long extense) {
+ if(!enabled) return;
+ super.stop(name, extense);
+ }
+
+ public void setEnabled(boolean enabled) {
+ if(this.enabled = enabled) start = System.currentTimeMillis();
+ else reset();
+ }
+}
diff --git a/AtlasParent/Atlas/src/main/java/cc/funkemunky/api/reflections/Reflections.java b/AtlasParent/Atlas/src/main/java/cc/funkemunky/api/reflections/Reflections.java
new file mode 100644
index 00000000..b94f783c
--- /dev/null
+++ b/AtlasParent/Atlas/src/main/java/cc/funkemunky/api/reflections/Reflections.java
@@ -0,0 +1,104 @@
+/*
+ * Created by Justin Heflin on 4/19/18 8:21 PM
+ * Copyright (c) 2018.
+ *
+ * Can be redistributed non commercially as long as credit is given to original copyright owner.
+ *
+ * last modified: 4/19/18 7:22 PM
+ */
+package cc.funkemunky.api.reflections;
+
+import cc.funkemunky.api.reflections.types.WrappedClass;
+import cc.funkemunky.api.tinyprotocol.api.ProtocolVersion;
+import cc.funkemunky.api.utils.objects.QuadFunction;
+import cc.funkemunky.api.utils.objects.TriFunction;
+import lombok.Getter;
+import lombok.SneakyThrows;
+import lombok.val;
+import org.bukkit.Bukkit;
+
+import java.lang.invoke.LambdaMetafactory;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+import java.lang.reflect.Method;
+import java.util.function.BiFunction;
+import java.util.function.Function;
+
+@Getter
+public class Reflections {
+ private static final String craftBukkitString;
+ private static final String netMinecraftServerString;
+ private static MethodHandles.Lookup lookup = MethodHandles.lookup();
+
+ static {
+ String version = Bukkit.getServer().getClass().getPackage().getName().split("\\.")[3];
+ craftBukkitString = "org.bukkit.craftbukkit." + version + ".";
+ netMinecraftServerString = "net.minecraft.server." + version + ".";
+ }
+
+ public static boolean classExists(String name) {
+ try {
+ Class.forName(name);
+ return true;
+ } catch (ClassNotFoundException e) {
+ return false;
+ }
+ }
+
+ public static WrappedClass getCBClass(String name) {
+ return getClass(craftBukkitString + name);
+ }
+
+ public static WrappedClass getNMSClass(String name) {
+ return getClass(netMinecraftServerString + name);
+ }
+
+ public static WrappedClass getClass(String name) {
+ try {
+ return new WrappedClass(Class.forName(name));
+ } catch (ClassNotFoundException | NoClassDefFoundError e) {
+ throw new NullPointerException("Class" + name + " could not be found!");
+ }
+ }
+
+ public static WrappedClass getUtilClass(String name) {
+ return getClass((ProtocolVersion.getGameVersion().isBelow(ProtocolVersion.V1_8)
+ ? "net.minecraft.util." : "") + name);
+ }
+
+ @SneakyThrows
+ public static T createMethodLambda(Method method) {
+ if(!method.isAccessible()) return null;
+ val handle = lookup.unreflect(method);
+ Class functionType;
+ switch(method.getParameterCount()) {
+ case 0:
+ functionType = Function.class;
+ break;
+ case 1:
+ functionType = BiFunction.class;
+ break;
+ case 2:
+ functionType = TriFunction.class;
+ break;
+ case 3:
+ functionType = QuadFunction.class;
+ default:
+ functionType = null;
+ break;
+ }
+
+ if(functionType != null) {
+ return (T) LambdaMetafactory.metafactory(lookup, "apply",
+ MethodType.methodType(functionType),
+ MethodType.methodType(method.getReturnType(), handle.type().parameterArray()),
+ handle, handle.type()).getTarget().invoke();
+ }
+
+ return null;
+ }
+
+ public static WrappedClass getClass(Class clazz) {
+ return new WrappedClass(clazz);
+ }
+}
diff --git a/AtlasParent/Atlas/src/main/java/cc/funkemunky/api/reflections/impl/BukkitReflection.java b/AtlasParent/Atlas/src/main/java/cc/funkemunky/api/reflections/impl/BukkitReflection.java
new file mode 100644
index 00000000..24ec502c
--- /dev/null
+++ b/AtlasParent/Atlas/src/main/java/cc/funkemunky/api/reflections/impl/BukkitReflection.java
@@ -0,0 +1,35 @@
+package cc.funkemunky.api.reflections.impl;
+
+import cc.funkemunky.api.reflections.Reflections;
+import cc.funkemunky.api.reflections.types.WrappedClass;
+import cc.funkemunky.api.reflections.types.WrappedField;
+import cc.funkemunky.api.reflections.types.WrappedMethod;
+import org.bukkit.Chunk;
+import org.bukkit.inventory.ItemStack;
+
+public class BukkitReflection {
+ public static WrappedField bukkitChunkField = MinecraftReflection.chunk.getFieldByType(Chunk.class, 0);
+ public static WrappedClass spigotConfig;
+ private static WrappedMethod asBukkitCopyItemStack = CraftReflection.craftItemStack
+ .getMethod("asBukkitCopy", MinecraftReflection.itemStack.getParent());
+
+ public static boolean isBungeeMode() {
+ if(spigotConfig == null) return false;
+
+ return spigotConfig.getFieldByName("bungee").get(null);
+ }
+
+ public static Chunk getChunkFromVanilla(Object vanillaChunk) {
+ return bukkitChunkField.get(vanillaChunk);
+ }
+
+ public static ItemStack getBukkitStackFromVanilla(Object object) {
+ return asBukkitCopyItemStack.invoke(null, object);
+ }
+
+ static {
+ if(Reflections.classExists("org.spigotmc.SpigotConfig")) {
+ spigotConfig = Reflections.getClass("org.spigotmc.SpigotConfig");
+ }
+ }
+}
diff --git a/AtlasParent/Atlas/src/main/java/cc/funkemunky/api/reflections/impl/CraftReflection.java b/AtlasParent/Atlas/src/main/java/cc/funkemunky/api/reflections/impl/CraftReflection.java
new file mode 100644
index 00000000..a91e0061
--- /dev/null
+++ b/AtlasParent/Atlas/src/main/java/cc/funkemunky/api/reflections/impl/CraftReflection.java
@@ -0,0 +1,74 @@
+package cc.funkemunky.api.reflections.impl;
+
+import cc.funkemunky.api.reflections.Reflections;
+import cc.funkemunky.api.reflections.types.WrappedClass;
+import cc.funkemunky.api.reflections.types.WrappedMethod;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.HumanEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+
+public class CraftReflection {
+ public static WrappedClass craftHumanEntity = Reflections.getCBClass("entity.CraftHumanEntity"); //1.7-1.14
+ public static WrappedClass craftEntity = Reflections.getCBClass("entity.CraftEntity"); //1.7-1.14
+ public static WrappedClass craftItemStack = Reflections.getCBClass("inventory.CraftItemStack"); //1.7-1.14
+ public static WrappedClass craftBlock = Reflections.getCBClass("block.CraftBlock"); //1.7-1.14
+ public static WrappedClass craftPlayer = Reflections.getCBClass("entity.CraftPlayer");
+ public static WrappedClass craftWorld = Reflections.getCBClass("CraftWorld"); //1.7-1.14
+ public static WrappedClass craftInventoryPlayer = Reflections.getCBClass("inventory.CraftInventoryPlayer"); //1.7-1.14
+ public static WrappedClass craftServer = Reflections.getCBClass("CraftServer"); //1.7-1.14
+
+ //Vanilla Instances
+ private static WrappedMethod itemStackInstance = craftItemStack.getMethod("asNMSCopy", ItemStack.class); //1.7-1.14
+ private static WrappedMethod humanEntityInstance = craftHumanEntity.getMethod("getHandle"); //1.7-1.14
+ private static WrappedMethod entityInstance = craftEntity.getMethod("getHandle"); //1.7-1.14
+ private static WrappedMethod blockInstance = craftBlock.getMethod("getNMSBlock"); //1.7-1.14
+ private static WrappedMethod worldInstance = craftWorld.getMethod("getHandle"); //1.7-1.14
+ private static WrappedMethod bukkitEntity = MinecraftReflection.entity.getMethod("getBukkitEntity"); //1.7-1.14
+ private static WrappedMethod getInventory = craftInventoryPlayer.getMethod("getInventory"); //1.7-1.14
+ private static WrappedMethod mcServerInstance = craftServer.getMethod("getServer"); //1.7-1.14
+ private static WrappedMethod entityPlayerInstance = craftPlayer.getMethod("getHandle");
+
+ public static T getVanillaItemStack(ItemStack stack) {
+ return itemStackInstance.invoke(null, stack);
+ }
+
+ public static T getEntityHuman(HumanEntity entity) {
+ return humanEntityInstance.invoke(entity);
+ }
+
+ public static T getEntity(Entity entity) {
+ return entityInstance.invoke(entity);
+ }
+
+ public static T getEntityPlayer(Player player) {
+ return entityPlayerInstance.invoke(player);
+ }
+
+ public static T getVanillaBlock(Block block) {
+ return blockInstance.invoke(block);
+ }
+
+ public static T getVanillaWorld(World world) {
+ return worldInstance.invoke(world);
+ }
+
+ public static Entity getBukkitEntity(Object vanillaEntity) {
+ return bukkitEntity.invoke(vanillaEntity);
+ }
+
+ public static T getVanillaInventory(Player player) {
+ return getInventory.invoke(player.getInventory());
+ }
+
+ public static T getMinecraftServer() {
+ return mcServerInstance.invoke(Bukkit.getServer());
+ }
+
+ static {
+
+ }
+}
\ No newline at end of file
diff --git a/AtlasParent/Atlas/src/main/java/cc/funkemunky/api/reflections/impl/MinecraftReflection.java b/AtlasParent/Atlas/src/main/java/cc/funkemunky/api/reflections/impl/MinecraftReflection.java
new file mode 100644
index 00000000..d1cf716c
--- /dev/null
+++ b/AtlasParent/Atlas/src/main/java/cc/funkemunky/api/reflections/impl/MinecraftReflection.java
@@ -0,0 +1,437 @@
+package cc.funkemunky.api.reflections.impl;
+
+import cc.funkemunky.api.reflections.Reflections;
+import cc.funkemunky.api.reflections.types.WrappedClass;
+import cc.funkemunky.api.reflections.types.WrappedConstructor;
+import cc.funkemunky.api.reflections.types.WrappedField;
+import cc.funkemunky.api.reflections.types.WrappedMethod;
+import cc.funkemunky.api.tinyprotocol.api.ProtocolVersion;
+import cc.funkemunky.api.tinyprotocol.packet.types.BaseBlockPosition;
+import cc.funkemunky.api.tinyprotocol.packet.types.Vec3D;
+import cc.funkemunky.api.tinyprotocol.packet.types.enums.WrappedEnumAnimation;
+import cc.funkemunky.api.utils.BoundingBox;
+import cc.funkemunky.api.utils.Materials;
+import org.bukkit.World;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.HumanEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+
+import javax.annotation.Nullable;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class MinecraftReflection {
+ public static WrappedClass entity = Reflections.getNMSClass("Entity");
+ public static WrappedClass axisAlignedBB = Reflections.getNMSClass("AxisAlignedBB");
+ public static WrappedClass entityHuman = Reflections.getNMSClass("EntityHuman");
+ public static WrappedClass entityLiving = Reflections.getNMSClass("EntityLiving");
+ public static WrappedClass block = Reflections.getNMSClass("Block");
+ public static WrappedClass iBlockData;
+ public static WrappedClass itemClass = Reflections.getNMSClass("Item");
+ public static WrappedClass world = Reflections.getNMSClass("World");
+ public static WrappedClass worldServer = Reflections.getNMSClass("WorldServer");
+ public static WrappedClass playerInventory = Reflections.getNMSClass("PlayerInventory");
+ public static WrappedClass itemStack = Reflections.getNMSClass("ItemStack");
+ public static WrappedClass enumAnimation = Reflections.getNMSClass("EnumAnimation");
+ public static WrappedClass chunk = Reflections.getNMSClass("Chunk");
+ public static WrappedClass minecraftServer = Reflections.getNMSClass("MinecraftServer");
+ public static WrappedClass entityPlayer = Reflections.getNMSClass("EntityPlayer");
+ public static WrappedClass playerConnection = Reflections.getNMSClass("PlayerConnection");
+ public static WrappedClass networkManager = Reflections.getNMSClass("NetworkManager");
+ public static WrappedClass serverConnection = Reflections.getNMSClass("ServerConnection");
+ public static WrappedClass gameProfile = Reflections.getUtilClass("com.mojang.authlib.GameProfile");
+ private static WrappedClass propertyMap = Reflections.getUtilClass("com.mojang.authlib.properties.PropertyMap");
+ private static WrappedClass forwardMultiMap = Reflections.getUtilClass("com.google.common.collect.ForwardingMultimap");
+ public static WrappedClass iChatBaseComponent = Reflections.getNMSClass("IChatBaseComponent");
+ public static WrappedClass vec3D = Reflections.getNMSClass("Vec3D");
+
+ private static WrappedMethod getProfile = CraftReflection.craftPlayer.getMethod("getProfile");
+ private static WrappedMethod getProperties = gameProfile.getMethod("getProperties");
+ private static WrappedMethod removeAll = forwardMultiMap.getMethod("removeAll", Object.class);
+ private static WrappedMethod putAll = propertyMap.getMethod("putAll", Object.class, Iterable.class);
+ private static WrappedMethod worldGetType;
+ //BoundingBoxes
+ private static WrappedMethod getCubes;
+ private static WrappedField aBB = axisAlignedBB.getFieldByName("a");
+ private static WrappedField bBB = axisAlignedBB.getFieldByName("b");
+ private static WrappedField cBB = axisAlignedBB.getFieldByName("c");
+ private static WrappedField dBB = axisAlignedBB.getFieldByName("d");
+ private static WrappedField eBB = axisAlignedBB.getFieldByName("e");
+ private static WrappedField fBB = axisAlignedBB.getFieldByName("f");
+ private static WrappedConstructor aabbConstructor;
+ private static WrappedMethod idioticOldStaticConstructorAABB;
+ private static WrappedField entityBoundingBox = entity.getFirstFieldByType(axisAlignedBB.getParent());
+
+ //ItemStack methods and fields
+ private static WrappedMethod enumAnimationStack;
+ private static WrappedField activeItemField;
+ private static WrappedMethod getItemMethod = itemStack.getMethod("getItem");
+ private static WrappedMethod getAnimationMethod = itemClass.getMethodByType(enumAnimation.getParent(), 0);
+ private static WrappedMethod canDestroyMethod;
+
+ //1.13+ only
+ private static WrappedClass voxelShape;
+ private static WrappedClass worldReader;
+ private static WrappedMethod getCubesFromVoxelShape;
+
+ private static WrappedField pingField = entityPlayer.getFieldByName("ping");
+
+ //Blocks
+ private static WrappedMethod addCBoxes;
+ public static WrappedClass blockPos;
+ private static WrappedConstructor blockPosConstructor;
+ private static WrappedMethod getBlockData, getBlock;
+ private static WrappedField blockData = block.getFieldByName("blockData");
+ private static WrappedField frictionFactor = block.getFieldByName("frictionFactor");
+ private static WrappedField strength = block.getFieldByName("strength");
+ private static WrappedField chunkProvider = MinecraftReflection.world
+ .getFieldByType(Reflections.getNMSClass("IChunkProvider").getParent(), 0);
+ private static WrappedField chunksList = Reflections.getNMSClass("ChunkProviderServer")
+ .getFieldByName("chunks");
+
+ //Entity Player fields
+ private static WrappedField connectionField = entityPlayer.getFieldByName("playerConnection");
+ private static WrappedField connectionNetworkField = playerConnection
+ .getFieldByType(networkManager.getParent(), 0);
+ private static WrappedField networkChannelField = networkManager.getFieldByName("channel");
+
+ //General Fields
+ private static WrappedField primaryThread = minecraftServer.getFirstFieldByType(Thread.class);
+
+ public static WrappedEnumAnimation getArmAnimation(HumanEntity entity) {
+ if(entity.getItemInHand() != null) {
+ return getItemAnimation(entity.getItemInHand());
+ }
+ return WrappedEnumAnimation.NONE;
+ }
+
+ public static WrappedEnumAnimation getItemAnimation(ItemStack stack) {
+ Object itemStack = CraftReflection.getVanillaItemStack(stack);
+
+ return WrappedEnumAnimation.fromNMS(enumAnimationStack.invoke(itemStack));
+ }
+
+ public static List getBlockBox(@Nullable Entity entity, Block block) {
+ Object vanillaBlock = getBlock(block);
+ Object world = CraftReflection.getVanillaWorld(block.getWorld());
+
+ //TODO Use increasedHeight if it doesnt get fence or wall boxes properly.
+ //boolean increasedHeight = BlockUtils.isFence(block) || BlockUtils.isWall(block);
+ //We do this so we can get the block inside
+ BoundingBox box = new BoundingBox(
+ block.getLocation().toVector(),
+ block.getLocation().clone()
+ .add(1,1,1)
+ .toVector());
+
+ List