From 9fca7430a86ab8f45e42d72f7da7386c7e926ae0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Elias=20M=C3=BCller?= Date: Sun, 5 Oct 2025 13:24:47 +0200 Subject: [PATCH 01/19] implemented working fingerprinting prototype --- .../DeviceFingerprinting.java | 218 ++++++++++++++++++ .../PlayerJoinListener.java | 27 +++ .../resources/deviceFingerprinting/README.md | 5 + .../deviceFingerprinting/gen_packs.py | 33 +++ .../resources/deviceFingerprinting/packs.json | 122 ++++++++++ .../deviceFingerprinting/packs/.gitignore | 1 + .../resources/deviceFingerprinting/packs/0 | Bin 0 -> 200 bytes .../resources/deviceFingerprinting/packs/1 | Bin 0 -> 200 bytes .../resources/deviceFingerprinting/packs/10 | Bin 0 -> 201 bytes .../resources/deviceFingerprinting/packs/11 | Bin 0 -> 201 bytes .../resources/deviceFingerprinting/packs/12 | Bin 0 -> 201 bytes .../resources/deviceFingerprinting/packs/13 | Bin 0 -> 201 bytes .../resources/deviceFingerprinting/packs/14 | Bin 0 -> 201 bytes .../resources/deviceFingerprinting/packs/15 | Bin 0 -> 201 bytes .../resources/deviceFingerprinting/packs/16 | Bin 0 -> 201 bytes .../resources/deviceFingerprinting/packs/17 | Bin 0 -> 201 bytes .../resources/deviceFingerprinting/packs/18 | Bin 0 -> 201 bytes .../resources/deviceFingerprinting/packs/19 | Bin 0 -> 201 bytes .../resources/deviceFingerprinting/packs/2 | Bin 0 -> 200 bytes .../resources/deviceFingerprinting/packs/20 | Bin 0 -> 201 bytes .../resources/deviceFingerprinting/packs/21 | Bin 0 -> 201 bytes .../resources/deviceFingerprinting/packs/22 | Bin 0 -> 201 bytes .../resources/deviceFingerprinting/packs/23 | Bin 0 -> 201 bytes .../resources/deviceFingerprinting/packs/3 | Bin 0 -> 200 bytes .../resources/deviceFingerprinting/packs/4 | Bin 0 -> 200 bytes .../resources/deviceFingerprinting/packs/5 | Bin 0 -> 200 bytes .../resources/deviceFingerprinting/packs/6 | Bin 0 -> 200 bytes .../resources/deviceFingerprinting/packs/7 | Bin 0 -> 200 bytes .../resources/deviceFingerprinting/packs/8 | Bin 0 -> 200 bytes .../resources/deviceFingerprinting/packs/9 | Bin 0 -> 200 bytes .../deviceFingerprinting/packs/base.zip | Bin 0 -> 37490 bytes .../spawn/core/api/server/HttpServer.java | 9 +- 32 files changed, 413 insertions(+), 2 deletions(-) create mode 100644 common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/tooling/deviceFingerprinting/DeviceFingerprinting.java create mode 100644 common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/tooling/deviceFingerprinting/PlayerJoinListener.java create mode 100644 common/src/main/resources/deviceFingerprinting/README.md create mode 100644 common/src/main/resources/deviceFingerprinting/gen_packs.py create mode 100644 common/src/main/resources/deviceFingerprinting/packs.json create mode 100644 common/src/main/resources/deviceFingerprinting/packs/.gitignore create mode 100644 common/src/main/resources/deviceFingerprinting/packs/0 create mode 100644 common/src/main/resources/deviceFingerprinting/packs/1 create mode 100644 common/src/main/resources/deviceFingerprinting/packs/10 create mode 100644 common/src/main/resources/deviceFingerprinting/packs/11 create mode 100644 common/src/main/resources/deviceFingerprinting/packs/12 create mode 100644 common/src/main/resources/deviceFingerprinting/packs/13 create mode 100644 common/src/main/resources/deviceFingerprinting/packs/14 create mode 100644 common/src/main/resources/deviceFingerprinting/packs/15 create mode 100644 common/src/main/resources/deviceFingerprinting/packs/16 create mode 100644 common/src/main/resources/deviceFingerprinting/packs/17 create mode 100644 common/src/main/resources/deviceFingerprinting/packs/18 create mode 100644 common/src/main/resources/deviceFingerprinting/packs/19 create mode 100644 common/src/main/resources/deviceFingerprinting/packs/2 create mode 100644 common/src/main/resources/deviceFingerprinting/packs/20 create mode 100644 common/src/main/resources/deviceFingerprinting/packs/21 create mode 100644 common/src/main/resources/deviceFingerprinting/packs/22 create mode 100644 common/src/main/resources/deviceFingerprinting/packs/23 create mode 100644 common/src/main/resources/deviceFingerprinting/packs/3 create mode 100644 common/src/main/resources/deviceFingerprinting/packs/4 create mode 100644 common/src/main/resources/deviceFingerprinting/packs/5 create mode 100644 common/src/main/resources/deviceFingerprinting/packs/6 create mode 100644 common/src/main/resources/deviceFingerprinting/packs/7 create mode 100644 common/src/main/resources/deviceFingerprinting/packs/8 create mode 100644 common/src/main/resources/deviceFingerprinting/packs/9 create mode 100644 common/src/main/resources/deviceFingerprinting/packs/base.zip diff --git a/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/tooling/deviceFingerprinting/DeviceFingerprinting.java b/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/tooling/deviceFingerprinting/DeviceFingerprinting.java new file mode 100644 index 0000000..73d1fde --- /dev/null +++ b/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/tooling/deviceFingerprinting/DeviceFingerprinting.java @@ -0,0 +1,218 @@ +package eu.mhsl.craftattack.spawn.common.appliances.tooling.deviceFingerprinting; + +import com.google.common.reflect.TypeToken; +import com.google.gson.Gson; +import eu.mhsl.craftattack.spawn.core.Main; +import eu.mhsl.craftattack.spawn.core.api.server.HttpServer; +import eu.mhsl.craftattack.spawn.core.appliance.Appliance; +import net.kyori.adventure.resource.ResourcePackInfo; +import net.kyori.adventure.resource.ResourcePackRequest; +import org.bukkit.entity.Player; +import org.bukkit.event.Listener; +import org.bukkit.event.player.PlayerResourcePackStatusEvent; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import spark.Response; + +import java.io.IOException; +import java.io.InputStreamReader; +import java.lang.reflect.Type; +import java.net.URI; +import java.util.*; + +public class DeviceFingerprinting extends Appliance { + public record PackInfo(String url, UUID uuid, String hash) { + private static final String failingUrl = "http://127.0.0.1:0"; + public PackInfo asFailing() { + return new PackInfo(failingUrl, this.uuid, this.hash); + } + } + + public enum PackStatus { + ERROR, + SUCCESS; + + public static PackStatus fromBukkitStatus(PlayerResourcePackStatusEvent.Status status) { + return switch(status) { + case DISCARDED -> SUCCESS; + case FAILED_DOWNLOAD -> ERROR; + default -> throw new IllegalStateException("Unexpected value: " + status); + }; + } + } + + public enum PlayerStatus { + PREPARATION, + TESTING, + FINISHED; + } + + public record FingerprintData( + Player player, + PlayerStatus status, + @Nullable Long fingerPrint, + @Nullable List pendingPacks + ) { + public FingerprintData(Player player) { + this(player, PlayerStatus.PREPARATION, null, null); + } + } + + private List packs; + private final Map> pendingPacks = new WeakHashMap<>(); + + @Override + public void onEnable() { + this.packs = this.readPacksFromConfig(); + + } + + public void testAllPacks(Player player) { + this.pendingPacks.put(player, Arrays.asList(new PackStatus[this.packs.size()])); + System.out.println("Sending packs..."); + this.packs.forEach(pack -> this.sendPack(player, pack.asFailing())); + } + + public void onPackReceive(Player player, UUID packId, PlayerResourcePackStatusEvent.Status status) { + if(!this.pendingPacks.containsKey(player)) return; + + PackInfo pack = this.packs.stream() + .filter(packInfo -> packInfo.uuid.equals(packId)) + .findFirst() + .orElse(null); + if(pack == null) return; + int packIndex = this.packs.indexOf(pack); + + List currentPendingStatus = this.pendingPacks.get(player); + try { + currentPendingStatus.set(packIndex, PackStatus.fromBukkitStatus(status)); + System.out.println(packIndex + " > " + PackStatus.fromBukkitStatus(status)); + } catch(IllegalStateException ignored) { + return; + } + + long fingerPrint = this.calculateFingerprintId(currentPendingStatus); + if(fingerPrint == -1) return; + + if(fingerPrint == 0) { + // new Player + long newFingerprintId = this.generateNewFingerprintId(); + System.out.println("New Fingerprint: " + newFingerprintId); + this.sendMarkedPacks(player, newFingerprintId); + } else { + System.out.println("Fingerprint: " + fingerPrint); + } + + this.pendingPacks.remove(player); + } + + private long calculateFingerprintId(List packStatus) { + long fingerprintId = 0; + for (int i = 0; i < packStatus.size(); i++) { + var status = packStatus.get(i); + if(status == null) return -1; + switch (status) { + case SUCCESS: + fingerprintId |= 1L << i; + break; + case ERROR: + break; + default: + return -1; + } + } + return fingerprintId; + } + + private long generateNewFingerprintId() { + long id = 0; + Random random = new Random(); + for (int i = 0; i < this.packs.size() / 2; i++) { + while (true) { + int bitIndex = random.nextInt(this.packs.size()); + if ((id & (1L << bitIndex)) == 0) { + id |= 1L << bitIndex; + break; + } + } + } + return id; + } + + private void sendMarkedPacks(Player player, long fingerprintId) { + for (int i = 0; i < this.packs.size(); i++) { + if ((fingerprintId & (1L << i)) != 0) { + PackInfo pack = this.packs.get(i); + this.sendPack(player, pack); + } + } + } + + public void sendPack(Player player, PackInfo pack) { + System.out.println("Sending pack: " + pack.url); + player.sendResourcePacks( + ResourcePackRequest.resourcePackRequest() + .required(true) + .packs(ResourcePackInfo.resourcePackInfo(pack.uuid, URI.create(pack.url), pack.hash)) + ); + } + + private List readPacksFromConfig() { + try (InputStreamReader reader = new InputStreamReader(Objects.requireNonNull(Main.class.getResourceAsStream("/deviceFingerprinting/packs.json")))) { + Type packListType = new TypeToken>(){}.getType(); + List packs = new Gson().fromJson(reader, packListType); + + if (packs.isEmpty()) + throw new IllegalStateException("No resource packs found in packs.json."); + + return packs; + } catch (Exception e) { + throw new IllegalStateException("Failed to parse packs.json.", e); + } + } + + @Override + public void httpApi(HttpServer.ApiBuilder apiBuilder) { + apiBuilder.rawGet( + "base.zip", + (request, response) -> this.servePack("base.zip", response) + ); + + for(int i = 0; i < this.packs.size(); i++) { + int packIndex = i; + apiBuilder.rawGet( + String.format("packs/%d", i), + (request, response) -> this.servePack(String.valueOf(packIndex), response) + ); + } + } + + private Object servePack(String name, Response response) { + try { + String resourcePath = String.format("/deviceFingerprinting/packs/%s", name); + var inputStream = Main.class.getResourceAsStream(resourcePath); + + if (inputStream == null) { + throw new IllegalStateException("Pack file not found: " + resourcePath); + } + + response.header("Content-Type", "application/zip"); + response.header("Content-Disposition", String.format("attachment; filename=\"pack-%s.zip\"", name)); + + var outputStream = response.raw().getOutputStream(); + inputStream.transferTo(outputStream); + outputStream.close(); + + return HttpServer.nothing; + } catch (IOException e) { + throw new RuntimeException(String.format("Failed to serve pack '%s'", name), e); + } + } + + @Override + protected @NotNull List listeners() { + return List.of( + new PlayerJoinListener() + ); + } +} diff --git a/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/tooling/deviceFingerprinting/PlayerJoinListener.java b/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/tooling/deviceFingerprinting/PlayerJoinListener.java new file mode 100644 index 0000000..2d92e04 --- /dev/null +++ b/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/tooling/deviceFingerprinting/PlayerJoinListener.java @@ -0,0 +1,27 @@ +package eu.mhsl.craftattack.spawn.common.appliances.tooling.deviceFingerprinting; + +import eu.mhsl.craftattack.spawn.core.appliance.ApplianceListener; +import org.bukkit.event.EventHandler; +import org.bukkit.event.player.PlayerJoinEvent; +import org.bukkit.event.player.PlayerResourcePackStatusEvent; + +class PlayerJoinListener extends ApplianceListener { + @EventHandler + public void onJoin(PlayerJoinEvent event) { +// if(Bukkit.getServer().getServerResourcePack() != null && !event.getPlayer().hasResourcePack()) { +// System.out.println("NO RESSOURCEPACK"); +// return; +// } + + this.getAppliance().testAllPacks(event.getPlayer()); + } + + @EventHandler + public void onResourcePackEvent(PlayerResourcePackStatusEvent event) { + this.getAppliance().onPackReceive( + event.getPlayer(), + event.getID(), + event.getStatus() + ); + } +} diff --git a/common/src/main/resources/deviceFingerprinting/README.md b/common/src/main/resources/deviceFingerprinting/README.md new file mode 100644 index 0000000..b40a304 --- /dev/null +++ b/common/src/main/resources/deviceFingerprinting/README.md @@ -0,0 +1,5 @@ +## Files originally from "TrackPack" +https://github.com/ALaggyDev/TrackPack/blob/main/README.md + + +Discovered by: [Laggy](https://github.com/ALaggyDev/) and [NikOverflow](https://github.com/NikOverflow) \ No newline at end of file diff --git a/common/src/main/resources/deviceFingerprinting/gen_packs.py b/common/src/main/resources/deviceFingerprinting/gen_packs.py new file mode 100644 index 0000000..2e7b1df --- /dev/null +++ b/common/src/main/resources/deviceFingerprinting/gen_packs.py @@ -0,0 +1,33 @@ +import zipfile +import hashlib +import uuid +import json + +SERVER_URL = "http://localhost:8080/api/devicefingerprinting" +packs = [] + +def file_sha1(path): + h = hashlib.sha1() + with open(path, "rb") as f: + for chunk in iter(lambda: f.read(8192), b""): + h.update(chunk) + return h.hexdigest() + +for i in range(0, 24): + path = f"packs/{i}" + + with zipfile.ZipFile(path, mode="w") as zf: + zf.writestr( + "pack.mcmeta", + '{"pack":{"pack_format":22,"supported_formats":[22,1000],"description":"pack ' + str(i) + '"}}', + ) + + hash = file_sha1(path) + packs.append({ + "url": f"{SERVER_URL}/packs/{i}", + "uuid": str(uuid.uuid4()), + "hash": hash + }) + +with open("packs.json", "w") as f: + json.dump(packs, f, indent=4) diff --git a/common/src/main/resources/deviceFingerprinting/packs.json b/common/src/main/resources/deviceFingerprinting/packs.json new file mode 100644 index 0000000..59cbad1 --- /dev/null +++ b/common/src/main/resources/deviceFingerprinting/packs.json @@ -0,0 +1,122 @@ +[ + { + "url": "http://localhost:8080/api/devicefingerprinting/packs/0", + "uuid": "b35f6e2f-1b50-4493-85be-fb18bd90f9bb", + "hash": "7a39af839ea6484431f7b707759546bea991d435" + }, + { + "url": "http://localhost:8080/api/devicefingerprinting/packs/1", + "uuid": "71095b62-d5ef-4ab2-ba3b-3c1b403f5e34", + "hash": "a9192ee73df1c5cff2c188fac6e9e638a1e7b6ce" + }, + { + "url": "http://localhost:8080/api/devicefingerprinting/packs/2", + "uuid": "a4dba0a2-f8f2-4a81-bbb2-a9a818820330", + "hash": "6b85b0eb54865dae70bbda89746d83717dc2a214" + }, + { + "url": "http://localhost:8080/api/devicefingerprinting/packs/3", + "uuid": "79fa2dc4-8c84-45fc-a09f-d89906f0d900", + "hash": "c7abf7a316f7e8c98985e8317a8b649e824e9f79" + }, + { + "url": "http://localhost:8080/api/devicefingerprinting/packs/4", + "uuid": "15702c9b-a22b-426d-b48a-3d65b0368e9a", + "hash": "10cd0e2c46f192deb87ac75c149827d44a713017" + }, + { + "url": "http://localhost:8080/api/devicefingerprinting/packs/5", + "uuid": "3d702d41-8e2f-4920-8dd0-1fd2146da9fb", + "hash": "8ad517d259e800b88a38ff00ee6721d5656822f2" + }, + { + "url": "http://localhost:8080/api/devicefingerprinting/packs/6", + "uuid": "c20a2e47-ef43-49da-a80d-adf238df3695", + "hash": "798677405a4fd678892e1cf55585c8c91f82e1e2" + }, + { + "url": "http://localhost:8080/api/devicefingerprinting/packs/7", + "uuid": "7ce51b81-1263-4919-9f4e-bb749ffe6e2e", + "hash": "af473b8eb7572f35d307bede5f2e20f263c0d804" + }, + { + "url": "http://localhost:8080/api/devicefingerprinting/packs/8", + "uuid": "0c70d586-fe48-4ffc-86b0-6b9ec3bfe045", + "hash": "2fb698ff88f2436637641f3b2e6792201feb5144" + }, + { + "url": "http://localhost:8080/api/devicefingerprinting/packs/9", + "uuid": "c7af75a8-0b72-495d-a0ff-c1c40e229c13", + "hash": "cf660460798eecf451d639873cc1fedc4661db1b" + }, + { + "url": "http://localhost:8080/api/devicefingerprinting/packs/10", + "uuid": "248dbce6-4b2a-44b5-b038-8d718b0ced99", + "hash": "a8ebe708d0f3747c76e4e5e68db5dcb561922706" + }, + { + "url": "http://localhost:8080/api/devicefingerprinting/packs/11", + "uuid": "10979174-cb02-40eb-a754-275551ad608d", + "hash": "54961b48db1582a1a0981c8cc9be5ae0f3122cf3" + }, + { + "url": "http://localhost:8080/api/devicefingerprinting/packs/12", + "uuid": "a361cfa7-674c-4493-a4cf-4baff851f276", + "hash": "013719dc8da79c96b45a1c5319c20bffe1a56cc9" + }, + { + "url": "http://localhost:8080/api/devicefingerprinting/packs/13", + "uuid": "24b39bdb-ada9-40ec-9e3a-132c74b81dc6", + "hash": "206898c6b6600d2648b2d79c61fc6255b19587d9" + }, + { + "url": "http://localhost:8080/api/devicefingerprinting/packs/14", + "uuid": "158fc5b4-be2c-4f7a-98cb-af5993adcc90", + "hash": "061b266a7c526fb3a3152a4ea70ca5592e0b503c" + }, + { + "url": "http://localhost:8080/api/devicefingerprinting/packs/15", + "uuid": "4f9097a7-be02-48ad-919c-f292307f8490", + "hash": "45a667a0fe06246defabca14ef1271fb6db5a1ac" + }, + { + "url": "http://localhost:8080/api/devicefingerprinting/packs/16", + "uuid": "3ce31e60-7e8a-4fb1-8c6d-da9065bea798", + "hash": "75bb12e46203d49e89aa9a826d267552372758bc" + }, + { + "url": "http://localhost:8080/api/devicefingerprinting/packs/17", + "uuid": "cd978e5c-3de0-4ada-8ec5-3a88a305eec6", + "hash": "5b20261f7be03e83e9c52307f1408b0c5e58358c" + }, + { + "url": "http://localhost:8080/api/devicefingerprinting/packs/18", + "uuid": "75001e58-3999-4779-a1d1-43ab161770ce", + "hash": "544420cffb6c17113c06fb49eeba892c208719d3" + }, + { + "url": "http://localhost:8080/api/devicefingerprinting/packs/19", + "uuid": "6a7005a9-c2ca-476d-9a12-07d120ee121a", + "hash": "fcc066a4d3193b60b102e3d906ad8dc0b0fcf65b" + }, + { + "url": "http://localhost:8080/api/devicefingerprinting/packs/20", + "uuid": "521c0d84-d82e-49ef-b096-d9b90f15aa19", + "hash": "4545835983ec7f07d02675a69181a80dc396f038" + }, + { + "url": "http://localhost:8080/api/devicefingerprinting/packs/21", + "uuid": "c1b590c5-43fc-41e3-83c0-47f35b14f845", + "hash": "8d4c670eaefc0482734e839b72758226dde13bc3" + }, + { + "url": "http://localhost:8080/api/devicefingerprinting/packs/22", + "uuid": "43958a18-c087-4f2b-a6ea-066231606eb1", + "hash": "004282602f7bdbb7cd7724f23aae23876f224092" + }, + { + "url": "http://localhost:8080/api/devicefingerprinting/packs/23", + "uuid": "4b91ac81-9de4-4c2b-a876-47e621496d10", + "hash": "dae68eae109e08ea4c4c943905502eb331939f64" + } +] \ No newline at end of file diff --git a/common/src/main/resources/deviceFingerprinting/packs/.gitignore b/common/src/main/resources/deviceFingerprinting/packs/.gitignore new file mode 100644 index 0000000..073c2a0 --- /dev/null +++ b/common/src/main/resources/deviceFingerprinting/packs/.gitignore @@ -0,0 +1 @@ +!base.zip \ No newline at end of file diff --git a/common/src/main/resources/deviceFingerprinting/packs/0 b/common/src/main/resources/deviceFingerprinting/packs/0 new file mode 100644 index 0000000000000000000000000000000000000000..9ed350355ee1c79a0bbb36b7efe24e1a47efd027 GIT binary patch literal 200 zcmWIWW@Zs#00GTp*XUK!dzJ?P*&xgf#081T*?PIjxv3?I)k+|ak`;uGPs=aLO)OEe zGBVOpDlRQ3$S*2MO@WFQD_KPY#SIM%3}SVZQc{bPi!uvJGV}A4tiXmS7%0`&26!_v hi7?}~8fZHhG%$iFB!>iev$BDN7=h3dNLPY53;?EBF3bP` literal 0 HcmV?d00001 diff --git a/common/src/main/resources/deviceFingerprinting/packs/1 b/common/src/main/resources/deviceFingerprinting/packs/1 new file mode 100644 index 0000000000000000000000000000000000000000..5303a21b7ccefb96225f2518393c6ac7ec3a8421 GIT binary patch literal 200 zcmWIWW@Zs#00GTp*XZ*#4Dta$HVAVAaY15owq9;>ZfZ$lwGxP7N>p|g6p~8@EcY*&xgf#081T*?PIjxv3?I)k+|ak`;uGPs=aLO)OEe zGBVOpDlRQ3$S*2MO@WFQD_KPY#SIM%3}SVZQc{bPi!uvJGV}A4tiXmS7#b?o)&_Vp iGKnzbwi{?Y7&I_~C?uBzc(byBgcyO)5=d8pI1B(9moJ3? literal 0 HcmV?d00001 diff --git a/common/src/main/resources/deviceFingerprinting/packs/12 b/common/src/main/resources/deviceFingerprinting/packs/12 new file mode 100644 index 0000000000000000000000000000000000000000..4104d6d2fed0a4e796374530f7f6874f386863ba GIT binary patch literal 201 zcmWIWW@Zs#00GTp*Jx+v?gN29HVAVAaY15owq9;>ZfZ$lwGxP7N>6)&_Vp iGKnzbwi{?Y7&I_~C?uBzc(byBgcyO)5=d8pI1B)8EHE|z literal 0 HcmV?d00001 diff --git a/common/src/main/resources/deviceFingerprinting/packs/15 b/common/src/main/resources/deviceFingerprinting/packs/15 new file mode 100644 index 0000000000000000000000000000000000000000..cac2af0b1013823143b35d013976897f2b9df822 GIT binary patch literal 201 zcmWIWW@Zs#00GTp*XUo?F|mO_HVAVAaY15owq9;>ZfZ$lwGxP7N> literal 0 HcmV?d00001 diff --git a/common/src/main/resources/deviceFingerprinting/packs/16 b/common/src/main/resources/deviceFingerprinting/packs/16 new file mode 100644 index 0000000000000000000000000000000000000000..5aaf529a1d67fc66448bd268b659d7ee0e635d36 GIT binary patch literal 201 zcmWIWW@Zs#00GTp*JzO`FZ~07Y!K!K;)2BFY`xs%+|-i9Y9$ay$qGWpr{x#rCYC5! z85!v)6_*wip|g6p~8p|g6p~8p|g6p~8ZfZ$lwGxP7N>ZfZ$lwGxP7N>p|g6p~8iev$BDN7=h3dNLPY53;^>kFKYk* literal 0 HcmV?d00001 diff --git a/common/src/main/resources/deviceFingerprinting/packs/6 b/common/src/main/resources/deviceFingerprinting/packs/6 new file mode 100644 index 0000000000000000000000000000000000000000..8bc5b39212686ccd24cb7df9a01ed108d902df6d GIT binary patch literal 200 zcmWIWW@Zs#00GTp*XS~r>rDYbHVAVAaY15owq9;>ZfZ$lwGxP7N>1Ew=)IY!K!K;)2BFY`xs%+|-i9Y9$ay$qGWpr{x#rCYC5! z85!v)6_*wiL+w+71MESX)RT0MQ19t9|Lt5Dt#CB-oD4(fAR9( z^u0Jo61dyn`@j9a&)xmm)iHR;C$!>M`}X6j`+so%7>>W|wrx1}4PE3-Jr}%btoNpb znKVKfJ>pPr5089@Ip!6W-frp1DEZ6?t@xQ48=cm>@OyXTR{;Es9zg}Yq1#R+AO3oC z?LC1@TmQ4E=b=?whQHT%Z)afHtXr-adu+j@Llb8YzPj=0j{4VzFPyY(T;V&v?ae*+ z>|gap?X?4e=Ismbj?bPt_j@a?2OeHizjE*U|Gne+S-1ad-+|YAUmskGyQ)HEkS(cD zQ{kGj9c0+bRaF7$1v!P93|3W8&&VkfoaaFuWwOc@%0R)qoI+g#pF9Iux|5VsET0n? zMZu_?Lir?mCMc&!KJ}DA5%pT1je?RobhxHMx`O?A$VMSa{kcy~JI94eDmU=qLZy}K&T*l#VL3elJVhuLO1&;2g|d>?S3Z5Gtt+>DHZnpg7D~OwXQRXh1#3!HkKogH+9;>qR2c7es#mD2f=l*@j!a3526(qR zVp=Gz+@ddHqKK(lpAbo*NJ>tje9m76Z*M5q{vsI#movCfvUWUu&R;fzOy!mikvvK& zH>HZ={!_V3kA@XoBS$T1!ylaKF}+8@rC-cIrgE7cGm)v>+AoGTUL*~F@RT@~K`}{l zDxX4SQB1iV##kQd2|2SDxTef7GL_q+GNULd=?bz>O{I__sY`&bIGA=$xs0-rsoWNa z=_okI>()`XqzgvyB%wPfFVEq|7uQi#xtV7?j^fH)2#F^ZoVmnPC@yJ|0Qa47Te)4A zc#nc>nRp(>l^cyM9pC$=+R$eOk)_ex!DnCA|% zl-n`0a>$Z28TQHZf^uU_B90Qu-Hn$>qJ*Ty6+G!o;OnB2Zc6Yel!FqI+8&(dNnKK! z!`*o@Y%6$KCTXFda_bmeDD|#2Bvst(Or{jvflY;^T~&j7gj7z_t|DBdw58m(R2pCU zSMJ(J+Cf1{i*ZT>qu8_xt>X(jHG2KeD*SF z<=S2*tKbuvnLNr$$|(4WOk0oP=bB>!AY<$<7a+5q`(^b4P zH)n(tygw;tqMULAO)iac$_>eRQ^9KudAwPz+fPa8kN`UMX0MKci{i$46TJr}xi(1OHrnHR6}6DfC1iOeCe!oIjGC zw;dzVkWNPL@9JDqS39wI*t+(%mKFH>4*UuX8I1poE>9lD-!AW3y0SHuN#GyPojZ43 zc=L$aOJ91bZp|9)>1loY@ZZ)rD>^@`HJvybDgF}dSkj_x9XhEE|1zPyrFmuBuTDNU zrw0G_{Ekz1o-{}9(6qOP)dsYhU880c-=wv-cDC$av~H898f?O+c+HWGYdi427RxjW zztVar-jE0-3`f8I<$l%S;t)0^Q)1Ndiy{tR($~!~!Q|mum+`FKwqh`=;8f1T*j=9CJ zOV58RRdTHs=>LlvZM@cb?8QS(e|w`CAM-^YxZD^?A9x1-T-n*95nC3lK65cdxn+_@ ztgM9SH^I=H53k<8bJ$70P%23vOPl~^Yy~-nuGYy6@fb)fxglxZx%;cTiEQQ^hKa6hk>=Gr z!J9d&hJg{1=ZeJ={|*z0CQ&T$UhE;R+&Vl5qFCbi5g?HW4r$_~qrB&_7bX&Wp;+Rg zkx-1Dnvf>epW}`3_b`!o2gMRCJhQ8uIoNdQN(IFdYw%nRB)UcfvBXC}qNfAoC9-{7 z{b(r0lIxG=^{xI<)uZtgX5{##56>0((ZEArsUFA<8!PJI085rWnpl|2OMKUl=qmWc z67L@46Qk?b6H6R>i4W10=ZPim_9MD?PKhPnikC{2o4=>Mqlp7)9Bi)k`4Z1x_Z3St zu<;*=kqGN(;y~IX+X0+`i6t8y4LtcOZ*%P#Gm^S zT}d2GykswLtuDj+3_#*wEnRu4@)M8y5na8T*cf{*_lePUw}~Z=#{WkRuvT3$8%^YI z9Xnwnv95_FHeLzFNR(<~iN67fo-d6io;h88>tHul){Tc^q-1EkNVd~C?Sm|t&cqTQ zm;eSzG-kX+wps&tf4p+@h>p+#;ho|e} zC9D4o#f= zO!eoH-Lv{GOmuBgygYWWx)ER21R^9VD6zytFp+qk#1dD}gktn0PP{~R==cC8dWI$% zdF_en6Nf#Ko3Dj}^z=(&i4(5_iNviWmUsXr5^<7PV#_DN7>N~$CeE*Wyy{6g+X4Im zCc4TaULKn_)+{hW;xiIUtf>cyL{=o0_y|b!OhjUd_4ux#%H67`84^o;7A6vh5KU~o znKx5EcRd)RD+uD{v7PFBFwe99@FLm9@#O|EM56W)OB{CtNF?4KvBV$3L?Y#(iJ$)> zZ{jSt5sc9_?(p*1v)BjnJe`hMqA>@G&~xR8C7ywaM1(^V%}v#xMYdKSya|kvSZ;WU z?9e!UE<`LTYK2Gd=}~x*Y~nltBVG3iFOLneS)jEb+=_kVw=UG;zl& z-pqL%CK9iPSYq=cFh(NH5KH_WOe97On)t>&)z>Q9uf}f&V{~;FVtF6IJlAEx%VYcT zZ7ooIo~S}Bab_z>Bo+#qcz93s=a8KM9E6FUVuBaRR_pS`V35Qg!AoQl^#n|G1`>(ZfhN9vgg0@1024iD122-T*7@yFke-l%m&mq`BOsBoEr>;i z?|_1&R0_OEwqDP`Na9JLiS?(ePac-|Ufu}JKuGHNL5@}^XbiATLbWo6#ZXC)-hjJ(E~v9w*0$#-b^O830)N`l*C4R2Wam0iCZoj zXStn#j`K?&n|t0cK+~u08vMdo@Ue3IfExZPHyV`a0sOCfs-$~<1G*gP%?G~ onCall) { + Spark.get(this.buildRoute(path), (req, resp) -> this.process(() -> onCall.apply(req, resp))); + } + public void get(String path, Function onCall) { Spark.get(this.buildRoute(path), (req, resp) -> this.process(() -> onCall.apply(req))); } - public void rawPost(String path, Function onCall) { - Spark.post(this.buildRoute(path), (req, resp) -> this.process(() -> onCall.apply(req))); + public void rawPost(String path, BiFunction onCall) { + Spark.post(this.buildRoute(path), (req, resp) -> this.process(() -> onCall.apply(req, resp))); } public void post(String path, Class clazz, RequestProvider onCall) { From aad1fcafa65cabd5c80f5f281f8ed7c3b48ed99a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Elias=20M=C3=BCller?= Date: Sun, 5 Oct 2025 15:46:45 +0200 Subject: [PATCH 02/19] added FingerprintData class and improved device fingerprinting logic --- .../DeviceFingerprinting.java | 136 ++++++------------ .../deviceFingerprinting/FingerprintData.java | 91 ++++++++++++ .../PlayerJoinListener.java | 9 +- 3 files changed, 140 insertions(+), 96 deletions(-) create mode 100644 common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/tooling/deviceFingerprinting/FingerprintData.java diff --git a/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/tooling/deviceFingerprinting/DeviceFingerprinting.java b/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/tooling/deviceFingerprinting/DeviceFingerprinting.java index 73d1fde..92147c3 100644 --- a/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/tooling/deviceFingerprinting/DeviceFingerprinting.java +++ b/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/tooling/deviceFingerprinting/DeviceFingerprinting.java @@ -11,7 +11,6 @@ import org.bukkit.entity.Player; import org.bukkit.event.Listener; import org.bukkit.event.player.PlayerResourcePackStatusEvent; import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; import spark.Response; import java.io.IOException; @@ -21,7 +20,7 @@ import java.net.URI; import java.util.*; public class DeviceFingerprinting extends Appliance { - public record PackInfo(String url, UUID uuid, String hash) { + public record PackInfo(@NotNull String url, @NotNull UUID uuid, @NotNull String hash) { private static final String failingUrl = "http://127.0.0.1:0"; public PackInfo asFailing() { return new PackInfo(failingUrl, this.uuid, this.hash); @@ -29,14 +28,15 @@ public class DeviceFingerprinting extends Appliance { } public enum PackStatus { - ERROR, - SUCCESS; + UNCACHED, + CACHED, + INVALID; public static PackStatus fromBukkitStatus(PlayerResourcePackStatusEvent.Status status) { return switch(status) { - case DISCARDED -> SUCCESS; - case FAILED_DOWNLOAD -> ERROR; - default -> throw new IllegalStateException("Unexpected value: " + status); + case DISCARDED -> CACHED; + case FAILED_DOWNLOAD -> UNCACHED; + default -> INVALID; }; } } @@ -44,102 +44,60 @@ public class DeviceFingerprinting extends Appliance { public enum PlayerStatus { PREPARATION, TESTING, - FINISHED; - } - - public record FingerprintData( - Player player, - PlayerStatus status, - @Nullable Long fingerPrint, - @Nullable List pendingPacks - ) { - public FingerprintData(Player player) { - this(player, PlayerStatus.PREPARATION, null, null); - } + FINISHED, + NEW } private List packs; - private final Map> pendingPacks = new WeakHashMap<>(); + private final Map fingerprints = new WeakHashMap<>(); + private final UUID basePackId = UUID.randomUUID(); @Override public void onEnable() { this.packs = this.readPacksFromConfig(); - } - public void testAllPacks(Player player) { - this.pendingPacks.put(player, Arrays.asList(new PackStatus[this.packs.size()])); - System.out.println("Sending packs..."); - this.packs.forEach(pack -> this.sendPack(player, pack.asFailing())); + public void startFingerprinting(Player player) { + this.fingerprints.put(player, FingerprintData.create(player)); + Main.logger().info(String.format("Sending base ressource-pack with id '%s' to '%s'%n", this.basePackId, player.getName())); + this.sendPack(player, new PackInfo("http://localhost:8080/api/devicefingerprinting/base.zip", this.basePackId, "3296e8bdd30b4f7cffd11c780a1dc70da2948e71")); } - public void onPackReceive(Player player, UUID packId, PlayerResourcePackStatusEvent.Status status) { - if(!this.pendingPacks.containsKey(player)) return; + public void onPackUpdate(Player player, UUID packId, PlayerResourcePackStatusEvent.Status status) { + if(!this.fingerprints.containsKey(player)) return; + FingerprintData playerFingerprint = this.fingerprints.get(player); + if(!playerFingerprint.isInTestingOrPreparation()) return; + + if(packId.equals(this.basePackId)) { + Main.logger().info(String.format("Base pack for '%s' updated: '%s'", player.getName(), status)); + + if(status != PlayerResourcePackStatusEvent.Status.ACCEPTED) return; + Main.logger().info(String.format("Base pack loaded successfully, sending now all packs to '%s'...", player.getName())); + playerFingerprint.setTesting(); + this.packs.forEach(pack -> this.sendPack(player, pack.asFailing())); + return; + } PackInfo pack = this.packs.stream() - .filter(packInfo -> packInfo.uuid.equals(packId)) - .findFirst() + .filter(packInfo -> Objects.equals(packInfo.uuid, packId)) + .findAny() .orElse(null); if(pack == null) return; int packIndex = this.packs.indexOf(pack); - List currentPendingStatus = this.pendingPacks.get(player); - try { - currentPendingStatus.set(packIndex, PackStatus.fromBukkitStatus(status)); - System.out.println(packIndex + " > " + PackStatus.fromBukkitStatus(status)); - } catch(IllegalStateException ignored) { - return; + List pendingPacks = playerFingerprint.getPendingPacks(); + PackStatus newPackStatus = PackStatus.fromBukkitStatus(status); + if(newPackStatus == PackStatus.INVALID) return; + pendingPacks.set(packIndex, newPackStatus); + + playerFingerprint.updateFingerprint(); + if(Objects.requireNonNull(playerFingerprint.getStatus()) == PlayerStatus.NEW) { + Main.logger().info(String.format("Sending fingerprint packs to Player '%s', as it is a unseen Player!", player.getName())); + this.sendNewFingerprint(player, Objects.requireNonNull(playerFingerprint.getFingerPrint())); } - - long fingerPrint = this.calculateFingerprintId(currentPendingStatus); - if(fingerPrint == -1) return; - - if(fingerPrint == 0) { - // new Player - long newFingerprintId = this.generateNewFingerprintId(); - System.out.println("New Fingerprint: " + newFingerprintId); - this.sendMarkedPacks(player, newFingerprintId); - } else { - System.out.println("Fingerprint: " + fingerPrint); - } - - this.pendingPacks.remove(player); } - private long calculateFingerprintId(List packStatus) { - long fingerprintId = 0; - for (int i = 0; i < packStatus.size(); i++) { - var status = packStatus.get(i); - if(status == null) return -1; - switch (status) { - case SUCCESS: - fingerprintId |= 1L << i; - break; - case ERROR: - break; - default: - return -1; - } - } - return fingerprintId; - } - - private long generateNewFingerprintId() { - long id = 0; - Random random = new Random(); - for (int i = 0; i < this.packs.size() / 2; i++) { - while (true) { - int bitIndex = random.nextInt(this.packs.size()); - if ((id & (1L << bitIndex)) == 0) { - id |= 1L << bitIndex; - break; - } - } - } - return id; - } - - private void sendMarkedPacks(Player player, long fingerprintId) { + private void sendNewFingerprint(Player player, long fingerprintId) { for (int i = 0; i < this.packs.size(); i++) { if ((fingerprintId & (1L << i)) != 0) { PackInfo pack = this.packs.get(i); @@ -149,7 +107,6 @@ public class DeviceFingerprinting extends Appliance { } public void sendPack(Player player, PackInfo pack) { - System.out.println("Sending pack: " + pack.url); player.sendResourcePacks( ResourcePackRequest.resourcePackRequest() .required(true) @@ -161,12 +118,9 @@ public class DeviceFingerprinting extends Appliance { try (InputStreamReader reader = new InputStreamReader(Objects.requireNonNull(Main.class.getResourceAsStream("/deviceFingerprinting/packs.json")))) { Type packListType = new TypeToken>(){}.getType(); List packs = new Gson().fromJson(reader, packListType); - - if (packs.isEmpty()) - throw new IllegalStateException("No resource packs found in packs.json."); - + if (packs.isEmpty()) throw new IllegalStateException("No resource packs found in packs.json."); return packs; - } catch (Exception e) { + } catch (IOException e) { throw new IllegalStateException("Failed to parse packs.json.", e); } } @@ -209,6 +163,10 @@ public class DeviceFingerprinting extends Appliance { } } + public List getPacks() { + return this.packs; + } + @Override protected @NotNull List listeners() { return List.of( diff --git a/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/tooling/deviceFingerprinting/FingerprintData.java b/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/tooling/deviceFingerprinting/FingerprintData.java new file mode 100644 index 0000000..f349e44 --- /dev/null +++ b/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/tooling/deviceFingerprinting/FingerprintData.java @@ -0,0 +1,91 @@ +package eu.mhsl.craftattack.spawn.common.appliances.tooling.deviceFingerprinting; + +import eu.mhsl.craftattack.spawn.core.Main; +import org.bukkit.entity.Player; +import org.jetbrains.annotations.Nullable; + +import java.util.Arrays; +import java.util.List; +import java.util.Random; + +class FingerprintData { + public final Player player; + private DeviceFingerprinting.PlayerStatus status; + private @Nullable Long fingerPrint; + private final List pendingPacks; + int packCount = Main.instance().getAppliance(DeviceFingerprinting.class).getPacks().size(); + + private FingerprintData(Player player) { + this.player = player; + this.status = DeviceFingerprinting.PlayerStatus.PREPARATION; + this.fingerPrint = null; + this.pendingPacks = Arrays.asList(new DeviceFingerprinting.PackStatus[this.packCount]); + } + + public static FingerprintData create(Player player) { + return new FingerprintData(player); + } + + public void setTesting() { + this.status = DeviceFingerprinting.PlayerStatus.TESTING; + } + + public void updateFingerprint() { + long fingerPrint = 0; + for (int i = 0; i < this.pendingPacks.size(); i++) { + var status = this.pendingPacks.get(i); + if(status == null) return; + switch (status) { + case CACHED: + fingerPrint |= 1L << i; + break; + case UNCACHED: + break; + default: + return; + } + } + + if(fingerPrint == 0) { + this.status = DeviceFingerprinting.PlayerStatus.NEW; + this.fingerPrint = this.createNewFingerprint(); + Main.logger().info(String.format("Player %s's was marked as a new Player!", this.player.getName())); + } else { + this.status = DeviceFingerprinting.PlayerStatus.FINISHED; + this.fingerPrint = fingerPrint; + } + + Main.logger().info(String.format("Player %s's fingerprint is '%s'", this.player.getName(), fingerPrint)); + } + + private long createNewFingerprint() { + long id = 0; + Random random = new Random(); + for (int i = 0; i < this.packCount / 2; i++) { + while (true) { + int bitIndex = random.nextInt(this.packCount); + if ((id & (1L << bitIndex)) == 0) { + id |= 1L << bitIndex; + break; + } + } + } + return id; + } + + public List getPendingPacks() { + return this.pendingPacks; + } + + public DeviceFingerprinting.PlayerStatus getStatus() { + return this.status; + } + + public @Nullable Long getFingerPrint() { + return this.fingerPrint; + } + + public boolean isInTestingOrPreparation() { + return this.status == DeviceFingerprinting.PlayerStatus.TESTING || this.status == DeviceFingerprinting.PlayerStatus.PREPARATION; + } +} diff --git a/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/tooling/deviceFingerprinting/PlayerJoinListener.java b/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/tooling/deviceFingerprinting/PlayerJoinListener.java index 2d92e04..fec1983 100644 --- a/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/tooling/deviceFingerprinting/PlayerJoinListener.java +++ b/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/tooling/deviceFingerprinting/PlayerJoinListener.java @@ -8,17 +8,12 @@ import org.bukkit.event.player.PlayerResourcePackStatusEvent; class PlayerJoinListener extends ApplianceListener { @EventHandler public void onJoin(PlayerJoinEvent event) { -// if(Bukkit.getServer().getServerResourcePack() != null && !event.getPlayer().hasResourcePack()) { -// System.out.println("NO RESSOURCEPACK"); -// return; -// } - - this.getAppliance().testAllPacks(event.getPlayer()); + this.getAppliance().startFingerprinting(event.getPlayer()); } @EventHandler public void onResourcePackEvent(PlayerResourcePackStatusEvent event) { - this.getAppliance().onPackReceive( + this.getAppliance().onPackUpdate( event.getPlayer(), event.getID(), event.getStatus() From db13a9f0a2413df7178c5d5d27d78cfe5bde12ff Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Elias=20M=C3=BCller?= Date: Sun, 19 Oct 2025 12:54:31 +0200 Subject: [PATCH 03/19] simplified event message handling logic in `ChatMessagesListener` --- .../chatMessages/ChatMessagesListener.java | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-) diff --git a/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/metaGameplay/chatMessages/ChatMessagesListener.java b/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/metaGameplay/chatMessages/ChatMessagesListener.java index 561c5bf..740ed52 100644 --- a/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/metaGameplay/chatMessages/ChatMessagesListener.java +++ b/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/metaGameplay/chatMessages/ChatMessagesListener.java @@ -21,18 +21,17 @@ class ChatMessagesListener extends ApplianceListener { public void onPlayerChatEvent(AsyncChatEvent event) { event.renderer( (source, sourceDisplayName, message, viewer) -> - Component.text("") + Component.text() .append(this.getAppliance().getReportablePlayerName(source)) .append(Component.text(" > ").color(TextColor.color(Color.GRAY.asRGB()))) .append(message).color(TextColor.color(Color.SILVER.asRGB())) + .build() ); } @EventHandler(priority = EventPriority.HIGH) public void onPlayerJoin(PlayerJoinEvent event) { - boolean wasHidden = event.joinMessage() == null; - event.joinMessage(null); - if(wasHidden) return; + if(event.joinMessage() == null) return; IteratorUtil.onlinePlayers(player -> { if(!Settings.instance().getSetting(player, Settings.Key.ShowJoinAndLeaveMessages, Boolean.class)) return; player.sendMessage( @@ -45,9 +44,7 @@ class ChatMessagesListener extends ApplianceListener { @EventHandler public void onPlayerLeave(PlayerQuitEvent event) { - boolean wasHidden = event.quitMessage() == null; - event.quitMessage(null); - if(wasHidden) return; + if(event.quitMessage() == null) return; IteratorUtil.onlinePlayers(player -> { if(!Settings.instance().getSetting(player, Settings.Key.ShowJoinAndLeaveMessages, Boolean.class)) return; player.sendMessage( From c2204790524462b7ee7ed0988a98cb81d1a92a52 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Elias=20M=C3=BCller?= Date: Mon, 27 Oct 2025 14:25:44 +0100 Subject: [PATCH 04/19] WIP: refactored report and feedback systems; updated repository models, APIs, and component utilities --- .../CraftAttackReportRepository.java | 5 +- .../api/repositories/ReportRepository.java | 17 +++-- .../metaGameplay/report/Report.java | 72 +++++++++++-------- .../spawn/core/util/text/ComponentUtil.java | 8 ++- .../api/repositories/FeedbackRepository.java | 18 +++-- .../api/repositories/WhitelistRepository.java | 13 ++-- .../metaGameplay/feedback/Feedback.java | 29 +++----- .../feedback/FeedbackCommand.java | 1 + .../feedback/RequestFeedbackCommand.java | 1 + .../appliances/tooling/strike/Strike.java | 21 ++++++ .../tooling/whitelist/Whitelist.java | 8 +-- 11 files changed, 110 insertions(+), 83 deletions(-) create mode 100644 craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/tooling/strike/Strike.java diff --git a/common/src/main/java/eu/mhsl/craftattack/spawn/common/api/repositories/CraftAttackReportRepository.java b/common/src/main/java/eu/mhsl/craftattack/spawn/common/api/repositories/CraftAttackReportRepository.java index 46723f5..232f4c7 100644 --- a/common/src/main/java/eu/mhsl/craftattack/spawn/common/api/repositories/CraftAttackReportRepository.java +++ b/common/src/main/java/eu/mhsl/craftattack/spawn/common/api/repositories/CraftAttackReportRepository.java @@ -11,15 +11,14 @@ public class CraftAttackReportRepository extends ReportRepository { public ReqResp queryReports(UUID player) { return this.get( - "report", - (parameters) -> parameters.addParameter("uuid", player.toString()), + "users/%s/reports".formatted(player.toString()), PlayerReports.class ); } public ReqResp createReport(ReportCreationInfo data) { return this.post( - "report", + "reports", data, ReportUrl.class ); diff --git a/common/src/main/java/eu/mhsl/craftattack/spawn/common/api/repositories/ReportRepository.java b/common/src/main/java/eu/mhsl/craftattack/spawn/common/api/repositories/ReportRepository.java index 4ed05cb..0e3fec5 100644 --- a/common/src/main/java/eu/mhsl/craftattack/spawn/common/api/repositories/ReportRepository.java +++ b/common/src/main/java/eu/mhsl/craftattack/spawn/common/api/repositories/ReportRepository.java @@ -23,19 +23,18 @@ public abstract class ReportRepository extends HttpRepository { public record PlayerReports( List from_self, - Object to_self + List to_self ) { public record Report( - @Nullable Reporter reported, - @NotNull String subject, - boolean draft, - @NotNull String status, + @Nullable UUID reported, + @NotNull String reason, + @Nullable Long created, + @Nullable Status status, @NotNull String url ) { - public record Reporter( - @NotNull String username, - @NotNull String uuid - ) { + public enum Status { + open, + closed, } } } diff --git a/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/metaGameplay/report/Report.java b/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/metaGameplay/report/Report.java index d5b1551..543abe0 100644 --- a/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/metaGameplay/report/Report.java +++ b/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/metaGameplay/report/Report.java @@ -6,6 +6,7 @@ import eu.mhsl.craftattack.spawn.core.api.client.ReqResp; import eu.mhsl.craftattack.spawn.common.api.repositories.CraftAttackReportRepository; import eu.mhsl.craftattack.spawn.core.appliance.Appliance; import eu.mhsl.craftattack.spawn.core.appliance.ApplianceCommand; +import eu.mhsl.craftattack.spawn.core.util.text.ComponentUtil; import net.kyori.adventure.text.Component; import net.kyori.adventure.text.ComponentBuilder; import net.kyori.adventure.text.TextComponent; @@ -19,7 +20,9 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import java.util.List; +import java.util.Objects; import java.util.Optional; +import java.util.function.Function; public class Report extends Appliance { public static Component helpText() { @@ -78,7 +81,7 @@ public class Report extends Appliance { .appendNewline() .append( Component - .text(createdReport.data().url(), NamedTextColor.GRAY) // URL mit Weltkugel-Emoji + .text(createdReport.data().url(), NamedTextColor.GRAY) .clickEvent(ClickEvent.clickEvent(ClickEvent.Action.OPEN_URL, createdReport.data().url())) ) .appendNewline() @@ -128,43 +131,50 @@ public class Report extends Appliance { return; } - List reports = userReports - .data() - .from_self() - .stream() - .filter(report -> !report.draft()) - .toList() - .reversed(); + Function, List> filterClosed = reports -> reports.stream() + .filter(report -> Objects.equals(report.status(), ReportRepository.PlayerReports.Report.Status.closed)) + .toList(); - if(reports.isEmpty()) { - issuer.sendMessage( - Component.text() - .append(Component.text("Du hast noch niemanden reportet.", NamedTextColor.RED)) - .appendNewline() - .append(Component.text("Um jemanden zu melden, nutze /report", NamedTextColor.GRAY)) - ); - return; - } + List reportsToOthers = filterClosed.apply(userReports.data().from_self()).reversed(); + List reportsToSelf = filterClosed.apply(userReports.data().to_self()).reversed(); ComponentBuilder component = Component.text() - .append(Component.newline()) - .append(Component.text("Von dir erstellte Reports: ", NamedTextColor.GOLD)) - .appendNewline(); + .append(Component.text( + !reportsToSelf.isEmpty() + ? "Du wurdest insgesamt %d mal von anderen Spielern gemeldet.".formatted(reportsToSelf.size()) + : "Du wurdest von keinem anderen Spieler gemeldet.", + NamedTextColor.GOLD) + ); - reports.forEach(report -> { - component - .append(Component.text(" - ", NamedTextColor.WHITE)) - .append( - report.reported() != null - ? Component.text(report.reported().username(), NamedTextColor.WHITE) - : Component.text("Unbekannt", NamedTextColor.YELLOW) - ) - .append(Component.text(String.format(": %s", report.subject()), NamedTextColor.GRAY)) + component.appendNewline(); + + component.append(Component.text("Von dir erstellte Reports: ", NamedTextColor.GOLD)); + reportsToOthers.forEach(report -> { + Component button = Component.text("[\uD83D\uDC41/\uD83D\uDD8A]") .clickEvent(ClickEvent.openUrl(report.url())) - .hoverEvent(HoverEvent.showText(Component.text("Klicke, um den Report einzusehen.", NamedTextColor.GOLD))); - component.appendNewline(); + .hoverEvent(HoverEvent.showText(ComponentUtil.clickLink(report.url()))); + + Component reportedDisplayName = report.reported() != null + ? Component.text(Optional.ofNullable(Bukkit.getOfflinePlayer(report.reported()).getName()).orElse(report.reported().toString()), NamedTextColor.WHITE) + : Component.text("Unbekannt", NamedTextColor.YELLOW); + + component + .appendNewline() + .append(Component.text(" \u27A1 ", NamedTextColor.GRAY)) + .append(button) + .append(Component.text(" du gegen ", NamedTextColor.GRAY)) + .append(reportedDisplayName) + .append(Component.text(String.format(": %s", report.reason()), NamedTextColor.GRAY)); }); + if(reportsToOthers.isEmpty()) { + component + .appendNewline() + .append(Component.text("Du hast noch niemanden reportet.", NamedTextColor.RED)) + .appendNewline() + .append(Component.text("Um jemanden zu melden, nutze /report", NamedTextColor.GRAY)); + } + issuer.sendMessage(component.build()); } diff --git a/core/src/main/java/eu/mhsl/craftattack/spawn/core/util/text/ComponentUtil.java b/core/src/main/java/eu/mhsl/craftattack/spawn/core/util/text/ComponentUtil.java index 6be7844..d802b36 100644 --- a/core/src/main/java/eu/mhsl/craftattack/spawn/core/util/text/ComponentUtil.java +++ b/core/src/main/java/eu/mhsl/craftattack/spawn/core/util/text/ComponentUtil.java @@ -5,6 +5,7 @@ import eu.mhsl.craftattack.spawn.core.util.statistics.ServerMonitor; import net.kyori.adventure.text.Component; import net.kyori.adventure.text.ComponentBuilder; import net.kyori.adventure.text.TextComponent; +import net.kyori.adventure.text.event.ClickEvent; import net.kyori.adventure.text.format.NamedTextColor; import net.kyori.adventure.text.format.TextColor; import org.bukkit.Bukkit; @@ -19,7 +20,12 @@ import java.util.stream.Stream; public class ComponentUtil { public static TextComponent pleaseWait() { - return Component.text("Bitte warte einen Augenblick...", NamedTextColor.GRAY); + return Component.text("\uD83D\uDCBE Daten werden geladen... Warte einen Augenblick!", NamedTextColor.GRAY); + } + + public static TextComponent clickLink(String url) { + return Component.text("Klicke, um zu öffnen: \uD83D\uDD17[%s]".formatted(url)) + .clickEvent(ClickEvent.openUrl(url)); } public static Component clearedSpace() { diff --git a/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/api/repositories/FeedbackRepository.java b/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/api/repositories/FeedbackRepository.java index d8243a9..3e551a7 100644 --- a/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/api/repositories/FeedbackRepository.java +++ b/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/api/repositories/FeedbackRepository.java @@ -1,13 +1,10 @@ package eu.mhsl.craftattack.spawn.craftattack.api.repositories; -import com.google.common.reflect.TypeToken; import eu.mhsl.craftattack.spawn.core.api.client.HttpRepository; import eu.mhsl.craftattack.spawn.core.api.client.ReqResp; import eu.mhsl.craftattack.spawn.common.api.CraftAttackApi; -import java.lang.reflect.Type; import java.util.List; -import java.util.Map; import java.util.UUID; public class FeedbackRepository extends HttpRepository { @@ -15,14 +12,15 @@ public class FeedbackRepository extends HttpRepository { super(CraftAttackApi.getBaseUri(), new RequestModifier(null, CraftAttackApi::withAuthorizationHeader)); } - public record Request(String event, List users) { + public record Request(String event, String title, List users) { } - public ReqResp> createFeedbackUrls(Request data) { - final Type responseType = new TypeToken>() { - }.getType(); - ReqResp rawData = this.post("feedback", data, Object.class); - // TODO: use convertToTypeToken from ReqResp - return new ReqResp<>(rawData.status(), this.gson.fromJson(this.gson.toJson(rawData.data()), responseType)); + public record Response(List feedback) { + public record Feedback(UUID uuid, String url) { + } + } + + public ReqResp createFeedbackUrls(Request data) { + return this.post("feedback", data, Response.class); } } diff --git a/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/api/repositories/WhitelistRepository.java b/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/api/repositories/WhitelistRepository.java index 8e3eda4..81aea86 100644 --- a/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/api/repositories/WhitelistRepository.java +++ b/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/api/repositories/WhitelistRepository.java @@ -4,6 +4,7 @@ import eu.mhsl.craftattack.spawn.core.api.client.HttpRepository; import eu.mhsl.craftattack.spawn.core.api.client.ReqResp; import eu.mhsl.craftattack.spawn.common.api.CraftAttackApi; +import java.util.List; import java.util.UUID; public class WhitelistRepository extends HttpRepository { @@ -16,17 +17,15 @@ public class WhitelistRepository extends HttpRepository { String username, String firstname, String lastname, - Long banned_until, - Long outlawed_until + List strikes ) { + public record Strike(int at, int weight) { + } } - private record UserQuery(UUID uuid) {} - public ReqResp getUserData(UUID userId) { - return this.post( - "player", - new UserQuery(userId), + return this.get( + "users/%s".formatted(userId.toString()), UserData.class ); } diff --git a/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/metaGameplay/feedback/Feedback.java b/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/metaGameplay/feedback/Feedback.java index b588c96..37eb437 100644 --- a/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/metaGameplay/feedback/Feedback.java +++ b/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/metaGameplay/feedback/Feedback.java @@ -1,7 +1,7 @@ package eu.mhsl.craftattack.spawn.craftattack.appliances.metaGameplay.feedback; -import eu.mhsl.craftattack.spawn.core.Main; import eu.mhsl.craftattack.spawn.core.api.client.ReqResp; +import eu.mhsl.craftattack.spawn.core.util.text.ComponentUtil; import eu.mhsl.craftattack.spawn.craftattack.api.repositories.FeedbackRepository; import eu.mhsl.craftattack.spawn.core.appliance.Appliance; import eu.mhsl.craftattack.spawn.core.appliance.ApplianceCommand; @@ -9,7 +9,6 @@ import eu.mhsl.craftattack.spawn.core.api.HttpStatus; import net.kyori.adventure.text.Component; import net.kyori.adventure.text.ComponentBuilder; import net.kyori.adventure.text.TextComponent; -import net.kyori.adventure.text.event.ClickEvent; import net.kyori.adventure.text.event.HoverEvent; import net.kyori.adventure.text.format.NamedTextColor; import org.bukkit.entity.Entity; @@ -18,32 +17,27 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import java.util.List; -import java.util.Map; -import java.util.UUID; public class Feedback extends Appliance { public Feedback() { super("feedback"); } - public void requestFeedback(String eventName, List receivers, @Nullable String question) { - ReqResp> response = this.queryRepository(FeedbackRepository.class).createFeedbackUrls( - new FeedbackRepository.Request(eventName, receivers.stream().map(Entity::getUniqueId).toList()) + public void requestFeedback(String eventName, String title, List receivers, @Nullable String question) { + ReqResp response = this.queryRepository(FeedbackRepository.class).createFeedbackUrls( + new FeedbackRepository.Request(eventName, title, receivers.stream().map(Entity::getUniqueId).toList()) ); - System.out.println(response.toString()); - System.out.println(response.status()); - - if(response.status() != HttpStatus.CREATED) throw new RuntimeException(); + if(response.status() != HttpStatus.OK) throw new RuntimeException(); Component border = Component.text("-".repeat(40), NamedTextColor.GRAY); receivers.forEach(player -> { - String feedbackUrl = response.data().get(player.getUniqueId()); - if(feedbackUrl == null) { - Main.logger().warning(String.format("FeedbackUrl not found for player '%s' from backend!", player.getUniqueId())); - return; - } + String feedbackUrl = response.data().feedback().stream() + .filter(feedback -> feedback.uuid().equals(player.getUniqueId())) + .findFirst() + .orElseThrow() + .url(); ComponentBuilder message = Component.text() .append(border) @@ -58,8 +52,7 @@ public class Feedback extends Appliance { message .append(Component.text("Klicke hier und gib uns Feedback, damit wir dein Spielerlebnis verbessern können!", NamedTextColor.DARK_GREEN) - .clickEvent(ClickEvent.openUrl(feedbackUrl))) - .hoverEvent(HoverEvent.showText(Component.text("Klicke, um Feedback zu geben."))) + .hoverEvent(HoverEvent.showText(ComponentUtil.clickLink(feedbackUrl)))) .appendNewline() .append(border); diff --git a/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/metaGameplay/feedback/FeedbackCommand.java b/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/metaGameplay/feedback/FeedbackCommand.java index a95f0b0..59abc5e 100644 --- a/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/metaGameplay/feedback/FeedbackCommand.java +++ b/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/metaGameplay/feedback/FeedbackCommand.java @@ -22,6 +22,7 @@ class FeedbackCommand extends ApplianceCommand.PlayerChecked { Main.instance(), () -> this.getAppliance().requestFeedback( "self-issued-ingame", + "Dein Feedback an uns", List.of(this.getPlayer()), null ) diff --git a/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/metaGameplay/feedback/RequestFeedbackCommand.java b/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/metaGameplay/feedback/RequestFeedbackCommand.java index bc5df1c..f7be48c 100644 --- a/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/metaGameplay/feedback/RequestFeedbackCommand.java +++ b/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/metaGameplay/feedback/RequestFeedbackCommand.java @@ -20,6 +20,7 @@ class RequestFeedbackCommand extends ApplianceCommand { Main.instance(), () -> this.getAppliance().requestFeedback( "admin-issued-ingame", + "Hilf uns dein Spielerlebnis zu verbessern!", new ArrayList<>(Bukkit.getOnlinePlayers()), String.join(" ", args) ) ); diff --git a/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/tooling/strike/Strike.java b/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/tooling/strike/Strike.java new file mode 100644 index 0000000..59e5010 --- /dev/null +++ b/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/tooling/strike/Strike.java @@ -0,0 +1,21 @@ +package eu.mhsl.craftattack.spawn.craftattack.appliances.tooling.strike; + +import eu.mhsl.craftattack.spawn.core.appliance.Appliance; + +import java.time.Duration; +import java.util.Map; + +public class Strike extends Appliance { + public Strike() { + super("strike"); + } + + private final Map strikePunishmentMap = Map.of( + 1, Duration.ofHours(1), + 2, Duration.ofHours(24), + 3, Duration.ofDays(3), + 4, Duration.ofDays(7) + ); + + +} diff --git a/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/tooling/whitelist/Whitelist.java b/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/tooling/whitelist/Whitelist.java index be76411..0e55b0a 100644 --- a/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/tooling/whitelist/Whitelist.java +++ b/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/tooling/whitelist/Whitelist.java @@ -47,7 +47,7 @@ public class Whitelist extends Appliance { player.getUniqueId() ); } - this.queryAppliance(Outlawed.class).updateForcedStatus(player, this.timestampRelevant(user.outlawed_until())); + this.queryAppliance(Outlawed.class).updateForcedStatus(player, this.timestampRelevant(0L)); // TODO String purePlayerName = Floodgate.isBedrock(player) ? Floodgate.getBedrockPlayer(player).getUsername() @@ -67,14 +67,14 @@ public class Whitelist extends Appliance { Main.instance().getLogger().info(String.format("Running integrityCheck for %s", name)); boolean overrideCheck = this.localConfig().getBoolean("overrideIntegrityCheck", false); WhitelistRepository.UserData user = overrideCheck - ? new WhitelistRepository.UserData(uuid, name, "", "", 0L, 0L) + ? new WhitelistRepository.UserData(uuid, name, "", "", List.of()) : this.fetchUserData(uuid); this.userData.put(uuid, user); Main.logger().info(String.format("got userdata %s", user.toString())); - if(this.timestampRelevant(user.banned_until())) { - Instant bannedDate = new Date(user.banned_until() * 1000L) + if(this.timestampRelevant(0L)) { //TODO + Instant bannedDate = new Date(0 * 1000L) // TODO .toInstant() .plus(1, ChronoUnit.HOURS); From bc5c9a2a131194917da9df2c57c07858c6669bdd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Elias=20M=C3=BCller?= Date: Mon, 27 Oct 2025 16:02:13 +0100 Subject: [PATCH 05/19] added AntiIllegalBundlePicker to track and notify admins on illegal bundle interactions --- .../AntiIllegalBundlePicker.java | 78 +++++++++++++++++++ .../OnBundlePickListener.java | 18 +++++ 2 files changed, 96 insertions(+) create mode 100644 common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/security/antiIllegalBundlePicker/AntiIllegalBundlePicker.java create mode 100644 common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/security/antiIllegalBundlePicker/OnBundlePickListener.java diff --git a/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/security/antiIllegalBundlePicker/AntiIllegalBundlePicker.java b/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/security/antiIllegalBundlePicker/AntiIllegalBundlePicker.java new file mode 100644 index 0000000..d75313b --- /dev/null +++ b/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/security/antiIllegalBundlePicker/AntiIllegalBundlePicker.java @@ -0,0 +1,78 @@ +package eu.mhsl.craftattack.spawn.common.appliances.security.antiIllegalBundlePicker; + +import eu.mhsl.craftattack.spawn.common.appliances.tooling.acInform.AcInform; +import eu.mhsl.craftattack.spawn.core.Main; +import eu.mhsl.craftattack.spawn.core.appliance.Appliance; +import org.bukkit.Bukkit; +import org.bukkit.Material; +import org.bukkit.entity.Player; +import org.bukkit.event.Listener; +import org.bukkit.event.inventory.InventoryClickEvent; +import org.bukkit.inventory.InventoryView; +import org.bukkit.inventory.ItemStack; +import org.bukkit.inventory.meta.BundleMeta; +import org.jetbrains.annotations.NotNull; + +import java.util.*; +import java.util.stream.Collectors; + +public class AntiIllegalBundlePicker extends Appliance { + private static final int visibleSlotsInBundle = 9; + + public void trackBundle(InventoryClickEvent event) { + ItemStack bundle = Objects.requireNonNull(event.getCurrentItem()); + final int rawSlot = event.getRawSlot(); + final Player player = (Player) event.getWhoClicked(); + final InventoryView view = event.getView(); + final List before = this.getBundleContents(bundle); + + Bukkit.getScheduler().runTask(Main.instance(), () -> { + ItemStack afterStack = view.getItem(rawSlot); + if(afterStack == null || afterStack.getType() != Material.BUNDLE) return; + + List after = this.getBundleContents(afterStack); + int removedSlotIndex = this.findRemoved(before, after); + + if(removedSlotIndex >= visibleSlotsInBundle) { + Main.instance().getAppliance(AcInform.class).notifyAdmins( + "internal", + player.getName(), + "illegalBundlePick", + (float) removedSlotIndex + ); + } + }); + } + + private int findRemoved(@NotNull List before, @NotNull List after) { + for (int i = 0; i < Math.max(before.size(), after.size()); i++) { + ItemStack a = i < after.size() ? after.get(i) : null; + ItemStack b = i < before.size() ? before.get(i) : null; + + if (b == null && a == null) continue; + if (b == null) throw new IllegalStateException("Size of bundle was smaller before pickup Action"); + + if (a == null) return i; + if (!a.isSimilar(b)) return i; + if (a.getAmount() != b.getAmount()) return i; + } + throw new IllegalStateException("Failed to find picked Item in bundle"); + } + + private List getBundleContents(@NotNull ItemStack bundle) { + if (bundle.getType() != Material.BUNDLE) + throw new IllegalStateException("ItemStack is not a bundle"); + + BundleMeta meta = (BundleMeta) bundle.getItemMeta(); + return meta.getItems().stream() + .map(ItemStack::clone) + .collect(Collectors.toCollection(ArrayList::new)); + } + + @Override + protected @NotNull List listeners() { + return List.of( + new OnBundlePickListener() + ); + } +} diff --git a/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/security/antiIllegalBundlePicker/OnBundlePickListener.java b/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/security/antiIllegalBundlePicker/OnBundlePickListener.java new file mode 100644 index 0000000..b25ae78 --- /dev/null +++ b/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/security/antiIllegalBundlePicker/OnBundlePickListener.java @@ -0,0 +1,18 @@ +package eu.mhsl.craftattack.spawn.common.appliances.security.antiIllegalBundlePicker; + +import eu.mhsl.craftattack.spawn.core.appliance.ApplianceListener; +import org.bukkit.Material; +import org.bukkit.event.EventHandler; +import org.bukkit.event.inventory.InventoryAction; +import org.bukkit.event.inventory.InventoryClickEvent; +import org.bukkit.inventory.ItemStack; + +class OnBundlePickListener extends ApplianceListener { + @EventHandler + public void onBundlePick(InventoryClickEvent event) { + if(!event.getAction().equals(InventoryAction.PICKUP_FROM_BUNDLE)) return; + final ItemStack bundle = event.getCurrentItem(); + if (bundle == null || bundle.getType() != Material.BUNDLE) return; + this.getAppliance().trackBundle(event); + } +} From e745ff4721601dbe8075e05aec4c3ddc07ddfdf2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Elias=20M=C3=BCller?= Date: Mon, 27 Oct 2025 17:10:44 +0100 Subject: [PATCH 06/19] added AntiFormattedBook to detect and sanitize illegal book formatting --- .../antiFormattedBook/AntiFormattedBook.java | 66 +++++++++++++++++++ .../antiFormattedBook/BookEditListener.java | 36 ++++++++++ 2 files changed, 102 insertions(+) create mode 100644 common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/security/antiFormattedBook/AntiFormattedBook.java create mode 100644 common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/security/antiFormattedBook/BookEditListener.java diff --git a/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/security/antiFormattedBook/AntiFormattedBook.java b/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/security/antiFormattedBook/AntiFormattedBook.java new file mode 100644 index 0000000..6af6d80 --- /dev/null +++ b/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/security/antiFormattedBook/AntiFormattedBook.java @@ -0,0 +1,66 @@ +package eu.mhsl.craftattack.spawn.common.appliances.security.antiFormattedBook; + +import eu.mhsl.craftattack.spawn.core.appliance.Appliance; +import net.kyori.adventure.text.*; +import net.kyori.adventure.text.format.Style; +import net.kyori.adventure.text.format.TextColor; +import net.kyori.adventure.text.format.TextDecoration; +import org.bukkit.event.Listener; +import org.bukkit.inventory.meta.BookMeta; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.List; +import java.util.Objects; + +public class AntiFormattedBook extends Appliance { + private static final char SECTION = '\u00A7'; + + public boolean containsFormatting(BookMeta meta) { + if (this.hasFormattingDeep(meta.title())) return true; + if (this.hasFormattingDeep(meta.author())) return true; + + for (Component c : meta.pages()) { + if (this.hasFormattingDeep(c)) return true; + } + return false; + } + + private boolean hasFormattingDeep(@Nullable Component component) { + if(component == null) return false; + if (this.hastFormatting(component)) return true; + + if (component instanceof TextComponent tc && tc.content().indexOf(SECTION) >= 0) return true; + + if (component instanceof NBTComponent nbt) { + if (nbt.separator() != null && this.hasFormattingDeep(nbt.separator())) return true; + } + + for (Component child : component.children()) { + if (this.hasFormattingDeep(child)) return true; + } + return false; + } + + private boolean hastFormatting(Component component) { + Style style = component.style(); + + TextColor color = style.color(); + if (color != null) return true; + if (style.font() != null) return true; + if (style.insertion() != null && !Objects.requireNonNull(style.insertion()).isEmpty()) return true; + + for (var decoration : style.decorations().entrySet()) { + if (decoration.getValue() == TextDecoration.State.TRUE) return true; + } + + return style.hoverEvent() != null || style.clickEvent() != null; + } + + @Override + protected @NotNull List listeners() { + return List.of( + new BookEditListener() + ); + } +} diff --git a/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/security/antiFormattedBook/BookEditListener.java b/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/security/antiFormattedBook/BookEditListener.java new file mode 100644 index 0000000..1fcf3c9 --- /dev/null +++ b/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/security/antiFormattedBook/BookEditListener.java @@ -0,0 +1,36 @@ +package eu.mhsl.craftattack.spawn.common.appliances.security.antiFormattedBook; + +import eu.mhsl.craftattack.spawn.common.appliances.tooling.acInform.AcInform; +import eu.mhsl.craftattack.spawn.core.Main; +import eu.mhsl.craftattack.spawn.core.appliance.ApplianceListener; +import net.kyori.adventure.text.Component; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.player.PlayerEditBookEvent; +import org.bukkit.inventory.meta.BookMeta; + +import java.util.List; + +class BookEditListener extends ApplianceListener { + @EventHandler + public void onBookEdit(PlayerEditBookEvent event) { + Player player = event.getPlayer(); + BookMeta meta = event.getNewBookMeta(); + + if (this.getAppliance().containsFormatting(meta)) { + Main.instance().getAppliance(AcInform.class).notifyAdmins( + "internal", + player.getName(), + "illegalBookFormatting", + 1f + ); + + BookMeta sanitized = meta.clone(); + sanitized.title(null); + sanitized.author(null); + //noinspection ResultOfMethodCallIgnored + sanitized.pages(List.of(Component.empty())); + event.setNewBookMeta(sanitized); + } + } +} From 469cd19b55ffd54785768a7d91321c073ce75939 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Elias=20M=C3=BCller?= Date: Mon, 27 Oct 2025 17:54:19 +0100 Subject: [PATCH 07/19] added AntiBoatFreecam to detect and notify admins of illegal boat yaw behavior --- .../antiBoatFreecam/AntiBoatFreecam.java | 51 +++++++++++++++++++ 1 file changed, 51 insertions(+) create mode 100644 common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/security/antiBoatFreecam/AntiBoatFreecam.java diff --git a/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/security/antiBoatFreecam/AntiBoatFreecam.java b/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/security/antiBoatFreecam/AntiBoatFreecam.java new file mode 100644 index 0000000..8313799 --- /dev/null +++ b/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/security/antiBoatFreecam/AntiBoatFreecam.java @@ -0,0 +1,51 @@ +package eu.mhsl.craftattack.spawn.common.appliances.security.antiBoatFreecam; + +import eu.mhsl.craftattack.spawn.common.appliances.tooling.acInform.AcInform; +import eu.mhsl.craftattack.spawn.core.Main; +import eu.mhsl.craftattack.spawn.core.appliance.Appliance; +import org.bukkit.Bukkit; +import org.bukkit.entity.Boat; +import org.bukkit.entity.Player; + +import java.util.HashMap; +import java.util.Map; + +@SuppressWarnings("unused") +public class AntiBoatFreecam extends Appliance { + private static final float MAX_YAW_OFFSET = 106.0f; + private final Map violatedPlayers = new HashMap<>(); + + public AntiBoatFreecam() { + Bukkit.getScheduler().runTaskTimerAsynchronously( + Main.instance(), + () -> Bukkit.getOnlinePlayers().forEach(player -> { + if(!(player.getVehicle() instanceof Boat boat)) return; + if(!boat.getPassengers().getFirst().equals(player)) return; + float playerYaw = player.getYaw(); + float boatYaw = boat.getYaw(); + + float yawDelta = wrapDegrees(playerYaw - boatYaw); + if(Math.abs(yawDelta) <= MAX_YAW_OFFSET) return; + + this.violatedPlayers.merge(player, 1f, Float::sum); + float violationCount = this.violatedPlayers.get(player); + if(violationCount != 1 && violationCount % 100 != 0) return; + Main.instance().getAppliance(AcInform.class).notifyAdmins( + "internal", + player.getName(), + "illegalBoatLookYaw", + violationCount + ); + }), + 1L, + 1L + ); + } + + private static float wrapDegrees(float deg) { + deg = deg % 360f; + if (deg >= 180f) deg -= 360f; + if (deg < -180f) deg += 360f; + return deg; + } +} From 239094971c9f78d68518ab4d60fea00ede312c1a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Elias=20M=C3=BCller?= Date: Sun, 2 Nov 2025 14:18:43 +0100 Subject: [PATCH 08/19] Revert "simplified event message handling logic in `ChatMessagesListener`" This reverts commit db13a9f0a2413df7178c5d5d27d78cfe5bde12ff. --- .../chatMessages/ChatMessagesListener.java | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/metaGameplay/chatMessages/ChatMessagesListener.java b/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/metaGameplay/chatMessages/ChatMessagesListener.java index 740ed52..561c5bf 100644 --- a/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/metaGameplay/chatMessages/ChatMessagesListener.java +++ b/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/metaGameplay/chatMessages/ChatMessagesListener.java @@ -21,17 +21,18 @@ class ChatMessagesListener extends ApplianceListener { public void onPlayerChatEvent(AsyncChatEvent event) { event.renderer( (source, sourceDisplayName, message, viewer) -> - Component.text() + Component.text("") .append(this.getAppliance().getReportablePlayerName(source)) .append(Component.text(" > ").color(TextColor.color(Color.GRAY.asRGB()))) .append(message).color(TextColor.color(Color.SILVER.asRGB())) - .build() ); } @EventHandler(priority = EventPriority.HIGH) public void onPlayerJoin(PlayerJoinEvent event) { - if(event.joinMessage() == null) return; + boolean wasHidden = event.joinMessage() == null; + event.joinMessage(null); + if(wasHidden) return; IteratorUtil.onlinePlayers(player -> { if(!Settings.instance().getSetting(player, Settings.Key.ShowJoinAndLeaveMessages, Boolean.class)) return; player.sendMessage( @@ -44,7 +45,9 @@ class ChatMessagesListener extends ApplianceListener { @EventHandler public void onPlayerLeave(PlayerQuitEvent event) { - if(event.quitMessage() == null) return; + boolean wasHidden = event.quitMessage() == null; + event.quitMessage(null); + if(wasHidden) return; IteratorUtil.onlinePlayers(player -> { if(!Settings.instance().getSetting(player, Settings.Key.ShowJoinAndLeaveMessages, Boolean.class)) return; player.sendMessage( From b4ccc3c4c874d1f565c597a4bbf6b0eeb33527bc Mon Sep 17 00:00:00 2001 From: lars Date: Fri, 7 Nov 2025 19:47:32 +0100 Subject: [PATCH 09/19] added statistics appliance in craftattack --- .../tooling/statistics/Statistics.java | 51 +++++++++++++++++++ 1 file changed, 51 insertions(+) create mode 100644 craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/tooling/statistics/Statistics.java diff --git a/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/tooling/statistics/Statistics.java b/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/tooling/statistics/Statistics.java new file mode 100644 index 0000000..535feec --- /dev/null +++ b/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/tooling/statistics/Statistics.java @@ -0,0 +1,51 @@ +package eu.mhsl.craftattack.spawn.craftattack.appliances.tooling.statistics; + +import eu.mhsl.craftattack.spawn.core.Main; +import eu.mhsl.craftattack.spawn.core.api.server.HttpServer; +import eu.mhsl.craftattack.spawn.core.appliance.Appliance; +import org.bukkit.Bukkit; +import org.bukkit.Material; +import org.bukkit.Statistic; + +import java.util.*; +import java.util.stream.Collectors; + +public class Statistics extends Appliance { + record StatisticsResponse(List playerStatistics) { + record PlayerStatistics(String player, Map values) { + } + } + + record MaterialStatistic(String name, String material) { + } + + record StatisticsRequest(List categories) { + } + + @Override + public void httpApi(HttpServer.ApiBuilder apiBuilder) { + apiBuilder.post( + "getStatistics", + StatisticsRequest.class, + (statistics, request) -> { + Main.instance().getLogger().info("API requested statistics"); + List statisticsList = Arrays.stream(Bukkit.getOfflinePlayers()) + .parallel() + .map(player -> new StatisticsResponse.PlayerStatistics( + player.getUniqueId().toString(), + statistics.categories().stream() + .map(s -> new AbstractMap.SimpleEntry<>(s, s.material().isBlank() + ? player.getStatistic(Statistic.valueOf(s.name)) + : player.getStatistic(Statistic.valueOf(s.name), Material.valueOf(s.material())) + )) + .collect(Collectors.toMap( + Map.Entry::getKey, + Map.Entry::getValue + )) + )) + .toList(); + return new StatisticsResponse(statisticsList); + } + ); + } +} From 62c025004913ee0867618783712a7a2d2ce42dc7 Mon Sep 17 00:00:00 2001 From: lars Date: Fri, 7 Nov 2025 21:27:33 +0100 Subject: [PATCH 10/19] added null value check for material --- .../tooling/statistics/Statistics.java | 21 +++++++++---------- 1 file changed, 10 insertions(+), 11 deletions(-) diff --git a/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/tooling/statistics/Statistics.java b/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/tooling/statistics/Statistics.java index 535feec..f200af5 100644 --- a/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/tooling/statistics/Statistics.java +++ b/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/tooling/statistics/Statistics.java @@ -8,15 +8,14 @@ import org.bukkit.Material; import org.bukkit.Statistic; import java.util.*; -import java.util.stream.Collectors; public class Statistics extends Appliance { record StatisticsResponse(List playerStatistics) { - record PlayerStatistics(String player, Map values) { + record PlayerStatistics(String player, List statistics) { } } - record MaterialStatistic(String name, String material) { + record MaterialStatistic(String name, String material, int value) { } record StatisticsRequest(List categories) { @@ -34,14 +33,14 @@ public class Statistics extends Appliance { .map(player -> new StatisticsResponse.PlayerStatistics( player.getUniqueId().toString(), statistics.categories().stream() - .map(s -> new AbstractMap.SimpleEntry<>(s, s.material().isBlank() - ? player.getStatistic(Statistic.valueOf(s.name)) - : player.getStatistic(Statistic.valueOf(s.name), Material.valueOf(s.material())) - )) - .collect(Collectors.toMap( - Map.Entry::getKey, - Map.Entry::getValue - )) + .map(category -> { + String material = (category.material() == null || category.material().isBlank()) ? null : category.material(); + return new MaterialStatistic(category.name(), material, material == null + ? player.getStatistic(Statistic.valueOf(category.name())) + : player.getStatistic(Statistic.valueOf(category.name()), Material.valueOf(material)) + ); + }) + .toList() )) .toList(); return new StatisticsResponse(statisticsList); From 4a5c24235bb77b0eac52e74eea2870e476363234 Mon Sep 17 00:00:00 2001 From: lars Date: Fri, 7 Nov 2025 21:46:16 +0100 Subject: [PATCH 11/19] added player display name to StatisticsResponse --- .../craftattack/appliances/tooling/statistics/Statistics.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/tooling/statistics/Statistics.java b/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/tooling/statistics/Statistics.java index f200af5..8055558 100644 --- a/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/tooling/statistics/Statistics.java +++ b/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/tooling/statistics/Statistics.java @@ -11,7 +11,7 @@ import java.util.*; public class Statistics extends Appliance { record StatisticsResponse(List playerStatistics) { - record PlayerStatistics(String player, List statistics) { + record PlayerStatistics(String playerName, String playerUuid, List statistics) { } } @@ -31,6 +31,7 @@ public class Statistics extends Appliance { List statisticsList = Arrays.stream(Bukkit.getOfflinePlayers()) .parallel() .map(player -> new StatisticsResponse.PlayerStatistics( + player.getName(), player.getUniqueId().toString(), statistics.categories().stream() .map(category -> { From 29a362b5809e6e7ed246978fcfc75e3e47b62590 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Elias=20M=C3=BCller?= Date: Sun, 9 Nov 2025 16:08:28 +0100 Subject: [PATCH 12/19] updated default shortcut setting value --- .../common/appliances/metaGameplay/infoBars/InfoBarSetting.java | 2 -- .../metaGameplay/settings/SettingsShortcutSetting.java | 2 +- 2 files changed, 1 insertion(+), 3 deletions(-) diff --git a/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/metaGameplay/infoBars/InfoBarSetting.java b/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/metaGameplay/infoBars/InfoBarSetting.java index 6439b11..23214ad 100644 --- a/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/metaGameplay/infoBars/InfoBarSetting.java +++ b/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/metaGameplay/infoBars/InfoBarSetting.java @@ -46,6 +46,4 @@ public class InfoBarSetting extends MultiBoolSetting dataType() { return InfoBarConfiguration.class; } - - } diff --git a/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/metaGameplay/settings/SettingsShortcutSetting.java b/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/metaGameplay/settings/SettingsShortcutSetting.java index 4737ba4..7c15f64 100644 --- a/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/metaGameplay/settings/SettingsShortcutSetting.java +++ b/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/metaGameplay/settings/SettingsShortcutSetting.java @@ -25,7 +25,7 @@ public class SettingsShortcutSetting extends BoolSetting implements CategorizedS @Override protected Boolean defaultValue() { - return false; + return true; } @Override From 0ab67bb4263e3f4b46e8a01dd0ae453e0c31fbb4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Elias=20M=C3=BCller?= Date: Sun, 9 Nov 2025 19:13:08 +0100 Subject: [PATCH 13/19] refactored strike handling logic; added ban determination and updated whitelist integration --- .../api/repositories/WhitelistRepository.java | 2 +- .../appliances/tooling/strike/Strike.java | 21 -------- .../appliances/tooling/strikes/Strikes.java | 48 +++++++++++++++++++ .../tooling/whitelist/Whitelist.java | 43 ++++++++--------- 4 files changed, 70 insertions(+), 44 deletions(-) delete mode 100644 craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/tooling/strike/Strike.java create mode 100644 craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/tooling/strikes/Strikes.java diff --git a/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/api/repositories/WhitelistRepository.java b/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/api/repositories/WhitelistRepository.java index 81aea86..cad137e 100644 --- a/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/api/repositories/WhitelistRepository.java +++ b/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/api/repositories/WhitelistRepository.java @@ -19,7 +19,7 @@ public class WhitelistRepository extends HttpRepository { String lastname, List strikes ) { - public record Strike(int at, int weight) { + public record Strike(long at, int weight) { } } diff --git a/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/tooling/strike/Strike.java b/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/tooling/strike/Strike.java deleted file mode 100644 index 59e5010..0000000 --- a/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/tooling/strike/Strike.java +++ /dev/null @@ -1,21 +0,0 @@ -package eu.mhsl.craftattack.spawn.craftattack.appliances.tooling.strike; - -import eu.mhsl.craftattack.spawn.core.appliance.Appliance; - -import java.time.Duration; -import java.util.Map; - -public class Strike extends Appliance { - public Strike() { - super("strike"); - } - - private final Map strikePunishmentMap = Map.of( - 1, Duration.ofHours(1), - 2, Duration.ofHours(24), - 3, Duration.ofDays(3), - 4, Duration.ofDays(7) - ); - - -} diff --git a/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/tooling/strikes/Strikes.java b/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/tooling/strikes/Strikes.java new file mode 100644 index 0000000..b52ba90 --- /dev/null +++ b/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/tooling/strikes/Strikes.java @@ -0,0 +1,48 @@ +package eu.mhsl.craftattack.spawn.craftattack.appliances.tooling.strikes; + +import eu.mhsl.craftattack.spawn.core.appliance.Appliance; +import eu.mhsl.craftattack.spawn.craftattack.api.repositories.WhitelistRepository; +import org.checkerframework.checker.nullness.qual.Nullable; + +import java.time.Duration; +import java.time.Instant; +import java.util.List; +import java.util.Map; + +public class Strikes extends Appliance { + public Strikes() { + super("strike"); + } + + private static final BanInfo falseInfo = new BanInfo(false, null, false); + public record BanInfo(boolean isBanned, @Nullable Instant bannedUntil, boolean isPermanent) { + } + + private final Map strikePunishmentMap = Map.of( + 1, Duration.ofHours(1), + 2, Duration.ofHours(24), + 3, Duration.ofDays(3), + 4, Duration.ofDays(7) + ); + + + public BanInfo isBanned(List strikes) { + if (strikes.isEmpty()) return falseInfo; + + int strikeCount = strikes.stream().mapToInt(WhitelistRepository.UserData.Strike::weight).sum(); + if (strikeCount < 1) return falseInfo; + if (strikeCount > this.strikePunishmentMap.size()) return new BanInfo(true, null, true); + + Instant lastPunishment = strikes.stream() + .map(strike -> Instant.ofEpochMilli(strike.at())) + .max(Instant::compareTo) + .orElse(Instant.EPOCH); + + Duration duration = this.strikePunishmentMap.get(strikeCount); + Instant bannedUntil = lastPunishment.plus(duration); + + boolean stillBanned = bannedUntil.isAfter(Instant.now()); + + return new BanInfo(stillBanned, bannedUntil, false); + } +} diff --git a/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/tooling/whitelist/Whitelist.java b/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/tooling/whitelist/Whitelist.java index 0e55b0a..0e5d690 100644 --- a/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/tooling/whitelist/Whitelist.java +++ b/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/tooling/whitelist/Whitelist.java @@ -8,21 +8,18 @@ import eu.mhsl.craftattack.spawn.core.appliance.Appliance; import eu.mhsl.craftattack.spawn.core.api.HttpStatus; import eu.mhsl.craftattack.spawn.core.util.server.Floodgate; import eu.mhsl.craftattack.spawn.core.util.text.DisconnectInfo; -import eu.mhsl.craftattack.spawn.craftattack.appliances.gameplay.outlawed.Outlawed; +import eu.mhsl.craftattack.spawn.craftattack.appliances.tooling.strikes.Strikes; import org.bukkit.Bukkit; import org.bukkit.entity.Player; import org.bukkit.event.Listener; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import java.time.Instant; -import java.time.ZoneOffset; +import javax.inject.Provider; +import java.time.ZoneId; +import java.time.ZonedDateTime; import java.time.format.DateTimeFormatter; -import java.time.temporal.ChronoUnit; -import java.util.Date; -import java.util.HashMap; -import java.util.List; -import java.util.UUID; +import java.util.*; import java.util.logging.Level; public class Whitelist extends Appliance { @@ -47,7 +44,6 @@ public class Whitelist extends Appliance { player.getUniqueId() ); } - this.queryAppliance(Outlawed.class).updateForcedStatus(player, this.timestampRelevant(0L)); // TODO String purePlayerName = Floodgate.isBedrock(player) ? Floodgate.getBedrockPlayer(player).getUsername() @@ -73,17 +69,25 @@ public class Whitelist extends Appliance { this.userData.put(uuid, user); Main.logger().info(String.format("got userdata %s", user.toString())); - if(this.timestampRelevant(0L)) { //TODO - Instant bannedDate = new Date(0 * 1000L) // TODO - .toInstant() - .plus(1, ChronoUnit.HOURS); + Strikes.BanInfo banInfo = Main.instance().getAppliance(Strikes.class).isBanned(user.strikes()); + Main.logger().info(String.format("got baninfo %s", banInfo.toString())); - DateTimeFormatter dateFormat = DateTimeFormatter.ofPattern("dd.MM.yyyy").withZone(ZoneOffset.UTC); - DateTimeFormatter timeFormat = DateTimeFormatter.ofPattern("HH:mm").withZone(ZoneOffset.UTC); + if (banInfo.isBanned()) { + Provider zoned = () -> { + Objects.requireNonNull(banInfo.bannedUntil(), "Cannot get zoned date time from null"); + return banInfo.bannedUntil().atZone(ZoneId.of("Europe/Berlin")); + }; + + DateTimeFormatter dateFormat = DateTimeFormatter.ofPattern("dd.MM.yyyy"); + DateTimeFormatter timeFormat = DateTimeFormatter.ofPattern("HH:mm"); + + String unbanText = banInfo.bannedUntil() != null + ? String.format("Dein Bann läuft am %s um %s ab!", dateFormat.format(zoned.get()), timeFormat.format(zoned.get())) + : "Bandauer ist unbekannt."; throw new DisconnectInfo.Throwable( "Du wurdest vom Server gebannt.", - String.format("Dein Bann läuft am %s um %s ab!", dateFormat.format(bannedDate), timeFormat.format(bannedDate)), + banInfo.isPermanent() ? "Dein Bann läuft nicht ab!" : unbanText, "Wende dich an einen Admin für weitere Informationen.", uuid ); @@ -94,18 +98,13 @@ public class Whitelist extends Appliance { Main.instance().getLogger().log(Level.SEVERE, e, e::getMessage); throw new DisconnectInfo.Throwable( "Interner Serverfehler", - "Deine Anmeldedaten konnten nicht abgerufen/ überprüft werden.", + "Deine Anmeldedaten konnten nicht abgerufen/überprüft werden.", "Versuche es später erneut oder kontaktiere einen Admin!", uuid ); } } - private boolean timestampRelevant(Long timestamp) { - if(timestamp == null) return false; - return timestamp > System.currentTimeMillis() / 1000L; - } - private WhitelistRepository.UserData fetchUserData(UUID uuid) throws DisconnectInfo.Throwable { ReqResp response = this.queryRepository(WhitelistRepository.class).getUserData(uuid); From f27474016aeeb4d600f93d2746b48376faffb31f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Elias=20M=C3=BCller?= Date: Sun, 9 Nov 2025 19:31:25 +0100 Subject: [PATCH 14/19] added `@Flags` annotation to `Appliance`, disabled `DeviceFingerprinting` appliance by default --- .../tooling/deviceFingerprinting/DeviceFingerprinting.java | 1 + .../src/main/java/eu/mhsl/craftattack/spawn/core/Main.java | 5 +++++ .../mhsl/craftattack/spawn/core/appliance/Appliance.java | 7 +++++++ 3 files changed, 13 insertions(+) diff --git a/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/tooling/deviceFingerprinting/DeviceFingerprinting.java b/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/tooling/deviceFingerprinting/DeviceFingerprinting.java index 92147c3..93215e0 100644 --- a/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/tooling/deviceFingerprinting/DeviceFingerprinting.java +++ b/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/tooling/deviceFingerprinting/DeviceFingerprinting.java @@ -19,6 +19,7 @@ import java.lang.reflect.Type; import java.net.URI; import java.util.*; +@Appliance.Flags(enabled = false) public class DeviceFingerprinting extends Appliance { public record PackInfo(@NotNull String url, @NotNull UUID uuid, @NotNull String hash) { private static final String failingUrl = "http://127.0.0.1:0"; diff --git a/core/src/main/java/eu/mhsl/craftattack/spawn/core/Main.java b/core/src/main/java/eu/mhsl/craftattack/spawn/core/Main.java index 6eaa8ec..e666a90 100644 --- a/core/src/main/java/eu/mhsl/craftattack/spawn/core/Main.java +++ b/core/src/main/java/eu/mhsl/craftattack/spawn/core/Main.java @@ -51,6 +51,11 @@ public final class Main extends JavaPlugin { Main.logger().info("Loading appliances..."); this.appliances = this.findSubtypesOf(Appliance.class).stream() .filter(applianceClass -> !disabledAppliances.contains(applianceClass.getSimpleName())) + .filter(appliance -> { + Appliance.Flags flags = appliance.getAnnotation(Appliance.Flags.class); + if(flags == null) return true; + return flags.enabled(); + }) .map(applianceClass -> { try { return (Appliance) applianceClass.getDeclaredConstructor().newInstance(); diff --git a/core/src/main/java/eu/mhsl/craftattack/spawn/core/appliance/Appliance.java b/core/src/main/java/eu/mhsl/craftattack/spawn/core/appliance/Appliance.java index 05eb73a..9650759 100644 --- a/core/src/main/java/eu/mhsl/craftattack/spawn/core/appliance/Appliance.java +++ b/core/src/main/java/eu/mhsl/craftattack/spawn/core/appliance/Appliance.java @@ -13,6 +13,8 @@ import org.bukkit.plugin.Plugin; import org.bukkit.plugin.java.JavaPlugin; import org.jetbrains.annotations.NotNull; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; import java.lang.reflect.Constructor; import java.util.ArrayList; import java.util.List; @@ -23,6 +25,11 @@ import java.util.Optional; * Appliances can be enabled or disabled independent of other appliances */ public abstract class Appliance { + @Retention(RetentionPolicy.RUNTIME) + public @interface Flags { + boolean enabled() default true; + } + private String localConfigPath; private List listeners; private List> commands; From 933c4c0db050b063a5141935e421cfa50b88994b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Elias=20M=C3=BCller?= Date: Sun, 9 Nov 2025 19:32:44 +0100 Subject: [PATCH 15/19] refactored `InfoBars` handling logic; replaced persistent data with direct visibility control --- .../metaGameplay/infoBars/InfoBars.java | 57 ++++--------------- 1 file changed, 11 insertions(+), 46 deletions(-) diff --git a/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/metaGameplay/infoBars/InfoBars.java b/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/metaGameplay/infoBars/InfoBars.java index 9ad7912..bc0d699 100644 --- a/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/metaGameplay/infoBars/InfoBars.java +++ b/common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/metaGameplay/infoBars/InfoBars.java @@ -1,25 +1,18 @@ package eu.mhsl.craftattack.spawn.common.appliances.metaGameplay.infoBars; import eu.mhsl.craftattack.spawn.common.appliances.metaGameplay.settings.Settings; -import eu.mhsl.craftattack.spawn.core.Main; import eu.mhsl.craftattack.spawn.core.appliance.Appliance; import eu.mhsl.craftattack.spawn.core.appliance.ApplianceCommand; import eu.mhsl.craftattack.spawn.common.appliances.metaGameplay.infoBars.bars.MsptBar; import eu.mhsl.craftattack.spawn.common.appliances.metaGameplay.infoBars.bars.PlayerCounterBar; import eu.mhsl.craftattack.spawn.common.appliances.metaGameplay.infoBars.bars.TpsBar; -import org.bukkit.Bukkit; -import org.bukkit.NamespacedKey; import org.bukkit.entity.Player; import org.bukkit.event.Listener; -import org.bukkit.persistence.PersistentDataContainer; -import org.bukkit.persistence.PersistentDataType; import org.jetbrains.annotations.NotNull; -import java.util.ArrayList; import java.util.List; public class InfoBars extends Appliance { - private final NamespacedKey infoBarKey = new NamespacedKey(Main.instance(), "infobars"); private final List infoBars = List.of( new TpsBar(), new MsptBar(), @@ -27,41 +20,19 @@ public class InfoBars extends Appliance { ); public void showAllEnabled(Player player) { - this.getEnabledBars(player).forEach(bar -> this.show(player, bar)); + InfoBarSetting.InfoBarConfiguration config = Settings.instance().getSetting(player, Settings.Key.InfoBars, InfoBarSetting.InfoBarConfiguration.class); + this.setVisible(player, MsptBar.name, config.mspt()); + this.setVisible(player, PlayerCounterBar.name, config.playerCounter()); + this.setVisible(player, TpsBar.name, config.tps()); } - public void hideAllEnabled(Player player) { - this.getEnabledBars(player).forEach(bar -> this.hide(player, bar)); - this.setEnabledBars(player, List.of()); - } - - public void show(Player player, String bar) { + public void setVisible(Player player, String bar, boolean visible) { this.validateBarName(bar); - List existingBars = new ArrayList<>(this.getEnabledBars(player)); - existingBars.add(bar); - player.showBossBar(this.getBarByName(bar).getBossBar()); - this.setEnabledBars(player, existingBars); - } - - public void hide(Player player, String bar) { - this.validateBarName(bar); - List existingBars = new ArrayList<>(this.getEnabledBars(player)); - existingBars.remove(bar); - player.hideBossBar(this.getBarByName(bar).getBossBar()); - this.setEnabledBars(player, existingBars); - } - - private List getEnabledBars(Player player) { - PersistentDataContainer container = player.getPersistentDataContainer(); - if(!container.has(this.infoBarKey)) return List.of(); - return container.get(this.infoBarKey, PersistentDataType.LIST.strings()); - } - - private void setEnabledBars(Player player, List bars) { - Bukkit.getScheduler().runTask( - Main.instance(), - () -> player.getPersistentDataContainer().set(this.infoBarKey, PersistentDataType.LIST.strings(), bars) - ); + if(visible) { + player.showBossBar(this.getBarByName(bar).getBossBar()); + } else { + player.hideBossBar(this.getBarByName(bar).getBossBar()); + } } private Bar getBarByName(String name) { @@ -79,13 +50,7 @@ public class InfoBars extends Appliance { @Override public void onEnable() { Settings.instance().declareSetting(InfoBarSetting.class); - Settings.instance().addChangeListener(InfoBarSetting.class, player -> { - this.hideAllEnabled(player); - InfoBarSetting.InfoBarConfiguration config = Settings.instance().getSetting(player, Settings.Key.InfoBars, InfoBarSetting.InfoBarConfiguration.class); - if(config.mspt()) this.show(player, MsptBar.name); - if(config.playerCounter()) this.show(player, PlayerCounterBar.name); - if(config.tps()) this.show(player, TpsBar.name); - }); + Settings.instance().addChangeListener(InfoBarSetting.class, this::showAllEnabled); } @Override From 448e9472db3723a0e719f268b6abda312612b3fd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Elias=20M=C3=BCller?= Date: Sun, 9 Nov 2025 20:36:21 +0100 Subject: [PATCH 16/19] updated outlawed info messages --- .../appliances/gameplay/outlawed/Outlawed.java | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/gameplay/outlawed/Outlawed.java b/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/gameplay/outlawed/Outlawed.java index db7c5d0..a322a38 100644 --- a/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/gameplay/outlawed/Outlawed.java +++ b/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/gameplay/outlawed/Outlawed.java @@ -51,8 +51,8 @@ public class Outlawed extends Appliance implements DisplayName.Prefixed { void askForConfirmation(Player player) { Component confirmationMessage = switch(this.getLawStatus(player)) { - case DISABLED -> Component.text("Wenn du Vogelfrei aktivierst, darfst du von allen Spielern grundlos angegriffen werden."); - case VOLUNTARILY -> Component.text("Wenn du Vogelfrei deaktivierst, darfst du nicht mehr grundlos von Spielern angegriffen werden."); + case DISABLED -> Component.text("Wenn du Vogelfrei aktivierst, darfst du von allen anderen vogelfreien Spielern grundlos angegriffen werden."); + case VOLUNTARILY -> Component.text("Wenn du Vogelfrei deaktivierst, darfst du nicht mehr grundlos von anderen Spielern angegriffen werden."); case FORCED -> Component.text("Du darfst zurzeit deinen Vogelfreistatus nicht ändern, da dieser als Strafe auferlegt wurde!"); }; String command = String.format("/%s confirm", OutlawedCommand.commandName); @@ -130,7 +130,11 @@ public class Outlawed extends Appliance implements DisplayName.Prefixed { .append(Component.text("Es gelten die normalen Regeln!", NamedTextColor.GOLD)); case VOLUNTARILY, FORCED -> Component.text("Vogelfreistatus aktiv: ", NamedTextColor.RED) - .append(Component.text("Du darfst von jedem angegriffen und getötet werden!", NamedTextColor.GOLD)); + .append(Component.text( + "Du darfst von allen anderen vogelfreien Spielern angegriffen und getötet werden!" + + "Wenn du getötet wirst, müssen andere Spieler deine Items nicht zurückerstatten!", + NamedTextColor.GOLD + )); }; } @@ -138,7 +142,9 @@ public class Outlawed extends Appliance implements DisplayName.Prefixed { public Component getNamePrefix(Player player) { if(this.isOutlawed(player)) { return Component.text("[☠]", NamedTextColor.RED) - .hoverEvent(HoverEvent.showText(Component.text("Vogelfreie Spieler dürfen ohne Grund angegriffen werden!"))); + .hoverEvent(HoverEvent.showText(Component.text( + "Vogelfreie Spieler dürfen von anderen vogelfreien Spielern ohne Grund angegriffen werden!" + ))); } return null; From 0b9dc5358d1d6c45319556f353fa169ea26cca07 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Elias=20M=C3=BCller?= Date: Sat, 15 Nov 2025 12:50:01 +0100 Subject: [PATCH 17/19] added HTTP hooks framework with actions for signup, report, and strike events; introduced `SpawnEvent` support for event broadcasting --- .../spawn/core/api/server/HttpServer.java | 8 ++- .../spawn/core/api/server/hooks/HttpHook.java | 55 +++++++++++++++++++ .../core/api/server/hooks/JsonAction.java | 26 +++++++++ .../core/api/server/hooks/RawAction.java | 18 ++++++ .../api/server/hooks/impl/WebsiteHook.java | 43 +++++++++++++++ .../spawn/core/event/ReportCreatedEvent.java | 15 +++++ .../spawn/core/event/SpawnEvent.java | 22 ++++++++ .../spawn/core/event/StrikeCreatedEvent.java | 17 ++++++ 8 files changed, 203 insertions(+), 1 deletion(-) create mode 100644 core/src/main/java/eu/mhsl/craftattack/spawn/core/api/server/hooks/HttpHook.java create mode 100644 core/src/main/java/eu/mhsl/craftattack/spawn/core/api/server/hooks/JsonAction.java create mode 100644 core/src/main/java/eu/mhsl/craftattack/spawn/core/api/server/hooks/RawAction.java create mode 100644 core/src/main/java/eu/mhsl/craftattack/spawn/core/api/server/hooks/impl/WebsiteHook.java create mode 100644 core/src/main/java/eu/mhsl/craftattack/spawn/core/event/ReportCreatedEvent.java create mode 100644 core/src/main/java/eu/mhsl/craftattack/spawn/core/event/SpawnEvent.java create mode 100644 core/src/main/java/eu/mhsl/craftattack/spawn/core/event/StrikeCreatedEvent.java diff --git a/core/src/main/java/eu/mhsl/craftattack/spawn/core/api/server/HttpServer.java b/core/src/main/java/eu/mhsl/craftattack/spawn/core/api/server/HttpServer.java index b6f2128..1b86556 100644 --- a/core/src/main/java/eu/mhsl/craftattack/spawn/core/api/server/HttpServer.java +++ b/core/src/main/java/eu/mhsl/craftattack/spawn/core/api/server/HttpServer.java @@ -2,6 +2,7 @@ package eu.mhsl.craftattack.spawn.core.api.server; import com.google.gson.Gson; import eu.mhsl.craftattack.spawn.core.Main; +import eu.mhsl.craftattack.spawn.core.api.server.hooks.HttpHook; import eu.mhsl.craftattack.spawn.core.appliance.Appliance; import org.bukkit.configuration.ConfigurationSection; import spark.Request; @@ -22,6 +23,11 @@ public class HttpServer { Spark.get("/ping", (request, response) -> System.currentTimeMillis()); + Spark.post("/hook/:hookId", (request, response) -> { + HttpHook.Hook hook = HttpHook.Hook.valueOf(request.params(":hookId").toUpperCase()); + return hook.getHook().runAction(request.headers(hook.getHeaderAction()), request, response); + }); + Main.instance().getAppliances().forEach(appliance -> appliance.httpApi(new ApiBuilder(appliance))); } @@ -64,7 +70,7 @@ public class HttpServer { }); } - public String buildRoute(String path) { + private String buildRoute(String path) { return String.format("/api/%s/%s", this.applianceName, path); } diff --git a/core/src/main/java/eu/mhsl/craftattack/spawn/core/api/server/hooks/HttpHook.java b/core/src/main/java/eu/mhsl/craftattack/spawn/core/api/server/hooks/HttpHook.java new file mode 100644 index 0000000..ffe357c --- /dev/null +++ b/core/src/main/java/eu/mhsl/craftattack/spawn/core/api/server/hooks/HttpHook.java @@ -0,0 +1,55 @@ +package eu.mhsl.craftattack.spawn.core.api.server.hooks; + +import eu.mhsl.craftattack.spawn.core.Main; +import eu.mhsl.craftattack.spawn.core.api.server.HttpServer; +import eu.mhsl.craftattack.spawn.core.api.server.hooks.impl.WebsiteHook; +import spark.Request; +import spark.Response; + +import java.util.HashMap; +import java.util.Map; + +public abstract class HttpHook { + public enum Hook { + WEBSITE("x-webhook-action", new WebsiteHook()); + + private final String headerAction; + private final HttpHook hook; + Hook(String headerAction, HttpHook handler) { + this.headerAction = headerAction; + this.hook = handler; + this.hook.registerHooks(); + } + + public HttpHook getHook() { + return this.hook; + } + + public String getHeaderAction() { + return this.headerAction; + } + } + + public abstract static class Action { + public abstract Object run(Request request, Response response); + } + + private final Map actions = new HashMap<>(); + + protected HttpHook() { + } + + protected abstract void registerHooks(); + + protected void addAction(String name, Action action) { + this.actions.put(name, action); + } + + public Object runAction(String action, Request request, Response response) { + if(!this.actions.containsKey(action)) { + Main.logger().warning(String.format("Webhook-Action '%s' not registered, skipping!", action)); + return HttpServer.nothing; + } + return this.actions.get(action).run(request, response); + } +} diff --git a/core/src/main/java/eu/mhsl/craftattack/spawn/core/api/server/hooks/JsonAction.java b/core/src/main/java/eu/mhsl/craftattack/spawn/core/api/server/hooks/JsonAction.java new file mode 100644 index 0000000..fa2613b --- /dev/null +++ b/core/src/main/java/eu/mhsl/craftattack/spawn/core/api/server/hooks/JsonAction.java @@ -0,0 +1,26 @@ +package eu.mhsl.craftattack.spawn.core.api.server.hooks; + +import com.google.gson.Gson; +import spark.Request; +import spark.Response; + +import java.util.function.Function; + +public class JsonAction extends HttpHook.Action { + private final Function handler; + private final Class requestClass; + + private final Gson gson = new Gson(); + + public JsonAction(Class requestClass, Function handler) { + this.requestClass = requestClass; + this.handler = handler; + } + + @Override + public Object run(Request request, Response response) { + TRequest req = this.gson.fromJson(request.body(), this.requestClass); + response.type("application/json"); + return this.gson.toJson(this.handler.apply(req)); + } +} diff --git a/core/src/main/java/eu/mhsl/craftattack/spawn/core/api/server/hooks/RawAction.java b/core/src/main/java/eu/mhsl/craftattack/spawn/core/api/server/hooks/RawAction.java new file mode 100644 index 0000000..1d1904d --- /dev/null +++ b/core/src/main/java/eu/mhsl/craftattack/spawn/core/api/server/hooks/RawAction.java @@ -0,0 +1,18 @@ +package eu.mhsl.craftattack.spawn.core.api.server.hooks; + +import spark.Request; +import spark.Response; + +import java.util.function.BiFunction; + +public class RawAction extends HttpHook.Action { + private final BiFunction handler; + public RawAction(BiFunction handler) { + this.handler = handler; + } + + @Override + public Object run(Request request, Response response) { + return this.handler.apply(request, response); + } +} diff --git a/core/src/main/java/eu/mhsl/craftattack/spawn/core/api/server/hooks/impl/WebsiteHook.java b/core/src/main/java/eu/mhsl/craftattack/spawn/core/api/server/hooks/impl/WebsiteHook.java new file mode 100644 index 0000000..73e7552 --- /dev/null +++ b/core/src/main/java/eu/mhsl/craftattack/spawn/core/api/server/hooks/impl/WebsiteHook.java @@ -0,0 +1,43 @@ +package eu.mhsl.craftattack.spawn.core.api.server.hooks.impl; + +import eu.mhsl.craftattack.spawn.core.Main; +import eu.mhsl.craftattack.spawn.core.api.server.HttpServer; +import eu.mhsl.craftattack.spawn.core.api.server.hooks.HttpHook; +import eu.mhsl.craftattack.spawn.core.api.server.hooks.JsonAction; +import eu.mhsl.craftattack.spawn.core.event.ReportCreatedEvent; +import eu.mhsl.craftattack.spawn.core.event.SpawnEvent; +import eu.mhsl.craftattack.spawn.core.event.StrikeCreatedEvent; +import org.checkerframework.checker.nullness.qual.Nullable; + +import java.util.UUID; + +public class WebsiteHook extends HttpHook { + @Override + protected void registerHooks() { + record CreatedSignup( + String firstname, + String lastname, + String birthday, + @Nullable String telephone, + String username, + String edition, + @Nullable UUID uuid + ) {} + this.addAction("signup", new JsonAction<>(CreatedSignup.class, createdSignup -> { + Main.logger().info(String.format("New Website-signup from Hook: %s %s (%s)", createdSignup.firstname, createdSignup.lastname, createdSignup.username)); + return HttpServer.nothing; + })); + + record CreatedReport(String reporter, String reported, String reason) {} + this.addAction("report", new JsonAction<>(CreatedReport.class, createdReport -> { + SpawnEvent.call(new ReportCreatedEvent(new ReportCreatedEvent.CreatedReport(createdReport.reporter, createdReport.reported, createdReport.reason))); + return HttpServer.nothing; + })); + + record CreatedStrike(UUID uuid) {} + this.addAction("strike", new JsonAction<>(CreatedStrike.class, createdStrike -> { + SpawnEvent.call(new StrikeCreatedEvent(new StrikeCreatedEvent.CreatedStrike(createdStrike.uuid))); + return HttpServer.nothing; + })); + } +} diff --git a/core/src/main/java/eu/mhsl/craftattack/spawn/core/event/ReportCreatedEvent.java b/core/src/main/java/eu/mhsl/craftattack/spawn/core/event/ReportCreatedEvent.java new file mode 100644 index 0000000..d0d40cb --- /dev/null +++ b/core/src/main/java/eu/mhsl/craftattack/spawn/core/event/ReportCreatedEvent.java @@ -0,0 +1,15 @@ +package eu.mhsl.craftattack.spawn.core.event; + +public class ReportCreatedEvent extends SpawnEvent { + public record CreatedReport(String reporter, String reported, String reason) {} + + private final CreatedReport report; + public ReportCreatedEvent(CreatedReport report) { + super(true); + this.report = report; + } + + public CreatedReport getReport() { + return this.report; + } +} diff --git a/core/src/main/java/eu/mhsl/craftattack/spawn/core/event/SpawnEvent.java b/core/src/main/java/eu/mhsl/craftattack/spawn/core/event/SpawnEvent.java new file mode 100644 index 0000000..3d55016 --- /dev/null +++ b/core/src/main/java/eu/mhsl/craftattack/spawn/core/event/SpawnEvent.java @@ -0,0 +1,22 @@ +package eu.mhsl.craftattack.spawn.core.event; + +import org.bukkit.Bukkit; +import org.bukkit.event.Event; +import org.bukkit.event.HandlerList; +import org.jetbrains.annotations.NotNull; + +public abstract class SpawnEvent extends Event { + private static final HandlerList HANDLERS = new HandlerList(); + @Override + public @NotNull HandlerList getHandlers() { + return HANDLERS; + } + + public static void call(SpawnEvent event) { + Bukkit.getPluginManager().callEvent(event); + } + + public SpawnEvent(boolean isAsync) { + super(isAsync); + } +} diff --git a/core/src/main/java/eu/mhsl/craftattack/spawn/core/event/StrikeCreatedEvent.java b/core/src/main/java/eu/mhsl/craftattack/spawn/core/event/StrikeCreatedEvent.java new file mode 100644 index 0000000..de8dbe3 --- /dev/null +++ b/core/src/main/java/eu/mhsl/craftattack/spawn/core/event/StrikeCreatedEvent.java @@ -0,0 +1,17 @@ +package eu.mhsl.craftattack.spawn.core.event; + +import java.util.UUID; + +public class StrikeCreatedEvent extends SpawnEvent { + public record CreatedStrike(UUID playerToStrike) {} + + private final CreatedStrike strike; + public StrikeCreatedEvent(CreatedStrike strike) { + super(true); + this.strike = strike; + } + + public CreatedStrike getStrike() { + return this.strike; + } +} From 7a2b9b97639862dd11d6e27bfaa6c9ca8fd085dc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Elias=20M=C3=BCller?= Date: Sun, 16 Nov 2025 12:00:58 +0100 Subject: [PATCH 18/19] updated Paper API dependency to 1.21.10-R0.1-SNAPSHOT across all modules --- common/build.gradle | 2 +- core/build.gradle | 2 +- craftattack/build.gradle | 2 +- varo/build.gradle | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/common/build.gradle b/common/build.gradle index ec69de6..5e7a917 100644 --- a/common/build.gradle +++ b/common/build.gradle @@ -1,7 +1,7 @@ dependencies { implementation project(':core') - compileOnly 'io.papermc.paper:paper-api:1.21.8-R0.1-SNAPSHOT' + compileOnly 'io.papermc.paper:paper-api:1.21.10-R0.1-SNAPSHOT' compileOnly 'org.geysermc.floodgate:api:2.2.4-SNAPSHOT' implementation 'org.apache.httpcomponents:httpclient:4.5.14' implementation 'com.sparkjava:spark-core:2.9.4' diff --git a/core/build.gradle b/core/build.gradle index d3f249c..11e9be3 100644 --- a/core/build.gradle +++ b/core/build.gradle @@ -1,5 +1,5 @@ dependencies { - compileOnly 'io.papermc.paper:paper-api:1.21.8-R0.1-SNAPSHOT' + compileOnly 'io.papermc.paper:paper-api:1.21.10-R0.1-SNAPSHOT' compileOnly 'org.geysermc.floodgate:api:2.2.4-SNAPSHOT' implementation 'org.apache.httpcomponents:httpclient:4.5.14' implementation 'com.sparkjava:spark-core:2.9.4' diff --git a/craftattack/build.gradle b/craftattack/build.gradle index 90a3c35..a0be4ef 100644 --- a/craftattack/build.gradle +++ b/craftattack/build.gradle @@ -2,7 +2,7 @@ dependencies { implementation project(':core') implementation project(':common') - compileOnly 'io.papermc.paper:paper-api:1.21.8-R0.1-SNAPSHOT' + compileOnly 'io.papermc.paper:paper-api:1.21.10-R0.1-SNAPSHOT' compileOnly 'org.geysermc.floodgate:api:2.2.4-SNAPSHOT' implementation 'org.apache.httpcomponents:httpclient:4.5.14' implementation 'com.sparkjava:spark-core:2.9.4' diff --git a/varo/build.gradle b/varo/build.gradle index 8557e5c..acddd52 100644 --- a/varo/build.gradle +++ b/varo/build.gradle @@ -2,7 +2,7 @@ dependencies { implementation project(':core') implementation project(':common') - compileOnly 'io.papermc.paper:paper-api:1.21.8-R0.1-SNAPSHOT' + compileOnly 'io.papermc.paper:paper-api:1.21.10-R0.1-SNAPSHOT' implementation 'org.apache.httpcomponents:httpclient:4.5.14' implementation 'com.sparkjava:spark-core:2.9.4' } \ No newline at end of file From ba2befb467e572cbc573f12e22d0e763c96f556b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Elias=20M=C3=BCller?= Date: Sun, 16 Nov 2025 12:02:49 +0100 Subject: [PATCH 19/19] refactored event hierarchy; replaced `SpawnEvent` with direct `Event` implementation, added `StrikeUpdateListener` and refactored whitelist profile update logic --- .../spawn/core/event/ReportCreatedEvent.java | 16 +++++++++++- .../spawn/core/event/SpawnEvent.java | 16 ++---------- .../spawn/core/event/StrikeCreatedEvent.java | 16 +++++++++++- .../whitelist/StrikeUpdateListener.java | 12 +++++++++ .../tooling/whitelist/Whitelist.java | 25 +++++++++++-------- 5 files changed, 59 insertions(+), 26 deletions(-) create mode 100644 craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/tooling/whitelist/StrikeUpdateListener.java diff --git a/core/src/main/java/eu/mhsl/craftattack/spawn/core/event/ReportCreatedEvent.java b/core/src/main/java/eu/mhsl/craftattack/spawn/core/event/ReportCreatedEvent.java index d0d40cb..777c02c 100644 --- a/core/src/main/java/eu/mhsl/craftattack/spawn/core/event/ReportCreatedEvent.java +++ b/core/src/main/java/eu/mhsl/craftattack/spawn/core/event/ReportCreatedEvent.java @@ -1,6 +1,20 @@ package eu.mhsl.craftattack.spawn.core.event; -public class ReportCreatedEvent extends SpawnEvent { +import org.bukkit.event.Event; +import org.bukkit.event.HandlerList; +import org.jetbrains.annotations.NotNull; + +public class ReportCreatedEvent extends Event { + private static final HandlerList HANDLERS = new HandlerList(); + @Override + public @NotNull HandlerList getHandlers() { + return HANDLERS; + } + + public static HandlerList getHandlerList() { + return HANDLERS; + } + public record CreatedReport(String reporter, String reported, String reason) {} private final CreatedReport report; diff --git a/core/src/main/java/eu/mhsl/craftattack/spawn/core/event/SpawnEvent.java b/core/src/main/java/eu/mhsl/craftattack/spawn/core/event/SpawnEvent.java index 3d55016..a0f34a5 100644 --- a/core/src/main/java/eu/mhsl/craftattack/spawn/core/event/SpawnEvent.java +++ b/core/src/main/java/eu/mhsl/craftattack/spawn/core/event/SpawnEvent.java @@ -2,21 +2,9 @@ package eu.mhsl.craftattack.spawn.core.event; import org.bukkit.Bukkit; import org.bukkit.event.Event; -import org.bukkit.event.HandlerList; -import org.jetbrains.annotations.NotNull; -public abstract class SpawnEvent extends Event { - private static final HandlerList HANDLERS = new HandlerList(); - @Override - public @NotNull HandlerList getHandlers() { - return HANDLERS; - } - - public static void call(SpawnEvent event) { +public abstract class SpawnEvent { + public static void call(Event event) { Bukkit.getPluginManager().callEvent(event); } - - public SpawnEvent(boolean isAsync) { - super(isAsync); - } } diff --git a/core/src/main/java/eu/mhsl/craftattack/spawn/core/event/StrikeCreatedEvent.java b/core/src/main/java/eu/mhsl/craftattack/spawn/core/event/StrikeCreatedEvent.java index de8dbe3..889deaf 100644 --- a/core/src/main/java/eu/mhsl/craftattack/spawn/core/event/StrikeCreatedEvent.java +++ b/core/src/main/java/eu/mhsl/craftattack/spawn/core/event/StrikeCreatedEvent.java @@ -1,8 +1,22 @@ package eu.mhsl.craftattack.spawn.core.event; +import org.bukkit.event.Event; +import org.bukkit.event.HandlerList; +import org.jetbrains.annotations.NotNull; + import java.util.UUID; -public class StrikeCreatedEvent extends SpawnEvent { +public class StrikeCreatedEvent extends Event { + private static final HandlerList HANDLERS = new HandlerList(); + @Override + public @NotNull HandlerList getHandlers() { + return HANDLERS; + } + + public static HandlerList getHandlerList() { + return HANDLERS; + } + public record CreatedStrike(UUID playerToStrike) {} private final CreatedStrike strike; diff --git a/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/tooling/whitelist/StrikeUpdateListener.java b/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/tooling/whitelist/StrikeUpdateListener.java new file mode 100644 index 0000000..b9bae4b --- /dev/null +++ b/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/tooling/whitelist/StrikeUpdateListener.java @@ -0,0 +1,12 @@ +package eu.mhsl.craftattack.spawn.craftattack.appliances.tooling.whitelist; + +import eu.mhsl.craftattack.spawn.core.appliance.ApplianceListener; +import eu.mhsl.craftattack.spawn.core.event.StrikeCreatedEvent; +import org.bukkit.event.EventHandler; + +public class StrikeUpdateListener extends ApplianceListener { + @EventHandler + public void onStrikeUpdate(StrikeCreatedEvent event) { + this.getAppliance().profileUpdated(event.getStrike().playerToStrike()); + } +} diff --git a/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/tooling/whitelist/Whitelist.java b/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/tooling/whitelist/Whitelist.java index 0e5d690..f903804 100644 --- a/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/tooling/whitelist/Whitelist.java +++ b/craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/tooling/whitelist/Whitelist.java @@ -122,20 +122,24 @@ public class Whitelist extends Appliance { return response.data(); } + public void profileUpdated(UUID uuid) { + Main.instance().getLogger().info(String.format("API Triggered Profile update for %s", uuid)); + Player player = Bukkit.getPlayer(uuid); + if(player != null) { + try { + this.fullIntegrityCheck(player); + } catch(DisconnectInfo.Throwable e) { + e.getDisconnectScreen().applyKick(player); + } + } + } + @Override public void httpApi(HttpServer.ApiBuilder apiBuilder) { record User(UUID user) { } apiBuilder.post("update", User.class, (user, request) -> { - Main.instance().getLogger().info(String.format("API Triggered Profile update for %s", user.user)); - Player player = Bukkit.getPlayer(user.user); - if(player != null) { - try { - this.fullIntegrityCheck(player); - } catch(DisconnectInfo.Throwable e) { - e.getDisconnectScreen().applyKick(player); - } - } + this.profileUpdated(user.user); return HttpServer.nothing; }); } @@ -144,7 +148,8 @@ public class Whitelist extends Appliance { @NotNull protected List listeners() { return List.of( - new PlayerJoinListener() + new PlayerJoinListener(), + new StrikeUpdateListener() ); } }