valueEntry : map.get(entryValues.getKey()).entrySet()) {
+ valueBuilder.appendField(valueEntry.getKey(), valueEntry.getValue());
+ allSkipped = false;
+ }
+ if (!allSkipped) {
+ reallyAllSkipped = false;
+ valuesBuilder.appendField(entryValues.getKey(), valueBuilder.build());
+ }
+ }
+ if (reallyAllSkipped) {
+ // Null = skip the chart
+ return null;
+ }
+ return new JsonObjectBuilder().appendField("values", valuesBuilder.build()).build();
+ }
+}
diff --git a/common/src/main/java/me/caseload/knockbacksync/stats/JsonObjectBuilder.java b/common/src/main/java/me/caseload/knockbacksync/stats/JsonObjectBuilder.java
new file mode 100644
index 0000000..5388784
--- /dev/null
+++ b/common/src/main/java/me/caseload/knockbacksync/stats/JsonObjectBuilder.java
@@ -0,0 +1,208 @@
+package me.caseload.knockbacksync.stats;
+
+import java.util.Arrays;
+import java.util.stream.Collectors; /**
+ * An extremely simple JSON builder.
+ *
+ * While this class is neither feature-rich nor the most performant one, it's sufficient enough
+ * for its use-case.
+ */
+public class JsonObjectBuilder {
+
+ private StringBuilder builder = new StringBuilder();
+
+ private boolean hasAtLeastOneField = false;
+
+ public JsonObjectBuilder() {
+ builder.append("{");
+ }
+
+ /**
+ * Appends a null field to the JSON.
+ *
+ * @param key The key of the field.
+ * @return A reference to this object.
+ */
+ public JsonObjectBuilder appendNull(String key) {
+ appendFieldUnescaped(key, "null");
+ return this;
+ }
+
+ /**
+ * Appends a string field to the JSON.
+ *
+ * @param key The key of the field.
+ * @param value The value of the field.
+ * @return A reference to this object.
+ */
+ public JsonObjectBuilder appendField(String key, String value) {
+ if (value == null) {
+ throw new IllegalArgumentException("JSON value must not be null");
+ }
+ appendFieldUnescaped(key, "\"" + escape(value) + "\"");
+ return this;
+ }
+
+ /**
+ * Appends an integer field to the JSON.
+ *
+ * @param key The key of the field.
+ * @param value The value of the field.
+ * @return A reference to this object.
+ */
+ public JsonObjectBuilder appendField(String key, int value) {
+ appendFieldUnescaped(key, String.valueOf(value));
+ return this;
+ }
+
+ /**
+ * Appends an object to the JSON.
+ *
+ * @param key The key of the field.
+ * @param object The object.
+ * @return A reference to this object.
+ */
+ public JsonObjectBuilder appendField(String key, JsonObject object) {
+ if (object == null) {
+ throw new IllegalArgumentException("JSON object must not be null");
+ }
+ appendFieldUnescaped(key, object.toString());
+ return this;
+ }
+
+ /**
+ * Appends a string array to the JSON.
+ *
+ * @param key The key of the field.
+ * @param values The string array.
+ * @return A reference to this object.
+ */
+ public JsonObjectBuilder appendField(String key, String[] values) {
+ if (values == null) {
+ throw new IllegalArgumentException("JSON values must not be null");
+ }
+ String escapedValues =
+ Arrays.stream(values)
+ .map(value -> "\"" + escape(value) + "\"")
+ .collect(Collectors.joining(","));
+ appendFieldUnescaped(key, "[" + escapedValues + "]");
+ return this;
+ }
+
+ /**
+ * Appends an integer array to the JSON.
+ *
+ * @param key The key of the field.
+ * @param values The integer array.
+ * @return A reference to this object.
+ */
+ public JsonObjectBuilder appendField(String key, int[] values) {
+ if (values == null) {
+ throw new IllegalArgumentException("JSON values must not be null");
+ }
+ String escapedValues =
+ Arrays.stream(values).mapToObj(String::valueOf).collect(Collectors.joining(","));
+ appendFieldUnescaped(key, "[" + escapedValues + "]");
+ return this;
+ }
+
+ /**
+ * Appends an object array to the JSON.
+ *
+ * @param key The key of the field.
+ * @param values The integer array.
+ * @return A reference to this object.
+ */
+ public JsonObjectBuilder appendField(String key, JsonObject[] values) {
+ if (values == null) {
+ throw new IllegalArgumentException("JSON values must not be null");
+ }
+ String escapedValues =
+ Arrays.stream(values).map(JsonObject::toString).collect(Collectors.joining(","));
+ appendFieldUnescaped(key, "[" + escapedValues + "]");
+ return this;
+ }
+
+ /**
+ * Appends a field to the object.
+ *
+ * @param key The key of the field.
+ * @param escapedValue The escaped value of the field.
+ */
+ private void appendFieldUnescaped(String key, String escapedValue) {
+ if (builder == null) {
+ throw new IllegalStateException("JSON has already been built");
+ }
+ if (key == null) {
+ throw new IllegalArgumentException("JSON key must not be null");
+ }
+ if (hasAtLeastOneField) {
+ builder.append(",");
+ }
+ builder.append("\"").append(escape(key)).append("\":").append(escapedValue);
+ hasAtLeastOneField = true;
+ }
+
+ /**
+ * Builds the JSON string and invalidates this builder.
+ *
+ * @return The built JSON string.
+ */
+ public JsonObject build() {
+ if (builder == null) {
+ throw new IllegalStateException("JSON has already been built");
+ }
+ JsonObject object = new JsonObject(builder.append("}").toString());
+ builder = null;
+ return object;
+ }
+
+ /**
+ * Escapes the given string like stated in https://www.ietf.org/rfc/rfc4627.txt.
+ *
+ *
This method escapes only the necessary characters '"', '\'. and '\u0000' - '\u001F'.
+ * Compact escapes are not used (e.g., '\n' is escaped as "\u000a" and not as "\n").
+ *
+ * @param value The value to escape.
+ * @return The escaped value.
+ */
+ private static String escape(String value) {
+ final StringBuilder builder = new StringBuilder();
+ for (int i = 0; i < value.length(); i++) {
+ char c = value.charAt(i);
+ if (c == '"') {
+ builder.append("\\\"");
+ } else if (c == '\\') {
+ builder.append("\\\\");
+ } else if (c <= '\u000F') {
+ builder.append("\\u000").append(Integer.toHexString(c));
+ } else if (c <= '\u001F') {
+ builder.append("\\u00").append(Integer.toHexString(c));
+ } else {
+ builder.append(c);
+ }
+ }
+ return builder.toString();
+ }
+
+ /**
+ * A super simple representation of a JSON object.
+ *
+ *
This class only exists to make methods of the {@link JsonObjectBuilder} type-safe and not
+ * allow a raw string inputs for methods like {@link JsonObjectBuilder#appendField(String,
+ * JsonObject)}.
+ */
+ public static class JsonObject {
+
+ private final String value;
+
+ private JsonObject(String value) {
+ this.value = value;
+ }
+
+ @Override
+ public String toString() {
+ return value;
+ }
+ }
+}
diff --git a/common/src/main/java/me/caseload/knockbacksync/stats/MultiLineChart.java b/common/src/main/java/me/caseload/knockbacksync/stats/MultiLineChart.java
new file mode 100644
index 0000000..1d868f0
--- /dev/null
+++ b/common/src/main/java/me/caseload/knockbacksync/stats/MultiLineChart.java
@@ -0,0 +1,44 @@
+package me.caseload.knockbacksync.stats;
+
+import java.util.Map;
+import java.util.concurrent.Callable;
+
+public 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 JsonObjectBuilder.JsonObject getChartData() throws Exception {
+ JsonObjectBuilder valuesBuilder = new JsonObjectBuilder();
+ 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) {
+ // Skip this invalid
+ continue;
+ }
+ allSkipped = false;
+ valuesBuilder.appendField(entry.getKey(), entry.getValue());
+ }
+ if (allSkipped) {
+ // Null = skip the chart
+ return null;
+ }
+ return new JsonObjectBuilder().appendField("values", valuesBuilder.build()).build();
+ }
+}
diff --git a/common/src/main/java/me/caseload/knockbacksync/stats/SimpleBarChart.java b/common/src/main/java/me/caseload/knockbacksync/stats/SimpleBarChart.java
new file mode 100644
index 0000000..6da7833
--- /dev/null
+++ b/common/src/main/java/me/caseload/knockbacksync/stats/SimpleBarChart.java
@@ -0,0 +1,34 @@
+package me.caseload.knockbacksync.stats;
+
+import java.util.Map;
+import java.util.concurrent.Callable;
+
+public 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 JsonObjectBuilder.JsonObject getChartData() throws Exception {
+ JsonObjectBuilder valuesBuilder = new JsonObjectBuilder();
+ Map map = callable.call();
+ if (map == null || map.isEmpty()) {
+ // Null = skip the chart
+ return null;
+ }
+ for (Map.Entry entry : map.entrySet()) {
+ valuesBuilder.appendField(entry.getKey(), new int[] {entry.getValue()});
+ }
+ return new JsonObjectBuilder().appendField("values", valuesBuilder.build()).build();
+ }
+}
diff --git a/common/src/main/java/me/caseload/knockbacksync/stats/SimplePie.java b/common/src/main/java/me/caseload/knockbacksync/stats/SimplePie.java
new file mode 100644
index 0000000..4b9b4e6
--- /dev/null
+++ b/common/src/main/java/me/caseload/knockbacksync/stats/SimplePie.java
@@ -0,0 +1,29 @@
+package me.caseload.knockbacksync.stats;
+
+import java.util.concurrent.Callable;
+
+public 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 JsonObjectBuilder.JsonObject getChartData() throws Exception {
+ String value = callable.call();
+ if (value == null || value.isEmpty()) {
+ // Null = skip the chart
+ return null;
+ }
+ return new JsonObjectBuilder().appendField("value", value).build();
+ }
+}
diff --git a/common/src/main/java/me/caseload/knockbacksync/stats/SingleLineChart.java b/common/src/main/java/me/caseload/knockbacksync/stats/SingleLineChart.java
new file mode 100644
index 0000000..0320cea
--- /dev/null
+++ b/common/src/main/java/me/caseload/knockbacksync/stats/SingleLineChart.java
@@ -0,0 +1,29 @@
+package me.caseload.knockbacksync.stats;
+
+import java.util.concurrent.Callable;
+
+public 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 JsonObjectBuilder.JsonObject getChartData() throws Exception {
+ int value = callable.call();
+ if (value == 0) {
+ // Null = skip the chart
+ return null;
+ }
+ return new JsonObjectBuilder().appendField("value", value).build();
+ }
+}
diff --git a/src/main/java/me/caseload/knockbacksync/stats/BuildTypePie.java b/common/src/main/java/me/caseload/knockbacksync/stats/custom/BuildTypePie.java
similarity index 69%
rename from src/main/java/me/caseload/knockbacksync/stats/BuildTypePie.java
rename to common/src/main/java/me/caseload/knockbacksync/stats/custom/BuildTypePie.java
index a0785ec..e3b0b56 100644
--- a/src/main/java/me/caseload/knockbacksync/stats/BuildTypePie.java
+++ b/common/src/main/java/me/caseload/knockbacksync/stats/custom/BuildTypePie.java
@@ -1,10 +1,9 @@
-package me.caseload.knockbacksync.stats;
+package me.caseload.knockbacksync.stats.custom;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
-import me.caseload.knockbacksync.KnockbackSync;
-import org.bstats.charts.SimplePie;
-import org.bukkit.Bukkit;
+import me.caseload.knockbacksync.KnockbackSyncBase;
+import me.caseload.knockbacksync.stats.SimplePie;
import org.kohsuke.github.GHAsset;
import org.kohsuke.github.GHRelease;
import org.kohsuke.github.GitHub;
@@ -24,8 +23,9 @@ public class BuildTypePie extends SimplePie {
private static final String RELEASES_FILE = "releases.txt";
private static final String DEV_BUILDS_FILE = "dev-builds.txt";
- private static final File dataFolder = KnockbackSync.INSTANCE.getDataFolder();
+ private static final File dataFolder = KnockbackSyncBase.INSTANCE.getDataFolder();
private static String cachedBuildType = null;
+ public static URL jarUrl;
public BuildTypePie() {
super("build_type", BuildTypePie::determineBuildType);
@@ -40,7 +40,7 @@ public static String determineBuildType() {
private static String calculateBuildType() {
try {
- String currentHash = getPluginJarHash();
+ String currentHash = KnockbackSyncBase.INSTANCE.pluginJarHashProvider.getPluginJarHash();
downloadBuildFiles();
if (isHashInFile(currentHash, new File(dataFolder, RELEASES_FILE))) {
@@ -63,7 +63,7 @@ private static void downloadBuildFiles() throws IOException {
List assets = latestRelease.listAssets().toList();
for (GHAsset asset : assets) {
if (asset.getName().equals(RELEASES_FILE) || asset.getName().equals(DEV_BUILDS_FILE)) {
- KnockbackSync.INSTANCE.getLogger().info("Downloading: " + asset.getName());
+ KnockbackSyncBase.INSTANCE.getLogger().info("Downloading: " + asset.getName());
String jsonContent = readStringFromURL(asset.getUrl().toString());
JsonObject jsonObject = JsonParser.parseString(jsonContent).getAsJsonObject();
@@ -74,7 +74,7 @@ private static void downloadBuildFiles() throws IOException {
inputStream.transferTo(outputStream);
}
- KnockbackSync.INSTANCE.getLogger().info("Downloaded: " + asset.getName());
+ KnockbackSyncBase.INSTANCE.getLogger().info("Downloaded: " + asset.getName());
}
}
}
@@ -87,26 +87,6 @@ private static boolean isHashInFile(String hash, File file) throws IOException {
return lines.contains(hash);
}
- private static String getPluginJarHash() throws Exception {
- URL jarUrl = Bukkit.getPluginManager().getPlugin("KnockbackSync").getClass().getProtectionDomain().getCodeSource().getLocation();
- MessageDigest digest = MessageDigest.getInstance("SHA-256");
- try (InputStream is = jarUrl.openStream()) {
- byte[] buffer = new byte[8192];
- int read;
- while ((read = is.read(buffer)) > 0) {
- digest.update(buffer, 0, read);
- }
- }
- byte[] hash = digest.digest();
- StringBuilder hexString = new StringBuilder();
- for (byte b : hash) {
- String hex = Integer.toHexString(0xff & b);
- if (hex.length() == 1) hexString.append('0');
- hexString.append(hex);
- }
- return hexString.toString();
- }
-
private static String readStringFromURL(String urlString) throws IOException {
try (InputStream inputStream = new URL(urlString).openStream()) {
return new String(inputStream.readAllBytes(), StandardCharsets.UTF_8);
diff --git a/common/src/main/java/me/caseload/knockbacksync/stats/custom/Metrics.java b/common/src/main/java/me/caseload/knockbacksync/stats/custom/Metrics.java
new file mode 100644
index 0000000..16cb658
--- /dev/null
+++ b/common/src/main/java/me/caseload/knockbacksync/stats/custom/Metrics.java
@@ -0,0 +1,5 @@
+package me.caseload.knockbacksync.stats.custom;
+
+public interface Metrics {
+ public void shutdown();
+}
diff --git a/common/src/main/java/me/caseload/knockbacksync/stats/custom/MetricsBase.java b/common/src/main/java/me/caseload/knockbacksync/stats/custom/MetricsBase.java
new file mode 100644
index 0000000..069597e
--- /dev/null
+++ b/common/src/main/java/me/caseload/knockbacksync/stats/custom/MetricsBase.java
@@ -0,0 +1,265 @@
+package me.caseload.knockbacksync.stats.custom;
+
+import me.caseload.knockbacksync.stats.CustomChart;
+import me.caseload.knockbacksync.stats.JsonObjectBuilder;
+
+import javax.net.ssl.HttpsURLConnection;
+import java.io.*;
+import java.net.URL;
+import java.nio.charset.StandardCharsets;
+import java.util.*;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+import java.util.zip.GZIPOutputStream;
+
+public class MetricsBase {
+
+ /** The version of the Metrics class. */
+ public static final String METRICS_VERSION = "3.1.0";
+
+ private static final String REPORT_URL = "https://bStats.org/api/v2/data/%s";
+
+ private final ScheduledExecutorService scheduler;
+
+ private final String platform;
+
+ private final String serverUuid;
+
+ private final int serviceId;
+
+ private final Consumer appendPlatformDataConsumer;
+
+ private final Consumer appendServiceDataConsumer;
+
+ private final Consumer submitTaskConsumer;
+
+ private final Supplier checkServiceEnabledSupplier;
+
+ private final BiConsumer errorLogger;
+
+ private final Consumer infoLogger;
+
+ private final boolean logErrors;
+
+ private final boolean logSentData;
+
+ private final boolean logResponseStatusText;
+
+ private final Set customCharts = new HashSet<>();
+
+ private final boolean enabled;
+
+ /**
+ * Creates a new MetricsBase class instance.
+ *
+ * @param platform The platform of the service.
+ * @param serviceId The id of the service.
+ * @param serverUuid The server uuid.
+ * @param enabled Whether or not data sending is enabled.
+ * @param appendPlatformDataConsumer A consumer that receives a {@code JsonObjectBuilder} and
+ * appends all platform-specific data.
+ * @param appendServiceDataConsumer A consumer that receives a {@code JsonObjectBuilder} and
+ * appends all service-specific data.
+ * @param submitTaskConsumer A consumer that takes a runnable with the submit task. This can be
+ * used to delegate the data collection to a another thread to prevent errors caused by
+ * concurrency. Can be {@code null}.
+ * @param checkServiceEnabledSupplier A supplier to check if the service is still enabled.
+ * @param errorLogger A consumer that accepts log message and an error.
+ * @param infoLogger A consumer that accepts info log messages.
+ * @param logErrors Whether or not errors should be logged.
+ * @param logSentData Whether or not the sent data should be logged.
+ * @param logResponseStatusText Whether or not the response status text should be logged.
+ * @param skipRelocateCheck Whether or not the relocate check should be skipped.
+ */
+ public MetricsBase(
+ String platform,
+ String serverUuid,
+ int serviceId,
+ boolean enabled,
+ Consumer appendPlatformDataConsumer,
+ Consumer appendServiceDataConsumer,
+ Consumer submitTaskConsumer,
+ Supplier checkServiceEnabledSupplier,
+ BiConsumer errorLogger,
+ Consumer infoLogger,
+ boolean logErrors,
+ boolean logSentData,
+ boolean logResponseStatusText,
+ boolean skipRelocateCheck) {
+ ScheduledThreadPoolExecutor scheduler =
+ new ScheduledThreadPoolExecutor(
+ 1,
+ task -> {
+ Thread thread = new Thread(task, "bStats-Metrics");
+ thread.setDaemon(true);
+ return thread;
+ });
+ // We want delayed tasks (non-periodic) that will execute in the future to be
+ // cancelled when the scheduler is shutdown.
+ // Otherwise, we risk preventing the server from shutting down even when
+ // MetricsBase#shutdown() is called
+ scheduler.setExecuteExistingDelayedTasksAfterShutdownPolicy(false);
+ this.scheduler = scheduler;
+ this.platform = platform;
+ this.serverUuid = serverUuid;
+ this.serviceId = serviceId;
+ this.enabled = enabled;
+ this.appendPlatformDataConsumer = appendPlatformDataConsumer;
+ this.appendServiceDataConsumer = appendServiceDataConsumer;
+ this.submitTaskConsumer = submitTaskConsumer;
+ this.checkServiceEnabledSupplier = checkServiceEnabledSupplier;
+ this.errorLogger = errorLogger;
+ this.infoLogger = infoLogger;
+ this.logErrors = logErrors;
+ this.logSentData = logSentData;
+ this.logResponseStatusText = logResponseStatusText;
+ if (!skipRelocateCheck) {
+ checkRelocation();
+ }
+ if (enabled) {
+ // WARNING: Removing the option to opt-out will get your plugin banned from
+ // bStats
+ startSubmitting();
+ }
+ }
+
+ public void addCustomChart(CustomChart chart) {
+ this.customCharts.add(chart);
+ }
+
+ public void shutdown() {
+ scheduler.shutdown();
+ }
+
+ private void startSubmitting() {
+ final Runnable submitTask =
+ () -> {
+ if (!enabled || !checkServiceEnabledSupplier.get()) {
+ // Submitting data or service is disabled
+ scheduler.shutdown();
+ return;
+ }
+ if (submitTaskConsumer != null) {
+ submitTaskConsumer.accept(this::submitData);
+ } else {
+ this.submitData();
+ }
+ };
+ // Many servers tend to restart at a fixed time at xx:00 which causes an uneven
+ // distribution of requests on the
+ // bStats backend. To circumvent this problem, we introduce some randomness into
+ // the initial and second delay.
+ // WARNING: You must not modify and part of this Metrics class, including the
+ // submit delay or frequency!
+ // WARNING: Modifying this code will get your plugin banned on bStats. Just
+ // don't do it!
+ long initialDelay = (long) (1000 * 60 * (3 + Math.random() * 3));
+ long secondDelay = (long) (1000 * 60 * (Math.random() * 30));
+ scheduler.schedule(submitTask, initialDelay, TimeUnit.MILLISECONDS);
+ scheduler.scheduleAtFixedRate(
+ submitTask, initialDelay + secondDelay, 1000 * 60 * 30, TimeUnit.MILLISECONDS);
+ }
+
+ private void submitData() {
+ final JsonObjectBuilder baseJsonBuilder = new JsonObjectBuilder();
+ appendPlatformDataConsumer.accept(baseJsonBuilder);
+ final JsonObjectBuilder serviceJsonBuilder = new JsonObjectBuilder();
+ appendServiceDataConsumer.accept(serviceJsonBuilder);
+ JsonObjectBuilder.JsonObject[] chartData =
+ customCharts.stream()
+ .map(customChart -> customChart.getRequestJsonObject(errorLogger, logErrors))
+ .filter(Objects::nonNull)
+ .toArray(JsonObjectBuilder.JsonObject[]::new);
+ serviceJsonBuilder.appendField("id", serviceId);
+ serviceJsonBuilder.appendField("customCharts", chartData);
+ baseJsonBuilder.appendField("service", serviceJsonBuilder.build());
+ baseJsonBuilder.appendField("serverUUID", serverUuid);
+ baseJsonBuilder.appendField("metricsVersion", METRICS_VERSION);
+ JsonObjectBuilder.JsonObject data = baseJsonBuilder.build();
+ scheduler.execute(
+ () -> {
+ try {
+ // Send the data
+ sendData(data);
+ } catch (Exception e) {
+ // Something went wrong! :(
+ if (logErrors) {
+ errorLogger.accept("Could not submit bStats metrics data", e);
+ }
+ }
+ });
+ }
+
+ private void sendData(JsonObjectBuilder.JsonObject data) throws Exception {
+ if (logSentData) {
+ infoLogger.accept("Sent bStats metrics data: " + data.toString());
+ }
+ String url = String.format(REPORT_URL, platform);
+ HttpsURLConnection connection = (HttpsURLConnection) new URL(url).openConnection();
+ // Compress the data to save bandwidth
+ byte[] compressedData = compress(data.toString());
+ connection.setRequestMethod("POST");
+ connection.addRequestProperty("Accept", "application/json");
+ connection.addRequestProperty("Connection", "close");
+ connection.addRequestProperty("Content-Encoding", "gzip");
+ connection.addRequestProperty("Content-Length", String.valueOf(compressedData.length));
+ connection.setRequestProperty("Content-Type", "application/json");
+ connection.setRequestProperty("User-Agent", "Metrics-Service/1");
+ connection.setDoOutput(true);
+ try (DataOutputStream outputStream = new DataOutputStream(connection.getOutputStream())) {
+ outputStream.write(compressedData);
+ }
+ StringBuilder builder = new StringBuilder();
+ try (BufferedReader bufferedReader =
+ new BufferedReader(new InputStreamReader(connection.getInputStream()))) {
+ String line;
+ while ((line = bufferedReader.readLine()) != null) {
+ builder.append(line);
+ }
+ }
+ if (logResponseStatusText) {
+ infoLogger.accept("Sent data to bStats and received response: " + builder);
+ }
+ }
+
+ /** Checks that the class was properly relocated. */
+ private void checkRelocation() {
+ // 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'});
+ final String examplePackage =
+ new String(new byte[] {'y', 'o', 'u', 'r', '.', 'p', 'a', 'c', 'k', 'a', 'g', 'e'});
+ // We want to make sure no one just copy & pastes the example and uses the wrong
+ // package names
+ if (MetricsBase.class.getPackage().getName().startsWith(defaultPackage)
+ || MetricsBase.class.getPackage().getName().startsWith(examplePackage)) {
+ throw new IllegalStateException("bStats Metrics class has not been relocated correctly!");
+ }
+ }
+ }
+
+ /**
+ * Gzips the given string.
+ *
+ * @param str The string to gzip.
+ * @return The gzipped string.
+ */
+ private static byte[] compress(final String str) throws IOException {
+ if (str == null) {
+ return null;
+ }
+ ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+ try (GZIPOutputStream gzip = new GZIPOutputStream(outputStream)) {
+ gzip.write(str.getBytes(StandardCharsets.UTF_8));
+ }
+ return outputStream.toByteArray();
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/me/caseload/knockbacksync/stats/PlayerVersionsPie.java b/common/src/main/java/me/caseload/knockbacksync/stats/custom/PlayerVersionsPie.java
similarity index 63%
rename from src/main/java/me/caseload/knockbacksync/stats/PlayerVersionsPie.java
rename to common/src/main/java/me/caseload/knockbacksync/stats/custom/PlayerVersionsPie.java
index 9c0447b..d9816a5 100644
--- a/src/main/java/me/caseload/knockbacksync/stats/PlayerVersionsPie.java
+++ b/common/src/main/java/me/caseload/knockbacksync/stats/custom/PlayerVersionsPie.java
@@ -1,10 +1,11 @@
-package me.caseload.knockbacksync.stats;
+package me.caseload.knockbacksync.stats.custom;
+import me.caseload.knockbacksync.KnockbackSyncBase;
import me.caseload.knockbacksync.manager.PlayerData;
import me.caseload.knockbacksync.manager.PlayerDataManager;
-import org.bstats.charts.AdvancedPie;
-import org.bukkit.Bukkit;
-import org.bukkit.entity.Player;
+import me.caseload.knockbacksync.player.PlatformPlayer;
+import me.caseload.knockbacksync.world.PlatformServer;
+import me.caseload.knockbacksync.stats.AdvancedPie;
import java.util.HashMap;
import java.util.Map;
@@ -15,8 +16,8 @@ public class PlayerVersionsPie extends AdvancedPie {
public PlayerVersionsPie() {
super("player_version", () -> {
Map valueMap = new HashMap<>();
- for (Player player : Bukkit.getOnlinePlayers()) {
- PlayerData playerData = PlayerDataManager.getPlayerData(player.getUniqueId());
+ for (PlatformPlayer player : KnockbackSyncBase.INSTANCE.platformServer.getOnlinePlayers()) {
+ PlayerData playerData = PlayerDataManager.getPlayerData(player.getUUID());
valueMap.put(playerData.getClientVersion().toString(), valueMap.getOrDefault(playerData.getClientVersion().toString(), 0) + 1);
}
return valueMap;
diff --git a/common/src/main/java/me/caseload/knockbacksync/stats/custom/PluginJarHashProvider.java b/common/src/main/java/me/caseload/knockbacksync/stats/custom/PluginJarHashProvider.java
new file mode 100644
index 0000000..cafdd10
--- /dev/null
+++ b/common/src/main/java/me/caseload/knockbacksync/stats/custom/PluginJarHashProvider.java
@@ -0,0 +1,33 @@
+package me.caseload.knockbacksync.stats.custom;
+
+import java.io.InputStream;
+import java.net.URL;
+import java.security.MessageDigest;
+
+public class PluginJarHashProvider {
+
+ protected URL jarURL;
+
+ public PluginJarHashProvider(URL jarURL) {
+ this.jarURL = jarURL;
+ }
+
+ public String getPluginJarHash() throws Exception {
+ MessageDigest digest = MessageDigest.getInstance("SHA-256");
+ try (InputStream is = jarURL.openStream()) {
+ byte[] buffer = new byte[8192];
+ int read;
+ while ((read = is.read(buffer)) > 0) {
+ digest.update(buffer, 0, read);
+ }
+ }
+ byte[] hash = digest.digest();
+ StringBuilder hexString = new StringBuilder();
+ for (byte b : hash) {
+ String hex = Integer.toHexString(0xff & b);
+ if (hex.length() == 1) hexString.append('0');
+ hexString.append(hex);
+ }
+ return hexString.toString();
+ }
+}
\ No newline at end of file
diff --git a/common/src/main/java/me/caseload/knockbacksync/stats/custom/StatsManager.java b/common/src/main/java/me/caseload/knockbacksync/stats/custom/StatsManager.java
new file mode 100644
index 0000000..d5da44b
--- /dev/null
+++ b/common/src/main/java/me/caseload/knockbacksync/stats/custom/StatsManager.java
@@ -0,0 +1,16 @@
+package me.caseload.knockbacksync.stats.custom;
+
+import me.caseload.knockbacksync.KnockbackSyncBase;
+
+public abstract class StatsManager {
+
+ Metrics metrics;
+
+ public Metrics getMetrics() {
+ return metrics;
+ }
+
+ public void init() {
+ throw new IllegalStateException("Empty stats class!");
+ }
+}
diff --git a/common/src/main/java/me/caseload/knockbacksync/util/BlockFaceUtil.java b/common/src/main/java/me/caseload/knockbacksync/util/BlockFaceUtil.java
new file mode 100644
index 0000000..2381b98
--- /dev/null
+++ b/common/src/main/java/me/caseload/knockbacksync/util/BlockFaceUtil.java
@@ -0,0 +1,44 @@
+package me.caseload.knockbacksync.util;
+
+import com.github.retrooper.packetevents.protocol.world.BlockFace;
+import com.github.retrooper.packetevents.protocol.world.Direction;
+
+public class BlockFaceUtil {
+// public static BlockFace getFrom(Direction direction) {
+// switch (direction) {
+// case NORTH:
+// return BlockFace.NORTH;
+// case SOUTH:
+// return BlockFace.SOUTH;
+// case EAST:
+// return BlockFace.EAST;
+// case WEST:
+// return BlockFace.WEST;
+// case UP:
+// return BlockFace.UP;
+// case DOWN:
+// return BlockFace.DOWN;
+// default:
+// return null;
+// }
+// }
+
+// public static BlockFace getFrom(org.bukkit.block.BlockFace direction) {
+// switch (direction) {
+// case NORTH:
+// return BlockFace.NORTH;
+// case SOUTH:
+// return BlockFace.SOUTH;
+// case EAST:
+// return BlockFace.EAST;
+// case WEST:
+// return BlockFace.WEST;
+// case UP:
+// return BlockFace.UP;
+// case DOWN:
+// return BlockFace.DOWN;
+// default:
+// return null;
+// }
+// }
+}
diff --git a/common/src/main/java/me/caseload/knockbacksync/util/ChatUtil.java b/common/src/main/java/me/caseload/knockbacksync/util/ChatUtil.java
new file mode 100644
index 0000000..f5c041e
--- /dev/null
+++ b/common/src/main/java/me/caseload/knockbacksync/util/ChatUtil.java
@@ -0,0 +1,20 @@
+package me.caseload.knockbacksync.util;
+
+import com.google.common.base.Preconditions;
+import org.jetbrains.annotations.NotNull;
+
+public class ChatUtil {
+ public static @NotNull String translateAlternateColorCodes(char altColorChar, @NotNull String textToTranslate) {
+ Preconditions.checkArgument(textToTranslate != null, "Cannot translate null text");
+ char[] b = textToTranslate.toCharArray();
+
+ for(int i = 0; i < b.length - 1; ++i) {
+ if (b[i] == altColorChar && "0123456789AaBbCcDdEeFfKkLlMmNnOoRrXx".indexOf(b[i + 1]) > -1) {
+ b[i] = 167;
+ b[i + 1] = Character.toLowerCase(b[i + 1]);
+ }
+ }
+
+ return new String(b);
+ }
+}
diff --git a/src/main/java/me/caseload/knockbacksync/util/FloodgateUtil.java b/common/src/main/java/me/caseload/knockbacksync/util/FloodgateUtil.java
similarity index 100%
rename from src/main/java/me/caseload/knockbacksync/util/FloodgateUtil.java
rename to common/src/main/java/me/caseload/knockbacksync/util/FloodgateUtil.java
diff --git a/common/src/main/java/me/caseload/knockbacksync/util/GeyserUtil.java b/common/src/main/java/me/caseload/knockbacksync/util/GeyserUtil.java
new file mode 100644
index 0000000..9bd706c
--- /dev/null
+++ b/common/src/main/java/me/caseload/knockbacksync/util/GeyserUtil.java
@@ -0,0 +1,83 @@
+package me.caseload.knockbacksync.util;
+
+import com.github.retrooper.packetevents.PacketEvents;
+import com.github.retrooper.packetevents.util.reflection.Reflection;
+import me.caseload.knockbacksync.KnockbackSyncBase;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.UUID;
+
+public class GeyserUtil {
+ private static boolean CHECKED_FOR_GEYSER = false;
+ private static boolean GEYSER_PRESENT = false;
+ private static Class GEYSER_CLASS;
+ private static Class GEYSER_API_CLASS;
+ private static Method GEYSER_API_METHOD;
+ private static Method CONNECTION_BY_UUID_METHOD;
+
+ public static boolean isGeyserPlayer(UUID uuid) {
+ if (!CHECKED_FOR_GEYSER) {
+ try {
+ switch (KnockbackSyncBase.INSTANCE.platform) {
+ case BUKKIT:
+ case FOLIA:
+ ClassLoader classLoader = PacketEvents.getAPI().getPlugin().getClass().getClassLoader();
+ GEYSER_CLASS = classLoader.loadClass("org.geysermc.api.Geyser");
+ break;
+ case FABRIC:
+ GEYSER_CLASS = Class.forName("org.geysermc.api.Geyser");
+ GEYSER_PRESENT = true;
+ break;
+ }
+
+ } catch (ClassNotFoundException e) {
+ GEYSER_PRESENT = false;
+ }
+ CHECKED_FOR_GEYSER = true;
+ }
+
+ if (GEYSER_PRESENT) {
+ if (GEYSER_API_CLASS == null) {
+ try {
+ switch (KnockbackSyncBase.INSTANCE.platform) {
+ case BUKKIT:
+ case FOLIA:
+ ClassLoader classLoader = PacketEvents.getAPI().getPlugin().getClass().getClassLoader();
+ GEYSER_API_CLASS = classLoader.loadClass("org.geysermc.api.GeyserApiBase");
+ break;
+ case FABRIC:
+ GEYSER_CLASS = Class.forName("org.geysermc.api.GeyserApiBase");
+ GEYSER_PRESENT = true;
+ break;
+ }
+ }
+ catch (ClassNotFoundException e) {
+ e.printStackTrace();
+ }
+ }
+ if (GEYSER_API_METHOD == null) {
+ GEYSER_API_METHOD = Reflection.getMethodExact(GEYSER_CLASS, "api", null);
+ }
+ if (CONNECTION_BY_UUID_METHOD == null) {
+ CONNECTION_BY_UUID_METHOD = Reflection.getMethod(GEYSER_API_CLASS, "connectionByUuid", 0);
+ }
+ Object apiInstance = null;
+ try {
+ apiInstance = GEYSER_API_METHOD.invoke(null);
+ } catch (IllegalAccessException | InvocationTargetException e) {
+ e.printStackTrace();
+ }
+ Object connection = null;
+ try {
+ if (apiInstance != null) {
+ connection = CONNECTION_BY_UUID_METHOD.invoke(apiInstance, uuid);
+ }
+ } catch (IllegalAccessException | InvocationTargetException e) {
+ e.printStackTrace();
+ }
+ return connection != null;
+ }
+ return false;
+ }
+}
diff --git a/src/main/java/me/caseload/knockbacksync/util/MathUtil.java b/common/src/main/java/me/caseload/knockbacksync/util/MathUtil.java
similarity index 96%
rename from src/main/java/me/caseload/knockbacksync/util/MathUtil.java
rename to common/src/main/java/me/caseload/knockbacksync/util/MathUtil.java
index d8ec238..ece9899 100644
--- a/src/main/java/me/caseload/knockbacksync/util/MathUtil.java
+++ b/common/src/main/java/me/caseload/knockbacksync/util/MathUtil.java
@@ -1,60 +1,60 @@
-package me.caseload.knockbacksync.util;
-
-public class MathUtil {
-
- private static final double TERMINAL_VELOCITY = 3.92;
- private static final double MULTIPLIER = 0.98;
- private static final int MAX_TICKS = 20;
-
- public static double calculateDistanceTraveled(double velocity, int time, double acceleration)
- {
- double totalDistance = 0;
-
- for (int i = 0; i < time; i++)
- {
- totalDistance += velocity;
- velocity = ((velocity - acceleration) * MULTIPLIER);
- velocity = Math.min(velocity, TERMINAL_VELOCITY);
- }
-
- return totalDistance;
- }
-
- public static int calculateFallTime(double initialVelocity, double distance, double acceleration) {
- double velocity = Math.abs(initialVelocity);
- int ticks = 0;
-
- while (distance > 0) {
- if (ticks > MAX_TICKS)
- return -1;
-
- velocity += acceleration;
- velocity = Math.min(velocity, TERMINAL_VELOCITY);
- velocity *= MULTIPLIER;
- distance -= velocity;
- ticks++;
- }
-
- return ticks;
- }
-
- public static int calculateTimeToMaxVelocity(double targetVerticalVelocity, double acceleration) {
- double a = -acceleration * MULTIPLIER;
- double b = acceleration + TERMINAL_VELOCITY * MULTIPLIER;
- double c = -2 * targetVerticalVelocity;
-
- double discriminant = b * b - 4 * a * c;
- if (discriminant < 0)
- return 0;
-
- double positiveRoot = (-b + Math.sqrt(discriminant)) / (2 * a);
- return (int) Math.ceil(positiveRoot * 20);
- }
-
- public static double clamp(double num, double min, double max) {
- if (num < min)
- return min;
-
- return Math.min(num, max);
- }
+package me.caseload.knockbacksync.util;
+
+public class MathUtil {
+
+ private static final double TERMINAL_VELOCITY = 3.92;
+ private static final double MULTIPLIER = 0.98;
+ private static final int MAX_TICKS = 20;
+
+ public static double calculateDistanceTraveled(double velocity, int time, double acceleration)
+ {
+ double totalDistance = 0;
+
+ for (int i = 0; i < time; i++)
+ {
+ totalDistance += velocity;
+ velocity = ((velocity - acceleration) * MULTIPLIER);
+ velocity = Math.min(velocity, TERMINAL_VELOCITY);
+ }
+
+ return totalDistance;
+ }
+
+ public static int calculateFallTime(double initialVelocity, double distance, double acceleration) {
+ double velocity = Math.abs(initialVelocity);
+ int ticks = 0;
+
+ while (distance > 0) {
+ if (ticks > MAX_TICKS)
+ return -1;
+
+ velocity += acceleration;
+ velocity = Math.min(velocity, TERMINAL_VELOCITY);
+ velocity *= MULTIPLIER;
+ distance -= velocity;
+ ticks++;
+ }
+
+ return ticks;
+ }
+
+ public static int calculateTimeToMaxVelocity(double targetVerticalVelocity, double acceleration) {
+ double a = -acceleration * MULTIPLIER;
+ double b = acceleration + TERMINAL_VELOCITY * MULTIPLIER;
+ double c = -2 * targetVerticalVelocity;
+
+ double discriminant = b * b - 4 * a * c;
+ if (discriminant < 0)
+ return 0;
+
+ double positiveRoot = (-b + Math.sqrt(discriminant)) / (2 * a);
+ return (int) Math.ceil(positiveRoot * 20);
+ }
+
+ public static double clamp(double num, double min, double max) {
+ if (num < min)
+ return min;
+
+ return Math.min(num, max);
+ }
}
\ No newline at end of file
diff --git a/common/src/main/java/me/caseload/knockbacksync/util/PlatformUtil.java b/common/src/main/java/me/caseload/knockbacksync/util/PlatformUtil.java
new file mode 100644
index 0000000..21604a7
--- /dev/null
+++ b/common/src/main/java/me/caseload/knockbacksync/util/PlatformUtil.java
@@ -0,0 +1,4 @@
+package me.caseload.knockbacksync.util;
+
+public class PlatformUtil {
+}
diff --git a/common/src/main/java/me/caseload/knockbacksync/world/PlatformServer.java b/common/src/main/java/me/caseload/knockbacksync/world/PlatformServer.java
new file mode 100644
index 0000000..6536a6a
--- /dev/null
+++ b/common/src/main/java/me/caseload/knockbacksync/world/PlatformServer.java
@@ -0,0 +1,27 @@
+package me.caseload.knockbacksync.world;
+
+import me.caseload.knockbacksync.player.PlatformPlayer;
+
+import java.util.Collection;
+import java.util.UUID;
+
+public interface PlatformServer {
+ Collection getOnlinePlayers();
+
+ PlatformPlayer getPlayer(UUID uuid);
+
+// switch (KnockbackSyncBase.INSTANCE.platform) {
+// case BUKKIT:
+// case FOLIA:
+// return Bukkit.getOnlinePlayers().stream()
+// .map(BukkitPlayer::new)
+// .collect(Collectors.toList());
+// case FABRIC:
+// MinecraftServer server = (MinecraftServer) FabricLoader.getInstance().getGameInstance();
+// return server.getPlayerList().getPlayers().stream()
+// .map(FabricPlayer::new)
+// .collect(Collectors.toList());
+// default:
+// throw new IllegalStateException("Unexpected platform: " + KnockbackSyncBase.INSTANCE.platform);
+// }
+}
\ No newline at end of file
diff --git a/common/src/main/java/me/caseload/knockbacksync/world/PlatformWorld.java b/common/src/main/java/me/caseload/knockbacksync/world/PlatformWorld.java
new file mode 100644
index 0000000..91b20dc
--- /dev/null
+++ b/common/src/main/java/me/caseload/knockbacksync/world/PlatformWorld.java
@@ -0,0 +1,14 @@
+package me.caseload.knockbacksync.world;
+
+import com.github.retrooper.packetevents.protocol.world.states.WrappedBlockState;
+import com.github.retrooper.packetevents.util.Vector3d;
+import me.caseload.knockbacksync.world.raytrace.FluidHandling;
+import me.caseload.knockbacksync.world.raytrace.RayTraceResult;
+
+public interface PlatformWorld {
+ WrappedBlockState getBlockStateAt(int x, int y, int z);
+
+ WrappedBlockState getBlockStateAt(Vector3d loc);
+
+ RayTraceResult rayTraceBlocks(Vector3d start, Vector3d direction, double maxDistance, FluidHandling fluidHandling, boolean ignorePassableBlocks);
+}
diff --git a/common/src/main/java/me/caseload/knockbacksync/world/raytrace/FluidHandling.java b/common/src/main/java/me/caseload/knockbacksync/world/raytrace/FluidHandling.java
new file mode 100644
index 0000000..a639056
--- /dev/null
+++ b/common/src/main/java/me/caseload/knockbacksync/world/raytrace/FluidHandling.java
@@ -0,0 +1,5 @@
+package me.caseload.knockbacksync.world.raytrace;
+
+public enum FluidHandling {
+ NONE, SOURCE_ONLY, ALWAYS
+}
diff --git a/common/src/main/java/me/caseload/knockbacksync/world/raytrace/RayTraceOption.java b/common/src/main/java/me/caseload/knockbacksync/world/raytrace/RayTraceOption.java
new file mode 100644
index 0000000..30c4466
--- /dev/null
+++ b/common/src/main/java/me/caseload/knockbacksync/world/raytrace/RayTraceOption.java
@@ -0,0 +1,5 @@
+package me.caseload.knockbacksync.world.raytrace;
+
+public enum RayTraceOption {
+ BLOCK, FLUID, NONE
+}
\ No newline at end of file
diff --git a/common/src/main/java/me/caseload/knockbacksync/world/raytrace/RayTraceResult.java b/common/src/main/java/me/caseload/knockbacksync/world/raytrace/RayTraceResult.java
new file mode 100644
index 0000000..b9322fd
--- /dev/null
+++ b/common/src/main/java/me/caseload/knockbacksync/world/raytrace/RayTraceResult.java
@@ -0,0 +1,23 @@
+package me.caseload.knockbacksync.world.raytrace;
+
+import com.github.retrooper.packetevents.protocol.world.BlockFace;
+import com.github.retrooper.packetevents.protocol.world.states.WrappedBlockState;
+import com.github.retrooper.packetevents.util.Vector3d;
+import com.github.retrooper.packetevents.util.Vector3i;
+import lombok.Getter;
+
+@Getter
+public class RayTraceResult {
+ private final Vector3d hitPosition;
+ private final BlockFace blockFace;
+ private final Vector3i hitBlockPosition;
+ private final WrappedBlockState hitBlock;
+
+ public RayTraceResult(Vector3d hitPosition, BlockFace blockFace, Vector3i hitBlockPosition, WrappedBlockState hitBlock) {
+ this.hitPosition = hitPosition;
+ this.blockFace = blockFace;
+ this.hitBlockPosition = hitBlockPosition;
+ this.hitBlock = hitBlock;
+ }
+
+}
\ No newline at end of file
diff --git a/src/main/resources/config.yml b/common/src/main/resources/config.yml
similarity index 73%
rename from src/main/resources/config.yml
rename to common/src/main/resources/config.yml
index 14bae41..8953a49 100644
--- a/src/main/resources/config.yml
+++ b/common/src/main/resources/config.yml
@@ -1,31 +1,41 @@
-#########################################
-# KnockbackSync Configuration #
-#########################################
-
-# Plugin enabled state
-# Toggleable using /knockbacksync toggle
-# Required permission: knockbacksync.toggle
-enabled: true
-
-# Notify staff about update availability
-# Required permission: knockbacksync.update
-notify_updates: true
-
-# Grabs the ping of combat-tagged players every x ticks
-# Disabling this may lead to inaccuracies in calculations
-runnable:
- enabled: true # Runnable enabled state
- interval: 5 # The interval in ticks between sending out pings to players
- combat_timer: 30 # The timer in ticks before being considered out of combat
-
-# The minimum change in ping required for it to be considered a lag spike.
-# If the difference between the latest and previous ping is greater than or equal to
-# the threshold, the previous ping value is used to avoid calculation inaccuracies.
-spike_threshold: 20
-
-enable_message: "&aSuccessfully enabled KnockbackSync."
-disable_message: "&cSuccessfully disabled KnockbackSync."
-player_enable_message: "&aSuccessfully enabled KnockbackSync for %player%."
-player_disable_message: "&cSuccessfully disabled KnockbackSync for %player%."
-player_ineligible_message: "&c%player% is ineligible for KnockbackSync. If you believe this is an error, please open an issue on the github page."
-reload_message: "&aSuccessfully reloaded KnockbackSync config."
\ No newline at end of file
+#########################################
+# KnockbackSync Configuration #
+#########################################
+
+# Plugin enabled state
+# Toggleable using /knockbacksync toggle
+# Required permission: knockbacksync.toggle
+enabled: true
+
+# Notify staff about update availability
+# Required permission: knockbacksync.update
+notify_updates: true
+
+# Grabs the ping of combat-tagged players every x ticks
+# Disabling this may lead to inaccuracies in calculations
+runnable:
+ enabled: true # Runnable enabled state
+ interval: 5 # The interval in ticks between sending out pings to players
+ combat_timer: 30 # The timer in ticks before being considered out of combat
+
+# The minimum change in ping required for it to be considered a lag spike.
+# If the difference between the latest and previous ping is greater than or equal to
+# the threshold, the previous ping value is used to avoid calculation inaccuracies.
+spike_threshold: 20
+
+enable_experimental_offground: false
+
+enable_message: "&aSuccessfully enabled KnockbackSync."
+disable_message: "&cSuccessfully disabled KnockbackSync."
+player_enable_message: "&aSuccessfully enabled KnockbackSync for %player%."
+player_disable_message: "&cSuccessfully disabled KnockbackSync for %player%."
+player_ineligible_message: "&c%player% is ineligible for KnockbackSync. If you believe this is an error, please open an issue on the github page."
+reload_message: "&aSuccessfully reloaded KnockbackSync config."
+global_status_message: "&eGlobal KnockbackSync status: "
+player_status_message: "&e%player%'s KnockbackSync status: "
+player_disabled_global_message: "&cDisabled (Global toggle is off)"
+enable_experimental_offground_message: "&aSuccessfully enabled offground experiment."
+disable_experimental_offground_message: "&cSuccessfully disabled offground experiment."
+
+# Read FAQ!
+ping_offset: 25
\ No newline at end of file
diff --git a/fabric/build.gradle.kts b/fabric/build.gradle.kts
new file mode 100644
index 0000000..d5d52ee
--- /dev/null
+++ b/fabric/build.gradle.kts
@@ -0,0 +1,77 @@
+plugins {
+ id("fabric-loom")
+ id("com.gradleup.shadow")
+}
+
+base {
+ archivesName.set("${rootProject.property("archives_base_name")}-fabric")
+}
+
+val shadeThisThing: Configuration by configurations.creating {
+ isCanBeConsumed = true
+ isTransitive = true
+}
+
+tasks.jar {
+ from(project(":common").sourceSets.named("main").get().output)
+}
+
+dependencies {
+ shadeThisThing(implementation(project(":common"))!!)
+
+ minecraft("com.mojang:minecraft:${rootProject.property("minecraft_version")}")
+ mappings(loom.layered {
+ officialMojangMappings()
+ parchment("org.parchmentmc.data:parchment-1.21:${rootProject.property("parchment_mappings")}")
+ })
+ modImplementation("net.fabricmc:fabric-loader:${rootProject.property("loader_version")}")
+ modImplementation("net.fabricmc.fabric-api:fabric-api:${rootProject.property("fabric_version")}")
+
+ include(modImplementation("me.lucko:fabric-permissions-api:0.3.1")!!)
+ include(modImplementation("com.github.retrooper:packetevents-fabric:2.5.8-SNAPSHOT")!!)
+
+ shadeThisThing(implementation("com.fasterxml.jackson.core:jackson-databind:2.17.2")!!)
+ shadeThisThing(implementation("com.fasterxml.jackson.dataformat:jackson-dataformat-yaml:2.17.2")!!)
+ shadeThisThing(implementation("org.kohsuke:github-api:1.326")!!)
+
+// include(implementation("com.fasterxml.jackson.core:jackson-databind:2.17.2")!!)
+// include(implementation("com.fasterxml.jackson.dataformat:jackson-dataformat-yaml:2.17.2")!!)
+// include(implementation("org.kohsuke:github-api:1.326")!!)
+
+// include(implementation("org.kohsuke:github-api:1.326") {
+// exclude(group = "commons-io", module = "commons-io")
+// exclude(group = "org.apache.commons", module = "commons-lang3")
+// })
+
+ compileOnly("org.geysermc.floodgate:api:2.0-SNAPSHOT")
+ compileOnly("org.projectlombok:lombok:1.18.34")
+ annotationProcessor("org.projectlombok:lombok:1.18.34")
+}
+
+tasks.shadowJar {
+ archiveClassifier.set("dev")
+ configurations = listOf(shadeThisThing)
+ isEnableRelocation = false
+ relocationPrefix = "${project.property("maven_group")}.${project.property("archives_base_name")}.shaded"
+ finalizedBy(tasks.remapJar)
+}
+tasks.remapJar {
+ archiveClassifier.set(null as String?)
+ dependsOn(tasks.shadowJar)
+ inputFile = tasks.shadowJar.get().archiveFile
+}
+
+tasks.processResources {
+ inputs.property("version", project.version)
+ inputs.property("minecraft_version", rootProject.property("minecraft_version"))
+ inputs.property("loader_version", rootProject.property("loader_version"))
+ filteringCharset = "UTF-8"
+
+ filesMatching("fabric.mod.json") {
+ expand(
+ "version" to project.version,
+ "minecraft_version" to rootProject.property("minecraft_version"),
+ "loader_version" to rootProject.property("loader_version")
+ )
+ }
+}
\ No newline at end of file
diff --git a/fabric/src/main/java/me/caseload/knockbacksync/KnockbackSyncFabric.java b/fabric/src/main/java/me/caseload/knockbacksync/KnockbackSyncFabric.java
new file mode 100644
index 0000000..107ea1e
--- /dev/null
+++ b/fabric/src/main/java/me/caseload/knockbacksync/KnockbackSyncFabric.java
@@ -0,0 +1,171 @@
+package me.caseload.knockbacksync;
+
+import com.github.retrooper.packetevents.PacketEvents;
+import io.github.retrooper.packetevents.factory.fabric.FabricPacketEventsBuilder;
+import me.caseload.knockbacksync.command.KnockbackSyncCommand;
+import me.caseload.knockbacksync.listener.fabric.FabricPlayerDamageListener;
+import me.caseload.knockbacksync.listener.fabric.FabricPlayerJoinQuitListener;
+import me.caseload.knockbacksync.listener.fabric.FabricPlayerKnockbackListener;
+import me.caseload.knockbacksync.permission.FabricPermissionChecker;
+import me.caseload.knockbacksync.permission.PermissionChecker;
+import me.caseload.knockbacksync.scheduler.FabricSchedulerAdapter;
+import me.caseload.knockbacksync.stats.custom.FabricStatsManager;
+import me.caseload.knockbacksync.stats.custom.PluginJarHashProvider;
+import me.caseload.knockbacksync.world.FabricServer;
+import net.fabricmc.api.ModInitializer;
+import net.fabricmc.fabric.api.command.v2.CommandRegistrationCallback;
+import net.fabricmc.fabric.api.event.lifecycle.v1.ServerLifecycleEvents;
+import net.fabricmc.loader.api.FabricLoader;
+import net.fabricmc.loader.api.ModContainer;
+import net.fabricmc.loader.api.entrypoint.PreLaunchEntrypoint;
+import net.minecraft.commands.Commands;
+import net.minecraft.server.MinecraftServer;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.nio.file.Files;
+import java.security.MessageDigest;
+import java.util.Optional;
+import java.util.logging.Logger;
+
+public class KnockbackSyncFabric implements PreLaunchEntrypoint, ModInitializer {
+
+// private static MinecraftServer SERVER;
+
+ private final KnockbackSyncBase core = new KnockbackSyncBase() {
+
+ {
+ statsManager = new FabricStatsManager();
+ platformServer = new FabricServer();
+ URL jarUrl = null;
+ Optional modContainer = FabricLoader.getInstance().getModContainer("knockbacksync");
+ if (modContainer.isPresent()) {
+ String jarPath = modContainer.get().getRootPath().getFileSystem().toString();
+ jarPath = jarPath.replaceAll("^jar:", "").replaceAll("!/$", "");
+ try {
+ jarUrl = new File(jarPath).toURI().toURL();
+ } catch (MalformedURLException e) {
+ throw new RuntimeException(e);
+ }
+ }
+ pluginJarHashProvider = new PluginJarHashProvider(jarUrl);
+ }
+
+ private final Logger logger = Logger.getLogger(KnockbackSyncFabric.class.getName());
+ private final FabricPermissionChecker permissionChecker = new FabricPermissionChecker();
+
+ @Override
+ public Logger getLogger() {
+ return logger;
+ }
+
+ @Override
+ public File getDataFolder() {
+ return FabricLoader.getInstance().getConfigDir().toFile();
+ }
+
+ @Override
+ public InputStream getResource(String filename) {
+ return getClass().getResourceAsStream("/config.yml");
+ }
+
+ @Override
+ public void load() {
+ PacketEvents.setAPI(FabricPacketEventsBuilder.build("knockbacksync"));
+ PacketEvents.getAPI().load();
+ }
+
+ @Override
+ public void initializeScheduler() {
+ scheduler = new FabricSchedulerAdapter();
+ }
+
+ @Override
+ protected void registerPlatformListeners() {
+ new FabricPlayerJoinQuitListener().register();
+ new FabricPlayerDamageListener().register();
+ new FabricPlayerKnockbackListener().register();
+ }
+
+ @Override
+ protected void registerCommands() {
+// ServerLifecycleEvents.SERVER_STARTED.register(server -> {
+// CommandDispatcher dispatcher = server.getCommands().getDispatcher();
+// dispatcher.register(KnockbackSyncCommand.build());
+// });
+ CommandRegistrationCallback.EVENT.register((dispatcher, registryAccess, environment) -> {
+ dispatcher.register(KnockbackSyncCommand.build());
+ dispatcher.register(
+ Commands.literal("kbsync")
+ .redirect(dispatcher.getRoot().getChild("knockbacksync")));
+ });
+ }
+
+ @Override
+ protected String getVersion() {
+ return FabricLoader.getInstance().getModContainer("knockbacksync")
+ .map(modContainer -> modContainer.getMetadata().getVersion().getFriendlyString())
+ .orElse("unknown");
+ }
+
+ @Override
+ public void saveDefaultConfig() {
+ File configFile = new File(FabricLoader.getInstance().getConfigDir().toFile(), "config.yml");
+ if (!configFile.exists()) {
+ try (InputStream inputStream = getClass().getResourceAsStream("/config.yml")) {
+ if (inputStream != null) {
+ Files.copy(inputStream, configFile.toPath());
+ }
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
+ }
+
+ @Override
+ public PermissionChecker getPermissionChecker() {
+ return permissionChecker;
+ }
+
+ @Override
+ public void initializePacketEvents() {
+ PacketEvents.getAPI().getSettings()
+ .checkForUpdates(false)
+ .debug(false);
+
+ PacketEvents.getAPI().init();
+ }
+ };
+
+ @Override
+ public void onPreLaunch() {
+ core.load();
+// ServerLifecycleEvents.SERVER_STARTING.register((minecraftServer -> {
+// SERVER = minecraftServer;
+// core.initializeScheduler();
+// core.configManager.loadConfig(false);
+// core.statsManager.init();
+// core.checkForUpdates();
+// }));
+ }
+
+ @Override
+ public void onInitialize() {
+ core.enable();
+ core.initializeScheduler();
+ core.configManager.loadConfig(false);
+ core.statsManager.init();
+ core.checkForUpdates();
+ ServerLifecycleEvents.SERVER_STOPPING.register((server) -> {
+ core.scheduler.shutdown();
+ core.statsManager.getMetrics().shutdown();
+ });
+ }
+
+ public static MinecraftServer getServer() {
+ return (MinecraftServer) FabricLoader.getInstance().getGameInstance();
+ }
+}
diff --git a/fabric/src/main/java/me/caseload/knockbacksync/callback/PlayerVelocityCallback.java b/fabric/src/main/java/me/caseload/knockbacksync/callback/PlayerVelocityCallback.java
new file mode 100644
index 0000000..179b550
--- /dev/null
+++ b/fabric/src/main/java/me/caseload/knockbacksync/callback/PlayerVelocityCallback.java
@@ -0,0 +1,24 @@
+package me.caseload.knockbacksync.callback;
+
+import net.fabricmc.fabric.api.event.Event;
+import net.fabricmc.fabric.api.event.EventFactory;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.InteractionResult;
+import net.minecraft.world.phys.Vec3;
+
+public interface PlayerVelocityCallback {
+ Event EVENT = EventFactory.createArrayBacked(PlayerVelocityCallback.class,
+ (listeners) -> (player, velocity) -> {
+ for (PlayerVelocityCallback listener : listeners) {
+ InteractionResult result = listener.onVelocityChange(player, velocity);
+
+ if (result != InteractionResult.PASS) {
+ return result;
+ }
+ }
+
+ return InteractionResult.PASS;
+ });
+
+ InteractionResult onVelocityChange(ServerPlayer player, Vec3 velocity);
+}
\ No newline at end of file
diff --git a/fabric/src/main/java/me/caseload/knockbacksync/listener/fabric/FabricPlayerDamageListener.java b/fabric/src/main/java/me/caseload/knockbacksync/listener/fabric/FabricPlayerDamageListener.java
new file mode 100644
index 0000000..d961969
--- /dev/null
+++ b/fabric/src/main/java/me/caseload/knockbacksync/listener/fabric/FabricPlayerDamageListener.java
@@ -0,0 +1,41 @@
+package me.caseload.knockbacksync.listener.fabric;
+
+
+import me.caseload.knockbacksync.listener.PlayerDamageListener;
+import me.caseload.knockbacksync.player.FabricPlayer;
+import me.caseload.knockbacksync.player.PlatformPlayer;
+import net.fabricmc.fabric.api.event.player.AttackEntityCallback;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.InteractionResult;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.player.Player;
+
+public class FabricPlayerDamageListener extends PlayerDamageListener {
+
+ public void register() {
+ AttackEntityCallback.EVENT.register((player, world, hand, entity, source) -> {
+ onPlayerDamage((ServerPlayer) player, entity);
+ return InteractionResult.PASS;
+ });
+
+ // Sending ping packets on tick if runnable is disabled
+// ServerTickEvents.END_SERVER_TICK.register(server -> {
+// if (!KnockbackSyncBase.INSTANCE.getConfigManager().isRunnableEnabled()) {
+// for (ServerPlayerEntity player : server.getPlayerList()) {
+// PlayerData playerData = PlayerDataManager.getPlayerData(player);
+// if (playerData != null) {
+// playerData.sendPing();
+// }
+// }
+// }
+// });
+ }
+
+ private void onPlayerDamage(ServerPlayer attacker, Entity victimEntity) {
+ if (victimEntity instanceof Player victim) {
+ PlatformPlayer platformAttacker = new FabricPlayer(attacker);
+ PlatformPlayer platformVictim = new FabricPlayer((ServerPlayer) victim);
+ super.onPlayerDamage(platformVictim, platformAttacker); // Call the shared method
+ }
+ }
+}
\ No newline at end of file
diff --git a/fabric/src/main/java/me/caseload/knockbacksync/listener/fabric/FabricPlayerJoinQuitListener.java b/fabric/src/main/java/me/caseload/knockbacksync/listener/fabric/FabricPlayerJoinQuitListener.java
new file mode 100644
index 0000000..5201878
--- /dev/null
+++ b/fabric/src/main/java/me/caseload/knockbacksync/listener/fabric/FabricPlayerJoinQuitListener.java
@@ -0,0 +1,17 @@
+package me.caseload.knockbacksync.listener.fabric;
+
+import me.caseload.knockbacksync.listener.PlayerJoinQuitListener;
+import me.caseload.knockbacksync.manager.PlayerData;
+import me.caseload.knockbacksync.player.FabricPlayer;
+import net.fabricmc.fabric.api.networking.v1.ServerPlayConnectionEvents;
+
+public class FabricPlayerJoinQuitListener extends PlayerJoinQuitListener {
+ public void register() {
+ ServerPlayConnectionEvents.JOIN.register((handler, sender, server) -> {
+ onPlayerJoin(new PlayerData(new FabricPlayer(handler.player)));
+ });
+ ServerPlayConnectionEvents.DISCONNECT.register(((handler, server) -> {
+ onPlayerQuit(handler.player.getUUID());
+ }));
+ }
+}
diff --git a/fabric/src/main/java/me/caseload/knockbacksync/listener/fabric/FabricPlayerKnockbackListener.java b/fabric/src/main/java/me/caseload/knockbacksync/listener/fabric/FabricPlayerKnockbackListener.java
new file mode 100644
index 0000000..cd5dd1b
--- /dev/null
+++ b/fabric/src/main/java/me/caseload/knockbacksync/listener/fabric/FabricPlayerKnockbackListener.java
@@ -0,0 +1,33 @@
+package me.caseload.knockbacksync.listener.fabric;
+
+import com.github.retrooper.packetevents.util.Vector3d;
+import me.caseload.knockbacksync.callback.PlayerVelocityCallback;
+import me.caseload.knockbacksync.listener.PlayerKnockbackListener;
+import me.caseload.knockbacksync.player.FabricPlayer;
+import net.minecraft.world.InteractionResult;
+import net.minecraft.world.damagesource.DamageSource;
+import net.minecraft.world.damagesource.DamageSources;
+import net.minecraft.world.damagesource.DamageTypes;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.player.Player;
+
+public class FabricPlayerKnockbackListener extends PlayerKnockbackListener {
+
+ public void register() {
+ PlayerVelocityCallback.EVENT.register((player, velocity) -> {
+ DamageSource lastDamageSource = player.getLastDamageSource();
+ if (lastDamageSource == null)
+ return InteractionResult.PASS;
+
+ // Check if the damage is from a player attack
+ if (!lastDamageSource.is(DamageTypes.PLAYER_ATTACK))
+ return InteractionResult.PASS;
+
+ onPlayerVelocity(new FabricPlayer(player), new Vector3d(velocity.x, velocity.y, velocity.z));
+ // This SHOULD mean we return original velocity for Fabric (no modification here)
+ // But since we set it ourselves due to following bukkit's design patterns and doing victim
+ // We return a pass so velocity isn't set twice
+ return InteractionResult.PASS;
+ });
+ }
+}
\ No newline at end of file
diff --git a/fabric/src/main/java/me/caseload/knockbacksync/mixin/PlayerMixin.java b/fabric/src/main/java/me/caseload/knockbacksync/mixin/PlayerMixin.java
new file mode 100644
index 0000000..03adc35
--- /dev/null
+++ b/fabric/src/main/java/me/caseload/knockbacksync/mixin/PlayerMixin.java
@@ -0,0 +1,37 @@
+package me.caseload.knockbacksync.mixin;
+
+import me.caseload.knockbacksync.callback.PlayerVelocityCallback;
+import net.minecraft.network.protocol.game.ClientboundSetEntityMotionPacket;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.InteractionResult;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.phys.Vec3;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+@Mixin(Player.class)
+public class PlayerMixin {
+
+ @Inject(method = "attack", at = @At(value = "INVOKE", target = "Lnet/minecraft/network/protocol/game/ClientboundSetEntityMotionPacket;(Lnet/minecraft/world/entity/Entity;)V"), cancellable = true)
+ private void onAttack(Entity target, CallbackInfo ci) {
+ if (target instanceof ServerPlayer serverPlayer && target.hurtMarked) {
+ Vec3 velocity = target.getDeltaMovement();
+
+ InteractionResult result = PlayerVelocityCallback.EVENT.invoker().onVelocityChange(serverPlayer, velocity);
+
+ if (result == InteractionResult.FAIL) {
+ target.hurtMarked = false;
+ ci.cancel(); // Prevent sending the velocity packet
+ } else if (result == InteractionResult.SUCCESS) {
+ // Currently unnecessary since we do this in the handler, will move later
+ target.setDeltaMovement(velocity);
+ serverPlayer.connection.send(new ClientboundSetEntityMotionPacket(target));
+ target.hurtMarked = false;
+ ci.cancel(); // Prevent sending the original velocity packet
+ }
+ }
+ }
+}
diff --git a/fabric/src/main/java/me/caseload/knockbacksync/mixin/ServerEntityMixin.java b/fabric/src/main/java/me/caseload/knockbacksync/mixin/ServerEntityMixin.java
new file mode 100644
index 0000000..e1e3f4c
--- /dev/null
+++ b/fabric/src/main/java/me/caseload/knockbacksync/mixin/ServerEntityMixin.java
@@ -0,0 +1,40 @@
+package me.caseload.knockbacksync.mixin;
+
+import me.caseload.knockbacksync.callback.PlayerVelocityCallback;
+import net.minecraft.server.level.ServerEntity;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.InteractionResult;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.phys.Vec3;
+import org.spongepowered.asm.mixin.Final;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+@Mixin(ServerEntity.class)
+public class ServerEntityMixin {
+
+
+ @Shadow @Final
+ private Entity entity;
+
+ @Inject(method = "sendChanges", at = @At(value = "FIELD", target = "Lnet/minecraft/world/entity/Entity;hurtMarked:Z", ordinal = 1))
+ private void onSendChanges(CallbackInfo ci) {
+ if (this.entity.hurtMarked && this.entity instanceof ServerPlayer) {
+ ServerPlayer player = (ServerPlayer) this.entity;
+ Vec3 velocity = player.getDeltaMovement();
+
+ InteractionResult result = PlayerVelocityCallback.EVENT.invoker().onVelocityChange(player, velocity);
+
+ if (result == InteractionResult.FAIL) {
+ this.entity.hurtMarked = false;
+ ci.cancel();
+ } else if (result == InteractionResult.SUCCESS) {
+ // Currently unnecessary since we do this in the handler, will move later
+ player.setDeltaMovement(velocity);
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/fabric/src/main/java/me/caseload/knockbacksync/permission/FabricPermissionChecker.java b/fabric/src/main/java/me/caseload/knockbacksync/permission/FabricPermissionChecker.java
new file mode 100644
index 0000000..7f464e1
--- /dev/null
+++ b/fabric/src/main/java/me/caseload/knockbacksync/permission/FabricPermissionChecker.java
@@ -0,0 +1,18 @@
+package me.caseload.knockbacksync.permission;
+
+import me.caseload.knockbacksync.player.FabricPlayer;
+import me.caseload.knockbacksync.player.PlatformPlayer;
+import me.lucko.fabric.api.permissions.v0.Permissions;
+import net.minecraft.commands.CommandSourceStack;
+
+public class FabricPermissionChecker implements PermissionChecker {
+ @Override
+ public boolean hasPermission(CommandSourceStack source, String s, boolean defaultIfUnset) {
+ return Permissions.check(source, s, defaultIfUnset);
+ }
+
+ @Override
+ public boolean hasPermission(PlatformPlayer platformPlayer, String s) {
+ return Permissions.check(((FabricPlayer) platformPlayer).fabricPlayer, s);
+ }
+}
diff --git a/fabric/src/main/java/me/caseload/knockbacksync/player/FabricPlayer.java b/fabric/src/main/java/me/caseload/knockbacksync/player/FabricPlayer.java
new file mode 100644
index 0000000..f5f8af4
--- /dev/null
+++ b/fabric/src/main/java/me/caseload/knockbacksync/player/FabricPlayer.java
@@ -0,0 +1,129 @@
+package me.caseload.knockbacksync.player;
+
+import com.github.retrooper.packetevents.util.Vector3d;
+import me.caseload.knockbacksync.world.FabricWorld;
+import me.caseload.knockbacksync.world.PlatformWorld;
+import net.minecraft.core.Holder;
+import net.minecraft.core.registries.Registries;
+import net.minecraft.data.registries.VanillaRegistries;
+import net.minecraft.network.chat.Component;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.item.enchantment.Enchantment;
+import net.minecraft.world.item.enchantment.EnchantmentHelper;
+import net.minecraft.world.item.enchantment.Enchantments;
+import net.minecraft.world.phys.Vec3;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Optional;
+import java.util.UUID;
+
+public class FabricPlayer implements PlatformPlayer {
+ public final ServerPlayer fabricPlayer;
+
+ public FabricPlayer(ServerPlayer player) {
+ this.fabricPlayer = player;
+ }
+
+ @Override
+ public UUID getUUID() {
+ return fabricPlayer.getUUID();
+ }
+
+ @Override
+ public String getName() {
+ return fabricPlayer.getName().toString();
+ }
+
+ @Override
+ public double getX() {
+ return fabricPlayer.getX();
+ }
+
+ @Override
+ public double getY() {
+ return fabricPlayer.getY();
+ }
+
+ @Override
+ public double getZ() {
+ return fabricPlayer.getZ();
+ }
+
+ @Override
+ public float getPitch() {
+ return fabricPlayer.getXRot();
+ }
+
+ @Override
+ public float getYaw() {
+ return fabricPlayer.getYRot();
+ }
+
+ @Override
+ public boolean isOnGround() {
+ return fabricPlayer.onGround();
+ }
+
+ @Override
+ public int getPing() {
+ return fabricPlayer.connection.latency();
+ }
+
+ @Override
+ public boolean isGliding() {
+ return fabricPlayer.isFallFlying();
+ }
+
+ @Override
+ public PlatformWorld getWorld() {
+ return new FabricWorld(fabricPlayer.level());
+ }
+
+ @Override
+ public Vector3d getLocation() {
+ Vec3 pos = fabricPlayer.position();
+ return new Vector3d(pos.x, pos.y, pos.z);
+ }
+
+ @Override
+ public void sendMessage(@NotNull String s) {
+ fabricPlayer.sendSystemMessage(Component.literal(s));
+ }
+
+ @Override
+ public double getAttackCooldown() {
+ // this is what paper does I have no idea how this works
+ return fabricPlayer.getAttackStrengthScale(0.5f);
+ }
+
+ @Override
+ public boolean isSprinting() {
+ return fabricPlayer.isSprinting();
+ }
+
+ @Override
+ public int getMainHandKnockbackLevel() {
+ Optional>
+ entry = VanillaRegistries.createLookup().asGetterLookup().get(
+ Registries.ENCHANTMENT, Enchantments.KNOCKBACK
+ );
+ Holder registryEntry1 = entry.orElseThrow(); // Reference implements RegistryEntry, this is fine
+ return EnchantmentHelper.getItemEnchantmentLevel(registryEntry1, fabricPlayer.getMainHandItem());
+ }
+
+ @Override
+ public @Nullable Integer getNoDamageTicks() {
+ return fabricPlayer.invulnerableTime;
+ }
+
+ @Override
+ public void setVelocity(Vector3d adjustedVelocity) {
+ fabricPlayer.setDeltaMovement(adjustedVelocity.x, adjustedVelocity.y, adjustedVelocity.z);
+ // TODO
+ // fix paper-ism? for some reason setVelocity() in paper marks the entity as hurt marked every time its called?
+ fabricPlayer.hurtMarked = true;
+ }
+
+ // Implement other methods
+}
diff --git a/fabric/src/main/java/me/caseload/knockbacksync/scheduler/FabricSchedulerAdapter.java b/fabric/src/main/java/me/caseload/knockbacksync/scheduler/FabricSchedulerAdapter.java
new file mode 100644
index 0000000..1c39a2b
--- /dev/null
+++ b/fabric/src/main/java/me/caseload/knockbacksync/scheduler/FabricSchedulerAdapter.java
@@ -0,0 +1,145 @@
+package me.caseload.knockbacksync.scheduler;
+
+import me.caseload.knockbacksync.KnockbackSyncBase;
+import me.caseload.knockbacksync.KnockbackSyncFabric;
+import net.fabricmc.fabric.api.event.lifecycle.v1.ServerTickEvents;
+import net.minecraft.server.MinecraftServer;
+
+import java.util.*;
+
+public class FabricSchedulerAdapter implements SchedulerAdapter {
+// private final MinecraftServer server;
+ private final Map taskMap = new HashMap<>();
+ private final Map asyncTasks = new HashMap<>();
+
+ public FabricSchedulerAdapter() {
+ ServerTickEvents.END_SERVER_TICK.register(this::handleTasks);
+ }
+
+ private void handleTasks(MinecraftServer server) {
+ Iterator iterator = taskMap.keySet().iterator();
+ while (iterator.hasNext()) {
+ ScheduledTask task = iterator.next();
+ if (server.getTickCount() >= task.nextRunTick) {
+ task.task.run();
+ if (task.isPeriodic) {
+ task.nextRunTick = server.getTickCount() + task.period;
+ } else {
+ iterator.remove();
+ }
+ }
+ }
+ }
+
+ @Override
+ public AbstractTaskHandle runTask(Runnable task) {
+ ScheduledTask scheduledTask = new ScheduledTask(task, KnockbackSyncFabric.getServer().getTickCount(), 0, false);
+ Runnable cancellationTask = () -> taskMap.remove(scheduledTask);
+ taskMap.put(scheduledTask, cancellationTask);
+ return new FabricTaskHandle(cancellationTask);
+ }
+
+ @Override
+ public AbstractTaskHandle runTaskAsynchronously(Runnable task) {
+ Thread thread = new Thread(task);
+ Runnable cancellationTask = () -> {
+ thread.interrupt();
+ asyncTasks.remove(thread);
+ };
+ asyncTasks.put(thread, cancellationTask);
+ thread.start();
+ return new FabricTaskHandle(cancellationTask);
+ }
+
+ @Override
+ public AbstractTaskHandle runTaskLater(Runnable task, long delayTicks) {
+ ScheduledTask scheduledTask = new ScheduledTask(task, KnockbackSyncFabric.getServer().getTickCount() + delayTicks, 0, false);
+ Runnable cancellationTask = () -> taskMap.remove(scheduledTask);
+ taskMap.put(scheduledTask, cancellationTask);
+ return new FabricTaskHandle(cancellationTask);
+ }
+
+ @Override
+ public AbstractTaskHandle runTaskTimer(Runnable task, long delayTicks, long periodTicks) {
+ ScheduledTask scheduledTask = new ScheduledTask(task, KnockbackSyncFabric.getServer().getTickCount() + delayTicks, periodTicks, true);
+ Runnable cancellationTask = () -> taskMap.remove(scheduledTask);
+ taskMap.put(scheduledTask, cancellationTask);
+ return new FabricTaskHandle(cancellationTask);
+ }
+
+ @Override
+ public AbstractTaskHandle runTaskLaterAsynchronously(Runnable task, long delay) {
+ Thread thread = new Thread(() -> {
+ try {
+ Thread.sleep(delay * 50); // Convert ticks to milliseconds
+ task.run();
+ } catch (InterruptedException e) {
+ // Handle interruption
+ }
+ });
+ Runnable cancellationTask = () -> {
+ thread.interrupt();
+ asyncTasks.remove(thread);
+ };
+ asyncTasks.put(thread, cancellationTask);
+ thread.start();
+ return new FabricTaskHandle(cancellationTask);
+ }
+
+ @Override
+ public AbstractTaskHandle runTaskTimerAsynchronously(Runnable task, long delay, long period) {
+ Thread thread = new Thread(() -> {
+ try {
+ Thread.sleep(delay * 50); // Convert ticks to milliseconds
+ while (!Thread.currentThread().isInterrupted()) {
+ task.run();
+ Thread.sleep(period * 50); // Convert ticks to milliseconds
+ }
+ } catch (InterruptedException e) {
+ // Handle interruption
+ }
+ });
+ Runnable cancellationTask = () -> {
+ thread.interrupt();
+ asyncTasks.remove(thread);
+ };
+ asyncTasks.put(thread, cancellationTask);
+ thread.start();
+ return new FabricTaskHandle(cancellationTask);
+ }
+
+ @Override
+ public void shutdown() {
+ // Create a new list to store the tasks that need to be executed
+ List tasksToExecute = new ArrayList<>();
+
+ // Add the tasks from the taskMap to the tasksToExecute list
+ tasksToExecute.addAll(taskMap.values());
+
+ // Add the tasks from the asyncTasks to the tasksToExecute list
+ tasksToExecute.addAll(asyncTasks.values());
+
+ // Clear the taskMap and asyncTasks to avoid further modifications
+ taskMap.clear();
+ asyncTasks.clear();
+
+ // Execute the tasks in the tasksToExecute list
+ for (Runnable task : tasksToExecute) {
+ task.run();
+ }
+ }
+
+ private static class ScheduledTask {
+ final Runnable task;
+ long nextRunTick;
+ final long period;
+ final boolean isPeriodic;
+
+ ScheduledTask(Runnable task, long nextRunTick, long period, boolean isPeriodic) {
+ this.task = task;
+ this.nextRunTick = nextRunTick;
+ this.period = period;
+ this.isPeriodic = isPeriodic;
+ }
+ }
+}
\ No newline at end of file
diff --git a/fabric/src/main/java/me/caseload/knockbacksync/scheduler/FabricTaskHandle.java b/fabric/src/main/java/me/caseload/knockbacksync/scheduler/FabricTaskHandle.java
new file mode 100644
index 0000000..f004e57
--- /dev/null
+++ b/fabric/src/main/java/me/caseload/knockbacksync/scheduler/FabricTaskHandle.java
@@ -0,0 +1,21 @@
+package me.caseload.knockbacksync.scheduler;
+
+public class FabricTaskHandle implements AbstractTaskHandle {
+ private Runnable cancellationTask;
+ private boolean cancelled = false;
+
+ public FabricTaskHandle(Runnable cancellationTask) {
+ this.cancellationTask = cancellationTask;
+ }
+
+ @Override
+ public boolean getCancelled() {
+ return this.cancelled;
+ }
+
+ @Override
+ public void cancel() {
+ this.cancellationTask.run();
+ this.cancelled = true;
+ }
+}
diff --git a/fabric/src/main/java/me/caseload/knockbacksync/stats/custom/FabricStatsManager.java b/fabric/src/main/java/me/caseload/knockbacksync/stats/custom/FabricStatsManager.java
new file mode 100644
index 0000000..5b3ea4d
--- /dev/null
+++ b/fabric/src/main/java/me/caseload/knockbacksync/stats/custom/FabricStatsManager.java
@@ -0,0 +1,16 @@
+package me.caseload.knockbacksync.stats.custom;
+
+import me.caseload.knockbacksync.KnockbackSyncBase;
+
+public class FabricStatsManager extends StatsManager {
+ @Override
+ public void init() {
+ KnockbackSyncBase.INSTANCE.getScheduler().runTaskAsynchronously(() -> {
+ BuildTypePie.determineBuildType(); // Function to calculate hash
+ MetricsFabric metrics = new MetricsFabric(23568);
+ metrics.addCustomChart(new PlayerVersionsPie());
+ metrics.addCustomChart(new BuildTypePie());
+ super.metrics = metrics;
+ });
+ }
+}
diff --git a/fabric/src/main/java/me/caseload/knockbacksync/stats/custom/MetricsFabric.java b/fabric/src/main/java/me/caseload/knockbacksync/stats/custom/MetricsFabric.java
new file mode 100644
index 0000000..b0b33d9
--- /dev/null
+++ b/fabric/src/main/java/me/caseload/knockbacksync/stats/custom/MetricsFabric.java
@@ -0,0 +1,149 @@
+package me.caseload.knockbacksync.stats.custom;
+
+/*
+ * This Metrics class was auto-generated and can be copied into your project if you are
+ * not using a build tool like Gradle or Maven for dependency management.
+ *
+ * IMPORTANT: You are not allowed to modify this class, except changing the package.
+ *
+ * Disallowed modifications include but are not limited to:
+ * - Remove the option for users to opt-out
+ * - Change the frequency for data submission
+ * - Obfuscate the code (every obfuscator should allow you to make an exception for specific files)
+ * - Reformat the code (if you use a linter, add an exception)
+ *
+ * Violations will result in a ban of your plugin and account from bStats.
+ */
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.dataformat.yaml.YAMLFactory;
+import me.caseload.knockbacksync.KnockbackSyncBase;
+import me.caseload.knockbacksync.KnockbackSyncFabric;
+import me.caseload.knockbacksync.stats.CustomChart;
+import me.caseload.knockbacksync.stats.JsonObjectBuilder;
+import net.fabricmc.loader.api.FabricLoader;
+import net.minecraft.server.MinecraftServer;
+
+import java.io.*;
+import java.util.UUID;
+import java.util.logging.Level;
+
+public class MetricsFabric implements Metrics {
+
+ private final MetricsBase metricsBase;
+
+ private static class Config {
+ public boolean enabled = true;
+ public String serverUuid;
+ public boolean logFailedRequests = false;
+ public boolean logSentData = false;
+ public boolean logResponseStatusText = false;
+ }
+
+ /**
+ * Creates a new Metrics instance.
+ *
+ * @param serviceId The id of the service. It can be found at What is my plugin id?
+ */
+ public MetricsFabric(int serviceId) {
+ // Get the config file
+ File bStatsFolder = new File(FabricLoader.getInstance().getConfigDir().toString(), "bStats");
+ File configFile = new File(bStatsFolder, "config.yml");
+ ObjectMapper mapper = new ObjectMapper(new YAMLFactory());
+ Config config;
+
+ try {
+ if (!configFile.exists()) {
+ bStatsFolder.mkdirs(); // Ensure the directory exists
+
+ config = new Config();
+ config.serverUuid = UUID.randomUUID().toString();
+
+ // Add header as a comment
+// mapper.writeValue(configFile,
+// "# bStats (https://bStats.org) collects some basic information for plugin authors, like how\n"
+// + "# many people use their plugin and their total player count. It's recommended to keep bStats\n"
+// + "# enabled, but if you're not comfortable with this, you can turn this setting off. There is no\n"
+// + "# performance penalty associated with having metrics enabled, and data sent to bStats is fully\n"
+// + "# anonymous.\n");
+ mapper.writeValue(configFile, config); // Write the config object as YAML
+ } else {
+ config = mapper.readValue(configFile, Config.class);
+ }
+ } catch (IOException ignored) {
+ // Handle the exception appropriately (e.g., log an error)
+ config = new Config(); // Fallback to default values
+ config.serverUuid = UUID.randomUUID().toString();
+ }
+
+ // Load the data
+ boolean enabled = config.enabled;
+ String serverUUID = config.serverUuid;
+ boolean logErrors = config.logFailedRequests;
+ boolean logSentData = config.logSentData;
+ boolean logResponseStatusText = config.logResponseStatusText;
+
+ metricsBase =
+ new // See https://github.com/Bastian/bstats-metrics/pull/126
+ // See https://github.com/Bastian/bstats-metrics/pull/126
+ // See https://github.com/Bastian/bstats-metrics/pull/126
+ // See https://github.com/Bastian/bstats-metrics/pull/126
+ // See https://github.com/Bastian/bstats-metrics/pull/126
+ // See https://github.com/Bastian/bstats-metrics/pull/126
+ // See https://github.com/Bastian/bstats-metrics/pull/126
+ MetricsBase(
+ "fabric",
+ serverUUID,
+ serviceId,
+ enabled,
+ this::appendPlatformData,
+ this::appendServiceData,
+ submitDataTask -> KnockbackSyncBase.INSTANCE.getScheduler().runTask(submitDataTask),
+ () -> true,
+ (message, error) -> KnockbackSyncBase.INSTANCE.getLogger().log(Level.WARNING, message, error),
+ (message) -> KnockbackSyncBase.INSTANCE.getLogger().log(Level.INFO, message),
+ logErrors,
+ logSentData,
+ logResponseStatusText,
+ false);
+ }
+
+ /** Shuts down the underlying scheduler service. */
+ public void shutdown() {
+ metricsBase.shutdown();
+ }
+
+ /**
+ * Adds a custom chart.
+ *
+ * @param chart The chart to add.
+ */
+ public void addCustomChart(CustomChart chart) {
+ metricsBase.addCustomChart(chart);
+ }
+
+ private void appendPlatformData(JsonObjectBuilder builder) {
+ builder.appendField("playerAmount", getPlayerAmount());
+ builder.appendField("onlineMode", KnockbackSyncFabric.getServer().usesAuthentication() ? 0 : 1);
+ builder.appendField("bukkitVersion", "Fabric " + FabricLoader.getInstance().getModContainer("fabricloader").get().getMetadata().getVersion().getFriendlyString() + " (MC: " + KnockbackSyncFabric.getServer().getServerVersion() + ")");
+ builder.appendField("bukkitName", "Fabric");
+ builder.appendField("javaVersion", System.getProperty("java.version"));
+ builder.appendField("osName", System.getProperty("os.name"));
+ builder.appendField("osArch", System.getProperty("os.arch"));
+ builder.appendField("osVersion", System.getProperty("os.version"));
+ builder.appendField("coreCount", Runtime.getRuntime().availableProcessors());
+ }
+
+ private void appendServiceData(JsonObjectBuilder builder) {
+ builder.appendField("pluginVersion", FabricLoader.getInstance().getModContainer("knockbacksync").get().getMetadata().getVersion().getFriendlyString());
+ }
+
+ private int getPlayerAmount() {
+ if (KnockbackSyncFabric.getServer().isRunning()) {
+ return KnockbackSyncFabric.getServer().getPlayerCount();
+ } else {
+ return 0;
+ }
+ }
+}
diff --git a/fabric/src/main/java/me/caseload/knockbacksync/world/FabricServer.java b/fabric/src/main/java/me/caseload/knockbacksync/world/FabricServer.java
new file mode 100644
index 0000000..6eec2f8
--- /dev/null
+++ b/fabric/src/main/java/me/caseload/knockbacksync/world/FabricServer.java
@@ -0,0 +1,23 @@
+package me.caseload.knockbacksync.world;
+
+import me.caseload.knockbacksync.KnockbackSyncFabric;
+import me.caseload.knockbacksync.player.FabricPlayer;
+import me.caseload.knockbacksync.player.PlatformPlayer;
+
+import java.util.Collection;
+import java.util.UUID;
+import java.util.stream.Collectors;
+
+public class FabricServer implements PlatformServer {
+ public Collection getOnlinePlayers() {
+ return KnockbackSyncFabric.getServer().getPlayerList().getPlayers().stream()
+ .map(FabricPlayer::new)
+ .collect(Collectors.toList());
+ }
+
+ @Override
+ public PlatformPlayer getPlayer(UUID uuid) {
+ return new FabricPlayer(KnockbackSyncFabric.getServer().getPlayerList().getPlayer(uuid));
+ }
+
+}
diff --git a/fabric/src/main/java/me/caseload/knockbacksync/world/FabricWorld.java b/fabric/src/main/java/me/caseload/knockbacksync/world/FabricWorld.java
new file mode 100644
index 0000000..e7d2b16
--- /dev/null
+++ b/fabric/src/main/java/me/caseload/knockbacksync/world/FabricWorld.java
@@ -0,0 +1,61 @@
+package me.caseload.knockbacksync.world;
+
+import com.github.retrooper.packetevents.protocol.world.BlockFace;
+import com.github.retrooper.packetevents.protocol.world.states.WrappedBlockState;
+import com.github.retrooper.packetevents.util.Vector3d;
+import com.github.retrooper.packetevents.util.Vector3i;
+import me.caseload.knockbacksync.world.raytrace.FluidHandling;
+import me.caseload.knockbacksync.world.raytrace.RayTraceResult;
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.level.ClipContext;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.phys.BlockHitResult;
+import net.minecraft.world.phys.HitResult;
+import net.minecraft.world.phys.Vec3;
+
+public class FabricWorld implements PlatformWorld {
+ private final Level world;
+
+ public FabricWorld(Level world) {
+ this.world = world;
+ }
+
+ @Override
+ public WrappedBlockState getBlockStateAt(int x, int y, int z) {
+ BlockState blockState = this.world.getBlockState(new BlockPos(x, y, z));
+ return WrappedBlockState.getByString(blockState.getBlock().getName().toString());
+ }
+
+ @Override
+ public WrappedBlockState getBlockStateAt(Vector3d loc) {
+ return getBlockStateAt((int) Math.floor(loc.x), (int) Math.floor(loc.x), (int) Math.floor(loc.x));
+ }
+
+ @Override
+ public RayTraceResult rayTraceBlocks(Vector3d start, Vector3d direction, double maxDistance, FluidHandling fluidHandling, boolean ignorePassableBlocks) {
+ Vec3 startVec = new Vec3(start.getX(), start.getY(), start.getZ());
+ Vec3 endVec = startVec.add(direction.getX() * maxDistance, direction.getY() * maxDistance, direction.getZ() * maxDistance);
+
+ BlockHitResult result = world.clip(new ClipContext(
+ startVec,
+ endVec,
+ ClipContext.Block.OUTLINE,
+ fluidHandling == FluidHandling.NONE ? ClipContext.Fluid.NONE :
+ fluidHandling == FluidHandling.SOURCE_ONLY ? ClipContext.Fluid.SOURCE_ONLY :
+ ClipContext.Fluid.ANY,
+ (Entity) null
+ ));
+
+ if (result.getType() == HitResult.Type.MISS) return null;
+
+ BlockPos blockPos = result.getBlockPos();
+ return new RayTraceResult(
+ new Vector3d(result.getLocation().x, result.getLocation().y, result.getLocation().z),
+ BlockFace.getBlockFaceByValue(result.getDirection().ordinal()),
+ new Vector3i(result.getBlockPos().getX(), result.getBlockPos().getY(), result.getBlockPos().getZ()),
+ WrappedBlockState.getByString(world.getBlockState(blockPos).getBlock().toString())
+ );
+ }
+}
\ No newline at end of file
diff --git a/fabric/src/main/resources/fabric.mod.json b/fabric/src/main/resources/fabric.mod.json
new file mode 100644
index 0000000..74f0154
--- /dev/null
+++ b/fabric/src/main/resources/fabric.mod.json
@@ -0,0 +1,25 @@
+{
+ "schemaVersion": 1,
+ "id": "knockbacksync",
+ "version": "${version}",
+ "name": "Knockback Sync",
+ "description": "",
+ "authors": [],
+ "contact": {},
+ "license": "All-Rights-Reserved",
+ "icon": "assets/knockbacksync/icon.png",
+ "environment": "*",
+ "entrypoints": {
+ "main": [
+ "me.caseload.knockbacksync.KnockbackSyncFabric"
+ ]
+ },
+ "mixins": [
+ "knockbacksync.mixins.json"
+ ],
+ "depends": {
+ "fabricloader": ">=${loader_version}",
+ "fabric": "*",
+ "minecraft": "~${minecraft_version}"
+ }
+}
diff --git a/fabric/src/main/resources/knockbacksync.mixins.json b/fabric/src/main/resources/knockbacksync.mixins.json
new file mode 100644
index 0000000..c52225a
--- /dev/null
+++ b/fabric/src/main/resources/knockbacksync.mixins.json
@@ -0,0 +1,13 @@
+{
+ "required": true,
+ "minVersion": "0.8",
+ "package": "me.caseload.knockbacksync.mixin",
+ "compatibilityLevel": "JAVA_21",
+ "mixins": [
+ "PlayerMixin",
+ "ServerEntityMixin"
+ ],
+ "injectors": {
+ "defaultRequire": 1
+ }
+}
diff --git a/gradle.properties b/gradle.properties
new file mode 100644
index 0000000..581251b
--- /dev/null
+++ b/gradle.properties
@@ -0,0 +1,20 @@
+# Gradle Properties
+org.gradle.jvmargs=-Xmx3G
+org.gradle.parallel=true
+
+# Fabric Properties
+# check these on https://modmuss50.me/fabric.html
+minecraft_version=1.21
+parchment_mappings=2024.07.28
+parchment_minecraft_version=1.21
+yarn_mappings=1.21+build.9
+loader_version=0.15.11
+
+# Mod Properties
+mod_version=1.3.3-dev-axionize-b23
+maven_group=me.caseload
+archives_base_name=knockbacksync
+
+# Dependencies
+# check this on https://modmuss50.me/fabric.html
+fabric_version=0.102.0+1.21
diff --git a/gradlew b/gradlew
new file mode 100755
index 0000000..b740cf1
--- /dev/null
+++ b/gradlew
@@ -0,0 +1,249 @@
+#!/bin/sh
+
+#
+# Copyright © 2015-2021 the original authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+##############################################################################
+#
+# Gradle start up script for POSIX generated by Gradle.
+#
+# Important for running:
+#
+# (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+# noncompliant, but you have some other compliant shell such as ksh or
+# bash, then to run this script, type that shell name before the whole
+# command line, like:
+#
+# ksh Gradle
+#
+# Busybox and similar reduced shells will NOT work, because this script
+# requires all of these POSIX shell features:
+# * functions;
+# * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+# «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+# * compound commands having a testable exit status, especially «case»;
+# * various built-in commands including «command», «set», and «ulimit».
+#
+# Important for patching:
+#
+# (2) This script targets any POSIX shell, so it avoids extensions provided
+# by Bash, Ksh, etc; in particular arrays are avoided.
+#
+# The "traditional" practice of packing multiple parameters into a
+# space-separated string is a well documented source of bugs and security
+# problems, so this is (mostly) avoided, by progressively accumulating
+# options in "$@", and eventually passing that to Java.
+#
+# Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+# and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+# see the in-line comments for details.
+#
+# There are tweaks for specific operating systems such as AIX, CygWin,
+# Darwin, MinGW, and NonStop.
+#
+# (3) This script is generated from the Groovy template
+# https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+# within the Gradle project.
+#
+# You can find Gradle at https://github.com/gradle/gradle/.
+#
+##############################################################################
+
+# Attempt to set APP_HOME
+
+# Resolve links: $0 may be a link
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+ APP_HOME=${app_path%"${app_path##*/}"} # leaves a trailing /; empty if no leading path
+ [ -h "$app_path" ]
+do
+ ls=$( ls -ld "$app_path" )
+ link=${ls#*' -> '}
+ case $link in #(
+ /*) app_path=$link ;; #(
+ *) app_path=$APP_HOME$link ;;
+ esac
+done
+
+# This is normally unused
+# shellcheck disable=SC2034
+APP_BASE_NAME=${0##*/}
+# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
+APP_HOME=$( cd "${APP_HOME:-./}" > /dev/null && pwd -P ) || exit
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD=maximum
+
+warn () {
+ echo "$*"
+} >&2
+
+die () {
+ echo
+ echo "$*"
+ echo
+ exit 1
+} >&2
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "$( uname )" in #(
+ CYGWIN* ) cygwin=true ;; #(
+ Darwin* ) darwin=true ;; #(
+ MSYS* | MINGW* ) msys=true ;; #(
+ NONSTOP* ) nonstop=true ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+ if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+ # IBM's JDK on AIX uses strange locations for the executables
+ JAVACMD=$JAVA_HOME/jre/sh/java
+ else
+ JAVACMD=$JAVA_HOME/bin/java
+ fi
+ if [ ! -x "$JAVACMD" ] ; then
+ die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+ fi
+else
+ JAVACMD=java
+ if ! command -v java >/dev/null 2>&1
+ then
+ die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+ fi
+fi
+
+# Increase the maximum file descriptors if we can.
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+ case $MAX_FD in #(
+ max*)
+ # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
+ # shellcheck disable=SC2039,SC3045
+ MAX_FD=$( ulimit -H -n ) ||
+ warn "Could not query maximum file descriptor limit"
+ esac
+ case $MAX_FD in #(
+ '' | soft) :;; #(
+ *)
+ # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
+ # shellcheck disable=SC2039,SC3045
+ ulimit -n "$MAX_FD" ||
+ warn "Could not set maximum file descriptor limit to $MAX_FD"
+ esac
+fi
+
+# Collect all arguments for the java command, stacking in reverse order:
+# * args from the command line
+# * the main class name
+# * -classpath
+# * -D...appname settings
+# * --module-path (only if needed)
+# * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+ APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+ CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+ JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+ # Now convert the arguments - kludge to limit ourselves to /bin/sh
+ for arg do
+ if
+ case $arg in #(
+ -*) false ;; # don't mess with options #(
+ /?*) t=${arg#/} t=/${t%%/*} # looks like a POSIX filepath
+ [ -e "$t" ] ;; #(
+ *) false ;;
+ esac
+ then
+ arg=$( cygpath --path --ignore --mixed "$arg" )
+ fi
+ # Roll the args list around exactly as many times as the number of
+ # args, so each arg winds up back in the position where it started, but
+ # possibly modified.
+ #
+ # NB: a `for` loop captures its iteration list before it begins, so
+ # changing the positional parameters here affects neither the number of
+ # iterations, nor the values presented in `arg`.
+ shift # remove old arg
+ set -- "$@" "$arg" # push replacement arg
+ done
+fi
+
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Collect all arguments for the java command:
+# * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+# and any embedded shellness will be escaped.
+# * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
+# treated as '${Hostname}' itself on the command line.
+
+set -- \
+ "-Dorg.gradle.appname=$APP_BASE_NAME" \
+ -classpath "$CLASSPATH" \
+ org.gradle.wrapper.GradleWrapperMain \
+ "$@"
+
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+ die "xargs is not available"
+fi
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+# readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+# set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+ printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+ xargs -n1 |
+ sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+ tr '\n' ' '
+ )" '"$@"'
+
+exec "$JAVACMD" "$@"
diff --git a/gradlew.bat b/gradlew.bat
new file mode 100644
index 0000000..25da30d
--- /dev/null
+++ b/gradlew.bat
@@ -0,0 +1,92 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+
+@if "%DEBUG%"=="" @echo off
+@rem ##########################################################################
+@rem
+@rem Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%"=="" set DIRNAME=.
+@rem This is normally unused
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if %ERRORLEVEL% equ 0 goto execute
+
+echo. 1>&2
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto execute
+
+echo. 1>&2
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
+
+goto fail
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+
+:end
+@rem End local scope for the variables with windows NT shell
+if %ERRORLEVEL% equ 0 goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+set EXIT_CODE=%ERRORLEVEL%
+if %EXIT_CODE% equ 0 set EXIT_CODE=1
+if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
+exit /b %EXIT_CODE%
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega
diff --git a/settings.gradle.kts b/settings.gradle.kts
new file mode 100644
index 0000000..aa35a8e
--- /dev/null
+++ b/settings.gradle.kts
@@ -0,0 +1,16 @@
+enableFeaturePreview("TYPESAFE_PROJECT_ACCESSORS")
+
+pluginManagement {
+ repositories {
+ gradlePluginPortal()
+ maven("https://maven.fabricmc.net/")
+ }
+}
+
+include("common", "fabric", "bukkit")
+
+rootProject.name = "KnockbackSync"
+
+plugins {
+ id("org.gradle.toolchains.foojay-resolver-convention") version "0.8.0"
+}
\ No newline at end of file
diff --git a/src/main/java/me/caseload/knockbacksync/KnockbackSync.java b/src/main/java/me/caseload/knockbacksync/KnockbackSync.java
deleted file mode 100644
index f08d6c8..0000000
--- a/src/main/java/me/caseload/knockbacksync/KnockbackSync.java
+++ /dev/null
@@ -1,116 +0,0 @@
-package me.caseload.knockbacksync;
-
-import com.github.retrooper.packetevents.PacketEvents;
-import dev.jorel.commandapi.CommandAPI;
-import dev.jorel.commandapi.CommandAPIBukkitConfig;
-import io.github.retrooper.packetevents.factory.spigot.SpigotPacketEventsBuilder;
-import lombok.Getter;
-import me.caseload.knockbacksync.command.MainCommand;
-import me.caseload.knockbacksync.listener.*;
-import me.caseload.knockbacksync.manager.ConfigManager;
-import me.caseload.knockbacksync.scheduler.BukkitSchedulerAdapter;
-import me.caseload.knockbacksync.scheduler.FoliaSchedulerAdapter;
-import me.caseload.knockbacksync.scheduler.SchedulerAdapter;
-import me.caseload.knockbacksync.stats.StatsManager;
-import org.bukkit.event.Listener;
-import org.bukkit.plugin.PluginManager;
-import org.bukkit.plugin.java.JavaPlugin;
-import org.kohsuke.github.GitHub;
-
-import java.util.logging.Logger;
-
-public final class KnockbackSync extends JavaPlugin {
-
- public static Logger LOGGER;
- public static KnockbackSync INSTANCE;
- @Getter
- private SchedulerAdapter scheduler;
- public final boolean isFolia = io.github.retrooper.packetevents.util.folia.FoliaScheduler.isFolia();
-
- @Getter
- private final ConfigManager configManager = new ConfigManager();
-
- @Override
- public void onLoad() {
- CommandAPI.onLoad(new CommandAPIBukkitConfig(this));
- PacketEvents.setAPI(SpigotPacketEventsBuilder.build(this));
- PacketEvents.getAPI().load();
- }
-
- @Override
- public void onEnable() {
- LOGGER = getLogger();
- INSTANCE = this;
- checkForUpdates();
-
- scheduler = isFolia ? new FoliaSchedulerAdapter(this) : new BukkitSchedulerAdapter(this);
-
- saveDefaultConfig();
- configManager.loadConfig(false);
-
- CommandAPI.onEnable();
- new MainCommand().register();
-
- registerListeners(
- new PlayerDamageListener(),
- new PlayerKnockbackListener(),
- new PlayerJoinQuitListener()
- );
-
- PacketEvents.getAPI().getEventManager().registerListeners(
- new AttributeChangeListener(),
- new PingReceiveListener()
- );
-
- PacketEvents.getAPI().getSettings()
- .checkForUpdates(false)
- .debug(false);
-
- PacketEvents.getAPI().load();
- PacketEvents.getAPI().init();
-
- StatsManager.init();
- }
-
- @Override
- public void onDisable() {
- CommandAPI.onDisable();
- PacketEvents.getAPI().terminate();
- }
-
- public static KnockbackSync getInstance() {
- return getPlugin(KnockbackSync.class);
- }
-
- private void registerListeners(Listener... listeners) {
- PluginManager pluginManager = getServer().getPluginManager();
- for (Listener listener : listeners)
- pluginManager.registerEvents(listener, this);
- }
-
- private void checkForUpdates() {
- getLogger().info("Checking for updates...");
-
- scheduler.runTaskAsynchronously(() -> {
- try {
- GitHub github = GitHub.connectAnonymously();
- String latestVersion = github.getRepository("CASELOAD7000/knockback-sync")
- .getLatestRelease()
- .getTagName();
-
- String currentVersion = getDescription().getVersion();
- boolean updateAvailable = !currentVersion.equalsIgnoreCase(latestVersion);
-
- if (updateAvailable) {
- LOGGER.warning("A new update is available for download at: https://github.com/CASELOAD7000/knockback-sync/releases/latest");
- } else {
- LOGGER.info("You are running the latest release.");
- }
-
- configManager.setUpdateAvailable(updateAvailable);
- } catch (Exception e) {
- LOGGER.severe("Failed to check for updates: " + e.getMessage());
- }
- });
- }
-}
\ No newline at end of file
diff --git a/src/main/java/me/caseload/knockbacksync/command/MainCommand.java b/src/main/java/me/caseload/knockbacksync/command/MainCommand.java
deleted file mode 100644
index 8823165..0000000
--- a/src/main/java/me/caseload/knockbacksync/command/MainCommand.java
+++ /dev/null
@@ -1,27 +0,0 @@
-package me.caseload.knockbacksync.command;
-
-import dev.jorel.commandapi.CommandAPICommand;
-import me.caseload.knockbacksync.command.subcommand.PingSubcommand;
-import me.caseload.knockbacksync.command.subcommand.ReloadSubcommand;
-import me.caseload.knockbacksync.command.subcommand.StatusSubcommand;
-import me.caseload.knockbacksync.command.subcommand.ToggleSubcommand;
-import org.bukkit.ChatColor;
-
-public class MainCommand {
-
- public void register() {
- new CommandAPICommand("knockbacksync")
- .withAliases("kbsync")
- .withSubcommand(new PingSubcommand().getCommand())
- .withSubcommand(new ToggleSubcommand().getCommand())
- .withSubcommand(new ReloadSubcommand().getCommand())
- .withSubcommand(new StatusSubcommand().getCommand())
- .executes((sender, args) -> {
- sender.sendMessage(ChatColor.translateAlternateColorCodes(
- '&',
- "&6This server is running the &eKnockbackSync &6plugin. &bhttps://github.com/CASELOAD7000/knockback-sync"
- ));
- })
- .register();
- }
-}
\ No newline at end of file
diff --git a/src/main/java/me/caseload/knockbacksync/command/subcommand/PingSubcommand.java b/src/main/java/me/caseload/knockbacksync/command/subcommand/PingSubcommand.java
deleted file mode 100644
index 15a1539..0000000
--- a/src/main/java/me/caseload/knockbacksync/command/subcommand/PingSubcommand.java
+++ /dev/null
@@ -1,23 +0,0 @@
-package me.caseload.knockbacksync.command.subcommand;
-
-import dev.jorel.commandapi.CommandAPICommand;
-import dev.jorel.commandapi.arguments.PlayerArgument;
-import me.caseload.knockbacksync.manager.PlayerData;
-import me.caseload.knockbacksync.manager.PlayerDataManager;
-import org.bukkit.entity.Player;
-
-public class PingSubcommand {
-
- public CommandAPICommand getCommand() {
- return new CommandAPICommand("ping")
- .withPermission("knockbacksync.ping")
- .withArguments(new PlayerArgument("target"))
- .executes((sender, args) -> {
- Player target = (Player) args.get("target");
- assert target != null;
-
- PlayerData playerData = PlayerDataManager.getPlayerData(target.getUniqueId());
- sender.sendMessage(target.getName() + "'s last ping packet took " + playerData.getPing() + "ms.");
- });
- }
-}
\ No newline at end of file
diff --git a/src/main/java/me/caseload/knockbacksync/command/subcommand/ReloadSubcommand.java b/src/main/java/me/caseload/knockbacksync/command/subcommand/ReloadSubcommand.java
deleted file mode 100644
index 4e703a5..0000000
--- a/src/main/java/me/caseload/knockbacksync/command/subcommand/ReloadSubcommand.java
+++ /dev/null
@@ -1,25 +0,0 @@
-package me.caseload.knockbacksync.command.subcommand;
-
-import dev.jorel.commandapi.CommandAPICommand;
-import me.caseload.knockbacksync.KnockbackSync;
-import me.caseload.knockbacksync.manager.ConfigManager;
-import org.bukkit.ChatColor;
-import org.bukkit.event.Listener;
-
-public class ReloadSubcommand implements Listener {
-
- public CommandAPICommand getCommand() {
- return new CommandAPICommand("reload")
- .withPermission("knockbacksync.reload")
- .executes((sender, args) -> {
- ConfigManager configManager = KnockbackSync.getInstance().getConfigManager();
- configManager.loadConfig(true);
-
- String reloadMessage = ChatColor.translateAlternateColorCodes('&',
- configManager.getReloadMessage()
- );
-
- sender.sendMessage(reloadMessage);
- });
- }
-}
\ No newline at end of file
diff --git a/src/main/java/me/caseload/knockbacksync/command/subcommand/StatusSubcommand.java b/src/main/java/me/caseload/knockbacksync/command/subcommand/StatusSubcommand.java
deleted file mode 100644
index fdab98b..0000000
--- a/src/main/java/me/caseload/knockbacksync/command/subcommand/StatusSubcommand.java
+++ /dev/null
@@ -1,58 +0,0 @@
-package me.caseload.knockbacksync.command.subcommand;
-
-import dev.jorel.commandapi.CommandAPICommand;
-import dev.jorel.commandapi.CommandPermission;
-import dev.jorel.commandapi.arguments.PlayerArgument;
-import me.caseload.knockbacksync.KnockbackSync;
-import me.caseload.knockbacksync.manager.ConfigManager;
-import me.caseload.knockbacksync.manager.PlayerDataManager;
-import org.bukkit.ChatColor;
-import org.bukkit.entity.Player;
-import org.bukkit.event.Listener;
-
-import java.util.UUID;
-
-public class StatusSubcommand implements Listener {
-
- public CommandAPICommand getCommand() {
- return new CommandAPICommand("status")
- .withPermission(CommandPermission.NONE)
- .withOptionalArguments(new PlayerArgument("target"))
- .executes((sender, args) -> {
- ConfigManager configManager = KnockbackSync.getInstance().getConfigManager();
- Player target = (Player) args.get("target");
-
- // Show global status
- boolean globalStatus = configManager.isToggled();
- sender.sendMessage(ChatColor.YELLOW + "Global KnockbackSync status: " +
- (globalStatus ? ChatColor.GREEN + "Enabled" : ChatColor.RED + "Disabled"));
-
- // Show player status
- if (target == null && sender instanceof Player)
- target = (Player) sender;
-
- if (target == null)
- return;
-
- if (sender.hasPermission("knockbacksync.status.self") ||
- (sender.hasPermission("knockbacksync.status.other") && !sender.equals(target))) {
-
- UUID uuid = target.getUniqueId();
- boolean playerStatus = !PlayerDataManager.containsPlayerData(uuid);
-
- if (!globalStatus) {
- sender.sendMessage(ChatColor.YELLOW + target.getName() + "'s KnockbackSync status: " +
- ChatColor.RED + "Disabled (Global toggle is off)");
- } else {
- sender.sendMessage(ChatColor.YELLOW + target.getName() + "'s KnockbackSync status: " +
- (playerStatus ? ChatColor.GREEN + "Enabled" : ChatColor.RED + "Disabled"));
- }
- } else {
- sender.sendMessage(ChatColor.RED + "You don't have the "
- + (sender.equals(target) ? "knockbacksync.status.self" : "knockbacksync.status.other") +
- " permission needed to check status for " +
- (sender.equals(target) ? "yourself" : "other players") + ".");
- }
- });
- }
-}
\ No newline at end of file
diff --git a/src/main/java/me/caseload/knockbacksync/command/subcommand/ToggleSubcommand.java b/src/main/java/me/caseload/knockbacksync/command/subcommand/ToggleSubcommand.java
deleted file mode 100644
index 2751e86..0000000
--- a/src/main/java/me/caseload/knockbacksync/command/subcommand/ToggleSubcommand.java
+++ /dev/null
@@ -1,86 +0,0 @@
-package me.caseload.knockbacksync.command.subcommand;
-
-import dev.jorel.commandapi.CommandAPICommand;
-import dev.jorel.commandapi.CommandPermission;
-import dev.jorel.commandapi.arguments.PlayerArgument;
-import me.caseload.knockbacksync.KnockbackSync;
-import me.caseload.knockbacksync.manager.ConfigManager;
-import me.caseload.knockbacksync.manager.PlayerData;
-import me.caseload.knockbacksync.manager.PlayerDataManager;
-import org.bukkit.ChatColor;
-import org.bukkit.entity.Player;
-import org.bukkit.command.CommandSender;
-import org.bukkit.event.Listener;
-
-import java.util.UUID;
-
-public class ToggleSubcommand implements Listener {
-
- public CommandAPICommand getCommand() {
- return new CommandAPICommand("toggle")
- .withPermission(CommandPermission.NONE)
- .withOptionalArguments(new PlayerArgument("target"))
- .executes((sender, args) -> {
- ConfigManager configManager = KnockbackSync.getInstance().getConfigManager();
- Player target = (Player) args.get("target");
- String message;
-
- if (target == null) {
- // Global toggle
- if (sender.hasPermission("knockbacksync.toggle.global")) {
- boolean toggledState = !configManager.isToggled();
- configManager.setToggled(toggledState);
-
- KnockbackSync.getInstance().getConfig().set("enabled", toggledState);
- KnockbackSync.getInstance().saveConfig();
-
- message = ChatColor.translateAlternateColorCodes('&',
- toggledState ? configManager.getEnableMessage() : configManager.getDisableMessage()
- );
- } else {
- message = ChatColor.RED + "You don't have permission to toggle the global setting.";
- }
- sender.sendMessage(message);
- } else {
- // Player-specific toggle
- if (!configManager.isToggled()) {
- message = ChatColor.RED + "Knockbacksync is currently disabled on this server. Contact your server administrator for more information.";
- sender.sendMessage(message);
- } else if (sender instanceof Player && sender.equals(target) && sender.hasPermission("knockbacksync.toggle.self")) {
- togglePlayerKnockback(target, configManager, sender);
- } else if (sender.hasPermission("knockbacksync.toggle.other")) {
- togglePlayerKnockback(target, configManager, sender);
- } else {
- message = ChatColor.RED + "You don't have permission to toggle knockback for " +
- (sender.equals(target) ? "yourself" : "other players") + ".";
- sender.sendMessage(message);
- }
- }
- });
- }
-
- private void togglePlayerKnockback(Player target, ConfigManager configManager, CommandSender sender) {
- UUID uuid = target.getUniqueId();
-
- if (PlayerDataManager.shouldExempt(uuid)) {
- String message = ChatColor.translateAlternateColorCodes('&',
- configManager.getPlayerIneligibleMessage()
- ).replace("%player%", target.getName());
-
- sender.sendMessage(message);
- return;
- }
-
- boolean hasPlayerData = PlayerDataManager.containsPlayerData(uuid);
- if (hasPlayerData)
- PlayerDataManager.removePlayerData(uuid);
- else
- PlayerDataManager.addPlayerData(uuid, new PlayerData(target));
-
- String message = ChatColor.translateAlternateColorCodes('&',
- hasPlayerData ? configManager.getPlayerDisableMessage() : configManager.getPlayerEnableMessage()
- ).replace("%player%", target.getName());
-
- sender.sendMessage(message);
- }
-}
\ No newline at end of file
diff --git a/src/main/java/me/caseload/knockbacksync/listener/PlayerDamageListener.java b/src/main/java/me/caseload/knockbacksync/listener/PlayerDamageListener.java
deleted file mode 100644
index 00b14f7..0000000
--- a/src/main/java/me/caseload/knockbacksync/listener/PlayerDamageListener.java
+++ /dev/null
@@ -1,32 +0,0 @@
-package me.caseload.knockbacksync.listener;
-
-import me.caseload.knockbacksync.KnockbackSync;
-import me.caseload.knockbacksync.manager.PlayerData;
-import me.caseload.knockbacksync.manager.PlayerDataManager;
-import org.bukkit.entity.Player;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.Listener;
-import org.bukkit.event.entity.EntityDamageByEntityEvent;
-
-public class PlayerDamageListener implements Listener {
-
- @EventHandler(ignoreCancelled = true)
- public void onPlayerDamage(EntityDamageByEntityEvent event) {
- if (!KnockbackSync.getInstance().getConfigManager().isToggled())
- return;
-
- if (!(event.getEntity() instanceof Player victim) || !(event.getDamager() instanceof Player attacker))
- return;
-
- PlayerData playerData = PlayerDataManager.getPlayerData(victim.getUniqueId());
- if (playerData == null)
- return;
-
- playerData.setVerticalVelocity(playerData.calculateVerticalVelocity(attacker)); // do not move this calculation
- playerData.setLastDamageTicks(victim.getNoDamageTicks());
- playerData.updateCombat();
-
- if (!KnockbackSync.getInstance().getConfigManager().isRunnableEnabled())
- playerData.sendPing();
- }
-}
\ No newline at end of file
diff --git a/src/main/java/me/caseload/knockbacksync/listener/PlayerJoinQuitListener.java b/src/main/java/me/caseload/knockbacksync/listener/PlayerJoinQuitListener.java
deleted file mode 100644
index 3f0bb5c..0000000
--- a/src/main/java/me/caseload/knockbacksync/listener/PlayerJoinQuitListener.java
+++ /dev/null
@@ -1,41 +0,0 @@
-package me.caseload.knockbacksync.listener;
-
-import me.caseload.knockbacksync.KnockbackSync;
-import me.caseload.knockbacksync.manager.PlayerData;
-import me.caseload.knockbacksync.manager.PlayerDataManager;
-import org.bukkit.ChatColor;
-import org.bukkit.entity.Player;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.Listener;
-import org.bukkit.event.player.PlayerJoinEvent;
-import org.bukkit.event.player.PlayerQuitEvent;
-
-import java.util.UUID;
-
-public class PlayerJoinQuitListener implements Listener {
-
- @EventHandler
- public void onPlayerJoin(PlayerJoinEvent event) {
- Player player = event.getPlayer();
- PlayerDataManager.addPlayerData(player.getUniqueId(), new PlayerData(player));
-
- if (KnockbackSync.getInstance().getConfigManager().isUpdateAvailable() && KnockbackSync.getInstance().getConfigManager().isNotifyUpdate() && player.hasPermission("knockbacksync.update"))
- player.sendMessage(ChatColor.translateAlternateColorCodes(
- '&',
- "&6An updated version of &eKnockbackSync &6is now available for download at: &bhttps://github.com/CASELOAD7000/knockback-sync/releases/latest"
- ));
- }
-
- @EventHandler
- public void onPlayerQuit(PlayerQuitEvent event) {
- UUID uuid = event.getPlayer().getUniqueId();
- PlayerData playerData = PlayerDataManager.getPlayerData(uuid);
- if (playerData == null)
- return;
-
- if (playerData.isInCombat())
- playerData.quitCombat(true);
-
- PlayerDataManager.removePlayerData(uuid);
- }
-}
diff --git a/src/main/java/me/caseload/knockbacksync/listener/PlayerKnockbackListener.java b/src/main/java/me/caseload/knockbacksync/listener/PlayerKnockbackListener.java
deleted file mode 100644
index b815671..0000000
--- a/src/main/java/me/caseload/knockbacksync/listener/PlayerKnockbackListener.java
+++ /dev/null
@@ -1,55 +0,0 @@
-package me.caseload.knockbacksync.listener;
-
-import me.caseload.knockbacksync.KnockbackSync;
-import me.caseload.knockbacksync.manager.PlayerData;
-import me.caseload.knockbacksync.manager.PlayerDataManager;
-import org.bukkit.entity.Entity;
-import org.bukkit.entity.Player;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.EventPriority;
-import org.bukkit.event.Listener;
-import org.bukkit.event.entity.EntityDamageByEntityEvent;
-import org.bukkit.event.entity.EntityDamageEvent;
-import org.bukkit.event.player.PlayerVelocityEvent;
-import org.bukkit.util.Vector;
-
-public class PlayerKnockbackListener implements Listener {
-
- @EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
- public void onPlayerVelocity(PlayerVelocityEvent event) {
- if (!KnockbackSync.getInstance().getConfigManager().isToggled())
- return;
-
- Player victim = event.getPlayer();
- EntityDamageEvent entityDamageEvent = victim.getLastDamageCause();
- if (entityDamageEvent == null)
- return;
-
- EntityDamageEvent.DamageCause damageCause = entityDamageEvent.getCause();
- if (damageCause != EntityDamageEvent.DamageCause.ENTITY_ATTACK)
- return;
-
- Entity attacker = ((EntityDamageByEntityEvent) entityDamageEvent).getDamager();
- if (!(attacker instanceof Player))
- return;
-
- PlayerData playerData = PlayerDataManager.getPlayerData(victim.getUniqueId());
- if (playerData == null)
- return;
-
- Integer damageTicks = playerData.getLastDamageTicks();
- if (damageTicks != null && damageTicks > 8)
- return;
-
- Vector velocity = victim.getVelocity();
- Double verticalVelocity = playerData.getVerticalVelocity();
- if (verticalVelocity == null || !playerData.isOnGround(velocity.getY()))
- return;
-
- Vector adjustedVelocity = velocity.clone().setY(
- verticalVelocity
- );
-
- victim.setVelocity(adjustedVelocity);
- }
-}
\ No newline at end of file
diff --git a/src/main/java/me/caseload/knockbacksync/manager/ConfigManager.java b/src/main/java/me/caseload/knockbacksync/manager/ConfigManager.java
index d3c1db4..e69de29 100644
--- a/src/main/java/me/caseload/knockbacksync/manager/ConfigManager.java
+++ b/src/main/java/me/caseload/knockbacksync/manager/ConfigManager.java
@@ -1,70 +0,0 @@
-package me.caseload.knockbacksync.manager;
-
-import lombok.Getter;
-import lombok.Setter;
-import me.caseload.knockbacksync.KnockbackSync;
-import me.caseload.knockbacksync.runnable.PingRunnable;
-import me.caseload.knockbacksync.scheduler.AbstractTaskHandle;
-import org.bukkit.scheduler.BukkitTask;
-
-@Getter
-@Setter
-public class ConfigManager {
-
- private boolean toggled;
- private boolean runnableEnabled;
- private boolean updateAvailable;
- private boolean notifyUpdate;
-
- private long runnableInterval;
- private long combatTimer;
- private long spikeThreshold;
-
- private String enableMessage;
- private String disableMessage;
- private String playerEnableMessage;
- private String playerDisableMessage;
- private String playerIneligibleMessage;
- private String reloadMessage;
-
- private AbstractTaskHandle pingTask;
-
- public void loadConfig(boolean reloadConfig) {
- KnockbackSync instance = KnockbackSync.getInstance();
-
- if (reloadConfig)
- instance.reloadConfig();
-
- toggled = instance.getConfig().getBoolean("enabled", true);
-
- // Checks to see if the runnable was enabled...
- // and if we now want to disable it
- boolean newRunnableEnabled = instance.getConfig().getBoolean("runnable.enabled", true);
- if (runnableEnabled && newRunnableEnabled && pingTask != null) // null check for first startup
- pingTask.cancel();
-
- runnableEnabled = newRunnableEnabled;
-
- if (runnableEnabled) {
- long initialDelay = 0L;
- long pingTaskRunnableInterval = runnableInterval;
- // Folia does not allow 0 ticks of wait time
- if (KnockbackSync.INSTANCE.isFolia) {
- initialDelay = 1L;
- pingTaskRunnableInterval = Math.max(pingTaskRunnableInterval, 1L);
- }
- pingTask = KnockbackSync.INSTANCE.getScheduler().runTaskTimerAsynchronously(new PingRunnable(), initialDelay, pingTaskRunnableInterval);
- }
-
- notifyUpdate = instance.getConfig().getBoolean("notify_updates", true);
- runnableInterval = instance.getConfig().getLong("runnable.interval", 5L);
- combatTimer = instance.getConfig().getLong("runnable.timer", 30L);
- spikeThreshold = instance.getConfig().getLong("spike_threshold", 20L);
- enableMessage = instance.getConfig().getString("enable_message", "&aSuccessfully enabled KnockbackSync.");
- disableMessage = instance.getConfig().getString("disable_message", "&cSuccessfully disabled KnockbackSync.");
- playerEnableMessage = instance.getConfig().getString("player_enable_message", "&aSuccessfully enabled KnockbackSync for %player%.");
- playerDisableMessage = instance.getConfig().getString("player_disable_message", "&cSuccessfully disabled KnockbackSync for %player%.");
- playerIneligibleMessage = instance.getConfig().getString("player_ineligible_message", "&c%player% is ineligible for KnockbackSync. If you believe this is an error, please open an issue on the github page.");
- reloadMessage = instance.getConfig().getString("reload_message", "&aSuccessfully reloaded KnockbackSync.");
- }
-}