Compare commits

..
Author SHA1 Message Date
Cubicake 4b9a5083ac Bump version 2026-05-30 15:50:55 +09:30
Cubicake f2e9919026 Free performance? 2026-05-30 15:50:34 +09:30
Cubicake c47535cdb1 Bump version 2026-05-30 13:23:18 +09:30
Cubicake 5ba314045e Make stale eviction thread safe 2026-05-30 13:22:35 +09:30
Cubicake 1e45335bad Actually log the ID it says it is logging 2026-05-30 13:02:57 +09:30
Cubicake d6356faf6a Bump version and disable file logger 2026-05-30 12:52:14 +09:30
Cubicake 81d05427e5 Use direct reference to submittedTick where possible 2026-05-30 12:45:00 +09:30
Cubicake 311b69433f Leash reconcilliation using new system 2026-05-30 12:43:36 +09:30
Cubicake 7861298502 This missed the rename somehow 2026-05-27 22:32:23 +09:30
Cubicake e6ba88d981 Use new system for leash and cache packets 2026-05-27 21:46:05 +09:30
Cubicake 081ccb9408 Make both PacketEntityViewController and PacketEventsEntityViewController have static singleton get methods (returning the same object) 2026-05-27 21:44:50 +09:30
Cubicake 63fab1d5ee Fix leash reconciliation 2026-05-27 21:44:00 +09:30
Cubicake bb628a7b41 Delete unused code 2026-05-27 21:15:41 +09:30
Cubicake 43980c1364 Pass in entity ID to entity spawn handler 2026-05-27 21:14:46 +09:30
Cubicake 321f8d4c3a Rename final fields to indicate that they are constants 2026-05-27 21:07:17 +09:30
Cubicake d19987d337 Fixup PECacheablePacketReconciliationTask 2026-05-27 21:05:41 +09:30
Cubicake 65a4b7c94e Delete unused code 2026-05-27 20:47:41 +09:30
Cubicake 8e0420b31f Remove now-pointless nettyTask queue 2026-05-27 20:34:40 +09:30
Cubicake f686e81430 Implement reconciliation entity-spawn tasks 2026-05-27 20:33:42 +09:30
Cubicake 0ba40c8dbb Document entity equipment packet 2026-05-27 20:31:58 +09:30
Cubicake 6bce78a254 Rename to EntitySpawnTask to better reflect use case rather than imply generic netty-thread running, and properly implement NettyData methods 2026-05-27 20:31:37 +09:30
Cubicake 7ea2602282 Run netty task during eviction 2026-05-27 20:09:52 +09:30
Cubicake bc37329ff7 Make FutureNettyTask use loops rather than recursion, add setNext and appendLinkedTask methods 2026-05-25 22:45:08 +09:30
Cubicake 8b57d5ce34 Create abstract implementation of FutureNettyTask 2026-05-25 22:40:11 +09:30
Cubicake 33cd4b0455 Evict old netty tasks each tick 2026-05-25 20:17:12 +09:30
Cubicake bf733b4c5b Add netty tasks to NettyData 2026-05-25 20:16:06 +09:30
Cubicake d3a088a30c Switch to updateOrInsertTileEntity 2026-05-24 21:45:23 +09:30
Cubicake 0166031975 Implement BlockView#insertTileEntityIfAbsent 2026-05-24 21:44:12 +09:30
Cubicake 3b712d6918 Update BlockView for mutable block IDs 2026-05-24 21:38:00 +09:30
Cubicake d44f3d0fdf Begin to make tile entities mutable again 2026-05-24 21:35:13 +09:30
Cubicake 0e4dfc08b7 Update readme 2026-05-24 21:10:54 +09:30
Cubicake dbe72d3c5e Merge pull request #52 from Cubicake/v2/fix-leashes 2026-05-24 21:07:52 +09:30
Cubicake 4e1c77fe7b Clean up code slightly 2026-05-24 21:07:17 +09:30
Cubicake 9c7bfdfa57 Make sure file logging isn't sent to console 2026-05-24 21:04:40 +09:30
Cubicake 1e73d78724 That doesn't exist 2026-05-24 20:56:02 +09:30
Cubicake a284eb98f5 Merge remote-tracking branch 'origin/v2/fix-leashes' into v2/fix-leashes 2026-05-24 20:54:37 +09:30
copilot-swe-agent[bot]andCubicake 2dafdb53af Avoid map mutation during unresolved leash iteration
Agent-Logs-Url: https://github.com/Cubicake/RaycastedAntiESP/sessions/b1bdce15-4fbb-47c3-b86a-cd4873214359

Co-authored-by: Cubicake <70577278+Cubicake@users.noreply.github.com>
2026-05-24 11:22:41 +00:00
Cubicake acb71072ac If leashing entity doesn't exist, handle properly 2026-05-24 20:49:17 +09:30
Cubicake fdde9d957f Change discord link 2026-05-24 14:57:23 +09:30
Cubicake 3abc73e9f7 Add JD note 2026-05-23 21:17:17 +09:30
Cubicake 130166d787 Bump version 2026-05-23 21:07:54 +09:30
Cubicake c2e9d81942 Log to file 2026-05-23 21:07:47 +09:30
Cubicake b80a9c0f3c clear pending leash holder references 2026-05-23 21:07:32 +09:30
Cubicake b493b1af2e Reconcile leashes 2026-05-23 13:36:34 +09:30
Cubicake 807bfa02f3 Add NettyData to PlayerData 2026-05-23 13:07:04 +09:30
Cubicake d134343bc9 Create NettyData 2026-05-23 13:06:50 +09:30
Cubicake 8c5aaea5f5 Add the ability to log arbitrary strings 2026-05-21 17:23:08 +09:30
Cubicake 93fd8b4d3e Check if vehicle exists before sending show 2026-05-20 21:31:17 +09:30
Cubicake 417ebae0ec Bump value because idk why else this would be broken 2026-05-20 21:15:10 +09:30
Cubicake 4cf4453996 Make run task use java 25 2026-05-20 21:14:06 +09:30
Cubicake 785729c443 Bump version 2026-05-20 09:41:22 +09:30
Cubicake eb2ec969a9 If a throwable is thrown before the tick threads are dispatched, clean up the tick threads running var 2026-05-20 09:41:08 +09:30
Cubicake fed0379899 Make sure NPEs don't throw 2026-05-20 09:40:31 +09:30
Cubicake 934825daef Merge pull request #51 from Cubicake/v2/abstract-packets
[v2] Abstract entity packet logic from actual packet manipulation
2026-05-19 17:29:40 +09:30
Cubicake 627c3c3f10 Properly always update player own location 2026-05-19 17:29:17 +09:30
Cubicake 36c349d7e9 Merge remote-tracking branch 'origin/v2/abstract-packets' into v2/abstract-packets 2026-05-19 17:21:00 +09:30
Cubicake 593211fad2 Add null guards 2026-05-19 17:20:29 +09:30
Cubicake e0037b5da9 Update logging 2026-05-19 17:15:19 +09:30
Cubicake 4a71852fd4 Bump version and downgrade java 2026-05-19 17:07:40 +09:30
Cubicake 0eb47f5a93 Preliminary work on assertion-based thread guarding, to be completed in a different branch 2026-05-19 17:07:16 +09:30
Cubicake 275fc53f9a Comment out debug logger 2026-05-19 17:06:53 +09:30
Cubicake e157f50f86 Check if config is enabled before setting block entities to hidden 2026-05-19 17:06:41 +09:30
Cubicake 27ca927d55 Null check before removing leashed entity 2026-05-19 17:06:03 +09:30
Cubicake a3e2f3d052 Update CubiLogs 2026-05-19 17:05:42 +09:30
Cubicake 0c16268142 Update logging 2026-05-18 19:50:15 +09:30
Cubicake 41bafad04c Track logging as submodule 2026-05-18 19:40:14 +09:30
Cubicake 9f7a06cc89 Make file writes async except on disable 2026-05-18 19:11:50 +09:30
Cubicake 94ee2ef6fd Fix test server version 2026-05-18 19:11:29 +09:30
Cubicake a2c09831cf Add file message log construction 2026-05-18 19:09:54 +09:30
Cubicake 8c61813bbf It would be helpful to put the loggers *before* the early return 2026-05-16 17:02:21 +09:30
Cubicake 49acaaf4fa Add file logging 2026-05-16 15:16:41 +09:30
Cubicake e6cca8d1b4 Fix priority 2026-05-16 14:10:35 +09:30
Cubicake 778ed7bb0e Bump version 2026-05-13 21:53:45 +09:30
Cubicake 5e6e249fd4 Bump version 2026-05-10 20:30:43 +09:30
Cubicake 6685d60fc4 Remove unneeded player info packet handling 2026-05-10 20:28:34 +09:30
Cubicake 7f9f6606bc Remove unneeded remnant of when there was only one view controller. 2026-05-10 20:27:46 +09:30
Cubicake e31349db26 Change magic numbers based on testing 2026-05-10 20:17:40 +09:30
Cubicake 58bab35223 Add a bit more info to the warning. 2026-05-10 20:12:25 +09:30
Cubicake 4afe454de9 Recursively update passenger positions whenever the vehicle moves. Move entityFromID to PlayerData. 2026-05-10 20:12:13 +09:30
Cubicake e75c3731b1 Note 2026-05-10 15:59:55 +09:30
Cubicake 2556f5b369 Comment 2026-05-10 15:56:18 +09:30
Cubicake 0243cef884 Add individualised delay factors 2026-05-10 15:55:31 +09:30
Cubicake f8fbbd8a74 Clean up unneeded code 2026-05-10 15:15:39 +09:30
Cubicake f22133efe8 Add delaying to leash and passenger packets 2026-05-10 15:15:10 +09:30
Cubicake 08db0d384f Simplify check 2026-05-09 21:34:29 +09:30
Cubicake 0ac8dc372f Send passenger packets on passenger show too 2026-05-09 21:34:09 +09:30
Cubicake c5a5009fe9 Remove unneeded code 2026-05-09 21:28:36 +09:30
Cubicake aae0060cd4 Add contract annotations 2026-05-09 21:26:26 +09:30
Cubicake 56ff445cb6 Remove unneeded abstract method 2026-05-09 21:26:17 +09:30
Cubicake be880e80c7 Untrack these files 2026-05-09 21:25:52 +09:30
Cubicake d80555c016 Merge branch 'main' into v2/abstract-packets 2026-05-09 20:37:04 +09:30
Cubicake 2e33bf9415 Make sure self players never change visibility 2026-05-09 20:36:12 +09:30
Cubicake 0f87b90787 Remove unused deprecated methods 2026-05-09 20:35:59 +09:30
Cubicake 0a9f115e92 Move entity destroy handling to PacketEntityViewController 2026-05-09 17:59:28 +09:30
Cubicake ebfa47efbc Properly dereference this 2026-05-09 17:59:03 +09:30
Cubicake 5be167fdb3 Self player should always be visible 2026-05-09 17:55:45 +09:30
Cubicake 0799b911a9 Leash and passenger packets are not related to packet cache 2026-05-09 17:55:33 +09:30
Cubicake 97d2bc7bdd Set vehicle IDs 2026-05-09 16:47:57 +09:30
Cubicake 0bd6b4203f Obey IntArrayList contract 2026-05-09 16:46:02 +09:30
Cubicake f4a61f43ff Use correct distance 2026-05-09 16:44:55 +09:30
Cubicake 9372928ae9 Oh right that's how logic works 2026-05-09 16:44:06 +09:30
Cubicake 68ed857f25 Handle leashing and riding entities, only the spawn entity packet is used in modern MC so remove everything else. 2026-05-09 16:37:05 +09:30
Cubicake 30569c711f Doc note 2026-05-09 16:35:52 +09:30
Cubicake 5005b3eb7b Move logging to a separate git module 2026-05-08 16:40:43 +09:30
Cubicake dd00bdd1fa Document leash/attach packet 2026-05-07 22:42:08 +09:30
Cubicake 0e1c2815ae Create primitive int arraylist handling util class and annotation 2026-05-07 22:40:24 +09:30
Cubicake 489db71b2b Replace spawn type with isSelfEntity boolean 2026-05-06 20:23:08 +09:30
Cubicake 2a821c0ebf Begin to remove unneeded generics and detach equipment, metadata, etc from entity locatables 2026-05-06 20:16:11 +09:30
Cubicake 7115fe6e34 Bump version 2026-05-04 23:15:08 +09:30
Cubicake 323c83c93e Handle entity attributes 2026-05-04 23:12:24 +09:30
Cubicake aa0dc3297a Mojang, simply why 2026-05-04 22:57:12 +09:30
Cubicake cb4c55fdbd Track a couple more packets and begin annotating 2026-05-04 22:48:02 +09:30
Cubicake a6c79d4bbe Start documenting packets and what PE class they map to 2026-05-04 22:47:23 +09:30
Cubicake 3f8ac5cc5d Fix stupid packet order issue 2026-05-04 22:09:13 +09:30
Cubicake 3bd4c5339c Netty action cache 2026-05-04 22:08:51 +09:30
Cubicake 9f3bb3793a Yet another debug command 2026-05-04 22:08:40 +09:30
Cubicake baf560546f Properly use packets to register player data. 2026-05-03 21:39:44 +09:30
Cubicake 9f27907a83 Add self entity tracking 2026-05-03 20:58:53 +09:30
Cubicake f4eba53f7f Oops 2026-05-03 16:17:55 +09:30
Cubicake f60934a023 Make ReplayData an append-only queue. 2026-05-03 16:10:45 +09:30
Cubicake e524d072b2 Make inserting tile entity to view the responsibility of PacketEntityViewController, as well as default visibility. Handle REMOVE_ENTITY_EFFECT packet. Implement concrete packet manipulation based off old monoclass. 2026-05-03 16:10:21 +09:30
Cubicake 4e1ca5401c Increase visibility 2026-05-03 16:08:19 +09:30
Cubicake 4381459a69 Shouldn't use the view like this 2026-05-03 16:04:03 +09:30
Cubicake 1e7be8637c Add set(x,y,z) method to MutableLocatable 2026-05-03 15:49:20 +09:30
Cubicake 5ee2a18173 Remove player-specific replay data 2026-05-03 15:48:35 +09:30
Cubicake c98c1c474f Add some needed methods to entity view 2026-05-02 20:13:21 +09:30
Cubicake d3ddb28ec3 Core shouldn't have access to packetevents 2026-05-02 20:12:49 +09:30
Cubicake 1a2469cbc4 Begin extracting logic from the packetevents specific classes 2026-05-02 20:12:06 +09:30
Cubicake 1fc5000782 Add visibility check without useless currentTick parameter 2026-05-02 16:16:52 +09:30
Cubicake 9121c0f4f6 Update StrokkCommands 2026-05-02 16:15:40 +09:30
Cubicake 5833213c20 Require entity visibility to be explicitly set 2026-04-26 18:21:26 +09:30
Cubicake 1d3d3f5b55 No need for two seperate methods 2026-04-26 18:21:16 +09:30
Cubicake dcb5af8721 Check distance to decide whether to auto hide an entity 2026-04-26 18:21:03 +09:30
Cubicake ac3745d1e4 Require tile visibility to be explicitly set 2026-04-26 18:20:41 +09:30
Cubicake 76d11242f6 Require entity visibility to be explicitly set 2026-04-26 18:20:32 +09:30
Cubicake 108ba8a5b4 Add a primitive distance method 2026-04-26 18:20:11 +09:30
Cubicake 5228e06033 Require tile visibility to be explicitly set 2026-04-26 18:20:00 +09:30
Cubicake 7884b02d8a Copilot is a tad dumb 2026-04-26 16:15:04 +09:30
Cubicake fb861860bb Update for 26.1 testing 2026-04-26 16:03:09 +09:30
Cubicake d7036dd9d6 Update gitignore 2026-04-26 16:00:04 +09:30
Cubicake 777e31cf59 Revert back to PE, keeping internals code for when it may be needed 2026-04-26 15:59:05 +09:30
Cubicake 7645335bb6 Merge pull request #44 from Cubicake/v2/new-new-config
Rework config
2026-04-26 14:20:40 +09:30
copilot-swe-agent[bot]andCubicake 297278b998 Add bounds validation in RaycastConfig before byte/short casts
Agent-Logs-Url: https://github.com/Cubicake/RaycastedAntiESP/sessions/4cfd15a0-1329-4512-813f-b4f19f613388

Co-authored-by: Cubicake <70577278+Cubicake@users.noreply.github.com>
2026-04-26 04:47:45 +00:00
Cubicake b3455dfb92 Add missing defaults 2026-04-26 14:04:39 +09:30
Cubicake 2eecde1ee3 Use StrokkCommands 2026-04-26 14:04:18 +09:30
Cubicake 688f39463b Remove unused permission 2026-04-26 14:03:23 +09:30
Cubicake fc23764bce Delete MovementTracker.java 2026-04-26 14:03:10 +09:30
Cubicake 5a57e44869 Fix log messages 2026-04-26 13:16:40 +09:30
Cubicake 4318f8b23e Rework config system 2026-04-26 13:15:28 +09:30
Cubicake 8b370d0fe2 Add a command to dump the block ids for adding to the checks 2026-04-23 21:21:18 +09:30
Cubicake 4a8527909a Bump size slightly 2026-04-23 20:48:39 +09:30
Cubicake eca024118f Directly get from player registry 2026-04-23 12:17:34 +09:30
Cubicake 3f814cd6d6 Merge branch 'v2/track-vehicles' 2026-04-22 23:00:55 +09:30
Cubicake 2cbe04c6cc Bump version 2026-04-22 23:00:25 +09:30
Cubicake 2151f88f95 Apparently it was that simple lmao 2026-04-22 22:45:35 +09:30
Cubicake af387145fa Merge remote-tracking branch 'origin/main' 2026-04-21 20:09:01 +09:30
Cubicake 8f760b7769 Merge pull request #39 from Cubicake/v2/attempt-3-per-player-snapshots
Per-player snapshots
2026-04-20 21:43:46 +09:30
Cubicake b4d35ab9f5 clearer JD note 2026-04-20 20:51:19 +09:30
Cubicake 1c510322a9 Bump version 2026-04-20 17:25:35 +09:30
Cubicake dd1dd32391 Correct value 2026-04-20 14:42:24 +09:30
Cubicake f1342514e0 Use bitsets to save memory 2026-04-20 14:34:24 +09:30
Cubicake 331bd2a4c0 Merge pull request #41 from Cubicake/v2/try-and-fix-mem-leak
Fix some bugs and hopefully a memory leak
2026-04-20 12:30:44 +09:30
Cubicake a9de49a9a9 Don't allocate the boolean array for empty chunks 2026-04-20 12:20:46 +09:30
Cubicake e2c61cb926 Add tick time debugging 2026-04-20 12:18:20 +09:30
Cubicake 036ff55317 Merge remote-tracking branch 'origin/v2/try-and-fix-mem-leak' into v2/try-and-fix-mem-leak 2026-04-20 12:05:08 +09:30
Cubicake 19c58d5a71 Insert new tile entity if id changes 2026-04-20 12:03:41 +09:30
Cubicake 6c3d75643a Rename replaceChunk to replaceChunkSection and properly remove chunk sections if empty. 2026-04-20 12:03:08 +09:30
Cubicake 587f45f86b Expand to all block locatables 2026-04-20 11:56:54 +09:30
Cubicake 5eb815010d Create insertTileEntity 2026-04-20 11:56:41 +09:30
Cubicake 70a0c1d1de Properly utilise the features of CanonicalSet, implement insertTileEntity 2026-04-20 11:56:29 +09:30
Cubicake c59d650a94 Don't save empty chunks 2026-04-20 11:51:14 +09:30
Cubicake bcdbdf3c94 Remove unused import 2026-04-20 11:50:24 +09:30
Cubicake 99eb62a72e Null safety 2026-04-20 11:48:57 +09:30
Cubicake e17d0b616a Null safety 2026-04-20 11:48:29 +09:30
Cubicake 7c44cc1614 Clean up imports 2026-04-20 11:46:57 +09:30
Cubicake d75c5604e0 Properly dispatch across several threads when configured to use more than one. 2026-04-20 10:56:38 +09:30
Cubicake 902d0dcf20 Get correct block id 2026-04-19 22:58:39 +09:30
Cubicake dbe04d1861 Null check 2026-04-19 22:58:18 +09:30
Cubicake a0ffab833e Debug command 2026-04-19 22:58:04 +09:30
Cubicake e95fb3a97b Bump version 2026-04-19 22:57:51 +09:30
Cubicake d033cba970 Tile entities can't move 2026-04-19 22:08:33 +09:30
Cubicake c810152fa8 Correctly use block hashing (and label as such) 2026-04-19 21:11:12 +09:30
Cubicake 28929c0e20 Only one thread ever touches this 2026-04-19 20:30:47 +09:30
Cubicake 8046bbad91 Implement strictEquality 2026-04-19 20:30:33 +09:30
Cubicake 59fef9cd5d Remove transition type "FORGET", implement clearable where possible 2026-04-19 20:30:20 +09:30
Cubicake 98b31ee4cf Refactor 2026-04-19 20:28:13 +09:30
Cubicake be5b1b59f6 Make blockID final, refactor package, implement strictEquality 2026-04-19 20:27:45 +09:30
Cubicake 49d8c7cbf7 Specify the stored canonical type. 2026-04-19 20:19:47 +09:30
Cubicake a51ff8beaa Make ThreadSafeLocatable equality and hashcode checks properly thread safe 2026-04-19 20:03:19 +09:30
Cubicake c3183ef3d4 Implement StrictEquality 2026-04-19 20:02:58 +09:30
Cubicake b5e78cc0ff Functionally identical 2026-04-19 19:59:34 +09:30
Cubicake 3c7fabb52e Create CanonicalSet 2026-04-19 19:43:58 +09:30
Cubicake 004fc8bec9 Fix wording 2026-04-19 16:04:10 +09:30
Cubicake 45c6306482 Use new block view 2026-04-19 16:04:00 +09:30
Cubicake b37624b38f Explicitly do some clean up on player leave 2026-04-19 16:03:46 +09:30
Cubicake 5aaa9bd6c9 Use new block view 2026-04-19 16:03:07 +09:30
Cubicake 89a2629b77 Use new block view 2026-04-19 16:02:42 +09:30
Cubicake 83759a1c61 Create ChunkSectionLocatable and make Locatable inherit it 2026-04-19 16:02:23 +09:30
Cubicake 79cf23d04f Replace old with new unified block view 2026-04-19 16:01:45 +09:30
Cubicake 513dfc2b96 Use new block view 2026-04-19 16:01:39 +09:30
Cubicake 1632258ae8 Replace old with new unified block view 2026-04-19 16:00:30 +09:30
Cubicake 98b910fd2e Update registry for new merged factory 2026-04-19 15:59:59 +09:30
Cubicake 4c97544ac7 Merge tile entity view and block snapshot manager 2026-04-19 15:59:44 +09:30
Cubicake d01b080207 Remove an unnecessary allocation 2026-04-19 15:52:55 +09:30
Cubicake f167004657 Test commands 2026-04-18 22:11:26 +09:30
Cubicake 260278c380 Oops forgot to delete imports 2026-04-18 21:57:25 +09:30
Cubicake fe864dfb42 Finally remove DataHolder 2026-04-18 21:53:34 +09:30
Cubicake ee84361f7f If it's been marked as visible, keep it visible 2026-04-18 21:07:07 +09:30
Cubicake 054b092b10 Make sure people can't break everything by joining too quickly 2026-04-18 21:03:24 +09:30
Cubicake 3dfcb5e8a4 Switch to PaperListener pattern, begin replacement of DataHolder 2026-04-18 20:54:55 +09:30
Cubicake 53ffc67492 Don't drop data from column other than tile entities 2026-04-18 20:26:45 +09:30
Cubicake 38d9f794e8 Unnecessary casts 2026-04-17 22:35:46 +09:30
Cubicake 19c1db1fec Fix up 2026-04-17 22:25:57 +09:30
Cubicake 38eeba1875 Bump version 2026-04-17 22:15:46 +09:30
Cubicake d3561e28ca Use generics 2026-04-17 22:15:33 +09:30
Cubicake 702ef77248 Move EntityLocatable, TileEntityLocatable, and implementations, and make generic 2026-04-17 22:00:34 +09:30
Cubicake e347904aa1 Organise packetevents module 2026-04-17 21:53:49 +09:30
Cubicake 03d0844907 Add debugging commands 2026-04-17 21:48:51 +09:30
Cubicake ca41d935aa Packet reading and writing 2026-04-17 21:48:33 +09:30
Cubicake a7764ada31 Just bodge config a bit until it temporarily works 2026-04-17 21:48:00 +09:30
Cubicake 53c3c5cb4c Remove unneeded 2026-04-17 21:47:46 +09:30
Cubicake a065180096 Chunk-based was only needed for global bukkit, which is gone now 2026-04-17 21:47:25 +09:30
Cubicake 2389ac0f8a Store and expose the new views 2026-04-17 21:47:01 +09:30
Cubicake b12037bbe9 Just bodge config a bit until it temporarily works 2026-04-17 21:45:30 +09:30
Cubicake 6b8abe25cf Adapt to new systems 2026-04-17 21:44:42 +09:30
Cubicake a791eabacb Create ViewRegistry (supersedes SnapshotManager) 2026-04-17 21:44:17 +09:30
Cubicake ceb0d48554 Renamed TrackedTileEntity to TileEntityLocatable 2026-04-17 21:43:36 +09:30
Cubicake 9e7c62dc02 Create and implement a TileEntityLocatable 2026-04-17 21:43:13 +09:30
Cubicake 4c21c16e3b Cache changes until on player's netty thread 2026-04-17 21:35:02 +09:30
Cubicake 2db473077f No need to take current tick 2026-04-17 21:33:47 +09:30
Cubicake 078cfa8266 Use views 2026-04-17 21:33:36 +09:30
Cubicake e7ee8991b9 Don't step past the entity 2026-04-17 21:32:40 +09:30
Cubicake 77a7394d22 View interfaces 2026-04-17 21:32:20 +09:30
Cubicake c34bfdb61f View interfaces 2026-04-17 21:29:12 +09:30
Cubicake 43e11210cf getType does not exist anymore 2026-04-17 21:28:54 +09:30
Cubicake cb39e82485 Update PacketBlockSnapshotManager to work with the new interface formats 2026-04-17 21:28:11 +09:30
Cubicake d3756978dc Add LocatableType.NettyEntity 2026-04-17 21:27:27 +09:30
Cubicake fcaffbabcc Implementation of EntityLocatable with thread safety as needed for netty-based systems 2026-04-17 21:26:14 +09:30
Cubicake c6e4af9cdb A locatable that represents a per-player entity 2026-04-17 21:25:16 +09:30
Cubicake 335958939b Begin working on folia support 2026-04-17 17:33:46 +09:30
Cubicake 12c3894d04 Support all versions possible 2026-04-17 17:32:36 +09:30
Cubicake 50fdebf44b Make it so that version numbers properly update 2026-04-17 17:32:20 +09:30
Cubicake f941b6cc7b Most of this stuff has migrated away from bukkit events 2026-04-17 15:00:44 +09:30
Cubicake c30aced6be Hard depend PE for now 2026-04-17 14:59:46 +09:30
Cubicake 7eb515d8c2 Turns out there are a lot more block IDs than I thought 2026-04-17 14:59:35 +09:30
Cubicake 36ddc2ab4b Superseded by the new tile/entity view interfaces and their packet implementations 2026-04-16 20:05:55 +09:30
Cubicake 5e13f99fbf All superceded by the new tile/entity view interfaces 2026-04-16 20:05:28 +09:30
Cubicake af1e35cf80 Replaced by new impl of packets 2026-04-16 20:04:24 +09:30
Cubicake 1ac28cca35 All superceded by the new tile/entity view interfaces 2026-04-16 20:03:27 +09:30
Cubicake 562f203d09 Thread safety 2026-04-15 20:13:50 +09:30
Cubicake a1c0a6d860 Add debug method 2026-04-14 20:53:18 +09:30
Cubicake 2e816d92b8 Merge remote-tracking branch 'origin/v2/attempt-3-per-player-snapshots' into v2/attempt-3-per-player-snapshots 2026-04-14 14:20:05 +09:30
Cubicake 3fedbc2a17 World getting via key 2026-04-14 14:19:39 +09:30
Cubicake abd2dab77c Shut the logger up 2026-04-14 13:09:05 +09:30
Cubicake a7eacf704d Add delay 2026-04-14 12:59:49 +09:30
Cubicake a55022d4fd Fix some issues 2026-04-14 12:48:14 +09:30
Cubicake 8b6b0332eb WIP per-player-isation 2026-04-14 12:11:26 +09:30
Cubicake 79f018cd13 Massive changes, still very borked 2026-04-14 12:11:11 +09:30
Cubicake 5815d327cf Clarify versioning details in README
Removed note about version number differences between platforms.
2026-04-09 16:20:21 +09:30
Cubicake b76b0c900b Merge pull request #36 from Cubicake/modularise
Modularise code for platform-independence
2026-04-09 16:16:20 +09:30
Cubicake 9c6ab79f1c Might as well use the cache 2026-04-09 16:15:47 +09:30
Cubicake 01f37f6e1d Unless specified, providing a throwable shouldn't result in it actually being thrown 2026-04-09 16:14:13 +09:30
Cubicake 958c6468b4 Use inherited method rather than config-specific 2026-04-09 16:02:11 +09:30
Cubicake 3977e21568 Fix versioning docs 2026-04-09 16:00:04 +09:30
Cubicake 92dfbe9599 Logger should never fail; Add FallbackLogger 2026-04-09 15:56:36 +09:30
Cubicake 74f823b1a7 Replace colons to avoid issues in file names on some platforms 2026-04-09 15:56:11 +09:30
Cubicake 7d07e67d5b Issue identified by copilot code review 2026-04-09 15:41:31 +09:30
Cubicake 7ddf475e90 Error identified by copilot review 2026-04-09 15:38:16 +09:30
Cubicake 20bd20b60a Put time first so sorting by file name sorts by build time 2026-04-09 15:32:36 +09:30
Cubicake e858c4e6eb I forgot that this was in every build script 2026-04-09 15:27:38 +09:30
Cubicake 5127ebd260 Turns out this isn't a thing on windows 2026-04-09 14:07:14 +09:30
Cubicake f88b482a65 No need to put each snapshot manager in its own package 2026-04-07 14:46:50 +09:30
Cubicake a325dcc05f No need to put each visibility changer in its own package 2026-04-07 14:46:18 +09:30
Cubicake 186dd11aeb Add build properties 2026-04-07 14:45:04 +09:30
Cubicake 4131f0c61b Does not need to specify a class 2026-04-07 14:44:51 +09:30
Cubicake 5d94735581 JD notes 2026-04-07 14:44:33 +09:30
Cubicake 7d6a4860f6 Init messages do not need to specify class 2026-04-07 14:44:09 +09:30
Cubicake 31b6ec3426 Renamed gradle project 2026-04-07 14:43:30 +09:30
Cubicake 97703c90d0 No need for this anymore 2026-04-07 14:43:23 +09:30
Cubicake d9109fcbcd Renamed gradle project 2026-04-07 14:43:07 +09:30
Cubicake ba93e28d09 WIP plan 2026-04-02 19:36:18 +10:30
Cubicake 55de301117 Update JD note: class names have changed 2026-04-02 17:19:33 +10:30
Cubicake 2da16f39a5 oops 2026-04-02 12:19:58 +10:30
Cubicake ff81ae5d1a Use platform-independent logging with class info 2026-04-02 12:19:45 +10:30
Cubicake 18472570f4 Use platform-independent logging with class info 2026-04-02 12:03:12 +10:30
Cubicake 07d563c343 Finish core migration 2026-04-02 11:36:01 +10:30
Cubicake 6b89ab91e1 Update logging 2026-04-02 11:35:49 +10:30
Cubicake 8b6c2a895f Update to match PlatformLogger 2026-04-02 11:29:22 +10:30
Cubicake eb49446618 Fixup 2026-04-02 11:26:06 +10:30
Cubicake 6d3e768689 Update logger and imports 2026-03-31 17:47:39 +10:30
Cubicake d828461ce5 Update logger and imports 2026-03-31 17:46:45 +10:30
Cubicake bf51d0cfb6 Update logger and imports 2026-03-31 17:46:32 +10:30
Cubicake 73cec9faf5 WIP add commit hash awareness to project 2026-03-31 17:45:15 +10:30
Cubicake af7c1253e2 Update logger and imports 2026-03-31 17:44:40 +10:30
Cubicake d84b4c4bd8 Update logger and imports 2026-03-31 17:44:22 +10:30
Cubicake b8998ca936 Abstracted particle spawning 2026-03-31 17:43:57 +10:30
Cubicake 2363190bbf Add faster getWorld lookup 2026-03-31 17:43:33 +10:30
Cubicake 7068eec49e Remove unneeded attribute 2026-03-31 17:43:06 +10:30
Cubicake 516f4425a7 Move EntityVisibilityChanger to core 2026-03-31 17:42:47 +10:30
Cubicake 5c541178a4 Update logger and imports 2026-03-31 15:14:34 +10:30
Cubicake acab9879e1 Update logger and imports 2026-03-31 15:13:37 +10:30
Cubicake d1c7efa586 Add deprecation tag to make it more clear where it needs to be removed from 2026-03-31 15:12:40 +10:30
Cubicake 21dceabb2f Slightly changed passing of parameters 2026-03-31 15:12:12 +10:30
Cubicake ea8e11710c Update imports 2026-03-31 15:11:19 +10:30
Cubicake 72b838921f Move PlayerRegistry and PlayerData to core 2026-03-31 15:09:18 +10:30
Cubicake 55d770496a Move PlayerVisibilityChanger to core 2026-03-31 15:08:50 +10:30
Cubicake bfbe635032 Update logger and imports 2026-03-31 15:07:33 +10:30
Cubicake d560cbbd56 Move VisibilityTracker to core 2026-03-31 15:06:42 +10:30
Cubicake a0a3834c13 Move VisibilityChangeHandlers to core 2026-03-31 15:06:17 +10:30
Cubicake 566cd93e8d Update logger and imports 2026-03-31 15:05:26 +10:30
Cubicake 78fcec3f11 Move TileEntityVisibilityChanger to core 2026-03-31 15:04:46 +10:30
Cubicake fbdbcd39e3 Update logger and imports 2026-03-31 15:04:23 +10:30
Cubicake 2f0555c030 Move RaycastUtil to core 2026-03-31 15:03:31 +10:30
Cubicake 758263345f Add central static logger instance, require class for all logs 2026-03-31 15:01:11 +10:30
Cubicake 56ec5ffcb7 Move SnapshotManager 2026-03-30 20:06:17 +10:30
Cubicake 7e58806271 Update impls for changed interface location and format; Move away from DataHolder 2026-03-30 20:03:56 +10:30
Cubicake 9791348634 Move Engine
todo: move more methods to this interface
2026-03-30 19:49:35 +10:30
Cubicake 09a95cc735 Move BlockSnapshotManager 2026-03-30 19:49:09 +10:30
Cubicake 529b7977d4 Move EntitySnapshotManager 2026-03-30 19:45:35 +10:30
Cubicake 6f4a6d4b2e Rename RaycastedAntiESPCore.java to Core.java 2026-03-26 18:14:36 +10:30
Cubicake f57829e7fc update comment 2026-03-26 15:17:49 +10:30
Cubicake cf69030c56 Migrate config to core 2026-03-22 20:20:53 +10:30
Cubicake 828f302d5c Turns out module-info doesn't work with the bukkit ecosystem 2026-03-21 21:03:27 +10:30
Cubicake 927066adb9 Fix errors until it compiles 2026-03-21 20:20:54 +10:30
Cubicake 7c2fc00a87 Fix errors until it compiles 2026-03-21 16:58:36 +10:30
Cubicake 29890541af This should all be in paper until the non-paper stuff can be extricated 2026-03-21 16:37:17 +10:30
Cubicake 0ebd1903b1 Rename package to raycastedantiesp while we're at it 2026-03-21 14:55:39 +10:30
Cubicake f0cb5d0281 Massive refactoring in progress 2026-03-21 14:49:29 +10:30
Cubicake 300ae927d7 Massive refactoring in progress 2026-03-21 12:34:06 +10:30
Cubicake 54dc47c89f Separate Locatables into new module 2026-03-21 12:13:02 +10:30
Cubicake 60f8ea55b0 WIP Locatable refactoring 2026-03-21 12:04:55 +10:30
Cubicake 47e7a08547 Merge branch 'main' into fix-locatable 2026-03-20 14:56:20 +10:30
Cubicake e2089aace3 Make ThreadSafeLocatable properly atomic 2026-03-20 14:52:10 +10:30
Cubicake cef2a0e7ee Fix whatever this is 2026-03-20 14:51:50 +10:30
Cubicake 609fa9f9f4 Update issue templates
Add spark config view command
2026-03-14 13:50:16 +10:30
Ayushman Gaur 383bfe0abe changes made 2026-03-09 17:00:02 +05:30
Ayushman Gaur bd2c0f0c62 fix-locatable and implement stampedLock 2026-03-09 16:04:24 +05:30
Cubicake 08dff2867f Clarify stable version access in README
Updated information on stable version availability.
2026-03-09 15:16:24 +10:30
Cubicake 84114b3325 Update README formatting and content
Contributing info moved to CONTRIBUTING.md
2026-03-09 15:15:37 +10:30
Cubicake 30f78ab351 Add CONTRIBUTING.md 2026-03-09 15:11:53 +10:30
Cubicake 0d8eec08ae Oops 2026-03-09 14:55:31 +10:30
Cubicake 79d67832ac Update version information in README.md 2026-03-09 14:54:24 +10:30
Cubicake 8429c33791 Update beta version to alpha version in README 2026-03-09 14:53:54 +10:30
Cubicake ddc5052741 Merge remote-tracking branch 'origin/main'
# Conflicts:
#	src/main/java/games/cubi/raycastedAntiESP/utils/ConcurrentSetMap.java
2026-02-27 19:50:09 +10:30
Cubicake 9aff6869d1 Add warning to JD note on ConcurrentSetMap#asActualConcurrentMap 2026-02-27 19:49:34 +10:30
Cubicake 09f92498fc Add warning to JD note on ConcurrentSetMap#asActualConcurrentMap 2026-02-27 19:46:40 +10:30
Cubicake 47182ad24a Create ConcurrentSetMap<K, V> and replace instances of ConcurrentHashMap<K, Set<V>> with it 2026-02-27 19:36:35 +10:30
Cubicake e1a7a9b278 Implement ImmutableLocatable 2026-02-27 18:03:17 +10:30
Cubicake 5390965693 Add JD notes 2026-02-27 18:02:33 +10:30
Cubicake 75e7a3ddff Move away from Paper Position
WIP: Platform Independence
2026-02-25 22:05:45 +10:30
Cubicake 17c0db3980 Move interface methods above static 2026-02-25 21:57:43 +10:30
Cubicake 13e6ece4ae Merge branch 'config' 2026-02-22 18:07:17 +10:30
Cubicake dfe1ff6f9c Merge remote-tracking branch 'origin/main' 2026-02-22 18:06:54 +10:30
Cubicake c84993571a AbstractBlockLocation 2026-02-22 17:59:46 +10:30
Cubicake a2efea0060 Add PacketEvents support for BlockSnapshotManager (WIP)
todo: actually populate PacketEventsBSM with data from packetevents, link to config so that the object can be created.
2026-02-21 22:36:02 +10:30
Cubicake 15d30ce397 Modrinth link changed 2026-02-20 18:56:14 +10:30
Cubicake 5baeb75619 Fix copilot 2026-02-19 22:03:31 +10:30
Cubicake 11ef7e6388 Merge pull request #31 from Cubicake/copilot/migrate-to-sponge-configurate
Migrate Bukkit config handling to Configurate YAML
2026-02-19 21:21:23 +10:30
copilot-swe-agent[bot]andCubicake 6c1b3fdc7c Finalize Configurate migration implementation
Co-authored-by: Cubicake <70577278+Cubicake@users.noreply.github.com>
2026-02-19 10:38:05 +00:00
copilot-swe-agent[bot]andCubicake 1a25c49271 Migrate config system to Configurate YAML
Co-authored-by: Cubicake <70577278+Cubicake@users.noreply.github.com>
2026-02-19 10:34:54 +00:00
copilot-swe-agent[bot]andCubicake 001e8b3688 Document Configurate migration plan
Co-authored-by: Cubicake <70577278+Cubicake@users.noreply.github.com>
2026-02-19 10:15:58 +00:00
copilot-swe-agent[bot] 22c1321873 Initial plan 2026-02-19 10:12:43 +00:00
Cubicake 167b4be8b8 Fixup merge 2026-02-19 20:25:42 +10:30
Cubicake 0a5c130cd1 Merge branch 'main' into config
# Conflicts:
#	src/main/java/games/cubi/raycastedAntiESP/Logger.java
#	src/main/java/games/cubi/raycastedAntiESP/config/RaycastConfig.java
#	src/main/java/games/cubi/raycastedAntiESP/config/TileEntityConfig.java
#	src/main/java/games/cubi/raycastedAntiESP/engine/Engine.java
#	src/main/java/games/cubi/raycastedAntiESP/engine/SimpleEngine.java
2026-02-19 20:21:48 +10:30
Cubicake eb64d03d05 Preparations to merge changes from main 2026-02-19 20:13:40 +10:30
Cubicake 95d14e97b3 Debugging statements 2026-02-19 20:12:20 +10:30
Cubicake c1e71c52aa Debugging statements 2026-02-16 21:50:29 +10:30
Cubicake 18e1857d83 Add methods to track if player can see chunk 2026-02-16 21:47:58 +10:30
Cubicake 6a1214e126 Check that player has loaded chunk 2026-02-16 21:47:40 +10:30
Cubicake 6b1f9cf24f Clean up 2026-02-16 21:47:25 +10:30
Cubicake 96dec1d654 Add method to check if player is registered 2026-02-16 21:46:33 +10:30
Cubicake b6507cb052 Move TileEntityVisibilityTracker to its own class as it is quite a bit more complex than the trackers for players and entities 2026-02-16 21:44:08 +10:30
Cubicake 5f27b1da1f Add chunk coord getters to Locatable 2026-02-16 21:43:31 +10:30
Cubicake 433a09b7c6 Bump version 2026-02-16 21:43:16 +10:30
Cubicake a57dba3ff4 Permission checks cannot occur within core systems as this will not work when made platform independent 2026-02-16 18:38:18 +10:30
Cubicake 5f34f0cc6f Switch to kotlin gradle, bump gradle version, add paperweight (for now just for easier source reading, may actually be used later) 2026-02-16 18:21:45 +10:30
Cubicake c09a69381f Clean up 2026-02-14 22:46:15 +10:30
Cubicake 44f9bf4196 Migrate Tile visibility tracking to a system similar to player and entity 2026-02-14 22:19:30 +10:30
Cubicake 973e500c9f Begin making Engine an interface 2026-02-11 20:56:16 +10:30
Cubicake f436f31dea Properly flush cache 2026-02-08 16:09:26 +10:30
Cubicake a6b9d34bab Properly calculate tile entity chunk radius 2026-02-08 15:46:30 +10:30
Cubicake b5ef1d7ac4 continue 2026-02-01 18:56:44 +10:30
Cubicake 516197aa36 Merge remote-tracking branch 'origin/main' 2026-01-30 21:57:46 +10:30
Cubicake 08212cdb78 Bump version 2026-01-30 21:57:35 +10:30
Cubicake 4658e99bd9 Fix entities not being untracked correctly 2026-01-30 21:57:24 +10:30
Cubicake f74d6c90e8 Fix tile entities not being hidden correctly until being seen once 2026-01-30 21:57:11 +10:30
Cubicake 26e830bdd0 fixup copilot 2026-01-29 23:31:07 +10:30
Cubicake 0fb6d31cde Revise version information in README.md
Updated version information and added beta version details.
2026-01-28 17:12:59 +10:30
Cubicake 07b2c50edc Merge pull request #27
Overhaul config for new format
2026-01-28 17:09:06 +10:30
copilot-swe-agent[bot]andCubicake be9796c712 Cache debug config factory
Co-authored-by: Cubicake <70577278+Cubicake@users.noreply.github.com>
2026-01-27 12:52:04 +00:00
copilot-swe-agent[bot]andCubicake 433f873f82 Fill snapshot defaults and packet placeholders
Co-authored-by: Cubicake <70577278+Cubicake@users.noreply.github.com>
2026-01-27 12:47:48 +00:00
copilot-swe-agent[bot]andCubicake 914909039e Refactor debug config factory
Co-authored-by: Cubicake <70577278+Cubicake@users.noreply.github.com>
2026-01-27 12:38:43 +00:00
copilot-swe-agent[bot]andCubicake 92c5a9f4d1 Refactor visibility handler configs
Co-authored-by: Cubicake <70577278+Cubicake@users.noreply.github.com>
2026-01-27 09:09:46 +00:00
copilot-swe-agent[bot]andCubicake bfaa8605f0 Clarify engine factory init and tile entity parsing
Co-authored-by: Cubicake <70577278+Cubicake@users.noreply.github.com>
2026-01-27 05:44:07 +00:00
copilot-swe-agent[bot]andCubicake 55f68eed8c Lazily init engine config factories
Co-authored-by: Cubicake <70577278+Cubicake@users.noreply.github.com>
2026-01-27 05:42:57 +00:00
copilot-swe-agent[bot]andCubicake 2634b1a59e Reuse engine factories and cleanup defaults
Co-authored-by: Cubicake <70577278+Cubicake@users.noreply.github.com>
2026-01-27 05:41:26 +00:00
copilot-swe-agent[bot]andCubicake dd4d0476dd Refine tile entity defaults
Co-authored-by: Cubicake <70577278+Cubicake@users.noreply.github.com>
2026-01-27 05:39:42 +00:00
copilot-swe-agent[bot]andCubicake b6bb3abd28 Tidy enum registration and defaults
Co-authored-by: Cubicake <70577278+Cubicake@users.noreply.github.com>
2026-01-27 05:38:16 +00:00
copilot-swe-agent[bot]andCubicake a70ecf0b9d Refactor config factories and defaults
Co-authored-by: Cubicake <70577278+Cubicake@users.noreply.github.com>
2026-01-27 05:35:52 +00:00
copilot-swe-agent[bot]andCubicake 40b7d9e58d Co-authored-by: Cubicake <70577278+Cubicake@users.noreply.github.com> 2026-01-27 05:06:52 +00:00
Cubicake 05e2caaf43 Delete deletion candidates 2026-01-27 15:28:35 +10:30
copilot-swe-agent[bot]andCubicake 4030db77c7 Plan config overhaul updates
Co-authored-by: Cubicake <70577278+Cubicake@users.noreply.github.com>
2026-01-27 02:31:44 +00:00
copilot-swe-agent[bot] d2913e2c64 Initial plan 2026-01-27 02:27:01 +00:00
Cubicake 9f5fa5cd3a Merge remote-tracking branch 'origin/config' into config 2026-01-27 12:55:04 +10:30
Cubicake 2f92860f76 Delete deletion candidates 2026-01-27 12:54:50 +10:30
Cubicake 4d06bac9a3 Merge pull request #26 from Cubicake/main
Update name
2026-01-27 12:44:01 +10:30
Cubicake 7b63d6b352 Begin implementing Entity 2026-01-27 12:41:28 +10:30
Cubicake 1fe44a8e45 Have config classes define their own factories as internal static classes, begin moving default configs to config classes 2026-01-27 11:44:57 +10:30
Cubicake bb3f06a070 Move Mode to its own class 2026-01-27 11:42:54 +10:30
Cubicake c9ee55f864 Add more support for setting configs using commands 2026-01-27 11:42:33 +10:30
Cubicake 5654216ac3 Update name 2026-01-26 17:31:13 +10:30
Cubicake 351397852c WIP, begin defining factory methods 2026-01-26 17:01:15 +10:30
Cubicake 6532fb619c wtf how???????? 2026-01-24 19:39:17 +10:30
Cubicake ae63a4c56f Bump version 2026-01-24 12:30:18 +10:30
Cubicake ae4ff7c593 Rename project 2026-01-24 12:30:04 +10:30
Cubicake e016d4339f superclass method requires entity visibility not to have been set yet 2026-01-24 12:17:47 +10:30
Cubicake d1071427d1 Remove unneeded comment 2026-01-24 12:16:41 +10:30
Cubicake c4d56582d8 Move PacketEvents initialisation fully to onLoad() 2026-01-23 22:51:32 +10:30
Cubicake 266e04aa0c Add new Frequency enum 2026-01-23 22:50:59 +10:30
Cubicake cf0240b940 Suppress unnecessary warning, fix interface conflicts 2026-01-23 22:50:43 +10:30
Cubicake 1eee0946a3 Suppress unnecessary warning 2026-01-23 22:50:26 +10:30
Cubicake f49f58749b Fail loudly 2026-01-23 22:49:57 +10:30
Cubicake 8e06c4a3d8 Mark deprecated things 2026-01-23 22:49:17 +10:30
Cubicake 1f5e428023 Since packet processor init was moved earlier, all this logic is redundant now 2026-01-23 22:06:49 +10:30
Cubicake 96a92e95e9 Make PacketEventsStatus#get() not null 2026-01-23 22:02:44 +10:30
Cubicake 5e80239c14 oops forgot to revert 2026-01-23 21:41:41 +10:30
Cubicake 8943800c59 Move init of important variables to as soon as possible 2026-01-23 21:40:39 +10:30
Cubicake 858b08d558 Increase stacktrace length 2026-01-23 21:26:30 +10:30
Cubicake 625218513f Update version check string 2026-01-19 21:30:12 +10:30
Cubicake e9cd8a031e Update version check string 2026-01-19 21:24:41 +10:30
Cubicake 4d161ca0a2 Fix a bug with the version check system so it properly checks when very out of date. 2026-01-19 21:20:59 +10:30
Cubicake 6a92d4de18 Refactor main class to be easier to read and thus maintain. 2026-01-17 20:47:34 +10:30
Cubicake b8ecbf3636 Refactor CommandsManager to be a util class, inline return variable, and rename cfg to config.
There was no stateful behaviour in this class previously, so having a useless CommandsManager object was weird.
2026-01-17 20:46:51 +10:30
Cubicake e53fad05e3 Move EntityVisibilityChangeCache to deletioncandidates 2026-01-17 20:43:16 +10:30
Cubicake 8138e326b6 Add unstable api usage warning suppression 2026-01-17 20:42:54 +10:30
Cubicake a31ba406c6 Remove unused imports 2026-01-17 20:41:29 +10:30
Cubicake 2237edc1fd Bump version 2026-01-17 20:41:17 +10:30
Cubicake f8ec2b7000 Add Locatable#toBukkitLocation as a default method 2026-01-17 20:36:26 +10:30
Cubicake 00ee95a537 Move methods 2026-01-17 20:34:20 +10:30
Cubicake 0e31708380 Label worker threads 2026-01-10 23:33:24 +01:00
Cubicake 5a3b083928 Make BukkitTVC properly handle hiding tile entities 2026-01-08 17:25:30 +01:00
Cubicake a9cc1ab604 Remove now-unneeded cast 2026-01-08 17:25:09 +01:00
Cubicake 4d20087dfa Formatting 2026-01-08 17:24:45 +01:00
Cubicake b8236c2e6d Make more of BukkitESM methods overrides of interface, add EntitySnapshotManager#removeEntityLocation 2026-01-08 17:24:33 +01:00
Cubicake d3d67de973 Add more entity tracking events to keep Bukkit EntitySnapshotManager updated 2026-01-08 17:23:49 +01:00
Cubicake 96ee9c6931 Add Locatable#clonePlainAndCentreIfBlockLocation and use it to make RaycastUtil#raycast correctly cast to the centre of the block 2026-01-08 17:23:12 +01:00
Cubicake b184eda584 Update contribution licensing terms in README
Clarified contribution rights and licensing terms in README.
2026-01-07 23:45:23 +01:00
Cubicake d15420d46a Update README.md
Add contribution notes
2026-01-07 23:37:54 +01:00
Cubicake b62a008063 Update issue templates 2026-01-07 23:35:08 +01:00
Cubicake 3e00bbf61b Update issue templates
Add bug report template
2026-01-07 23:33:36 +01:00
Cubicake 359feffdcf Insert value if it did not exist 2026-01-06 21:56:56 +01:00
Cubicake 06978953b1 TODO note 2026-01-06 21:56:37 +01:00
Cubicake e1fc76df77 Update PlayerData info when changing visibility 2026-01-06 21:56:27 +01:00
Cubicake 4153cf4aac Update permission name 2026-01-06 21:55:55 +01:00
Cubicake 2d7303eb33 Add null checks 2026-01-06 21:55:39 +01:00
Cubicake b0d8e32202 Fix bypass permission check 2026-01-06 21:04:55 +01:00
Cubicake 5649f4ad7c Comment 2026-01-05 17:53:46 +01:00
Cubicake 9e5ad8c0a3 Bump version 2026-01-05 17:53:37 +01:00
Cubicake 57848b81f8 Remove redundant comment 2026-01-02 21:28:03 +01:00
Cubicake 2dc2dbb5f7 Fix bypass permission check, populate players into entity snapshot manager on join 2026-01-02 21:27:43 +01:00
Cubicake 34690d2408 Properly call Metrics#shutdown to avoid edge-cases 2026-01-02 21:26:50 +01:00
Cubicake 90f5ddbe8a Debugging 2025-12-25 21:27:05 +10:30
Cubicake 98edc8968b Fix typo 2025-12-25 21:26:59 +10:30
Cubicake e632a5b98d Plugin name has changed 2025-12-24 18:38:23 +10:30
Cubicake 5d8c786ba4 Update error logging to include a log level so it can be excluded 2025-12-24 18:37:11 +10:30
Cubicake bd1edf8332 Remove now-incorrect JD notes 2025-12-23 22:30:14 +10:30
Cubicake 7a003368ff Hook new systems into EventListener 2025-12-23 22:29:59 +10:30
Cubicake 542d681bb4 Update main class to use new systems 2025-12-23 22:29:42 +10:30
Cubicake 500aa72106 Add processCache method 2025-12-23 22:29:22 +10:30
Cubicake e9a22ff518 Add methods to TileEntitySnapshotManager 2025-12-23 22:29:11 +10:30
Cubicake fca7cc9d2d Add processCache method 2025-12-23 22:28:48 +10:30
Cubicake 4486e60ff2 Moved stateful handling of entity caching from interface to abstract class 2025-12-23 22:28:18 +10:30
Cubicake f322ab668a Remove imports 2025-12-23 22:27:00 +10:30
Cubicake 59059248df Implement TileEntityVisibilityChanger for Bukkit 2025-12-23 22:26:48 +10:30
Cubicake b499b62745 Abstract TileEntity caching which will be used by all impls of TVC 2025-12-23 22:26:18 +10:30
Cubicake 2d7dc391ae Add enums to check which snapshot managers are present 2025-12-23 22:25:46 +10:30
Cubicake d81a7bde44 Rename methods, add compareAndSet method 2025-12-23 22:25:23 +10:30
Cubicake 149bae4ac2 Implement TileEntitySnapshotManager for Bukkit, leeching off of BukkitBSM/old ChunkSnapshotManager for now 2025-12-23 22:24:44 +10:30
Cubicake d61be5ba8d Conform EntityLocationService to the EntitySnapshotManager interface, rename to match 2025-12-23 22:23:32 +10:30
Cubicake c06fe81df3 Conform ChunkSnapshotManager to the BlockSnapshotManager interface, rename to match 2025-12-23 22:23:09 +10:30
Cubicake 9c7dd360a5 Fix bug when logging messages 2025-12-23 22:22:31 +10:30
Cubicake c58417f15b Abstract caching into its own class, share logic between Bukkit impls of entity and player visibility handling. 2025-12-22 17:03:45 +10:30
Cubicake 7b6c663510 Change visibility, add flush methods to interface 2025-12-21 22:32:01 +10:30
Cubicake 1a97a70d9b Remove methods pointing to nowhere 2025-12-21 22:31:31 +10:30
Cubicake ee473162bf Migrate away from DataHolder by separating packetevents tracking into its own class in the packets package 2025-12-19 22:32:01 +10:30
Cubicake 41b41cace6 Move interfaces into their own package with implementations 2025-12-19 22:29:40 +10:30
Cubicake 01cd0d04da Add deprecation markers 2025-12-19 22:28:33 +10:30
Cubicake 7b6aa88e0f Add getType method 2025-12-19 22:28:07 +10:30
Cubicake dbef12eb7b Refactor EventListener to use new systems 2025-12-19 22:27:34 +10:30
Cubicake 15f5d77bae Add change caching to EntityVisibilityChanger, move away from EntityVisibilityChangeCache 2025-12-19 21:43:33 +10:30
Cubicake f45c85a838 Add visibility changer types and update changeHandlers method 2025-12-19 21:42:04 +10:30
Cubicake 8cdad10f14 Change debug log defaults, rename initiateConfigManager to initialiseConfigManager 2025-12-17 17:56:54 +10:30
Cubicake ae98d76ded Remove unnecessary imports 2025-12-17 17:56:16 +10:30
Cubicake 3f1e3a170d Add toString() method for each Locatable object 2025-12-17 17:53:17 +10:30
Cubicake 3c053dbacc change interface to supply boolean instead of Material 2025-12-16 14:17:32 +10:30
Cubicake 1e0f08083e Migrate away from WrappedBukkitLocation 2025-12-16 14:17:15 +10:30
Cubicake ae66f039f7 oops forgot this method 2025-12-16 14:16:46 +10:30
Cubicake 5224317545 Can directly pass UUID 2025-12-16 14:16:32 +10:30
Cubicake 6a3a8b5768 add javadocs comment to communicate how the method works 2025-12-16 14:16:17 +10:30
Cubicake 4eeb2b5d06 Move normalize() to default locatable 2025-12-16 14:15:24 +10:30
Cubicake 0995d546da Add set method which takes boolean 2025-12-16 14:15:07 +10:30
Cubicake a01ff503f4 Add set method which takes boolean 2025-12-16 14:15:01 +10:30
Cubicake 066c6a32ea Move LocatableImpl#normalize() to default Locatable method 2025-12-16 14:14:48 +10:30
Cubicake 5d2b6c9f4a Make AbstractBlockLocation extend Locatable 2025-12-16 14:14:14 +10:30
Cubicake 7a8a7364df Add more methods 2025-12-14 22:48:53 +10:30
Cubicake 0072c9ff8e Add setEntityVisibilityForPlayer method 2025-12-14 22:48:21 +10:30
Cubicake d78f562762 Work on implementing engine 2025-12-14 22:47:05 +10:30
Cubicake c6e845527e import package changed 2025-12-14 22:46:42 +10:30
Cubicake 68cb54c0ed Add more static conversion methods 2025-12-13 19:23:05 +10:30
Cubicake 7c45f6ec4e Add default implementation of Locatable 2025-12-13 19:22:34 +10:30
Cubicake 53f0615805 Improve equals and hashcode 2025-12-13 19:22:18 +10:30
Cubicake dd9d807d92 Add min and max distance checks to RaycastUtil#raycast, optimise raycasting 2025-12-12 23:06:05 +10:30
Cubicake 902ed25a5b SnapshotManager is a static util class now 2025-12-12 15:35:06 +10:30
Cubicake 7a90d92c0a Match styling 2025-12-12 15:34:36 +10:30
Cubicake 7ca097b35c Update RaycastUtil to work with new objects, make MutableBlockVector behave like a floating-point vector except it equals and hashcodes like a BlockLocation 2025-12-11 17:03:36 +10:30
Cubicake d0a6c8475e Update RaycastUtil to work with new objects, make MutableBlockVector behave like a floating-point vector except it equals and hashcodes like a BlockLocation 2025-12-11 17:01:38 +10:30
Cubicake b1fa7e7c96 Update interface for new AbstractBlockLocation 2025-12-09 14:17:05 +10:30
Cubicake 70bbb06ee9 Create Interface Methods 2025-12-09 14:16:38 +10:30
Cubicake 8193baf9df Implement vector methods from Locatable 2025-12-09 14:16:13 +10:30
Cubicake d6e62f11ee Rename to ThreadSafeLocation, implement vector methods from Locatable 2025-12-09 14:16:00 +10:30
Cubicake 992dad2775 deletion candidate 2025-12-09 14:15:34 +10:30
Cubicake 814cf86541 deletion candidate 2025-12-09 14:15:21 +10:30
Cubicake f3e4c1cb47 Add vector methods to Locatable 2025-12-09 14:15:02 +10:30
Cubicake 0bf28b6951 Add mutable version of block location for raycast iteration, make common interface 2025-12-09 14:14:27 +10:30
Cubicake e71e9006fd Locatable package moved 2025-12-05 18:08:49 +10:30
Cubicake 06b3395d03 Change Locatable to only cover ThreadSafeLoc and WrappedBukkitLocation 2025-12-05 18:07:44 +10:30
Cubicake 222987baae Update README.md with new version 2025-11-26 17:11:29 +10:30
Cubicake a495d3946d Create util class for handling visibility change 2025-11-25 22:04:54 +10:30
Cubicake 7a514d6236 Split entity and player visibility tracking, have data modified by generic methods but invoked by entity or player specific methods 2025-11-25 22:04:13 +10:30
Cubicake 26a4d4c10c Modify TileEntitySnapshotManager interface to add methods needed for engine 2025-11-25 22:03:19 +10:30
Cubicake cbb48372ac Update RaycastUtil to use new objects 2025-11-25 22:02:43 +10:30
Cubicake ff31d9085a TODO note 2025-11-25 22:02:00 +10:30
Cubicake 1d93653422 TODO note 2025-11-25 22:01:53 +10:30
Cubicake db13824a0f Add process distribution over multiple threads, begin impl of actual checks 2025-11-25 22:01:38 +10:30
Cubicake dba313847c Change config paths to include "checks" 2025-11-25 22:00:45 +10:30
Cubicake c319a6ffd4 Clean up unnecessary files 2025-11-25 21:58:48 +10:30
Cubicake 486e5dcb36 Move logic to tile entity snapshotting manager 2025-11-18 21:00:15 +10:30
Cubicake 20842449af Formatting fix 2025-11-18 20:59:35 +10:30
Cubicake 027f62727a Make ThreadSafeLoc implement locatable 2025-11-18 20:59:06 +10:30
Cubicake 3ae7ca0d2e Create abstracted interfaces for snapshotting so that different methods of snapshotting can be implemented 2025-11-18 20:58:47 +10:30
Cubicake 3fa02c2561 Create abstracted interfaces for visibility change handling so that different methods of handling can be implemented 2025-11-18 20:58:10 +10:30
Cubicake 32a0b94f61 WIP 2025-11-13 22:16:54 +10:30
Cubicake e28b7b6f23 WIP: Abstract snapshotting so that multiple different snapshotting means can exist 2025-11-13 22:10:10 +10:30
Cubicake 2fc7e50145 WIP: Make all locations implement Locatable 2025-11-13 22:09:32 +10:30
Cubicake c56ee078c9 Merge branch 'v1.7.x' 2025-11-10 18:17:41 +10:30
Cubicake 4400151878 Merge branch 'v1.7.x' 2025-11-10 18:13:01 +10:30
Cubicake 50d0e54687 prepare for merge with v1.7.x branch 2025-11-08 17:46:10 +10:30
Cubicake 2f15ca9d5b prepare for merge with v1.7.x branch 2025-11-08 17:45:17 +10:30
Cubicake f6535848c0 prepare for merge with v1.7.x branch 2025-11-08 16:43:45 +10:30
Cubicake 4b96935f34 Change package in preparation of merge with v1.7.x branch 2025-11-08 16:43:09 +10:30
Cubicake 40b99d5c43 Clean up 2025-11-08 16:36:33 +10:30
Cubicake e448e18472 Support lower versions 2025-11-08 16:36:24 +10:30
Cubicake d806ae3c0b Support lower versions 2025-10-21 19:49:51 +10:30
Cubicake 34fe60a7ae Merge remote-tracking branch 'origin/main'
# Conflicts:
#	src/main/java/games/cubi/raycastedEntityOcclusion/Snapshot/ChunkSnapshotManager.java
2025-10-21 19:42:12 +10:30
Cubicake 0ff67e11a7 Improve Regex to handle suffixes ie v1.6.3-beta 2025-10-21 19:38:34 +10:30
Cubicake 98eaf72cae Part of the snapshot changes 2025-10-21 19:37:55 +10:30
Cubicake e5c7f6ef90 Comment 2025-10-21 19:37:27 +10:30
Cubicake da73bb26ec Temporary BlockLocation changes (v1.7.x already has a better system) 2025-10-21 19:37:04 +10:30
Cubicake bd57a9b72c Version bump 2025-10-21 19:36:26 +10:30
Cubicake 116f5e8e03 IntelliJ is having a fit 2025-10-18 16:04:25 +10:30
Cubicake bcfdd731e2 IntelliJ is having a fit 2025-10-18 15:59:17 +10:30
Cubicake e83ec5e6a2 Investigating a bug where tile entities being removed is not properly handled 2025-10-18 15:55:49 +10:30
Cubicake 2b48e7e8d2 Investigating a bug where tile entities being removed is not properly handled 2025-10-18 15:50:37 +10:30
Cubicake 38c39aecc5 Update README with dependencies and known issues
(cherry picked from commit a68bcfdbf5)
2025-10-17 10:39:48 +10:30
Cubicake 70ec4c212f Create FUNDING.yml
(cherry picked from commit 77825067de)
2025-10-17 10:39:48 +10:30
Cubicake d5026d28d4 Fix minor bug with better version checking
(cherry picked from commit 87aba0e2b5)
2025-10-17 10:39:19 +10:30
Cubicake df5e9f6ca8 Implement better version checking
(cherry picked from commit d46d63668b)
2025-10-17 10:39:18 +10:30
Cubicake 7f1a284eae Remove unused import 2025-10-17 09:56:48 +10:30
Cubicake 87aba0e2b5 Fix minor bug with better version checking 2025-10-16 12:38:43 +10:30
Cubicake d46d63668b Implement better version checking 2025-10-16 12:08:49 +10:30
Cubicake 83a278b00a Add run-paper plugin, bump version number 2025-10-16 12:08:12 +10:30
Cubicake c1e0db5613 Merge remote-tracking branch 'origin/main' 2025-10-16 11:08:23 +10:30
Cubicake 34db141f08 Re-enable logging, clean up Logger.java 2025-10-16 11:08:07 +10:30
Cubicake 61831a813a Updated CommandsManager for new name and config format, added exempted blocks config to TileEntityConfig, continued EngineNewer work 2025-10-16 11:06:13 +10:30
Cubicake a68bcfdbf5 Update README with dependencies and known issues 2025-10-02 21:43:39 -04:00
Cubicake 9ca8b4ee3a Rename plugin 2025-09-20 16:11:34 +09:30
Cubicake 77825067de Create FUNDING.yml 2025-09-18 21:22:52 +09:30
Cubicake 635f407c3a Tick store per entity 2025-09-16 12:54:10 +09:30
Cubicake c18b30da36 Added logging to file, an error method which serves as an early return, refactored EntityLocationPair.java as a record, refactored DataHolder.java into 3 seperate data storage objects with references accessed via DataHolder 2025-09-12 12:17:44 +09:30
Cubicake b524cfdf10 Merge remote-tracking branch 'origin/v1.7.x' into v1.7.x
# Conflicts:
#	src/main/java/games/cubi/raycastedAntiESP/Logger.java
#	src/main/java/games/cubi/raycastedAntiESP/config/DebugConfig.java
2025-09-06 13:07:41 +09:30
Cubicake 968c803106 Moved getting from config and defaults into the config objects, added entity location tracking 2025-09-06 13:05:15 +09:30
Cubicake 77c5a18433 Engine is WIP, DataHolder is a mess rn 2025-09-05 11:13:07 +09:30
Cubicake 085fa59e42 Disable logging temp 2025-09-05 10:00:32 +09:30
Cubicake 2db88a4498 lazy load debug particles 2025-09-03 09:00:29 +09:30
Cubicake 081e762c5c clean up comments 2025-08-29 16:00:35 +09:30
Cubicake 1733fd1884 Improve update checks 2025-08-29 13:36:14 +09:30
Cubicake 773378e6cb Moved getting from config and defaults into the config objects, added entity location tracking 2025-08-29 12:57:16 +09:30
Cubicake ac67aa8786 Make ConfigManager a singleton, remove old config manager, add entity location tracking (inc mutating ThreadSafeLocs instead of reasigning) 2025-08-27 22:29:04 +09:30
Cubicake 40bbaeb5ff Merge remote-tracking branch 'origin/v1.7.x' into v1.7.x
# Conflicts:
#	src/main/java/games/cubi/raycastedAntiESP/config/ConfigManager.java
2025-08-26 20:20:21 +09:30
Cubicake 76f5816162 Package names should all be lowercase 2025-08-26 20:18:10 +09:30
Cubicake 1201ff1370 Rename and refactor plugin 2025-08-26 17:59:16 +09:30
Cubicake e9935f0350 Update latest version to v1.6.1 2025-08-26 08:42:50 +09:30
Cubicake 11f1c6ecb7 Config changes finished, all files updated to handle the new config system (or just commented out for now). Added ThreadSafeLoc.java 2025-08-17 11:31:55 +09:30
Cubicake 0a6302674d Config changes finished, all files updated to handle the new config system (or just commented out for now). Added ThreadSafeLoc.java 2025-08-16 21:29:45 +09:30
Cubicake 4283dfd87b Massively WIP 2025-08-15 21:29:43 +09:30
Cubicake 9d01af18f3 The Subscribers field is never reassigned so it can be final 2025-08-15 18:57:30 +09:30
Cubicake 77dd9bb31a Make getter methods static so that plugin instances don't need to be passed into all static methods 2025-08-15 18:56:39 +09:30
Cubicake 47f862323b WIP 2025-08-13 12:34:22 +09:30
Cubicake c356ed0172 Fix offset 2025-08-13 11:03:01 +09:30
Cubicake 8d39fa5427 Bump version 2025-08-13 10:55:53 +09:30
Cubicake 7e0725c538 Merge changes from v1.6.x branch 2025-08-12 21:04:36 +09:30
Cubicake b958d0dc46 Make intellij shut up 2025-08-12 12:05:36 +09:30
Cubicake e9adb65690 Instead of throwing an error, try and fx the situation. 2025-08-12 12:03:16 +09:30
Cubicake 6a289c81a9 Check world so that distance check doesn't error 2025-08-12 10:40:05 +09:30
Cubicake 34b04ff059 Include update link in update checker 2025-08-11 21:17:52 +09:30
Cubicake 1a73c2509a Fix the previous commit 2025-08-11 20:49:45 +09:30
Cubicake e3731f76f0 Debug mode logging 2025-08-11 20:49:14 +09:30
Cubicake bd1f6ad482 Don't spawn a new thread for each tile entity update 2025-08-11 20:36:26 +09:30
Cubicake 951e4f4ad9 Fix change delta being ignored 2025-08-11 20:28:22 +09:30
Cubicake 114746aeaf Resolves #11 2025-08-11 20:08:06 +09:30
Cubicake 9dc9652917 Use snapshotChunk 2025-08-11 18:03:29 +09:30
Cubicake b97f675159 Bump version 2025-08-11 18:03:08 +09:30
Cubicake f5e16fc75d Resolves #10
OMFG I hate myself
2025-08-11 18:02:48 +09:30
Cubicake 6dc3f2f84e Config rework WIP 2025-08-09 17:11:47 +09:30
Cubicake 8e76557a88 new config layout, to replace config.yml at a later date
(cherry picked from commit d5e3281cf2)
2025-08-09 16:28:01 +09:30
Cubicake f76e2bbcf7 WIP 2025-08-09 16:25:44 +09:30
Cubicake c228cef24a Merge remote-tracking branch 'origin/main' 2025-08-09 16:19:36 +09:30
Cubicake 098aab5e31 Don't hardcode plugin name 2025-08-09 16:19:20 +09:30
Cubicake 31b500bc7b Fix bug in issue #9 2025-08-04 11:35:13 +09:30
Cubicake d5e3281cf2 new config layout, to replace config.yml at a later date 2025-08-04 11:33:47 +09:30
Cubicake 98dbefd576 For future packet handling 2025-08-04 11:33:17 +09:30
Cubicake 4dce9b3278 WIP improved debugging 2025-08-04 11:32:45 +09:30
Cubicake d5bf02b4ea Merge remote-tracking branch 'origin/main' 2025-07-27 18:52:36 +09:30
Cubicake ed98e2abeb Update README.md 2025-07-27 17:39:13 +09:30
Cubicake 9a07bd0119 v1.6.0 release 2025-07-27 17:21:42 +09:30
Cubicake 87cd59b346 Pull changes from main 2025-07-27 16:45:57 +09:30
Cubicake 74aca26910 Update .gitignore 2025-07-27 16:32:49 +09:30
Cubicake 25f5652a12 Kinda crappy way to hopefully fix the missing snapshots while I work on a more permanant fix 2025-07-27 16:08:40 +09:30
Cubicake 7679f08d06 Use the new logger to format messages 2025-07-27 16:07:26 +09:30
Cubicake 7ad99917d1 Might use this later? 2025-07-27 16:06:44 +09:30
Cubicake ce56eb316e Might use this later? 2025-07-27 16:06:39 +09:30
Cubicake 74426d80af Mark as mojmapped 2025-07-27 16:06:13 +09:30
Cubicake fdb1f567ac Snapshot changes 2025-07-26 16:26:14 +09:30
Cubicake e823f7a2f7 Move string operations to their own methods 2025-07-26 16:25:15 +09:30
Cubicake 7c1f7fd2a6 Version bump 2025-07-25 20:35:25 +09:30
Cubicake c26e6a1623 Oops forgot to pass config to movement tracker 2025-07-25 20:35:16 +09:30
Cubicake 8155903342 More readable imports 2025-07-25 20:32:53 +09:30
Cubicake f2ade6b0b8 Merge remote-tracking branch 'origin/main' 2025-07-25 20:31:26 +09:30
Cubicake f486d1fc2e Stop intellij from complaining 2025-07-25 20:30:09 +09:30
Cubicake 50eeab8cfe Bump api version 2025-07-25 20:26:37 +09:30
Cubicake 4009fe6d02 Use built in bukkit chunk keys instead of making custom ones 2025-07-25 20:26:25 +09:30
Cubicake b7e6fa9c5f Stop using * imports, use plugin logger, use built in bukkit chunk keys instead of making custom ones, hopefully fix chunks not being snapshotted. 2025-07-25 20:25:44 +09:30
Cubicake dcc986c232 Stop using * imports 2025-07-23 13:47:52 +09:30
Cubicake 95cea9f875 Stop using * imports 2025-07-23 13:47:20 +09:30
Cubicake a151bdbeca WIP 2025-07-21 16:17:16 +09:30
Cubicake 6d288de95b WIP 2025-07-20 12:05:29 +09:30
Cubicake aa0ebdbc93 Individual player recheck intervals will both spread out heavier recheck operations and will allow for changing the value without a server restart 2025-07-20 11:20:49 +09:30
Cubicake af50b9c69c On join add player to engine list 2025-07-18 16:46:52 +09:30
Cubicake 963fbbe9be Create new Engine 2025-07-18 16:42:29 +09:30
Cubicake 02ef0c3343 Clean up 2025-07-18 16:41:41 +09:30
Cubicake 1ac6e6b50b New data storage classes 2025-07-18 16:40:56 +09:30
Cubicake f1dfe64d67 Prepare for removal 2025-07-18 16:40:45 +09:30
Cubicake 6e8d47b96e Optimise engine-mode = 1 2025-07-15 13:49:58 +09:30
Cubicake f04b79bb4a Move all listeners to EventListener.java and have UpdateChecker.checkForUpdates called from there 2025-07-14 14:30:58 +09:30
Cubicake bf17a65246 Move packetevents loading to a different class so that plugin still runs without packetevents 2025-07-14 14:30:22 +09:30
Cubicake 3d4702e520 Clean up imports 2025-07-14 14:10:07 +09:30
Cubicake 266302f09c Merge pull request #8 from Cubicake/packetevents
PacketEvents functionality
2025-07-14 14:01:27 +09:30
Cubicake ac130a739e Merge pull request #7 from Cubicake/main
Update README.md
2025-07-14 13:59:21 +09:30
Cubicake dcc316e7e7 Edit defaults, add whitespace 2025-07-14 13:58:00 +09:30
Cubicake 754214fa8d Increment version 2025-07-14 13:55:29 +09:30
Cubicake a6f47f137c Edit outdated version message 2025-07-14 13:54:01 +09:30
Cubicake 97e43e65f8 Metrics moved to separate folder 2025-07-14 13:53:32 +09:30
Cubicake ef81d97eef Remove imports 2025-07-14 13:53:05 +09:30
Cubicake 36d75c8933 Relocate class 2025-07-14 13:52:47 +09:30
Cubicake b37f8465aa Add custom metrics 2025-07-14 13:52:37 +09:30
Cubicake 3d34992fcc Consolidate defaults 2025-07-14 13:52:24 +09:30
Cubicake 4602dde7df Implemented packetevents based tablist fixing, removed PDC handling as it's not needed anymore, remove VIM as it was never implemented 2025-07-13 18:08:04 +09:30
Cubicake a81d5caa45 Implemented packetevents based tablist fixing, removed PDC handling as it's not needed anymore, remove VIM as it was never implemented 2025-07-13 18:07:21 +09:30
Cubicake 7ef25e5dc3 typo 2025-07-11 18:11:19 +09:30
Cubicake 529ab3f583 Clean up 2025-07-11 18:09:36 +09:30
Cubicake 951883cb1b Clean up imports and comments 2025-07-11 18:08:50 +09:30
Cubicake 08113b57ba Prevent calling getKey() and System.currentTimeMillis() twice in a row 2025-07-10 08:26:43 +09:30
Cubicake 63e9c8bea1 Prevent calling getKey() twice in a row 2025-07-10 08:25:18 +09:30
Cubicake 1d14468924 WIP 2025-07-10 08:19:51 +09:30
Cubicake 5378fd5907 search radius and always show radius results were ignored 2025-07-09 10:43:25 +09:30
Cubicake 5e8d8bb43e Refactor 2025-07-01 16:08:36 +09:30
Cubicake da5c68b07c Refactor 2025-07-01 16:08:00 +09:30
Cubicake 0f9af7c217 Packet based tablist fix 2025-07-01 16:03:47 +09:30
Cubicake 1fd227e8ba Update README.md
still hi
2025-05-29 10:30:32 +09:30
Cubicake e4c653fe6a work in progress 2025-05-28 20:18:39 +09:30
Cubicake f2dc9f7d18 Merge remote-tracking branch 'origin/main' 2025-05-28 20:10:26 +09:30
Cubicake 8998338563 Update README.md 2025-05-28 19:21:29 +09:30
Cubicake 361bbf84bc Added a sanity check because of a bug report 2025-05-25 19:52:44 +09:30
Cubicake 384393358c Update README.md 2025-05-21 15:10:06 +09:30
Cubicake 9c2d542f3c Fixed a bug with entities outside of the world (above max build height or below min) 2025-05-11 17:18:04 +09:30
Cubicake ab930c4c30 Updated defaults based on real-world testing on an SMP 2025-05-10 21:08:24 +09:30
Cubicake 1f64514366 Increment version 2025-05-06 20:15:44 +09:30
Cubicake 398592225e Bug fixes 2025-05-06 20:15:33 +09:30
Cubicake a95b79d428 Update README.md 2025-05-05 19:07:24 +09:30
Cubicake 67c9758a96 Update README.md 2025-05-05 19:07:04 +09:30
Cubicake f555249cc9 Bug fixes 2025-05-05 18:16:08 +09:30
Cubicake 5e4bc1f0fb Increment version 2025-05-05 18:15:59 +09:30
Cubicake 53d49cf542 Update checking 2025-05-05 18:15:45 +09:30
Cubicake 9b34fa51a0 Update Checking 2025-05-05 18:15:30 +09:30
Cubicake 573d8331dc new permission 2025-05-05 18:15:15 +09:30
Cubicake 333b211b00 Load at startup
Plugin needs to load before chunks so that said chunks can be snapshotted.
2025-05-05 11:33:56 +09:30
Cubicake 81718b8848 Implemented tile entity checks 2025-05-04 20:51:20 +09:30
Cubicake 6084a373c8 I am very confused 2025-05-04 16:46:07 +09:30
Cubicake f22f6db331 Permission bypass 2025-05-04 14:14:43 +09:30
Cubicake 4c7733420f Permission bypass 2025-05-04 14:14:37 +09:30
Cubicake 88c004997d Bug fix 2025-05-02 20:36:53 +09:30
Cubicake 8eb18e8793 Noted that snapshot-refresh-interval only changes on restarts. 2025-05-02 20:36:40 +09:30
Cubicake f56a4e147b Refactored and split engine logic into its own file 2025-05-02 20:36:10 +09:30
Cubicake 651668b62e Increment version 2025-05-02 20:35:54 +09:30
Cubicake 1e4f45d4ee Merge remote-tracking branch 'origin/main' 2025-04-29 18:13:53 +09:30
Cubicake 0bab09e26b Stop making a new DustOptions instance each time 2025-04-29 18:13:38 +09:30
Cubicake 848e0ccbe8 Update README.md 2025-04-28 20:43:43 +09:30
Cubicake ee402042e6 Updated version to v1.4.1 release 2025-04-28 20:42:29 +09:30
Cubicake 744bc97f0f WIP Update Checker (for v1.4.2) 2025-04-28 20:42:16 +09:30
Cubicake c27da66cf0 Implemented Brigadier command API, ability to change config using commands. 2025-04-28 17:25:09 +09:30
Cubicake 0039ee0e0f Fixes 2025-04-28 14:58:59 +09:30
Cubicake 1c8347ecb4 Added a comment explaining its purpose 2025-04-27 21:20:17 +09:30
Cubicake 9e86c1680d Refactored literally everything. Old files have been moved to a subfolder and are not used 2025-04-27 21:19:54 +09:30
Cubicake 065f2e2a17 Many changes, still a WIP 2025-04-18 13:40:42 +09:30
Cubicake 3cba095d77 Merge remote-tracking branch 'origin/main' 2025-02-14 19:42:34 +10:30
Cubicake 24f99bebfb Converted MoreChecks to EngineMode, added two new engine modes. 2025-02-14 19:42:15 +10:30
Cubicake f650cda9f6 Converted OccludePlayers to CullPlayers 2025-02-13 18:35:14 +10:30
Cubicake 392b503223 Create LICENSE
Changed to GPL v3
2025-02-13 11:39:52 +10:30
Cubicake d66b270051 Delete LICENSE
Changing Licence
2025-02-13 11:36:45 +10:30
Cubicake fa7fd4fdd7 Implemented SneakListener and associated config value, implemented config fixing if missing values. 2025-02-12 22:02:23 +10:30
Cubicake d8d81c4662 Coded 2025-02-12 21:36:04 +10:30
Cubicake b338dc2175 Update README.md 2025-02-05 20:45:10 +10:30
Cubicake 3ab250e4ef Update README.md 2025-02-05 20:41:43 +10:30
Cubicake 231d2bc7d1 Update README.md 2025-02-05 20:40:05 +10:30
Cubicake d10865070b Added bStats support, refactored code, added CommandHandler.java 2025-01-25 22:00:28 +10:30
Cubicake 3fe9434856 Merge remote-tracking branch 'origin/main' 2025-01-23 22:09:53 +10:30
Cubicake 43dc579078 Added more config options: MoreChecks and OccludePlayers 2025-01-23 22:09:23 +10:30
Cubicake 4d290c2803 Create LICENSE 2025-01-19 18:40:00 +10:30
125 changed files with 10018 additions and 256 deletions

No files matched your search

+15
View File
@@ -0,0 +1,15 @@
# These are supported funding model platforms
github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
patreon: # Replace with a single Patreon username
open_collective: # Replace with a single Open Collective username
ko_fi: cubicake
tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
liberapay: # Replace with a single Liberapay username
issuehunt: # Replace with a single IssueHunt username
lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry
polar: # Replace with a single Polar username
buy_me_a_coffee: # Replace with a single Buy Me a Coffee username
thanks_dev: # Replace with a single thanks.dev username
custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']
+26
View File
@@ -0,0 +1,26 @@
---
name: Bug report
about: Create a report to help us improve
title: "[Bug]: xyz"
labels: ''
assignees: ''
---
**Describe the bug**
A clear and concise description of what the bug is.
**To Reproduce**
Steps to reproduce the behaviour. A video or images may be helpful here.
**Expected behavior**
A clear and concise description of what you expected to happen.
**General debugging information**
- Any relevant crash or console logs
- The output of `/raycastedentityocclusions`
- The output of `/raycastedentityocclusions config-values`
- The link returned by `/spark profiler start --timeout 11`
**Additional context**
Add any other context about the problem here.
+20
View File
@@ -0,0 +1,20 @@
---
name: Feature request
about: Suggest an idea for this project
title: "[Feature Request]"
labels: ''
assignees: ''
---
**Is your feature request related to a problem? Please describe.**
A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
**Describe the solution you'd like**
A clear and concise description of what you want to happen.
**Describe alternatives you've considered**
A clear and concise description of any alternative solutions or features you've considered.
**Additional context**
Add any other context or screenshots about the feature request here.
+5
View File
@@ -1,10 +1,14 @@
# User-specific stuff
.idea/
README.md
*.md
*.iml
*.ipr
*.iws
# IntelliJ
out/
# mpeltonen/sbt-idea plugin
@@ -114,6 +118,7 @@ gradle-app.setting
# Common working directory
run/
runs/
run-1-21-11/
# Avoid ignoring Gradle wrapper jar file (.jar files are usually ignored)
!gradle-wrapper.jar
+3
View File
@@ -0,0 +1,3 @@
[submodule "logging"]
path = logging
url = https://github.com/Cubicake/CubiLogging.git
+6
View File
@@ -0,0 +1,6 @@
## Contributions
Contributions via pull requests are welcome. Please join our [discord](https://discord.cubi.games) or make an `issue` to discuss any contributions beforehand to make sure they will not conflict with or hinder existing plans.
A good place to start with contributions is to look for `issue`s flagged with the label `help wanted`.
You must hold the rights to any code you contribute, and must agree to licence it under the same licence as the rest of the project in perpetuity, explicitly including any and all changes to the project's licence by project maintainers in the future. The project's licence can always be found at [LICENSE.md](LICENSE.md).
+661
View File
@@ -0,0 +1,661 @@
GNU AFFERO GENERAL PUBLIC LICENSE
Version 3, 19 November 2007
Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The GNU Affero General Public License is a free, copyleft license for
software and other kinds of works, specifically designed to ensure
cooperation with the community in the case of network server software.
The licenses for most software and other practical works are designed
to take away your freedom to share and change the works. By contrast,
our General Public Licenses are intended to guarantee your freedom to
share and change all versions of a program--to make sure it remains free
software for all its users.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
them if you wish), that you receive source code or can get it if you
want it, that you can change the software or use pieces of it in new
free programs, and that you know you can do these things.
Developers that use our General Public Licenses protect your rights
with two steps: (1) assert copyright on the software, and (2) offer
you this License which gives you legal permission to copy, distribute
and/or modify the software.
A secondary benefit of defending all users' freedom is that
improvements made in alternate versions of the program, if they
receive widespread use, become available for other developers to
incorporate. Many developers of free software are heartened and
encouraged by the resulting cooperation. However, in the case of
software used on network servers, this result may fail to come about.
The GNU General Public License permits making a modified version and
letting the public access it on a server without ever releasing its
source code to the public.
The GNU Affero General Public License is designed specifically to
ensure that, in such cases, the modified source code becomes available
to the community. It requires the operator of a network server to
provide the source code of the modified version running there to the
users of that server. Therefore, public use of a modified version, on
a publicly accessible server, gives the public access to the source
code of the modified version.
An older license, called the Affero General Public License and
published by Affero, was designed to accomplish similar goals. This is
a different license, not a version of the Affero GPL, but Affero has
released a new version of the Affero GPL which permits relicensing under
this license.
The precise terms and conditions for copying, distribution and
modification follow.
TERMS AND CONDITIONS
0. Definitions.
"This License" refers to version 3 of the GNU Affero General Public License.
"Copyright" also means copyright-like laws that apply to other kinds of
works, such as semiconductor masks.
"The Program" refers to any copyrightable work licensed under this
License. Each licensee is addressed as "you". "Licensees" and
"recipients" may be individuals or organizations.
To "modify" a work means to copy from or adapt all or part of the work
in a fashion requiring copyright permission, other than the making of an
exact copy. The resulting work is called a "modified version" of the
earlier work or a work "based on" the earlier work.
A "covered work" means either the unmodified Program or a work based
on the Program.
To "propagate" a work means to do anything with it that, without
permission, would make you directly or secondarily liable for
infringement under applicable copyright law, except executing it on a
computer or modifying a private copy. Propagation includes copying,
distribution (with or without modification), making available to the
public, and in some countries other activities as well.
To "convey" a work means any kind of propagation that enables other
parties to make or receive copies. Mere interaction with a user through
a computer network, with no transfer of a copy, is not conveying.
An interactive user interface displays "Appropriate Legal Notices"
to the extent that it includes a convenient and prominently visible
feature that (1) displays an appropriate copyright notice, and (2)
tells the user that there is no warranty for the work (except to the
extent that warranties are provided), that licensees may convey the
work under this License, and how to view a copy of this License. If
the interface presents a list of user commands or options, such as a
menu, a prominent item in the list meets this criterion.
1. Source Code.
The "source code" for a work means the preferred form of the work
for making modifications to it. "Object code" means any non-source
form of a work.
A "Standard Interface" means an interface that either is an official
standard defined by a recognized standards body, or, in the case of
interfaces specified for a particular programming language, one that
is widely used among developers working in that language.
The "System Libraries" of an executable work include anything, other
than the work as a whole, that (a) is included in the normal form of
packaging a Major Component, but which is not part of that Major
Component, and (b) serves only to enable use of the work with that
Major Component, or to implement a Standard Interface for which an
implementation is available to the public in source code form. A
"Major Component", in this context, means a major essential component
(kernel, window system, and so on) of the specific operating system
(if any) on which the executable work runs, or a compiler used to
produce the work, or an object code interpreter used to run it.
The "Corresponding Source" for a work in object code form means all
the source code needed to generate, install, and (for an executable
work) run the object code and to modify the work, including scripts to
control those activities. However, it does not include the work's
System Libraries, or general-purpose tools or generally available free
programs which are used unmodified in performing those activities but
which are not part of the work. For example, Corresponding Source
includes interface definition files associated with source files for
the work, and the source code for shared libraries and dynamically
linked subprograms that the work is specifically designed to require,
such as by intimate data communication or control flow between those
subprograms and other parts of the work.
The Corresponding Source need not include anything that users
can regenerate automatically from other parts of the Corresponding
Source.
The Corresponding Source for a work in source code form is that
same work.
2. Basic Permissions.
All rights granted under this License are granted for the term of
copyright on the Program, and are irrevocable provided the stated
conditions are met. This License explicitly affirms your unlimited
permission to run the unmodified Program. The output from running a
covered work is covered by this License only if the output, given its
content, constitutes a covered work. This License acknowledges your
rights of fair use or other equivalent, as provided by copyright law.
You may make, run and propagate covered works that you do not
convey, without conditions so long as your license otherwise remains
in force. You may convey covered works to others for the sole purpose
of having them make modifications exclusively for you, or provide you
with facilities for running those works, provided that you comply with
the terms of this License in conveying all material for which you do
not control copyright. Those thus making or running the covered works
for you must do so exclusively on your behalf, under your direction
and control, on terms that prohibit them from making any copies of
your copyrighted material outside their relationship with you.
Conveying under any other circumstances is permitted solely under
the conditions stated below. Sublicensing is not allowed; section 10
makes it unnecessary.
3. Protecting Users' Legal Rights From Anti-Circumvention Law.
No covered work shall be deemed part of an effective technological
measure under any applicable law fulfilling obligations under article
11 of the WIPO copyright treaty adopted on 20 December 1996, or
similar laws prohibiting or restricting circumvention of such
measures.
When you convey a covered work, you waive any legal power to forbid
circumvention of technological measures to the extent such circumvention
is effected by exercising rights under this License with respect to
the covered work, and you disclaim any intention to limit operation or
modification of the work as a means of enforcing, against the work's
users, your or third parties' legal rights to forbid circumvention of
technological measures.
4. Conveying Verbatim Copies.
You may convey verbatim copies of the Program's source code as you
receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy an appropriate copyright notice;
keep intact all notices stating that this License and any
non-permissive terms added in accord with section 7 apply to the code;
keep intact all notices of the absence of any warranty; and give all
recipients a copy of this License along with the Program.
You may charge any price or no price for each copy that you convey,
and you may offer support or warranty protection for a fee.
5. Conveying Modified Source Versions.
You may convey a work based on the Program, or the modifications to
produce it from the Program, in the form of source code under the
terms of section 4, provided that you also meet all of these conditions:
a) The work must carry prominent notices stating that you modified
it, and giving a relevant date.
b) The work must carry prominent notices stating that it is
released under this License and any conditions added under section
7. This requirement modifies the requirement in section 4 to
"keep intact all notices".
c) You must license the entire work, as a whole, under this
License to anyone who comes into possession of a copy. This
License will therefore apply, along with any applicable section 7
additional terms, to the whole of the work, and all its parts,
regardless of how they are packaged. This License gives no
permission to license the work in any other way, but it does not
invalidate such permission if you have separately received it.
d) If the work has interactive user interfaces, each must display
Appropriate Legal Notices; however, if the Program has interactive
interfaces that do not display Appropriate Legal Notices, your
work need not make them do so.
A compilation of a covered work with other separate and independent
works, which are not by their nature extensions of the covered work,
and which are not combined with it such as to form a larger program,
in or on a volume of a storage or distribution medium, is called an
"aggregate" if the compilation and its resulting copyright are not
used to limit the access or legal rights of the compilation's users
beyond what the individual works permit. Inclusion of a covered work
in an aggregate does not cause this License to apply to the other
parts of the aggregate.
6. Conveying Non-Source Forms.
You may convey a covered work in object code form under the terms
of sections 4 and 5, provided that you also convey the
machine-readable Corresponding Source under the terms of this License,
in one of these ways:
a) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by the
Corresponding Source fixed on a durable physical medium
customarily used for software interchange.
b) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by a
written offer, valid for at least three years and valid for as
long as you offer spare parts or customer support for that product
model, to give anyone who possesses the object code either (1) a
copy of the Corresponding Source for all the software in the
product that is covered by this License, on a durable physical
medium customarily used for software interchange, for a price no
more than your reasonable cost of physically performing this
conveying of source, or (2) access to copy the
Corresponding Source from a network server at no charge.
c) Convey individual copies of the object code with a copy of the
written offer to provide the Corresponding Source. This
alternative is allowed only occasionally and noncommercially, and
only if you received the object code with such an offer, in accord
with subsection 6b.
d) Convey the object code by offering access from a designated
place (gratis or for a charge), and offer equivalent access to the
Corresponding Source in the same way through the same place at no
further charge. You need not require recipients to copy the
Corresponding Source along with the object code. If the place to
copy the object code is a network server, the Corresponding Source
may be on a different server (operated by you or a third party)
that supports equivalent copying facilities, provided you maintain
clear directions next to the object code saying where to find the
Corresponding Source. Regardless of what server hosts the
Corresponding Source, you remain obligated to ensure that it is
available for as long as needed to satisfy these requirements.
e) Convey the object code using peer-to-peer transmission, provided
you inform other peers where the object code and Corresponding
Source of the work are being offered to the general public at no
charge under subsection 6d.
A separable portion of the object code, whose source code is excluded
from the Corresponding Source as a System Library, need not be
included in conveying the object code work.
A "User Product" is either (1) a "consumer product", which means any
tangible personal property which is normally used for personal, family,
or household purposes, or (2) anything designed or sold for incorporation
into a dwelling. In determining whether a product is a consumer product,
doubtful cases shall be resolved in favor of coverage. For a particular
product received by a particular user, "normally used" refers to a
typical or common use of that class of product, regardless of the status
of the particular user or of the way in which the particular user
actually uses, or expects or is expected to use, the product. A product
is a consumer product regardless of whether the product has substantial
commercial, industrial or non-consumer uses, unless such uses represent
the only significant mode of use of the product.
"Installation Information" for a User Product means any methods,
procedures, authorization keys, or other information required to install
and execute modified versions of a covered work in that User Product from
a modified version of its Corresponding Source. The information must
suffice to ensure that the continued functioning of the modified object
code is in no case prevented or interfered with solely because
modification has been made.
If you convey an object code work under this section in, or with, or
specifically for use in, a User Product, and the conveying occurs as
part of a transaction in which the right of possession and use of the
User Product is transferred to the recipient in perpetuity or for a
fixed term (regardless of how the transaction is characterized), the
Corresponding Source conveyed under this section must be accompanied
by the Installation Information. But this requirement does not apply
if neither you nor any third party retains the ability to install
modified object code on the User Product (for example, the work has
been installed in ROM).
The requirement to provide Installation Information does not include a
requirement to continue to provide support service, warranty, or updates
for a work that has been modified or installed by the recipient, or for
the User Product in which it has been modified or installed. Access to a
network may be denied when the modification itself materially and
adversely affects the operation of the network or violates the rules and
protocols for communication across the network.
Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.
7. Additional Terms.
"Additional permissions" are terms that supplement the terms of this
License by making exceptions from one or more of its conditions.
Additional permissions that are applicable to the entire Program shall
be treated as though they were included in this License, to the extent
that they are valid under applicable law. If additional permissions
apply only to part of the Program, that part may be used separately
under those permissions, but the entire Program remains governed by
this License without regard to the additional permissions.
When you convey a copy of a covered work, you may at your option
remove any additional permissions from that copy, or from any part of
it. (Additional permissions may be written to require their own
removal in certain cases when you modify the work.) You may place
additional permissions on material, added by you to a covered work,
for which you have or can give appropriate copyright permission.
Notwithstanding any other provision of this License, for material you
add to a covered work, you may (if authorized by the copyright holders of
that material) supplement the terms of this License with terms:
a) Disclaiming warranty or limiting liability differently from the
terms of sections 15 and 16 of this License; or
b) Requiring preservation of specified reasonable legal notices or
author attributions in that material or in the Appropriate Legal
Notices displayed by works containing it; or
c) Prohibiting misrepresentation of the origin of that material, or
requiring that modified versions of such material be marked in
reasonable ways as different from the original version; or
d) Limiting the use for publicity purposes of names of licensors or
authors of the material; or
e) Declining to grant rights under trademark law for use of some
trade names, trademarks, or service marks; or
f) Requiring indemnification of licensors and authors of that
material by anyone who conveys the material (or modified versions of
it) with contractual assumptions of liability to the recipient, for
any liability that these contractual assumptions directly impose on
those licensors and authors.
All other non-permissive additional terms are considered "further
restrictions" within the meaning of section 10. If the Program as you
received it, or any part of it, contains a notice stating that it is
governed by this License along with a term that is a further
restriction, you may remove that term. If a license document contains
a further restriction but permits relicensing or conveying under this
License, you may add to a covered work material governed by the terms
of that license document, provided that the further restriction does
not survive such relicensing or conveying.
If you add terms to a covered work in accord with this section, you
must place, in the relevant source files, a statement of the
additional terms that apply to those files, or a notice indicating
where to find the applicable terms.
Additional terms, permissive or non-permissive, may be stated in the
form of a separately written license, or stated as exceptions;
the above requirements apply either way.
8. Termination.
You may not propagate or modify a covered work except as expressly
provided under this License. Any attempt otherwise to propagate or
modify it is void, and will automatically terminate your rights under
this License (including any patent licenses granted under the third
paragraph of section 11).
However, if you cease all violation of this License, then your
license from a particular copyright holder is reinstated (a)
provisionally, unless and until the copyright holder explicitly and
finally terminates your license, and (b) permanently, if the copyright
holder fails to notify you of the violation by some reasonable means
prior to 60 days after the cessation.
Moreover, your license from a particular copyright holder is
reinstated permanently if the copyright holder notifies you of the
violation by some reasonable means, this is the first time you have
received notice of violation of this License (for any work) from that
copyright holder, and you cure the violation prior to 30 days after
your receipt of the notice.
Termination of your rights under this section does not terminate the
licenses of parties who have received copies or rights from you under
this License. If your rights have been terminated and not permanently
reinstated, you do not qualify to receive new licenses for the same
material under section 10.
9. Acceptance Not Required for Having Copies.
You are not required to accept this License in order to receive or
run a copy of the Program. Ancillary propagation of a covered work
occurring solely as a consequence of using peer-to-peer transmission
to receive a copy likewise does not require acceptance. However,
nothing other than this License grants you permission to propagate or
modify any covered work. These actions infringe copyright if you do
not accept this License. Therefore, by modifying or propagating a
covered work, you indicate your acceptance of this License to do so.
10. Automatic Licensing of Downstream Recipients.
Each time you convey a covered work, the recipient automatically
receives a license from the original licensors, to run, modify and
propagate that work, subject to this License. You are not responsible
for enforcing compliance by third parties with this License.
An "entity transaction" is a transaction transferring control of an
organization, or substantially all assets of one, or subdividing an
organization, or merging organizations. If propagation of a covered
work results from an entity transaction, each party to that
transaction who receives a copy of the work also receives whatever
licenses to the work the party's predecessor in interest had or could
give under the previous paragraph, plus a right to possession of the
Corresponding Source of the work from the predecessor in interest, if
the predecessor has it or can get it with reasonable efforts.
You may not impose any further restrictions on the exercise of the
rights granted or affirmed under this License. For example, you may
not impose a license fee, royalty, or other charge for exercise of
rights granted under this License, and you may not initiate litigation
(including a cross-claim or counterclaim in a lawsuit) alleging that
any patent claim is infringed by making, using, selling, offering for
sale, or importing the Program or any portion of it.
11. Patents.
A "contributor" is a copyright holder who authorizes use under this
License of the Program or a work on which the Program is based. The
work thus licensed is called the contributor's "contributor version".
A contributor's "essential patent claims" are all patent claims
owned or controlled by the contributor, whether already acquired or
hereafter acquired, that would be infringed by some manner, permitted
by this License, of making, using, or selling its contributor version,
but do not include claims that would be infringed only as a
consequence of further modification of the contributor version. For
purposes of this definition, "control" includes the right to grant
patent sublicenses in a manner consistent with the requirements of
this License.
Each contributor grants you a non-exclusive, worldwide, royalty-free
patent license under the contributor's essential patent claims, to
make, use, sell, offer for sale, import and otherwise run, modify and
propagate the contents of its contributor version.
In the following three paragraphs, a "patent license" is any express
agreement or commitment, however denominated, not to enforce a patent
(such as an express permission to practice a patent or covenant not to
sue for patent infringement). To "grant" such a patent license to a
party means to make such an agreement or commitment not to enforce a
patent against the party.
If you convey a covered work, knowingly relying on a patent license,
and the Corresponding Source of the work is not available for anyone
to copy, free of charge and under the terms of this License, through a
publicly available network server or other readily accessible means,
then you must either (1) cause the Corresponding Source to be so
available, or (2) arrange to deprive yourself of the benefit of the
patent license for this particular work, or (3) arrange, in a manner
consistent with the requirements of this License, to extend the patent
license to downstream recipients. "Knowingly relying" means you have
actual knowledge that, but for the patent license, your conveying the
covered work in a country, or your recipient's use of the covered work
in a country, would infringe one or more identifiable patents in that
country that you have reason to believe are valid.
If, pursuant to or in connection with a single transaction or
arrangement, you convey, or propagate by procuring conveyance of, a
covered work, and grant a patent license to some of the parties
receiving the covered work authorizing them to use, propagate, modify
or convey a specific copy of the covered work, then the patent license
you grant is automatically extended to all recipients of the covered
work and works based on it.
A patent license is "discriminatory" if it does not include within
the scope of its coverage, prohibits the exercise of, or is
conditioned on the non-exercise of one or more of the rights that are
specifically granted under this License. You may not convey a covered
work if you are a party to an arrangement with a third party that is
in the business of distributing software, under which you make payment
to the third party based on the extent of your activity of conveying
the work, and under which the third party grants, to any of the
parties who would receive the covered work from you, a discriminatory
patent license (a) in connection with copies of the covered work
conveyed by you (or copies made from those copies), or (b) primarily
for and in connection with specific products or compilations that
contain the covered work, unless you entered into that arrangement,
or that patent license was granted, prior to 28 March 2007.
Nothing in this License shall be construed as excluding or limiting
any implied license or other defenses to infringement that may
otherwise be available to you under applicable patent law.
12. No Surrender of Others' Freedom.
If conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot convey a
covered work so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you may
not convey it at all. For example, if you agree to terms that obligate you
to collect a royalty for further conveying from those to whom you convey
the Program, the only way you could satisfy both those terms and this
License would be to refrain entirely from conveying the Program.
13. Remote Network Interaction; Use with the GNU General Public License.
Notwithstanding any other provision of this License, if you modify the
Program, your modified version must prominently offer all users
interacting with it remotely through a computer network (if your version
supports such interaction) an opportunity to receive the Corresponding
Source of your version by providing access to the Corresponding Source
from a network server at no charge, through some standard or customary
means of facilitating copying of software. This Corresponding Source
shall include the Corresponding Source for any work covered by version 3
of the GNU General Public License that is incorporated pursuant to the
following paragraph.
Notwithstanding any other provision of this License, you have
permission to link or combine any covered work with a work licensed
under version 3 of the GNU General Public License into a single
combined work, and to convey the resulting work. The terms of this
License will continue to apply to the part which is the covered work,
but the work with which it is combined will remain governed by version
3 of the GNU General Public License.
14. Revised Versions of this License.
The Free Software Foundation may publish revised and/or new versions of
the GNU Affero General Public License from time to time. Such new versions
will be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the
Program specifies that a certain numbered version of the GNU Affero General
Public License "or any later version" applies to it, you have the
option of following the terms and conditions either of that numbered
version or of any later version published by the Free Software
Foundation. If the Program does not specify a version number of the
GNU Affero General Public License, you may choose any version ever published
by the Free Software Foundation.
If the Program specifies that a proxy can decide which future
versions of the GNU Affero General Public License can be used, that proxy's
public statement of acceptance of a version permanently authorizes you
to choose that version for the Program.
Later license versions may give you additional or different
permissions. However, no additional obligations are imposed on any
author or copyright holder as a result of your choosing to follow a
later version.
15. Disclaimer of Warranty.
THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. Limitation of Liability.
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGES.
17. Interpretation of Sections 15 and 16.
If the disclaimer of warranty and limitation of liability provided
above cannot be given local legal effect according to their terms,
reviewing courts shall apply local law that most closely approximates
an absolute waiver of all civil liability in connection with the
Program, unless a warranty or assumption of liability accompanies a
copy of the Program in return for a fee.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
state the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
<one line to give the program's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published
by the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see <https://www.gnu.org/licenses/>.
Also add information on how to contact you by electronic and paper mail.
If your software can interact with users remotely through a computer
network, you should also make sure that it provides a way for users to
get its source. For example, if your program is a web application, its
interface could display a "Source" link that leads users to an archive
of the code. There are many ways you could offer source, and different
solutions will be better for different programs; see section 13 for the
specific requirements.
You should also get your employer (if you work as a programmer) or school,
if any, to sign a "copyright disclaimer" for the program, if necessary.
For more information on this, and how to apply and follow the GNU AGPL, see
<https://www.gnu.org/licenses/>.
+30 -20
View File
@@ -1,26 +1,36 @@
This is a simple server-side plugin for PaperMC (May also work with Spigot, this is untested) that hides entities from players if they do not have line-of-sight. All raycasts are run async to reduce performance impact.
Use cases:
### Latest stable version: v1.6.5
- To prevent mob nametags from being visible through walls
- If the mobs don't exist, you can't see them
- Act as an "anticheat" to block players from using mods such as freecam to find entities through walls
- This is not an actual anticheat and will not detect freecam, instead just making freecam less useful
- Freecam will still be useful for locating structures and features such as caves
- Reduce client lag
- In servers with large megabases full of item frames, armour stands and other entities, RaycastedEntityOcclusion will prevent these entities from lagging the client unless they are within line-of-sight
The latest stable version can currently only be found on Modrinth https://modrinth.com/plugin/raycasted-anti-esp/ or by compiling from `v1.6.x`. The latest alpha version can be found on the [Discord](https://discord.gg/hGTRAK2hNM) or by compiling from `main`.
Config info:
This is a predominantly async plugin for PaperMC and its forks that hides/culls entities (and tile entities) from players if they do not have line-of-sight.
The config has three settings:
The supported versions are 1.21.x PaperMC and Pufferfish. Other server versions and software may work too. v2 alpha builds support 26.x.
AlwaysShowRadius: 4
RaycastRadius: 64
SearchRadius: 72
## Use cases:
Entities inside the AlwaysShowRadius are always shown, even if occluded. This is to prevent nasty surprises when turning a corner quickly.
The SearchRadius is a misnomer, it's actually a cubic bounding box around the player within which entities will be checked. If an entity is within the SearchRadius but not the RaycastRadius, it will be automatically hidden.
The RaycastRadius is the radius where entities will be checked. If an entity is currently hidden it will run a raycast every tick. This is to quickly detect when the entity becomes visible. If the entity is currently visible, it will only ruun the raycast every 10 ticks to reduce performance impact.
- Prevent cheating (anti-esp hacks)
- Block usage of pie-ray to locate underground bases
- Prevent mods such as mini-maps or cheat clients from displaying the locations of hidden entities
- Increase client-side performance for low-end devices
- Massive megabases containing hundreds of armour stands, item frames, banners etc can cause performance issues on low-end devices unable to process so many entities. REO will cull those entities for the client, reducing the number of entities to process.
- Hide nametags behind walls
- Yes, this plugin is a bit overkill for doing that, yes you can do it anyways.
## Dependencies:
- Packetevents (soft depend)
- Only needed if you are using the cull-players option and wish for the players to remain in the tablist
Known issues:
- Players are also occluded. This itself is not an issue, however hiding players also removes them from the tab list and command autocomplete.
- Due to the nature of the plugin, there will be a short delay once an entity should be visible before it appears, causing it to appear like it "popped" into view
## Known issues:
- Due to the nature of the plugin, there will be a short delay once an entity should be visible before it appears, causing it to appear like it "popped" into view. This issue is partially resolved by turning engine-mode to 2, and is worse for players with higher ping.
## Versioning:
Note that the following versioning information only applies to v2 and beyond.
RaycastedAntiESP binaries are composed of four distinct modules: the core, Locatable-lib (used for platform-independent location objects), [CubiLogging](https://github.com/Cubicake/CubiLogging/tree/main), and a platform adapter.
Each of these has its own versioning system. Locatable-lib and the logging api both declare public apis, and follow [Semantic Versioning](https://semver.org/#semantic-versioning-specification-semver). The platform adapter and core do not declare public apis, and thus [cannot follow semantic versioning](https://semver.org/#spec-item-1). They still follow a major.minor.patch versioning system, but which version number increments is less deterministic. Generally, major version bumps will be for when significant refactoring or rewriting has occurred, or a very significant distinct feature has been added or removed. Minor version bumps will be for the addition/removal of smaller distinct features, while patch version bumps are for bug fixes and tweaks or minor addition/removals which are related to the features added/removed in the minor version bumps.
In addition to the versions for each module, there is also an overall version for each platform binary, which is the version that is advertised in the description and file name, and is used for update checks. This version is a combination of the core and platform adapter versions, in the format `{core version}-PlatformName-{platform adapter version}`. This allows all platforms to share the same first three version numbers, while still allowing for differences in the platform adapter versions.
## Contributions:
Contributions via pull requests are welcome. See [CONTRIBUTING.md](CONTRIBUTING.md) for details.
-49
View File
@@ -1,49 +0,0 @@
plugins {
id 'java'
}
group = 'games.cubi'
version = '1.0-SNAPSHOT'
repositories {
mavenCentral()
maven {
name = "papermc-repo"
url = "https://repo.papermc.io/repository/maven-public/"
}
maven {
name = "sonatype"
url = "https://oss.sonatype.org/content/groups/public/"
}
}
dependencies {
compileOnly("io.papermc.paper:paper-api:1.21.4-R0.1-SNAPSHOT")
}
def targetJavaVersion = 21
java {
def javaVersion = JavaVersion.toVersion(targetJavaVersion)
sourceCompatibility = javaVersion
targetCompatibility = javaVersion
if (JavaVersion.current() < javaVersion) {
toolchain.languageVersion = JavaLanguageVersion.of(targetJavaVersion)
}
}
tasks.withType(JavaCompile).configureEach {
options.encoding = 'UTF-8'
if (targetJavaVersion >= 10 || JavaVersion.current().isJava10Compatible()) {
options.release.set(targetJavaVersion)
}
}
processResources {
def props = [version: version]
inputs.properties props
filteringCharset 'UTF-8'
filesMatching('plugin.yml') {
expand props
}
}
+74
View File
@@ -0,0 +1,74 @@
import java.time.Instant
plugins {
id("java-library")
}
repositories {
mavenCentral()
maven { url = uri("https://repo.codemc.io/repository/maven-releases/") }
maven { url = uri("https://repo.codemc.io/repository/maven-snapshots/") }
}
dependencies {
compileOnly("org.spongepowered:configurate-core:4.2.0")
compileOnly("org.spongepowered:configurate-yaml:4.2.0")
compileOnly("it.unimi.dsi:fastutil:8.5.18")
implementation(project(":locatable-lib"))
compileOnly(project(":logging"))
}
val coreVersion = "0.4.1-SNAPSHOT"
val isRelease = gradle.startParameter.taskNames.any {
it.contains("buildRelease")
}
fun getVersionString(): String {
if (isRelease) {
return coreVersion.substringBefore("-") // Remove any suffixes like "-SNAPSHOT"
} else {
return coreVersion
}
}
fun getBasicVersionString(): String {
return if (isRelease) {
coreVersion.substringBefore("-") // Remove any suffixes like "-SNAPSHOT"
} else {
coreVersion
}
}
version = getVersionString()
val commitShort = providers.exec {
commandLine("git", "rev-parse", "--short=8", "HEAD")
}.standardOutput.asText.map { it.trim() }
val commitFull = providers.exec {
commandLine("git", "rev-parse", "HEAD")
}.standardOutput.asText.map { it.trim() }
val buildTime = providers.provider {
Instant.now().toString()
}
tasks {
processResources {
val gitProps = mapOf(
"short_git" to commitShort.get(),
"long_git" to commitFull.get(),
"build_time" to buildTime.get(),
"version" to getBasicVersionString()
)
inputs.properties(gitProps)
filesMatching("build-properties/core.yml") {
expand(gitProps)
}
}
}
java {
toolchain.languageVersion = JavaLanguageVersion.of(21)
}
@@ -0,0 +1,30 @@
package games.cubi.raycastedantiesp.core;
import games.cubi.logs.PlatformLogger;
import games.cubi.logs.Logger;
public class Core {
public static Core instance;
private Core(PlatformLogger logger) {
Logger.init(logger);
}
public static Core initialize(PlatformLogger logger) {
if (instance != null) {
return instance;
}
instance = new Core(logger);
return instance;
}
public static Core getInstance() {
if (instance == null) {
Logger.error(new IllegalStateException("Core has not been initialized yet but Core#getInstance called!"),1, Core.class);
}
return instance;
}
public void intelliJStopThinkingThisIsAUtilClass() {}
}
@@ -0,0 +1,18 @@
package games.cubi.raycastedantiesp.core.config;
import org.spongepowered.configurate.ConfigurationNode;
public record BlockProcessorConfig(BlockProcessorMode mode, boolean trackAllBlocks) implements Config {
public static BlockProcessorConfig load(ConfigurationNode root) {
ConfigurationNode node = ConfigReader.node(root, "block-processor");
String modeName = ConfigReader.string(ConfigReader.node(node, "mode"), "block-processor.mode");
BlockProcessorMode mode = BlockProcessorMode.fromString(modeName);
if (mode == null) {
throw new ConfigLoadException("block-processor.mode has unsupported value '" + modeName + "'");
}
return new BlockProcessorConfig(
mode,
ConfigReader.bool(ConfigReader.node(node, "track-all-blocks"), "block-processor.track-all-blocks")
);
}
}
@@ -0,0 +1,31 @@
package games.cubi.raycastedantiesp.core.config;
import org.jetbrains.annotations.Nullable;
public enum BlockProcessorMode implements ConfigEnum {
PACKETEVENTS("packetevents");
private final String configName;
BlockProcessorMode(String configName) {
this.configName = configName;
}
public String getName() {
return configName;
}
public static @Nullable BlockProcessorMode fromString(String name) {
for (BlockProcessorMode mode : values()) {
if (mode.configName.equalsIgnoreCase(name)) {
return mode;
}
}
return null;
}
@Override
public String[] getValues() {
return new String[] {configName};
}
}
@@ -0,0 +1,28 @@
package games.cubi.raycastedantiesp.core.config;
import games.cubi.raycastedantiesp.core.config.raycast.ChunkSectionConfig;
import games.cubi.raycastedantiesp.core.config.raycast.EntityConfig;
import games.cubi.raycastedantiesp.core.config.raycast.PlayerConfig;
import games.cubi.raycastedantiesp.core.config.raycast.SoundEffectsConfig;
import games.cubi.raycastedantiesp.core.config.raycast.TileEntityConfig;
import org.spongepowered.configurate.ConfigurationNode;
public record ChecksConfig(PlayerConfig playerConfig, EntityConfig entityConfig, TileEntityConfig tileEntityConfig, SoundEffectsConfig soundEffectsConfig, ChunkSectionConfig chunkSectionConfig) implements Config {
public static ChecksConfig load(ConfigurationNode root) {
ConfigurationNode checks = ConfigReader.node(root, "checks");
return new ChecksConfig(
PlayerConfig.load(ConfigReader.node(checks, "player"), "checks.player"),
EntityConfig.load(ConfigReader.node(checks, "entity"), "checks.entity"),
TileEntityConfig.load(ConfigReader.node(checks, "tile-entity"), "checks.tile-entity"),
SoundEffectsConfig.load(ConfigReader.node(checks, "sound-effects"), "checks.sound-effects"),
ChunkSectionConfig.load(ConfigReader.node(checks, "chunk-section"), "checks.chunk-section")
);
}
public boolean hasRestartOnlyChanges(ChecksConfig startup) {
return playerConfig.enabled() != startup.playerConfig.enabled()
|| entityConfig.enabled() != startup.entityConfig.enabled()
|| tileEntityConfig.enabled() != startup.tileEntityConfig.enabled()
|| chunkSectionConfig.enabled() != startup.chunkSectionConfig.enabled();
}
}
@@ -0,0 +1,4 @@
package games.cubi.raycastedantiesp.core.config;
public interface Config {
}
@@ -0,0 +1,33 @@
package games.cubi.raycastedantiesp.core.config;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
public interface ConfigEnum {
String[] getValues();
Registry REGISTRY = new Registry();
default void register() {
REGISTRY.add(this.getClass());
}
static String[] getAllValues() {
return REGISTRY.getAllValues();
}
final class Registry {
private final Set<Class<? extends ConfigEnum>> enums = new HashSet<>();
void add(Class<? extends ConfigEnum> e) {
enums.add(e);
}
String[] getAllValues() {
return enums.stream()
.flatMap(e -> Arrays.stream(e.getEnumConstants()[0].getValues()))
.toArray(String[]::new);
}
}
}
@@ -0,0 +1,13 @@
package games.cubi.raycastedantiesp.core.config;
import org.spongepowered.configurate.ConfigurationNode;
public interface ConfigExtension<T extends Config> {
Class<T> type();
T load(ConfigurationNode config, BlockProcessorConfig blockProcessorConfig);
default boolean requiresRestart(T startupConfig, T nextConfig) {
return !startupConfig.equals(nextConfig);
}
}
@@ -0,0 +1,11 @@
package games.cubi.raycastedantiesp.core.config;
public class ConfigLoadException extends RuntimeException {
public ConfigLoadException(String message) {
super(message);
}
public ConfigLoadException(String message, Throwable cause) {
super(message, cause);
}
}
@@ -0,0 +1,357 @@
package games.cubi.raycastedantiesp.core.config;
import games.cubi.logs.Logger;
import games.cubi.raycastedantiesp.core.config.engine.EngineConfig;
import games.cubi.raycastedantiesp.core.config.raycast.EntityConfig;
import games.cubi.raycastedantiesp.core.config.raycast.PlayerConfig;
import games.cubi.raycastedantiesp.core.config.raycast.TileEntityConfig;
import org.spongepowered.configurate.ConfigurationNode;
import org.spongepowered.configurate.yaml.NodeStyle;
import org.spongepowered.configurate.yaml.YamlConfigurationLoader;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Supplier;
public class ConfigManager {
private static final String REQUIRED_CONFIG_VERSION = "2.0";
private static ConfigManager instance;
private final Supplier<InputStream> resourceSupplier;
private final Path dataFolder;
private final Path configPath;
private final YamlConfigurationLoader loader;
private final List<ConfigExtension<? extends Config>> extensions;
private ConfigurationNode config;
private RootConfig startupConfig;
private volatile RootConfig activeConfig;
private ConfigManager(Supplier<InputStream> resourceSupplier, Path dataFolder, List<ConfigExtension<? extends Config>> extensions) {
this.resourceSupplier = resourceSupplier;
this.dataFolder = dataFolder;
this.extensions = List.copyOf(extensions);
this.configPath = dataFolder.resolve("config.yml");
this.loader = YamlConfigurationLoader.builder()
.path(configPath)
.nodeStyle(NodeStyle.BLOCK)
.build();
load();
}
public static ConfigManager initialiseConfigManager(Supplier<InputStream> resourceSupplier, Path dataFolder, List<ConfigExtension<? extends Config>> extensions) {
if (instance == null) {
instance = new ConfigManager(resourceSupplier, dataFolder, extensions);
}
return instance;
}
public static ConfigManager get() {
if (instance == null) {
Logger.errorAndReturn(new RuntimeException("ConfigManager accessed before being initiated. Please report this."), 2, ConfigManager.class);
}
return instance;
}
public void load() {
ensureConfigFileExists();
ConfigurationNode loaded = loadConfigNode();
ConfigurationNode defaults = loadBundledDefaults();
if (defaults != null && mergeMissing(defaults, loaded)) {
saveConfigNode(loaded);
}
RootConfig parsed = parse(loaded);
validateReload(parsed);
config = loaded;
if (startupConfig == null) {
startupConfig = parsed;
}
activeConfig = parsed;
}
public SetConfigResult setConfigValue(String path, String rawValue) {
ConfigurationNode candidate = loadConfigNode();
ConfigurationNode target = node(candidate, path);
if (target.virtual()) {
return SetConfigResult.invalid("Unknown config path: " + path);
}
ConfigReader.setRaw(target, ConfigReader.parseRawValue(rawValue));
return applyCandidate(candidate, false);
}
public SetConfigResult addConfigListValue(String path, String rawValue) {
return mutateConfigListValue(path, rawValue, ListMutation.ADD);
}
public SetConfigResult removeConfigListValue(String path, String rawValue) {
return mutateConfigListValue(path, rawValue, ListMutation.REMOVE);
}
private SetConfigResult mutateConfigListValue(String path, String rawValue, ListMutation mutation) {
ConfigurationNode candidate = loadConfigNode();
ConfigurationNode target = node(candidate, path);
if (target.virtual()) {
return SetConfigResult.invalid("Unknown config path: " + path);
}
if (!target.childrenMap().isEmpty()) {
return SetConfigResult.invalid(path + " is not a list path");
}
List<Object> values = new ArrayList<>(target.childrenList().stream().map(ConfigurationNode::raw).toList());
if (values.isEmpty() && target.raw() != null && !(target.raw() instanceof List<?>)) {
return SetConfigResult.invalid(path + " is not a list path");
}
Object parsedValue = ConfigReader.parseRawValue(rawValue);
boolean changed = switch (mutation) {
case ADD -> {
if (values.contains(parsedValue)) {
yield false;
}
values.add(parsedValue);
yield true;
}
case REMOVE -> values.remove(parsedValue);
};
if (!changed) {
return SetConfigResult.invalid("No change made for " + path);
}
ConfigReader.setRaw(target, values);
return applyCandidate(candidate, true);
}
private SetConfigResult applyCandidate(ConfigurationNode candidate, boolean allowRestartRequired) {
RootConfig parsed;
try {
parsed = parse(candidate);
validateReload(parsed);
} catch (RestartRequiredException e) {
if (!allowRestartRequired) {
return SetConfigResult.invalid(e.getMessage());
}
config = candidate;
saveConfigNode(candidate);
return SetConfigResult.restartRequired(e.getMessage());
} catch (ConfigLoadException e) {
return SetConfigResult.invalid(e.getMessage());
}
config = candidate;
activeConfig = parsed;
saveConfigNode(candidate);
return SetConfigResult.ok();
}
public PlayerConfig getPlayerConfig() {
return activeConfig.checksConfig().playerConfig();
}
public EntityConfig getEntityConfig() {
return activeConfig.checksConfig().entityConfig();
}
public TileEntityConfig getTileEntityConfig() {
return activeConfig.checksConfig().tileEntityConfig();
}
public DebugConfig getDebugConfig() {
RootConfig current = activeConfig;
return current == null ? null : current.debugConfig();
}
public EngineConfig getEngineConfig() {
return activeConfig.engineConfig();
}
public BlockProcessorConfig getBlockProcessorConfig() {
return activeConfig.blockProcessorConfig();
}
public <T extends Config> T getExtensionConfig(Class<T> type) {
return activeConfig.extensionConfig(type);
}
public ConfigurationNode getConfigFile() {
return config;
}
public Map<String, Object> getConfigValues() {
Map<String, Object> values = new LinkedHashMap<>();
collectConfigValues(config, "", values);
return values;
}
private RootConfig parse(ConfigurationNode loaded) {
String version = ConfigReader.string(ConfigReader.node(loaded, "config-version"), "config-version");
if (!REQUIRED_CONFIG_VERSION.equals(version)) {
throw new ConfigLoadException("Unsupported config-version '" + version + "'. RaycastedAntiESP requires config-version '2.0'.");
}
ChecksConfig checksConfig = ChecksConfig.load(loaded);
EngineConfig engineConfig = EngineConfig.load(loaded);
BlockProcessorConfig blockProcessorConfig = BlockProcessorConfig.load(loaded);
DebugConfig debugConfig = DebugConfig.load(loaded);
Map<Class<? extends Config>, Config> extensionConfigs = new LinkedHashMap<>();
for (ConfigExtension<? extends Config> extension : extensions) {
extensionConfigs.put(extension.type(), extension.load(loaded, blockProcessorConfig));
}
if (!blockProcessorConfig.trackAllBlocks() && checksConfig.chunkSectionConfig().enabled()) {
throw new ConfigLoadException("checks.chunk-section.enabled must be false when block-processor.track-all-blocks is false");
}
return new RootConfig(version, checksConfig, engineConfig, blockProcessorConfig, debugConfig, Map.copyOf(extensionConfigs));
}
private void validateReload(RootConfig next) {
if (startupConfig == null) {
return;
}
if (next.engineConfig().mode() != startupConfig.engineConfig().mode()) {
throw new RestartRequiredException("engine.mode cannot be changed without a restart");
}
if (!next.blockProcessorConfig().equals(startupConfig.blockProcessorConfig())) {
throw new RestartRequiredException("block-processor cannot be changed without a restart");
}
if (next.checksConfig().hasRestartOnlyChanges(startupConfig.checksConfig())) {
throw new RestartRequiredException("checks cannot be enabled or disabled without a restart");
}
for (ConfigExtension<? extends Config> extension : extensions) {
validateExtensionReload(extension, next);
}
}
private <T extends Config> void validateExtensionReload(ConfigExtension<T> extension, RootConfig next) {
T startupExtensionConfig = startupConfig.extensionConfig(extension.type());
T nextExtensionConfig = next.extensionConfig(extension.type());
if (extension.requiresRestart(startupExtensionConfig, nextExtensionConfig)) {
throw new RestartRequiredException("block-processor." + extension.type().getSimpleName() + " cannot be changed without a restart");
}
}
private void collectConfigValues(ConfigurationNode node, String path, Map<String, Object> values) {
if (node.childrenMap().isEmpty() && node.childrenList().isEmpty()) {
if (!path.isEmpty() && !node.virtual()) {
values.put(path, node.raw());
}
return;
}
if (!node.childrenList().isEmpty()) {
values.put(path, node.childrenList().stream().map(ConfigurationNode::raw).toList());
return;
}
for (Map.Entry<Object, ? extends ConfigurationNode> entry : node.childrenMap().entrySet()) {
String key = String.valueOf(entry.getKey());
String nextPath = path.isEmpty() ? key : path + "." + key;
collectConfigValues(entry.getValue(), nextPath, values);
}
}
private void ensureConfigFileExists() {
try {
Files.createDirectories(dataFolder);
if (!Files.exists(configPath)) {
InputStream resource = resourceSupplier.get();
if (resource != null) {
try (resource) {
Files.copy(resource, configPath);
}
} else {
Files.createFile(configPath);
}
}
} catch (IOException e) {
throw new ConfigLoadException("Failed to create config.yml", e);
}
}
private ConfigurationNode loadConfigNode() {
try {
return loader.load();
} catch (IOException e) {
throw new ConfigLoadException("Failed to load config.yml", e);
}
}
private ConfigurationNode loadBundledDefaults() {
InputStream resource = resourceSupplier.get();
if (resource == null) {
return null;
}
try (resource) {
return YamlConfigurationLoader.builder()
.source(() -> new BufferedReader(new InputStreamReader(resource)))
.build()
.load();
} catch (IOException e) {
throw new ConfigLoadException("Failed to load bundled config defaults", e);
}
}
private boolean mergeMissing(ConfigurationNode defaults, ConfigurationNode target) {
if (target.virtual()) {
target.from(defaults);
return true;
}
boolean changed = false;
if (!defaults.childrenMap().isEmpty()) {
for (Map.Entry<Object, ? extends ConfigurationNode> entry : defaults.childrenMap().entrySet()) {
changed |= mergeMissing(entry.getValue(), target.node(entry.getKey()));
}
}
return changed;
}
private void saveConfigNode(ConfigurationNode node) {
try {
loader.save(node);
} catch (IOException e) {
throw new ConfigLoadException("Failed to save config.yml", e);
}
}
private ConfigurationNode node(ConfigurationNode root, String path) {
String[] parts = path.split("\\.");
return ConfigReader.node(root, parts);
}
private enum ListMutation {
ADD,
REMOVE
}
private static final class RestartRequiredException extends ConfigLoadException {
private RestartRequiredException(String message) {
super(message);
}
}
public record SetConfigResult(boolean success, boolean restartRequired, String message) {
public static SetConfigResult ok() {
return new SetConfigResult(true, false, "Config value updated.");
}
public static SetConfigResult restartRequired(String message) {
return new SetConfigResult(true, true, message);
}
public static SetConfigResult invalid(String message) {
return new SetConfigResult(false, false, message);
}
}
}
@@ -0,0 +1,112 @@
package games.cubi.raycastedantiesp.core.config;
import org.spongepowered.configurate.ConfigurationNode;
import org.spongepowered.configurate.serialize.SerializationException;
import java.util.ArrayList;
import java.util.List;
public final class ConfigReader {
private ConfigReader() {}
public static ConfigurationNode node(ConfigurationNode parent, String... path) {
return parent.node((Object[]) path);
}
public static String string(ConfigurationNode node, String path) {
Object raw = node.raw();
if (raw instanceof String value) {
return value;
}
throw invalid(path, "string", raw);
}
public static int integer(ConfigurationNode node, String path) {
Object raw = node.raw();
if (raw instanceof Number value && value.doubleValue() % 1 == 0) {
return value.intValue();
}
throw invalid(path, "integer", raw);
}
public static boolean bool(ConfigurationNode node, String path) {
Object raw = node.raw();
if (raw instanceof Boolean value) {
return value;
}
throw invalid(path, "boolean", raw);
}
public static List<String> stringList(ConfigurationNode node, String path) {
if (node.virtual() || node.raw() == null) {
return List.of();
}
if (node.childrenList().isEmpty()) {
Object raw = node.raw();
if (raw instanceof List<?> list && list.isEmpty()) {
return List.of();
}
throw invalid(path, "list of strings", raw);
}
List<String> values = new ArrayList<>();
for (ConfigurationNode child : node.childrenList()) {
Object raw = child.raw();
if (!(raw instanceof String value)) {
throw invalid(path, "list of strings", raw);
}
values.add(value);
}
return List.copyOf(values);
}
public static List<Integer> integerList(ConfigurationNode node, String path) {
if (node.virtual() || node.raw() == null) {
return List.of();
}
if (node.childrenList().isEmpty()) {
Object raw = node.raw();
if (raw instanceof List<?> list && list.isEmpty()) {
return List.of();
}
throw invalid(path, "list of integers", raw);
}
List<Integer> values = new ArrayList<>();
for (ConfigurationNode child : node.childrenList()) {
Object raw = child.raw();
if (!(raw instanceof Number value) || value.doubleValue() % 1 != 0) {
throw invalid(path, "list of integers", raw);
}
int id = value.intValue();
if (id < 0) {
throw new ConfigLoadException(path + " cannot contain negative block state IDs: " + id);
}
values.add(id);
}
return List.copyOf(values);
}
public static Object parseRawValue(String rawValue) {
try {
ConfigurationNode parsed = org.spongepowered.configurate.yaml.YamlConfigurationLoader.builder()
.source(() -> new java.io.BufferedReader(new java.io.StringReader("value: " + rawValue)))
.build()
.load();
return parsed.node("value").raw();
} catch (java.io.IOException e) {
throw new ConfigLoadException("Invalid YAML value: " + rawValue, e);
}
}
public static void setRaw(ConfigurationNode node, Object value) {
try {
node.set(value);
} catch (SerializationException e) {
throw new ConfigLoadException("Failed to set config value", e);
}
}
private static ConfigLoadException invalid(String path, String expected, Object raw) {
String actual = raw == null ? "null" : raw.getClass().getSimpleName();
return new ConfigLoadException(path + " must be a " + expected + " but was " + actual);
}
}
@@ -0,0 +1,77 @@
package games.cubi.raycastedantiesp.core.config;
import org.spongepowered.configurate.ConfigurationNode;
import java.util.List;
public record DebugConfig(byte infoLevel, List<String> infoExemptedClasses, byte warnLevel, List<String> warnExemptedClasses,
byte errorLevel, List<String> errorExemptedClasses, boolean debugParticles, boolean timings) implements Config {
public static DebugConfig load(ConfigurationNode root) {
ConfigurationNode node = ConfigReader.node(root, "debug");
return new DebugConfig(
level(ConfigReader.node(node, "info-level"), "debug.info-level"),
ConfigReader.stringList(ConfigReader.node(node, "info-exempted-classes"), "debug.info-exempted-classes"),
level(ConfigReader.node(node, "warn-level"), "debug.warn-level"),
ConfigReader.stringList(ConfigReader.node(node, "warn-exempted-classes"), "debug.warn-exempted-classes"),
level(ConfigReader.node(node, "error-level"), "debug.error-level"),
ConfigReader.stringList(ConfigReader.node(node, "error-exempted-classes"), "debug.error-exempted-classes"),
ConfigReader.bool(ConfigReader.node(node, "particles"), "debug.particles"),
ConfigReader.bool(ConfigReader.node(node, "timings"), "debug.timings")
);
}
public byte getInfoLevel() {
return infoLevel;
}
public byte getWarnLevel() {
return warnLevel;
}
public byte getErrorLevel() {
return errorLevel;
}
public boolean showDebugParticles() {
return debugParticles;
}
public boolean recordTimings() {
return timings;
}
public boolean isExempted(Severity severity, Class<?>... sources) {
List<String> exempted = switch (severity) {
case INFO -> infoExemptedClasses;
case WARN -> warnExemptedClasses;
case ERROR -> errorExemptedClasses;
};
if (sources == null || exempted.isEmpty()) {
return false;
}
for (Class<?> source : sources) {
if (source == null) {
continue;
}
if (exempted.contains(source.getSimpleName()) || exempted.contains(source.getName())) {
return true;
}
}
return false;
}
private static byte level(ConfigurationNode node, String path) {
int level = ConfigReader.integer(node, path);
if (level < 0 || level > 10) {
throw new ConfigLoadException(path + " must be between 0 and 10");
}
return (byte) level;
}
public enum Severity {
INFO,
WARN,
ERROR
}
}
@@ -0,0 +1,12 @@
package games.cubi.raycastedantiesp.core.config;
import games.cubi.raycastedantiesp.core.config.engine.EngineConfig;
import java.util.Map;
public record RootConfig(String configVersion, ChecksConfig checksConfig, EngineConfig engineConfig, BlockProcessorConfig blockProcessorConfig, DebugConfig debugConfig, Map<Class<? extends Config>, Config> extensionConfigs) implements Config {
public <T extends Config> T extensionConfig(Class<T> type) {
Config config = extensionConfigs.get(type);
return type.cast(config);
}
}
@@ -0,0 +1,22 @@
package games.cubi.raycastedantiesp.core.config.engine;
import games.cubi.raycastedantiesp.core.config.Config;
import games.cubi.raycastedantiesp.core.config.ConfigLoadException;
import games.cubi.raycastedantiesp.core.config.ConfigReader;
import org.spongepowered.configurate.ConfigurationNode;
public record EngineConfig(EngineMode mode, SimpleEngineConfig simpleConfig) implements Config {
public static EngineConfig load(ConfigurationNode root) {
ConfigurationNode node = ConfigReader.node(root, "engine");
String modeName = ConfigReader.string(ConfigReader.node(node, "mode"), "engine.mode");
EngineMode mode = EngineMode.fromString(modeName);
if (mode == null) {
throw new ConfigLoadException("engine.mode has unsupported value '" + modeName + "'");
}
return new EngineConfig(mode, SimpleEngineConfig.load(ConfigReader.node(node, "simple")));
}
public EngineMode getMode() {
return mode;
}
}
@@ -0,0 +1,33 @@
package games.cubi.raycastedantiesp.core.config.engine;
import games.cubi.raycastedantiesp.core.config.ConfigEnum;
import org.jetbrains.annotations.Nullable;
public enum EngineMode implements ConfigEnum {
SIMPLE("simple"),
NETTY("netty");
private final String configName;
EngineMode(String configName) {
this.configName = configName;
}
public String getName() {
return configName;
}
public static @Nullable EngineMode fromString(String name) {
for (EngineMode mode : values()) {
if (mode.configName.equalsIgnoreCase(name)) {
return mode;
}
}
return null;
}
@Override
public String[] getValues() {
return new String[] {"simple", "netty"};
}
}
@@ -0,0 +1,16 @@
package games.cubi.raycastedantiesp.core.config.engine;
import games.cubi.raycastedantiesp.core.config.Config;
import games.cubi.raycastedantiesp.core.config.ConfigLoadException;
import games.cubi.raycastedantiesp.core.config.ConfigReader;
import org.spongepowered.configurate.ConfigurationNode;
public record SimpleEngineConfig(int asyncProcessingThreads) implements Config {
public static SimpleEngineConfig load(ConfigurationNode node) {
int threads = ConfigReader.integer(ConfigReader.node(node, "async-processing-threads"), "engine.simple.async-processing-threads");
if (threads < 1) {
throw new ConfigLoadException("engine.simple.async-processing-threads must be at least 1");
}
return new SimpleEngineConfig(threads);
}
}
@@ -0,0 +1,16 @@
package games.cubi.raycastedantiesp.core.config.raycast;
import games.cubi.raycastedantiesp.core.config.Config;
import games.cubi.raycastedantiesp.core.config.ConfigReader;
import org.spongepowered.configurate.ConfigurationNode;
public record ChunkSectionConfig(boolean enabled, int maxOccludingCount, int alwaysShowRadiusChunks, int visibleRecheckIntervalTicks) implements Config {
public static ChunkSectionConfig load(ConfigurationNode node, String path) {
return new ChunkSectionConfig(
ConfigReader.bool(ConfigReader.node(node, "enabled"), path + ".enabled"),
ConfigReader.integer(ConfigReader.node(node, "max-occluding-count"), path + ".max-occluding-count"),
ConfigReader.integer(ConfigReader.node(node, "always-show-radius-chunks"), path + ".always-show-radius-chunks"),
ConfigReader.integer(ConfigReader.node(node, "visible-recheck-interval-ticks"), path + ".visible-recheck-interval-ticks")
);
}
}
@@ -0,0 +1,14 @@
package games.cubi.raycastedantiesp.core.config.raycast;
import org.spongepowered.configurate.ConfigurationNode;
public class EntityConfig extends RaycastConfig {
private EntityConfig(RaycastConfig config) {
super(config.enabled(), config.hideSoundsWhenHidden(), config.getMaxOccludingCount(), config.getAlwaysShowRadius(),
config.getRaycastRadius(), config.hideOnSpawnDistance(), config.getVisibleRecheckIntervalTicks());
}
public static EntityConfig load(ConfigurationNode node, String path) {
return new EntityConfig(RaycastConfig.load(node, path, true));
}
}
@@ -0,0 +1,14 @@
package games.cubi.raycastedantiesp.core.config.raycast;
import org.spongepowered.configurate.ConfigurationNode;
public class PlayerConfig extends RaycastConfig {
private PlayerConfig(RaycastConfig config) {
super(config.enabled(), config.hideSoundsWhenHidden(), config.getMaxOccludingCount(), config.getAlwaysShowRadius(),
config.getRaycastRadius(), config.hideOnSpawnDistance(), config.getVisibleRecheckIntervalTicks());
}
public static PlayerConfig load(ConfigurationNode node, String path) {
return new PlayerConfig(RaycastConfig.load(node, path, true));
}
}
@@ -0,0 +1,93 @@
package games.cubi.raycastedantiesp.core.config.raycast;
import games.cubi.logs.Logger;
import games.cubi.raycastedantiesp.core.config.Config;
import games.cubi.raycastedantiesp.core.config.ConfigLoadException;
import games.cubi.raycastedantiesp.core.config.ConfigReader;
import org.spongepowered.configurate.ConfigurationNode;
public class RaycastConfig implements Config {
private final boolean enabled;
private final boolean hideSoundsWhenHidden;
private final byte maxOccludingCount;
private final short alwaysShowRadius;
private final short raycastRadius;
private final short hideOnSpawnDistance;
private final short visibleRecheckIntervalTicks;
public RaycastConfig(boolean enabled, boolean hideSoundsWhenHidden, int maxOccludingCount, int alwaysShowRadius,
int raycastRadius, int hideOnSpawnDistance, int visibleRecheckIntervalTicks) {
this.enabled = enabled;
this.hideSoundsWhenHidden = hideSoundsWhenHidden;
this.maxOccludingCount = (byte) maxOccludingCount;
this.alwaysShowRadius = (short) alwaysShowRadius;
this.raycastRadius = (short) raycastRadius;
this.hideOnSpawnDistance = (short) hideOnSpawnDistance;
this.visibleRecheckIntervalTicks = (short) visibleRecheckIntervalTicks;
}
protected static RaycastConfig load(ConfigurationNode node, String path, boolean hasHideSoundsWhenHidden) {
int maxOccludingCount = ConfigReader.integer(ConfigReader.node(node, "max-occluding-count"), path + ".max-occluding-count");
if (maxOccludingCount < -1 || maxOccludingCount > Byte.MAX_VALUE) {
Logger.warning(path + ".max-occluding-count must be between -1 and " + Byte.MAX_VALUE + " but was " + maxOccludingCount +". Defaulting to 3.", 4, RaycastConfig.class);
maxOccludingCount = 3;
}
int alwaysShowRadius = ConfigReader.integer(ConfigReader.node(node, "always-show-radius"), path + ".always-show-radius");
if (alwaysShowRadius < -1 || alwaysShowRadius > Short.MAX_VALUE) {
Logger.warning(path + ".always-show-radius must be between -1 and " + Short.MAX_VALUE + " but was " + alwaysShowRadius +". Defaulting to 8.", 4, RaycastConfig.class);
alwaysShowRadius = 8;
}
int raycastRadius = ConfigReader.integer(ConfigReader.node(node, "raycast-radius"), path + ".raycast-radius");
if (raycastRadius < -1 || raycastRadius > Short.MAX_VALUE) {
Logger.warning(path + ".raycast-radius must be between -1 and " + Short.MAX_VALUE + " but was " + raycastRadius +". Defaulting to 48.", 4, RaycastConfig.class);
raycastRadius = 48;
}
int hideOnSpawnDistance = ConfigReader.integer(ConfigReader.node(node, "hide-on-spawn-distance"), path + ".hide-on-spawn-distance");
if (hideOnSpawnDistance < -1 || hideOnSpawnDistance > Short.MAX_VALUE) {
Logger.warning(path + ".hide-on-spawn-distance must be between -1 and " + Short.MAX_VALUE + " but was " + hideOnSpawnDistance +". Defaulting to 32.", 4, RaycastConfig.class);
hideOnSpawnDistance = 32;
}
int visibleRecheckIntervalTicks = ConfigReader.integer(ConfigReader.node(node, "visible-recheck-interval-ticks"), path + ".visible-recheck-interval-ticks");
if (visibleRecheckIntervalTicks < -1 || visibleRecheckIntervalTicks > Short.MAX_VALUE) {
Logger.warning(path + ".visible-recheck-interval-ticks must be between -1 and " + Short.MAX_VALUE + " but was " + visibleRecheckIntervalTicks +". Defaulting to 5.", 4, RaycastConfig.class);
visibleRecheckIntervalTicks = 5;
}
return new RaycastConfig(
ConfigReader.bool(ConfigReader.node(node, "enabled"), path + ".enabled"),
hasHideSoundsWhenHidden && ConfigReader.bool(ConfigReader.node(node, "hide-sounds-when-hidden"), path + ".hide-sounds-when-hidden"),
maxOccludingCount,
alwaysShowRadius,
raycastRadius,
hideOnSpawnDistance,
visibleRecheckIntervalTicks
);
}
public boolean enabled() {
return enabled;
}
public boolean hideSoundsWhenHidden() {
return hideSoundsWhenHidden;
}
public byte getMaxOccludingCount() {
return maxOccludingCount;
}
public short getAlwaysShowRadius() {
return alwaysShowRadius;
}
public short getRaycastRadius() {
return raycastRadius;
}
public short hideOnSpawnDistance() {
return hideOnSpawnDistance;
}
public short getVisibleRecheckIntervalTicks() {
return visibleRecheckIntervalTicks;
}
}
@@ -0,0 +1,21 @@
package games.cubi.raycastedantiesp.core.config.raycast;
import games.cubi.raycastedantiesp.core.config.Config;
import games.cubi.raycastedantiesp.core.config.ConfigReader;
import org.spongepowered.configurate.ConfigurationNode;
public record SoundEffectsConfig(
boolean enabled,
int maxOccludingCount,
int alwaysPlayRadius,
int raycastRadius
) implements Config {
public static SoundEffectsConfig load(ConfigurationNode node, String path) {
return new SoundEffectsConfig(
ConfigReader.bool(ConfigReader.node(node, "enabled"), path + ".enabled"),
ConfigReader.integer(ConfigReader.node(node, "max-occluding-count"), path + ".max-occluding-count"),
ConfigReader.integer(ConfigReader.node(node, "always-play-radius"), path + ".always-play-radius"),
ConfigReader.integer(ConfigReader.node(node, "raycast-radius"), path + ".raycast-radius")
);
}
}
@@ -0,0 +1,14 @@
package games.cubi.raycastedantiesp.core.config.raycast;
import org.spongepowered.configurate.ConfigurationNode;
public class TileEntityConfig extends RaycastConfig {
private TileEntityConfig(RaycastConfig config) {
super(config.enabled(), false, config.getMaxOccludingCount(), config.getAlwaysShowRadius(),
config.getRaycastRadius(), config.hideOnSpawnDistance(), config.getVisibleRecheckIntervalTicks());
}
public static TileEntityConfig load(ConfigurationNode node, String path) {
return new TileEntityConfig(RaycastConfig.load(node, path, false));
}
}
@@ -0,0 +1,5 @@
package games.cubi.raycastedantiesp.core.engine;
public interface AsyncRunner {
void runNow(Runnable task);
}
@@ -0,0 +1,5 @@
package games.cubi.raycastedantiesp.core.engine;
public interface Engine {
void tick();
}
@@ -0,0 +1,202 @@
package games.cubi.raycastedantiesp.core.engine;
import games.cubi.locatables.BlockLocatable;
import games.cubi.locatables.Locatable;
import games.cubi.logs.Logger;
import games.cubi.raycastedantiesp.core.config.ConfigManager;
import games.cubi.raycastedantiesp.core.config.DebugConfig;
import games.cubi.raycastedantiesp.core.config.raycast.EntityConfig;
import games.cubi.raycastedantiesp.core.config.raycast.PlayerConfig;
import games.cubi.raycastedantiesp.core.config.raycast.TileEntityConfig;
import games.cubi.raycastedantiesp.core.players.PlayerData;
import games.cubi.raycastedantiesp.core.players.PlayerRegistry;
import games.cubi.raycastedantiesp.core.raycast.ParticleSpawner;
import games.cubi.raycastedantiesp.core.raycast.RaycastUtil;
import games.cubi.raycastedantiesp.core.view.BlockView;
import games.cubi.raycastedantiesp.core.view.EntityView;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
import java.util.function.IntSupplier;
public class SimpleEngine implements Engine {
private final ConfigManager config;
private final ParticleSpawner particleSpawner;
private final IntSupplier currentTickSupplier;
private final AtomicInteger tickThreadsRunning = new AtomicInteger(0);
private final AtomicLong tickNanos = new AtomicLong(0);
private final AsyncRunner asyncRunner;
public SimpleEngine(ConfigManager config, ParticleSpawner particleSpawner, IntSupplier currentTickSupplier, AsyncRunner asyncRunner) {
this.config = config;
this.particleSpawner = particleSpawner;
this.currentTickSupplier = currentTickSupplier;
this.asyncRunner = asyncRunner;
}
@Override
public void tick() {
int threads = config.getEngineConfig().simpleConfig().asyncProcessingThreads();
if (threads < 1) threads = 1;
if (!tickThreadsRunning.compareAndSet(0, threads)) {
Logger.warning("RaycastedAntiESP is still ticking from the last tick! Skipping this tick to avoid concurrent modification issues. Current tick: " + currentTickSupplier.getAsInt(), 2, SimpleEngine.class);
return;
}
boolean handedOffToSubTick = false;
try {
tickNanos.set(System.nanoTime());
final int currentTick = currentTickSupplier.getAsInt();
Collection<PlayerData> allPlayers = PlayerRegistry.getInstance().getAllPlayerData();
EntityConfig entityConfig = config.getEntityConfig();
PlayerConfig playerConfig = config.getPlayerConfig();
TileEntityConfig tileEntityConfig = config.getTileEntityConfig();
DebugConfig debugConfig = config.getDebugConfig();
/*
Logger.debug("Tick #" + currentTick);
if (currentTick % 1200 == 0) {
Logger.debug("Printing player data");
for (PlayerData playerData : allPlayers) {
Logger.debug("Player " + playerData.getPlayerUUID() + " location=" + playerData.ownLocation());
Logger.debug("EntityView:" + playerData.entityView().getStringDataForDebugging());
Logger.debug("PlayerView:" + playerData.playerView().getStringDataForDebugging());
}
}*/
// If only one thread is configured, just use the current async thread to avoid the overhead of scheduling tasks and context switching.
if (threads == 1) {
handedOffToSubTick = true;
subTick(new ArrayList<>(allPlayers), entityConfig, playerConfig, tileEntityConfig, debugConfig, currentTick);
return;
}
List<List<PlayerData>> batches = new ArrayList<>(threads);
for (int i = 0; i < threads; i++) {
batches.add(new ArrayList<>());
}
int index = 0;
for (PlayerData playerData : allPlayers) {
batches.get(index++ % threads).add(playerData);
}
int scheduledBatches = 0;
try {
for (List<PlayerData> batch : batches) {
asyncRunner.runNow(() -> subTick(batch, entityConfig, playerConfig, tileEntityConfig, debugConfig, currentTick));
scheduledBatches++;
}
handedOffToSubTick = true;
}
finally {
if (scheduledBatches < threads) {
tickThreadsRunning.addAndGet(-(threads - scheduledBatches));
handedOffToSubTick = true;
}
}
}
finally {
if (!handedOffToSubTick) {
tickThreadsRunning.set(0);
Logger.error("An error occurred during tick scheduling before handing off to sub-tick processing. Resetting tickThreadsRunning to 0 to avoid deadlock. Current tick: " + currentTickSupplier.getAsInt(), 2, SimpleEngine.class);
}
}
}
private void subTick(List<PlayerData> batch, EntityConfig entityConfig, PlayerConfig playerConfig, TileEntityConfig tileEntityConfig, DebugConfig debugConfig, int currentTick) {
try {
processTickForPlayers(batch, entityConfig, playerConfig, tileEntityConfig, debugConfig.showDebugParticles(), currentTick);
}
finally {
int threadsRemaining = tickThreadsRunning.decrementAndGet();
if (threadsRemaining < 0) {
Logger.warning("tickThreadsRunning went below 0! This should never happen. Resetting to 0 to avoid further issues.", 2, SimpleEngine.class);
tickThreadsRunning.set(0);
}
if (threadsRemaining == 0) {
long elapsedNanos = System.nanoTime() - tickNanos.get();
if (elapsedNanos > 40 * 1000000) {//40 ms
Logger.warning("Tick completed in " + (elapsedNanos / 1_000_000.0) + " ms. If you see this warning frequently, consider reducing the raycasting load by adjusting the configuration.", 5, SimpleEngine.class);
}
}
}
}
private void processTickForPlayers(List<PlayerData> playerDataList, EntityConfig entityConfig, PlayerConfig playerConfig, TileEntityConfig tileEntityConfig,
boolean debugParticles, int currentTick) {
for (PlayerData playerData : playerDataList) {
playerData.nettyData().markPendingPostSpawnTasksForEviction();
if (playerData.hasBypassPermission()) continue;
BlockView blockView = playerData.blockView();
Locatable playerLocation = playerData.ownLocation();
if (playerLocation == null) {
continue;
}
if (entityConfig.enabled()) checkEntities(playerData, playerLocation, entityConfig, debugParticles, blockView, currentTick);
if (playerConfig.enabled()) checkPlayers(playerData, playerLocation, playerConfig, debugParticles, blockView, currentTick);
if (tileEntityConfig.enabled()) checkTileEntities(playerData, playerLocation, tileEntityConfig, debugParticles, blockView, currentTick);
}
}
private void checkEntities(PlayerData player, Locatable playerLocation, EntityConfig entityConfig, boolean debugParticles, BlockView blockView, int currentTick) {
EntityView<?> entityView = player.entityView();
for (UUID entityUUID : entityView.getNeedingRecheck(entityConfig.getVisibleRecheckIntervalTicks(), currentTick)) {
boolean wasVisible = entityView.isVisible(entityUUID, currentTick);
Locatable entityLocation = entityView.getLocation(entityUUID);
if (entityLocation == null) {
Logger.debug("SimpleEngine.checkEntities skipped-null-location viewer=" + player.getPlayerUUID()
+ " target=" + entityUUID
+ " wasVisible=" + wasVisible
+ " tick=" + currentTick);
continue;
}
boolean canSee = RaycastUtil.raycast(player, playerLocation, entityLocation, entityConfig.getMaxOccludingCount(), entityConfig.getAlwaysShowRadius(), entityConfig.getRaycastRadius(), debugParticles, blockView, 1, particleSpawner);
entityView.setVisibility(entityUUID, canSee, currentTick);
}
}
private void checkPlayers(PlayerData player, Locatable playerLocation, PlayerConfig playerConfig, boolean debugParticles, BlockView blockView, int currentTick) {
EntityView<?> playerView = player.playerView();
for (UUID otherPlayerUUID : playerView.getNeedingRecheck(playerConfig.getVisibleRecheckIntervalTicks(), currentTick)) {
boolean wasVisible = playerView.isVisible(otherPlayerUUID, currentTick);
Locatable otherPlayerLocation = playerView.getLocation(otherPlayerUUID);
if (otherPlayerLocation == null) {
Logger.debug("SimpleEngine.checkPlayers skipped-null-location viewer=" + player.getPlayerUUID()
+ " target=" + otherPlayerUUID
+ " wasVisible=" + wasVisible
+ " tick=" + currentTick);
continue;
}
boolean canSee = RaycastUtil.raycast(player, playerLocation, otherPlayerLocation, playerConfig.getMaxOccludingCount(), playerConfig.getAlwaysShowRadius(), playerConfig.getRaycastRadius(), debugParticles, blockView, 1, particleSpawner);
playerView.setVisibility(otherPlayerUUID, canSee, currentTick);
}
}
private void checkTileEntities(PlayerData player, Locatable playerLocation, TileEntityConfig tileEntityConfig, boolean debugParticles, BlockView blockView, int currentTick) {
for (BlockLocatable tileEntityLocation : blockView.getNeedingRecheck(tileEntityConfig.getVisibleRecheckIntervalTicks(), currentTick)) {
if (tileEntityLocation.world() == null || !tileEntityLocation.world().equals(playerLocation.world())) {
continue;
}
if (playerLocation.distanceSquared(tileEntityLocation) > (double) tileEntityConfig.getRaycastRadius() * tileEntityConfig.getRaycastRadius()) {
blockView.setVisibility(tileEntityLocation, false, currentTick);
continue;
}
boolean canSee = RaycastUtil.raycast(player, playerLocation, tileEntityLocation, tileEntityConfig.getMaxOccludingCount() + 1, tileEntityConfig.getAlwaysShowRadius(), tileEntityConfig.getRaycastRadius(), debugParticles, blockView, 1, particleSpawner);
blockView.setVisibility(tileEntityLocation, canSee, currentTick);
}
}
}
@@ -0,0 +1,73 @@
package games.cubi.raycastedantiesp.core.locatables;
import games.cubi.locatables.MutableLocatable;
import org.jetbrains.annotations.Nullable;
import java.util.UUID;
/**
* Per-player platform-independent representation of an entity
*/
public interface EntityLocatable<EntityType, PacketReplayData> extends MutableLocatable {
int entityID();
UUID entityUUID();
boolean visible();
EntityLocatable<?, ?> setVisible(boolean visible);
int lastChecked();
EntityLocatable<?, ?> setLastChecked(int lastChecked);
boolean clientVisible();
EntityLocatable<?, ?> setClientVisible(boolean clientVisible);
boolean isSelfEntity();
float yaw();
EntityLocatable<?, ?> setYaw(float yaw);
float pitch();
EntityLocatable<?, ?> setPitch(float pitch);
float headYaw();
EntityLocatable<?, ?> setHeadYaw(float headYaw);
double velocityX();
double velocityY();
double velocityZ();
EntityLocatable<?, ?> setVelocity(double velocityX, double velocityY, double velocityZ);
boolean onGround();
EntityLocatable<?, ?> setOnGround(boolean onGround);
EntityType entityType();
int entityData();
EntityLocatable<?, ?> setEntityData(int entityData);
int[] passengerIDs();
EntityLocatable<?, ?> setPassengerIDs(int[] passengerIDs);
void setVehicleID(int vehicleID);
int vehicleID();
void addLeashedEntity(int leashedEntityID);
void removeLeashedEntity(int leashedEntityID);
int@Nullable[] leashedEntityIDsOrNull();
int leashingEntity();
void setLeashingEntity(int leashingEntityID);
PacketReplayData packetReplayData();
EntityLocatable<?, ?> setPacketReplayData(PacketReplayData packetReplayData);
/**
* For use when the player disconnects, clears all data.
*/
void clear();
default <T> T cast() {
return (T) this;
}
}
@@ -0,0 +1,420 @@
package games.cubi.raycastedantiesp.core.locatables;
import games.cubi.locatables.Locatable;
import games.cubi.locatables.MutableLocatable;
import games.cubi.locatables.implementations.MutableLocatableImpl;
import games.cubi.raycastedantiesp.core.players.PlayerData;
import games.cubi.raycastedantiesp.core.utils.Clearable;
import games.cubi.raycastedantiesp.core.utils.IntArrayList;
import games.cubi.raycastedantiesp.core.utils.IntArrayListMarker;
import org.jetbrains.annotations.Nullable;
import java.util.UUID;
/**
* Designed for use with netty-based systems, where entity data updates only ever come from one thread, but reads may come from multiple threads. This is however not enforced, and must be kept in mind when using this class.
* A representation of an entity for a specific player.
*/
public abstract class NettyEntityLocatable<EntityType, PacketReplayData extends Clearable> implements EntityLocatable<EntityType, PacketReplayData> {
// immutable fields
private final int entityID;
private final UUID entityUUID;
private final boolean isSelfEntity;
private final EntityType entityType;
private final PlayerData owningPlayer;
// Netty mutatable fields. Should NEVER be mutated from the engine thread, but reads are fine.
private volatile UUID world;
private volatile double x, y, z;
private volatile float yaw;
private volatile float pitch;
private volatile float headYaw;
private volatile double velocityX;
private volatile double velocityY;
private volatile double velocityZ;
private volatile boolean onGround = true;
private int@IntArrayListMarker[] leashedIDs;
private int leasherID = NO_LEASHER;
private int[] passengerIDs;
private int vehicleID = NO_VEHICLE;
private volatile int entityData;
private volatile PacketReplayData packetReplayData; // For use storing the packets we can't be bothered to directly store, with all cached packets being sent back out to the client when entity is visible again.
// mutatable by several threads (engine and netty), may need to investigate atomic updates for thread safety
private volatile int lastChecked;
private volatile boolean clientVisible = true;
// engine thread mutable, reads from netty and engine.
private volatile boolean visible;
public NettyEntityLocatable(PlayerData owningPlayer, UUID world, double x, double y, double z, int entityID, UUID entityUUID, boolean isSelfEntity, EntityType entityType, boolean visible) {
this.world = world;
this.x = x; this.y = y; this.z = z;
this.entityID = entityID;
this.entityUUID = entityUUID;
this.isSelfEntity = isSelfEntity;
this.entityType = entityType;
this.visible = visible;
this.owningPlayer = owningPlayer;
}
// For creating the self entity, where we don't have access to the world or position. Always visible.
protected NettyEntityLocatable(PlayerData selfData, int selfPlayerID, UUID ownUUID) {
entityID = selfPlayerID;
entityUUID = ownUUID;
owningPlayer = selfData;
isSelfEntity = true;
entityType = null;
clientVisible = true;
visible = true;
}
@Override
public LocatableType getType() {
return LocatableType.NettyEntity;
}
@Override
public int entityID() {
return entityID;
}
@Override
public UUID entityUUID() {
return entityUUID;
}
@Override
public boolean visible() {
return visible;
}
/**
* Wherever possible, effort should be made to only call this from the engine thread, for thread safety reasons.
*/
@Override
public EntityLocatable<?, ?> setVisible(boolean visible) {
this.visible = visible;
return this;
}
@Override
public int lastChecked() {
return lastChecked;
}
// todo it may be that this is only ever set by the engine thread? If so, just volatile annotation may be safe enough, as no two engine threads should update a single player at the same time (add guard lock for this)
@Override
public EntityLocatable<?, ?> setLastChecked(int lastChecked) {
this.lastChecked = lastChecked;
return this;
}
@Override
public boolean clientVisible() {
return clientVisible;
}
@Override
public EntityLocatable<?, ?> setClientVisible(boolean clientVisible) {
this.clientVisible = clientVisible;
return this;
}
@Override
public boolean isSelfEntity() {
return isSelfEntity;
}
@Override
public float yaw() {
return yaw;
}
/**
* THIS METHOD IS ONLY SAFE TO CALL FROM THE PLAYER's NETTY THREAD
*/
@Override
public EntityLocatable<?, ?> setYaw(float yaw) {
this.yaw = yaw;
return this;
}
@Override
public float pitch() {
return pitch;
}
/**
* THIS METHOD IS ONLY SAFE TO CALL FROM THE PLAYER's NETTY THREAD
*/
@Override
public EntityLocatable<?, ?> setPitch(float pitch) {
this.pitch = pitch;
return this;
}
@Override
public float headYaw() {
return headYaw;
}
/**
* THIS METHOD IS ONLY SAFE TO CALL FROM THE PLAYER's NETTY THREAD
*/
@Override
public EntityLocatable<?, ?> setHeadYaw(float headYaw) {
this.headYaw = headYaw;
return this;
}
@Override
public double velocityX() {
return velocityX;
}
@Override
public double velocityY() {
return velocityY;
}
@Override
public double velocityZ() {
return velocityZ;
}
/**
* THIS METHOD IS ONLY SAFE TO CALL FROM THE PLAYER's NETTY THREAD
*/
@Override
public EntityLocatable<?, ?> setVelocity(double velocityX, double velocityY, double velocityZ) {
this.velocityX = velocityX;
this.velocityY = velocityY;
this.velocityZ = velocityZ;
return this;
}
@Override
public boolean onGround() {
return onGround;
}
/**
* THIS METHOD IS ONLY SAFE TO CALL FROM THE PLAYER's NETTY THREAD
*/
@Override
public EntityLocatable<?, ?> setOnGround(boolean onGround) {
this.onGround = onGround;
return this;
}
@Override
public EntityType entityType() {
return entityType;
}
@Override
public int entityData() {
return entityData;
}
@Override
public EntityLocatable<?, ?> setEntityData(int entityData) {
this.entityData = entityData;
return this;
}
@Override
public int[] passengerIDs() {
return passengerIDs == null ? null : passengerIDs.clone();
}
@Override
public EntityLocatable<?, ?> setPassengerIDs(int[] passengerIDs) {
this.passengerIDs = passengerIDs == null ? new int[0] : passengerIDs.clone();
return this;
}
@Override
public void setVehicleID(int vehicleID) {
this.vehicleID = vehicleID;
}
@Override
public int vehicleID() {
return vehicleID;
}
@Override
public void addLeashedEntity(int leashedEntityID) {
leashedIDs = IntArrayList.add(leashedIDs, leashedEntityID);
}
@Override
public void removeLeashedEntity(int leashedEntityID) {
leashedIDs = IntArrayList.remove(leashedIDs, leashedEntityID);
}
public int@Nullable[] leashedEntityIDsOrNull() {
return IntArrayList.getCopyOrNull(leashedIDs);
}
public static final int NO_VEHICLE = -1;
public static final int NO_LEASHER = -2;
@Override
public int leashingEntity() {
return leasherID;
}
@Override
public void setLeashingEntity(int leashingEntityID) {
this.leasherID = leashingEntityID;
}
@Override
public PacketReplayData packetReplayData() {
return packetReplayData;
}
@Override
public EntityLocatable<?, ?> setPacketReplayData(PacketReplayData packetReplayData) {
this.packetReplayData = packetReplayData;
return this;
}
@Override
public double x() {
return x;
}
@Override
public double y() {
return y;
}
@Override
public double z() {
return z;
}
@Override
public UUID world() {
return world;
}
@Override
public MutableLocatable clonePlainAndCentreIfBlockLocation() {
return new MutableLocatableImpl(world, x, y, z);
}
@Override
public MutableLocatable setX(double x) {
this.x = x;
return this;
}
@Override
public MutableLocatable setY(double y) {
this.y = y;
return this;
}
@Override
public MutableLocatable setZ(double z) {
this.z = z;
return this;
}
@Override
public MutableLocatable setWorld(UUID world) {
this.world = world;
return this;
}
@Override
public MutableLocatable set(double x, double y, double z) {
this.x = x;
this.y = y;
this.z = z;
updatePassengerPositions();
return this;
}
@Override
public MutableLocatable add(double x, double y, double z) {
this.x += x;
this.y += y;
this.z += z;
updatePassengerPositions();
return this;
}
// This does not correctly set the passenger position, as the passenger is above the vehicle. It is however close enough to minimise annoying interpolation on show.
private void updatePassengerPositions() {
if (passengerIDs == null || passengerIDs.length == 0) return;
for (int passengerID : passengerIDs) {
NettyEntityLocatable<?, ?> passenger = owningPlayer.entityFromID(passengerID);
if (passenger != null) {
passenger.setVehicleID(entityID);
passenger.setWorld(world);
passenger.setX(x);
passenger.setY(y);
passenger.setZ(z);
passenger.updatePassengerPositions();
}
}
}
@Override
public void clear() {
world = null;
packetReplayData.clear();
packetReplayData = null;
vehicleID = NO_VEHICLE;
passengerIDs = null;
leashedIDs = null;
leasherID = NO_LEASHER;
}
@Override
public boolean equals(Object other) {
return isEqualTo(other);
}
@Override
public int hashCode() {
return makeHash();
}
@Override
public String toString() {
return "NettyEntityLocatable{" +
"entityID=" + entityID +
", entityUUID=" + entityUUID +
", isSelfEntity=" + isSelfEntity +
", entityType=" + entityType +
", world=" + world +
", x=" + x +
", y=" + y +
", z=" + z +
", yaw=" + yaw +
", pitch=" + pitch +
", headYaw=" + headYaw +
", velocityX=" + velocityX +
", velocityY=" + velocityY +
", velocityZ=" + velocityZ +
", onGround=" + onGround +
", leashedIDs=" + (leashedIDs == null ? null : IntArrayList.toString(leashedIDs)) +
", leasherID=" + leasherID +
", passengerIDs=" + (passengerIDs == null ? null : IntArrayList.toString(passengerIDs)) +
", vehicleID=" + vehicleID +
", entityData=" + entityData +
'}';
}
}
@@ -0,0 +1,129 @@
package games.cubi.raycastedantiesp.core.locatables;
import games.cubi.locatables.Locatable;
import games.cubi.raycastedantiesp.core.utils.Clearable;
import java.util.UUID;
public abstract class NettyTileEntity<PacketReplayData extends Clearable> implements TileEntityLocatable<PacketReplayData> {
private volatile boolean visible;
private volatile int lastChecked;
private volatile int blockID;
private volatile PacketReplayData extraData;
private final int x, y, z;
private final UUID world;
public NettyTileEntity(Locatable location, boolean visible, int lastChecked, int blockID) {
x = location.blockX();
y = location.blockY();
z = location.blockZ();
world = location.world();
this.blockID = blockID;
this.visible = visible;
this.lastChecked = lastChecked;
}
public NettyTileEntity(UUID world, int x, int y, int z, boolean visible, int blockID) {
this.x = x;
this.y = y;
this.z = z;
this.visible = visible;
this.blockID = blockID;
this.world = world;
lastChecked = 0;
}
@Override
public boolean visible() {
return visible;
}
@Override
public TileEntityLocatable<PacketReplayData> setVisible(boolean visible) {
this.visible = visible;
return this;
}
@Override
public int lastChecked() {
return lastChecked;
}
@Override
public TileEntityLocatable<PacketReplayData> setLastChecked(int lastChecked) {
this.lastChecked = lastChecked;
return this;
}
@Override
public int blockID() {
return blockID;
}
@Override
public TileEntityLocatable<PacketReplayData> setBlockID(int blockID) {
this.blockID = blockID;
return this;
}
@Override
public PacketReplayData extraData() {
return extraData;
}
@Override
public TileEntityLocatable<PacketReplayData> setExtraData(PacketReplayData extraData) {
this.extraData = extraData;
return this;
}
@Override
public int blockX() {
return x;
}
@Override
public int blockY() {
return y;
}
@Override
public int blockZ() {
return z;
}
@Override
public LocatableType getType() {
return LocatableType.NettyTileEntity;
}
@Override
public UUID world() {
return world;
}
@Override
public void clear() {
if (extraData != null) {
extraData.clear();
}
}
@Override
public boolean equals(Object other) {
return isEqualTo(other);
}
@Override
public int hashCode() {
return blockHash();
}
@Override
public String toString() {
return toStringForm();
}
}
@@ -0,0 +1,30 @@
package games.cubi.raycastedantiesp.core.locatables;
import games.cubi.locatables.BlockLocatable;
import games.cubi.locatables.ImmutableLocatable;
import games.cubi.locatables.MutableLocatable;
import games.cubi.raycastedantiesp.core.utils.Clearable;
public interface TileEntityLocatable<T> extends BlockLocatable, ImmutableLocatable, Clearable {
boolean visible();
TileEntityLocatable<T> setVisible(boolean visible);
int lastChecked();
TileEntityLocatable<T> setLastChecked(int lastChecked);
int blockID();
TileEntityLocatable<T> setBlockID(int blockID);
T extraData();
TileEntityLocatable<T> setExtraData(T extraData);
@Override
default boolean isMutable() {
return false;
}
@Override
default MutableLocatable castToMutableOrNull() {
return null;
}
}
@@ -0,0 +1,148 @@
package games.cubi.raycastedantiesp.core.players;
import games.cubi.logs.Logger;
import games.cubi.raycastedantiesp.core.utils.*;
import games.cubi.raycastedantiesp.core.utils.Packet.Packets;
import it.unimi.dsi.fastutil.ints.Int2ObjectArrayMap;
import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
import it.unimi.dsi.fastutil.objects.ObjectIterator;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.VarHandle;
/**
* Per-player mutable state intended for Netty-side packet tracking and deferred reconciliation.
*/
public class NettyData implements Clearable {
//
// ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// START Leash tracking:
//
private final Int2ObjectArrayMap<int[]> unresolvedLeashedEntityIDsByHolderID = new Int2ObjectArrayMap<>(16); // shot in the dark guess at capacity here. Can't be the more generic Int2ObjectMap because that doesn't expose a fast iterator.
public void addUnresolvedLeash(int holderEntityID, int leashedEntityID) {
unresolvedLeashedEntityIDsByHolderID.compute(holderEntityID, (ignored, existing) -> {
if (IntArrayList.contains(existing, leashedEntityID)) {
return existing;
}
return IntArrayList.add(existing, leashedEntityID);
});
}
public boolean removeUnresolvedLeash(int holderEntityID, int leashedEntityID) {
final boolean[] removed = new boolean[1];
unresolvedLeashedEntityIDsByHolderID.computeIfPresent(holderEntityID, (ignored, existing) -> {
if (!IntArrayList.contains(existing, leashedEntityID)) {
return existing;
}
removed[0] = true;
int[] updated = IntArrayList.remove(existing, leashedEntityID);
return IntArrayList.isEmpty(updated) ? null : updated;
});
return removed[0];
}
public int[] consumeUnresolvedLeashes(int holderEntityID) {
return unresolvedLeashedEntityIDsByHolderID.remove(holderEntityID);
}
public void removeUnresolvedLeashedEntityFromAll(int leashedEntityID) {
ObjectIterator<Int2ObjectMap.Entry<int @IntArrayListMarker []>> iterator = unresolvedLeashedEntityIDsByHolderID.int2ObjectEntrySet().fastIterator();
while (iterator.hasNext()) {
Int2ObjectMap.Entry<int @IntArrayListMarker []> entry = iterator.next();
int[] existing = entry.getValue();
if (!IntArrayList.contains(existing, leashedEntityID)) {
continue;
}
int[] updated = IntArrayList.remove(existing, leashedEntityID);
if (IntArrayList.isEmpty(updated)) {
iterator.remove();
continue;
}
entry.setValue(updated);
}
}
//
// END Leash tracking.
// ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//
//
// ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// START Netty entity spawn task queue:
//
private final Int2ObjectArrayMap<EntitySpawnTask> pendingPostEntitySpawnTasksByEntityID = new Int2ObjectArrayMap<>(16); // shot in the dark guess at capacity here. Can't be the more generic Int2ObjectMap because that doesn't expose a fast iterator.
private volatile boolean evictPendingPostSpawnTasksOnNextPacket = false;
private static final VarHandle EVICT_PENDING_POST_SPAWN_TASKS_ON_NEXT_PACKET_HANDLE; //TBH there is minimal advantage to using a VarHandle over an AtomicBoolean here, just felt like it.
static {
try {
EVICT_PENDING_POST_SPAWN_TASKS_ON_NEXT_PACKET_HANDLE = MethodHandles.lookup().findVarHandle( NettyData.class, "evictPendingPostSpawnTasksOnNextPacket", boolean.class);
} catch (ReflectiveOperationException e) {
throw new ExceptionInInitializerError(e);
}
}
/**
* This is intended for reconciliation tasks due to Minecraft sending packets out of order. For example, {@link Packets#ENTITY_EQUIPMENT} is sent before the corresponding {@link Packets#SPAWN_ENTITY} packet, so caching of the equipment packet must await the spawn packet.
* @param entityID The entity ID to associate the task with. Immediately after a {@link Packets#SPAWN_ENTITY} packet is processed for this entity ID, the task will be consumed and run.
* @param task The task to run.
*/
public void addPostEntitySpawnTask(int entityID, EntitySpawnTask task) {
if (task.getNext() != null) {
Logger.errorAndReturn(new IllegalArgumentException("Pending netty task was chained before queueing. Task=" + task), 4, NettyData.class);
}
EntitySpawnTask existing = pendingPostEntitySpawnTasksByEntityID.get(entityID);
if (existing == null) {
pendingPostEntitySpawnTasksByEntityID.put(entityID, task);
return;
}
existing.appendLinkedTask(task);
}
public void runPendingPostSpawnTaskForEntity(int entityID) {
EntitySpawnTask pendingTasks = consumePendingPostSpawnTasksForEntity(entityID);
if (pendingTasks != null) {
pendingTasks.runLinkedTasks();
}
}
public void evictPendingPostSpawnTasksIfRequired(int currentTick) {
if (EVICT_PENDING_POST_SPAWN_TASKS_ON_NEXT_PACKET_HANDLE.compareAndSet(this, true, false)) evictOldPendingPostSpawnTasks(currentTick);
}
public void markPendingPostSpawnTasksForEviction() {
evictPendingPostSpawnTasksOnNextPacket = true;
}
public EntitySpawnTask consumePendingPostSpawnTasksForEntity(int entityID) {
return pendingPostEntitySpawnTasksByEntityID.remove(entityID);
}
public void clearPendingPostSpawnTasksForEntity(int entityID) {
pendingPostEntitySpawnTasksByEntityID.remove(entityID);
}
public void evictOldPendingPostSpawnTasks(int currentTick) {
ObjectIterator<Int2ObjectMap.Entry<EntitySpawnTask>> iterator = pendingPostEntitySpawnTasksByEntityID.int2ObjectEntrySet().fastIterator();
while (iterator.hasNext()) {
Int2ObjectMap.Entry<EntitySpawnTask> entry = iterator.next();
EntitySpawnTask survivingHead = entry.getValue().trimExpiredTasks(currentTick);
if (survivingHead == null) {
iterator.remove();
} else {
entry.setValue(survivingHead);
}
}
}
//
// END Netty entity spawn task queue.
// ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//
@Override
public void clear() {
unresolvedLeashedEntityIDsByHolderID.clear();
pendingPostEntitySpawnTasksByEntityID.clear();
}
}
@@ -0,0 +1,117 @@
package games.cubi.raycastedantiesp.core.players;
import games.cubi.locatables.Locatable;
import games.cubi.locatables.implementations.ThreadSafeLocatable;
import games.cubi.logs.Logger;
import games.cubi.raycastedantiesp.core.locatables.NettyEntityLocatable;
import games.cubi.raycastedantiesp.core.view.BlockView;
import games.cubi.raycastedantiesp.core.view.EntityView;
import games.cubi.raycastedantiesp.core.view.ViewRegistry;
import games.cubi.raycastedantiesp.core.view.controller.PacketEntityViewController;
import java.util.UUID;
public class PlayerData {
private final UUID playerUUID;
private final int joinTick;
private volatile boolean hasBypassPermission;
private final ThreadSafeLocatable ownLocation;
private final BlockView blockView;
private final EntityView<?> entityView;
private final EntityView<?> playerView;
private final NettyData nettyData;
public PlayerData(UUID player, boolean hasBypassPermission, int joinTick) {
this(player, joinTick);
this.hasBypassPermission = hasBypassPermission;
}
public PlayerData(UUID player, int joinTick) {
this.joinTick = joinTick;
this.playerUUID = player;
blockView = ViewRegistry.createBlockView();
entityView = ViewRegistry.createEntityView();
playerView = ViewRegistry.createPlayerEntityView();
nettyData = new NettyData();
ownLocation = new ThreadSafeLocatable(null, 0, 0, 0);
}
public EntityView<?> entityView() {
return entityView;
}
public EntityView<?> playerView() {
return playerView;
}
public NettyData nettyData() {
return nettyData;
}
public BlockView blockView() {
return blockView;
}
public void updateOwnLocation(UUID world, double x, double y, double z) {
ownLocation.set(x, y, z, world);
}
public Locatable ownLocation() {
ThreadSafeLocatable existing = ownLocation;
return existing == null ? null : existing.clonePlainAndCentreIfBlockLocation();
}
public UUID getPlayerUUID() {
return playerUUID;
}
public boolean hasBypassPermission() {
return hasBypassPermission;
}
public int getJoinTick() {
return joinTick;
}
/**
* @return Either the entity or player view for this player, depending on the entity ID
*/
public EntityView<?> viewFromEntityID(int entityID) {
if (entityView.exists(entityID)) {
return entityView;
}
if (playerView.exists(entityID)) {
return playerView;
}
Logger.warning("Could not find view for entityID=" + entityID + " uuid=" + playerUUID, 6, PacketEntityViewController.class);
return null;
}
public NettyEntityLocatable<?,?> entityFromID(int entityID) {
EntityView<?> entityView = viewFromEntityID(entityID);
if (entityView == null) {
return null;
}
return (NettyEntityLocatable<?, ?>) entityView.getEntity(entityID);
}
public void setBypassPermission(boolean hasBypassPermission) {
this.hasBypassPermission = hasBypassPermission;
} //todo: need to link up
@Override
public String toString() {
return "PlayerData{" +
"playerUUID=" + playerUUID +
", joinTick=" + joinTick +
", hasBypassPermission=" + hasBypassPermission +
", ownLocation=" + ownLocation +
", blockView=" + blockView +
", entityView=" + entityView +
", playerView=" + playerView +
", nettyData=" + nettyData +
'}';
}
}
@@ -0,0 +1,64 @@
package games.cubi.raycastedantiesp.core.players;
import java.util.Collection;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
public class PlayerRegistry {
private static PlayerRegistry instance;
private PlayerRegistry() {}
public static PlayerRegistry getInstance() {
if (instance == null) {
instance = new PlayerRegistry();
}
return instance;
}
private final ConcurrentHashMap<UUID, PlayerData> playerDataMap = new ConcurrentHashMap<>();
public void registerPlayerIfAbsent(UUID playerUUID, boolean hasBypassPermission, int joinTick) {
playerDataMap.putIfAbsent(playerUUID, new PlayerData(playerUUID, hasBypassPermission, joinTick));
}
/** Forcefully registers a player and returns the new PlayerData, even if they were already registered.**/
public PlayerData registerAndGetPlayer(UUID playerUUID, int joinTick) {
PlayerData newData = new PlayerData(playerUUID, joinTick);
playerDataMap.put(playerUUID, newData);
return newData;
}
public PlayerData registerAndGetPlayerIfAbsent(UUID playerUUID, boolean hasBypassPermission, int joinTick) {
PlayerData newData = new PlayerData(playerUUID, hasBypassPermission, joinTick);
PlayerData existingData = playerDataMap.putIfAbsent(playerUUID, newData);
return existingData != null ? existingData : newData;
}
public void unregisterPlayer(UUID playerUUID) {
PlayerData unregisteredPlayer = playerDataMap.remove(playerUUID);
if (unregisteredPlayer == null) {
return;
}
unregisteredPlayer.blockView().clear();
unregisteredPlayer.entityView().clear();
unregisteredPlayer.playerView().clear();
unregisteredPlayer.nettyData().clear();
}
public PlayerData getPlayerData(UUID playerUUID) {
return playerDataMap.get(playerUUID);
}
public boolean isPlayerRegistered(UUID playerUUID) {
return playerDataMap.containsKey(playerUUID);
}
/**
* @return Live, mutable collection of all PlayerData instances.
* **/
public Collection<PlayerData> getAllPlayerData() {
return playerDataMap.values();
}
}
@@ -0,0 +1,12 @@
package games.cubi.raycastedantiesp.core.raycast;
import games.cubi.locatables.Locatable;
public interface ParticleSpawner {
enum Colour {
RED, GREEN, BLUE,
}
void spawnParticleAt(Locatable locatable, Colour color);
}
@@ -0,0 +1,42 @@
package games.cubi.raycastedantiesp.core.raycast;
import games.cubi.locatables.Locatable;
import games.cubi.locatables.MutableLocatable;
import games.cubi.locatables.implementations.MutableBlockVector;
import games.cubi.logs.Logger;
import games.cubi.raycastedantiesp.core.players.PlayerData;
import games.cubi.raycastedantiesp.core.view.BlockView;
public class RaycastUtil {
//True: Has line-of-sight
public static boolean raycast(PlayerData player, Locatable start, Locatable end, int maxOccluding, int alwaysShowRadius, int maxRaycastRadius, boolean debug, BlockView snap, int stepSize, ParticleSpawner particleSpawner) {
if (!start.world().equals(end.world())) return false;
MutableLocatable clonedEnd = end.clonePlainAndCentreIfBlockLocation();
double total = start.distance(clonedEnd) - stepSize; //benchmarking shows that calling distance() is faster than distanceSquared() then checking distanceSquared < stepSize*stepSize every time despite the latter replacing a square root with multiplication
if (total <= alwaysShowRadius) return true;
if (total > maxRaycastRadius) return false;
if (debug && particleSpawner == null) {
Logger.errorAndReturn(new RuntimeException("raycast called with debug enabled but no ParticleSpawner supplied"), 2, RaycastUtil.class);
}
Locatable dir = clonedEnd.subtract(start).normalize().scalarMultiply(stepSize);
MutableBlockVector current = new MutableBlockVector(start.world(), start.x(),start.y(),start.z());
for (double traveled = 0; traveled < total; traveled += stepSize) { //benchmarking shows that for loop is marginally faster than while loop initially (after running for a while they are equal
current.add(dir);
if (snap.isBlockOccluding(current)) {//This works as MutableBlockVector resolves to a block location in #equals and #hashCode, and thus works fine as a key in the snapshot manager
maxOccluding--;
if (debug) particleSpawner.spawnParticleAt(current, ParticleSpawner.Colour.RED);
if (maxOccluding < 1) return false;
continue;
}
if (debug) particleSpawner.spawnParticleAt(current, ParticleSpawner.Colour.GREEN);
}
return true;
}
}
@@ -0,0 +1,34 @@
package games.cubi.raycastedantiesp.core.utils;
import games.cubi.logs.Logger;
import org.jetbrains.annotations.Nullable;
public abstract class BaseEntitySpawnTask implements EntitySpawnTask {
protected final int submittedTick;
private @Nullable EntitySpawnTask next;
protected BaseEntitySpawnTask(int submittedTick) {
this.submittedTick = submittedTick;
}
@Override
public final int getSubmittedTick() {
return submittedTick;
}
@Override
public final @Nullable EntitySpawnTask getNext() {
return next;
}
@Override
public final void setNext(@Nullable EntitySpawnTask next) {
if (next == this) {
Logger.errorAndReturn(new IllegalArgumentException("A FutureNettyTask cannot link to itself: " + this), 1, BaseEntitySpawnTask.class);
}
if (this.next != null && next != null) {
Logger.errorAndReturn(new IllegalStateException("FutureNettyTask already has a next task. Existing next=" + this.next + ", attempted next=" + next + ", task=" + this), 1, BaseEntitySpawnTask.class);
}
this.next = next;
}
}
@@ -0,0 +1,93 @@
package games.cubi.raycastedantiesp.core.utils;
import games.cubi.logs.Logger;
import org.jspecify.annotations.NullMarked;
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;
// Not specific to RaycastedAntiESP, could be moved to a more general utils package if needed
@NullMarked
public record BuildProperties(String gitHashLong, String gitHashShort, String buildTime, Version version) {
public static final BuildProperties CORE = fromResource("build-properties/core.yml");
public static final BuildProperties PLATFORM = fromResource("build-properties/platform.yml");
public static final BuildProperties LOGGER = fromResource("build-properties/logging.yml");
public static final BuildProperties LOCATABLES = fromResource("build-properties/locatable-lib.yml");
public static BuildProperties fromResource(String resourcePath) {
try (InputStream inputStream = BuildProperties.class.getClassLoader().getResourceAsStream(resourcePath)) {
if (inputStream == null) {
Logger.error(new IllegalArgumentException("BuildProperties resource not found: " + resourcePath), 2, BuildProperties.class);
return error();
}
String shortGit = null;
String longGit = null;
String buildTime = null;
Version version = null;
try (BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, StandardCharsets.UTF_8))) {
String line;
while ((line = reader.readLine()) != null) {
String trimmedLine = line.trim();
if (trimmedLine.isEmpty() || trimmedLine.startsWith("#")) continue;
String[] parts = trimmedLine.split(":", 2);
if (parts.length != 2) continue;
String key = parts[0].trim();
String value = parts[1].trim();
if ((value.startsWith("\"") && value.endsWith("\"")) || (value.startsWith("'") && value.endsWith("'"))) {
value = value.substring(1, value.length() - 1);
}
switch (key) {
case "short-git" -> shortGit = value;
case "long-git" -> longGit = value;
case "build-time" -> buildTime = value;
case "version" -> version = Version.parse(value);
}
}
}
if (shortGit == null || longGit == null || buildTime == null || version == null) {
Logger.error(new IllegalArgumentException("Missing required build properties in resource: " + resourcePath + ". Found shortGit=" + shortGit + ", longGit=" + longGit + ", buildTime=" + buildTime + ", version=" + version), 2, BuildProperties.class);
return error();
}
return new BuildProperties(longGit, shortGit, buildTime, version);
} catch (Exception e) {
Logger.error(new IllegalArgumentException("Failed to parse BuildProperties resource: " + resourcePath, e), 2, BuildProperties.class);
return error();
}
}
private static BuildProperties error() {
return new BuildProperties("unknown", "unknown", "unknown", new Version(-1, -1, -1, true));
}
record Version(short major, short minor, short patch, boolean snapshot) {
Version(int major, int minor, int patch, boolean snapshot) {
this((short) major, (short) minor, (short) patch, snapshot);
}
public static Version parse(String versionString) {
String[] parts = versionString.split("[.-]");
if (parts.length < 3) {
Logger.errorAndReturn(new IllegalArgumentException("Version string must be in the format 'major.minor.patch'"), 2, BuildProperties.class, Version.class);
}
try {
short major = Short.parseShort(parts[0]);
short minor = Short.parseShort(parts[1]);
short patch = Short.parseShort(parts[2]);
boolean snapshot = versionString.contains("SNAPSHOT");
return new Version(major, minor, patch, snapshot);
} catch (NumberFormatException e) {
Logger.errorAndReturn(new IllegalArgumentException("Version parts must be valid short integers. Attempted: " + versionString, e), 2, BuildProperties.class, Version.class);
return new Version(-1, -1, -1, true);
}
}
}
}
@@ -0,0 +1,40 @@
package games.cubi.raycastedantiesp.core.utils;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.Collection;
import java.util.Set;
import java.util.function.Function;
/**
* A Set-like data structure that stores canonical instances of key values.
* Any compatible key type may be used for lookup, but only canonical values
* of type {@code V} may be stored.
*
* @param <K> key type used for lookup
* @param <V> stored canonical value type
*/
public interface CanonicalSet<K, V extends K> {
int size();
boolean isEmpty();
boolean contains(K keyValue);
@Nullable V get(K keyValue);
@Nullable V add(V keyValue);
void addAll(Set<? extends V> keyValues);
@Nullable V computeIfAbsent(K keyValue, @NotNull Function<? super K, ? extends V> mappingFunction);
@Nullable V remove(K keyValue);
void clear();
@NotNull Set<V> keySet();
@NotNull Collection<V> values();
}
@@ -0,0 +1,8 @@
package games.cubi.raycastedantiesp.core.utils;
public interface Clearable {
/**
* Dereferences all internal references to other objects, allowing them to be garbage collected. In theory this isn't needed but idk what's causing the memory leak so we're covering all bases.
*/
void clear();
}
@@ -0,0 +1,92 @@
package games.cubi.raycastedantiesp.core.utils;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.Collection;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Function;
public class ConcurrentSelfMap<K, V extends K> implements CanonicalSet<K, V> {
private final ConcurrentHashMap<V, V> backingMap = new ConcurrentHashMap<>();
public ConcurrentSelfMap() {}
@Override
public int size() {
return backingMap.size();
}
@Override
public boolean isEmpty() {
return backingMap.isEmpty();
}
@Override
public boolean contains(K keyValue) {
return backingMap.containsKey(keyValue);
}
@Override
public @Nullable V get(K keyValue) {
return backingMap.get(keyValue);
}
@Override
public @Nullable V add(V keyValue) {
return backingMap.put(keyValue, keyValue);
}
@Override
public void addAll(Set<? extends V> keyValues) {
for (V keyValue : keyValues) {
backingMap.put(keyValue, keyValue);
}
}
@Override
public @Nullable V computeIfAbsent(
K keyValue,
@NotNull Function<? super K, ? extends V> mappingFunction
) {
V existing = backingMap.get(keyValue);
if (existing != null) {
return existing;
}
V canonicalValue = mappingFunction.apply(keyValue);
if (canonicalValue == null) {
return null;
}
if (!canonicalValue.equals(keyValue)) {
throw new IllegalArgumentException(
"Computed canonical value must be equal to the key value."
);
}
V racedValue = backingMap.putIfAbsent(canonicalValue, canonicalValue);
return racedValue != null ? racedValue : canonicalValue;
}
@Override
public @Nullable V remove(K keyValue) {
return backingMap.remove(keyValue);
}
@Override
public void clear() {
backingMap.clear();
}
@Override
public @NotNull Set<V> keySet() {
return backingMap.keySet();
}
@Override
public @NotNull Collection<V> values() {
return backingMap.values();
}
}
@@ -0,0 +1,72 @@
package games.cubi.raycastedantiesp.core.utils;
import games.cubi.logs.Logger;
import org.jetbrains.annotations.Nullable;
/**
* For runnable tasks which should be run immediately after an entity is spawned.
*/
public interface EntitySpawnTask extends Runnable {
int TICKS_BEFORE_EVICTION = 3;
int getSubmittedTick();
default boolean thisShouldBeEvicted(int currentTick) {
return ( currentTick - getSubmittedTick() ) >= TICKS_BEFORE_EVICTION;
}
/**
* Appends the provided task to the end of this linked task chain.
*/
default void appendLinkedTask(EntitySpawnTask task) {
EntitySpawnTask current = this;
while (current.getNext() != null) {
current = current.getNext();
}
current.setNext(task);
}
/**
* @return the first task in this chain that should not be evicted yet, or null if all tasks should be evicted.
*/
@Nullable
default EntitySpawnTask trimExpiredTasks(int currentTick) {
EntitySpawnTask current = this;
while (current != null && current.thisShouldBeEvicted(currentTick)) {
Logger.warning("A task was evicted from the Netty task queue due to being too old! This should not happen under normal circumstances and may indicate a problem with the system being overloaded or tasks taking too long to execute. Current tick=" + currentTick + " Task=" + current, 3, EntitySpawnTask.class);
EntitySpawnTask next = current.getNext();
current.setNext(null);
current.run(); // perhaps the task is salvageable even if we missed the correct caller
current = next;
}
return current;
}
default void runLinkedTasks() {
EntitySpawnTask current = this;
while (current != null) {
EntitySpawnTask next = current.getNext();
current.setNext(null);
try {
current.run();
} catch (Exception e) {
Logger.error("Error while running future netty task " + current, e, 3, EntitySpawnTask.class);
}
current = next;
}
}
/**
* Allows linking of tasks into lists for each entity, so that when an entity is processed, all pending tasks for that entity can be processed at once.
* @return the next task in the list, or null if this is the end of the list. Order of tasks is guaranteed to be in ascending order of submitted tick.
*/
@Nullable EntitySpawnTask getNext();
/**
* Sets the next task in the linked task chain.
* Passing null is allowed and is used when detaching already-linked tasks before eviction or execution.
* <p>
* This should generally not be called directly, use {@link #appendLinkedTask} to link tasks together and let the system handle detaching when necessary.
*/
void setNext(@Nullable EntitySpawnTask next);
}
@@ -0,0 +1,103 @@
package games.cubi.raycastedantiesp.core.utils;
import games.cubi.logs.Logger;
/**
* Static utility class for operations on int arrays annotated with {@link IntArrayListMarker}, which are intended to be used as lists of integers without the overhead of autoboxing.
* <p>
* {@link IntArrayListMarker} fields may be null or non-initialised to save memory, {@code IntArrayList} methods will treat null or non-initialised arrays as empty lists.
* <p>
* Arrays expand and contract as needed such that the length of the backing array is always equal to the number of elements in the list, so there is no extra capacity. This means that adding or removing elements from the list will involve creating a new array and copying the existing elements, which can be inefficient for large lists. However, this design choice was made to save memory and avoid the overhead of maintaining a separate size field and capacity management logic.
*/
public class IntArrayList {
private IntArrayList() {}
public static int size(int@IntArrayListMarker[] array) {
return array == null ? 0 : array.length;
}
public static boolean isEmpty(int@IntArrayListMarker[] array) {
return array == null || array.length == 0;
}
public static boolean contains(int@IntArrayListMarker[] array, int value) {
if (array == null) return false;
for (int i : array) {
if (i == value) return true;
}
return false;
}
/**
* Caller of this method <b>must</b> reassign the returned array to the original array reference, as the original array will not be modified and a new array with the added element will be returned.
*/
public static int@IntArrayListMarker[] add(int@IntArrayListMarker[] array, int value) {
if (array == null) {
return new int[]{value};
} else {
int[] newArray = new int[array.length + 1];
System.arraycopy(array, 0, newArray, 0, array.length);
newArray[array.length] = value;
return newArray;
}
}
/**
* Caller of this method <b>must</b> reassign the returned array to the original array reference, as the original array will not be modified and a new array with the added element will be returned.
*/
public static int@IntArrayListMarker[] remove(int@IntArrayListMarker[] array, int value) {
if (array == null) return null;
int index = -1;
for (int i = 0; i < array.length; i++) {
if (array[i] == value) {
index = i;
break;
}
}
if (index == -1) return array; // value not found, return original array
int[] newArray = new int[array.length - 1];
System.arraycopy(array, 0, newArray, 0, index);
System.arraycopy(array, index + 1, newArray, index, array.length - index - 1);
return newArray;
}
/**
* Caller of this method <b>must</b> reassign the returned array to the original array reference, as the original array will not be modified and a new array with the added element will be returned.
*/
public static int@IntArrayListMarker[] clear(int@IntArrayListMarker[] array) {
return null;
}
public static int get(int@IntArrayListMarker[] array, int index) {
if (array == null) Logger.errorAndReturn(new IndexOutOfBoundsException("Attempted to find value at index: " + index + ", for IntArrayList with size: 0"), 3, IntArrayList.class);
if (index < 0 || index >= array.length) Logger.errorAndReturn(new IndexOutOfBoundsException("Attempted to find value at index: " + index + ", for IntArrayList with size: " + size(array)), 3, IntArrayList.class);
return array[index];
}
public static int@IntArrayListMarker[] set(int@IntArrayListMarker[] array, int index, int value) {
array[index] = value;
return array;
}
public static int[] getCopyOrNull(int@IntArrayListMarker[] array) {
if (size(array) == 0) return null;
int[] copy = new int[array.length];
System.arraycopy(array, 0, copy, 0, array.length);
return copy;
}
public static String toString(int@IntArrayListMarker[] array) {
if (array == null) return "[]";
StringBuilder sb = new StringBuilder();
sb.append("[");
for (int i = 0; i < array.length; i++) {
sb.append(array[i]);
if (i < array.length - 1) {
sb.append(", ");
}
}
sb.append("]");
return sb.toString();
}
}
@@ -0,0 +1,11 @@
package games.cubi.raycastedantiesp.core.utils;
import java.lang.annotation.*; /**
* {@code int[]} fields annotated with this are backing arrays for {@code IntArrayLists}. {@code IntArrayLists} are not objects directly, instead just an {@code int[]} array, with static operations provided by {@link IntArrayList}.
* <p>
* This is used to avoid the overhead of an actual object for each {@link IntArrayList}. To further reduce overhead, the field may not be initialised, {@link IntArrayList} is null safe.
*
* <p> Do not use this array directly, all calls should go through {@link IntArrayList}.
*/
@Documented @Retention(RetentionPolicy.SOURCE) @Target({ElementType.TYPE_USE, ElementType.FIELD, ElementType.PARAMETER})
public @interface IntArrayListMarker {}
@@ -0,0 +1,40 @@
package games.cubi.raycastedantiesp.core.utils;
import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
@Documented
@Retention(RetentionPolicy.SOURCE)
public @interface Packet {
//todo note: spawn living entity and painting are really old and no longer used, delete them from code maybe
enum Packets {
@Until("1.9")
SPAWN_LIVING_ENTITY("N/A", "WrapperPlayServerSpawnEntityLiving"),
SPAWN_ENTITY("https://minecraft.wiki/w/Java_Edition_protocol/Packets#Spawn_Entity", "WrapperPlayServerSpawnEntity"), //Note does not fire for self player
ENTITY_ANIMATION("https://minecraft.wiki/w/Java_Edition_protocol/Packets#Entity_Animation", "WrapperPlayServerEntityAnimation"),
ENTITY_EVENT("https://minecraft.wiki/w/Java_Edition_protocol/Packets#Entity_Event", "WrapperPlayServerEntityStatus"),
HURT_ANIMATION("https://minecraft.wiki/w/Java_Edition_protocol/Packets#Hurt_Animation", "WrapperPlayServerHurtAnimation"),
UPDATE_ATTRIBUTES("https://minecraft.wiki/w/Java_Edition_protocol/Packets#Update_Attributes", "WrapperPlayServerUpdateAttributes"),
LEASH_ENTITY("https://minecraft.wiki/w/Java_Edition_protocol/Packets#Link_Entities", "WrapperPlayServerAttachEntity"), //Note in 1.8 and below this was also used for setting passengers
ENTITY_EQUIPMENT("https://minecraft.wiki/w/Java_Edition_protocol/Packets#Set_Equipment", "WrapperPlayServerEntityEquipment"),
;
Packets(String wikiURL, String PEName) {
}
}
Packets value();
@Documented
@Retention(RetentionPolicy.SOURCE)
@interface Since {
String value();
}
@Documented
@Retention(RetentionPolicy.SOURCE)
@interface Until {
String value();
}
}
@@ -0,0 +1,19 @@
package games.cubi.raycastedantiesp.core.utils;
public class ThreadGuard {
public static final boolean ASSERTIONS_ENABLED = areAssertionsEnabled();
@SuppressWarnings("PointlessBooleanExpression")
/**
* @return true if assertions are enabled, false otherwise
*/
private static boolean areAssertionsEnabled() {
try {
assert true == false; // can be simplified to assert false but this reads more clearly to me as a statement which will fail.
return false;
} catch (AssertionError e) {
return true;
}
}
}
@@ -0,0 +1,196 @@
package games.cubi.raycastedantiesp.core.view;
import games.cubi.locatables.BlockLocatable;
import games.cubi.locatables.ChunkSectionLocatable;
import games.cubi.locatables.Locatable;
import games.cubi.locatables.implementations.ImmutableBlockLocatable;
import games.cubi.logs.Logger;
import games.cubi.raycastedantiesp.core.locatables.TileEntityLocatable;
import games.cubi.raycastedantiesp.core.utils.CanonicalSet;
import games.cubi.raycastedantiesp.core.utils.ConcurrentSelfMap;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedQueue;
public abstract class AbstractBlockView<T extends TileEntityLocatable<?>> implements BlockView {
public static final int CHUNK_SIZE = 16;
public static final int LOCAL_MASK = CHUNK_SIZE - 1;
private final Map<ChunkSectionLocatable, BitSet /*true if that position is occluding. Positions are 0-15 for x,y,z*/> chunks = new ConcurrentHashMap<>();
private final CanonicalSet<Locatable, T> knownTileEntities = new ConcurrentSelfMap<>();
private final ConcurrentLinkedQueue<BlockViewTransition> transitions = new ConcurrentLinkedQueue<>();
@Deprecated
protected abstract T createTrackedTileEntity(BlockLocatable location, int blockID, boolean visible);
protected abstract T createTrackedTileEntity(UUID world, int x, int y, int z, int blockID);
public boolean isBlockOccluding(UUID world, int x, int y, int z) {
final BitSet chunk = getChunk(world, x >> 4, y >> 4, z >> 4);
if (chunk == null) {
// chunks may be empty if there are no occluding blocks in that chunk
return false;
}
return chunk.get(maskAndPack(x, y, z));
}
@Override
public boolean isBlockOccluding(BlockLocatable location) {
return location != null
&& location.world() != null
&& isBlockOccluding(location.world(), location.blockX(), location.blockY(), location.blockZ());
}
public int loadedChunkCount() {
return chunks.size();
}
@Override
public void updateOrInsertTileEntity(BlockLocatable location, int blockID, boolean visibleIfNew) {
T tileEntity = knownTileEntities.computeIfAbsent(location, ignored -> createTrackedTileEntity(location, blockID, visibleIfNew));
if (tileEntity == null) {
Logger.error("Tile entity null when attempting to update or insert", 3, AbstractBlockView.class);
return;
}
tileEntity.setBlockID(blockID);
}
@Override
public void removeTileEntity(BlockLocatable location) {
T tileEntity = knownTileEntities.remove(location);
if (tileEntity != null) {
tileEntity.clear();
}
}
@Override
public T getTrackedTileEntity(BlockLocatable location) {
return knownTileEntities.get(location);
}
@Override
public T getTrackedTileEntity(ImmutableBlockLocatable location) {
return knownTileEntities.get(location);
}
@Override
public boolean isVisible(BlockLocatable location, int currentTick) {
T state = knownTileEntities.get(location);
return state == null || state.visible();
}
@Override
public void setVisibility(BlockLocatable location, boolean visible, int currentTick) {
T existing = knownTileEntities.get(location);
if (existing == null) {
return;
}
if (existing.visible() != visible) {
transitions.add(new BlockViewTransition(
visible ? BlockViewTransition.Type.SHOW : BlockViewTransition.Type.HIDE,
location
));
}
existing.setVisible(visible);
existing.setLastChecked(currentTick);
}
@Override
public Collection<BlockLocatable> getKnownTileEntities() {
return List.copyOf(knownTileEntities.keySet());
}
@Override
public Collection<BlockLocatable> getNeedingRecheck(int recheckTicks, int currentTick) {
List<BlockLocatable> needingRecheck = new ArrayList<>();
for (T tileEntity : knownTileEntities.values()) {
if (tileEntity.visible() && currentTick - tileEntity.lastChecked() < recheckTicks) {
continue;
}
needingRecheck.add(tileEntity);
}
return needingRecheck;
}
@Override
public boolean hasPendingTransitions() {
return !transitions.isEmpty();
}
@Override
public List<BlockViewTransition> drainTransitions() {
List<BlockViewTransition> drained = new ArrayList<>();
BlockViewTransition transition;
while ((transition = transitions.poll()) != null) {
drained.add(transition);
}
return drained;
}
@Override
public void upsertBlock(UUID world, int x, int y, int z, boolean occluding) {
final BitSet chunk = getOrCreateChunk(world, x >> 4, y >> 4, z >> 4);
chunk.set(maskAndPack(x, y, z), occluding);
}
@Override
public void removeChunk(UUID world, int chunkX, int chunkZ) {
chunks.entrySet().removeIf(entry ->
entry.getKey().world().equals(world)
&& entry.getKey().chunkX() == chunkX
&& entry.getKey().chunkZ() == chunkZ
);
}
@Override
public void removeChunkSection(UUID world, int chunkX, int chunkY, int chunkZ) {
chunks.remove(new ChunkSectionLocatable.ImmutableChunkSectionLocatable(world, chunkX, chunkY, chunkZ));
}
@Override
public void replaceChunkSection(UUID world, int chunkX, int chunkY, int chunkZ, BitSet occludingBlocks) {
chunks.put(new ChunkSectionLocatable.ImmutableChunkSectionLocatable(world, chunkX, chunkY, chunkZ), occludingBlocks
);
}
@Override
public void clear() {
chunks.clear();
knownTileEntities.clear();
transitions.clear();
}
public static int maskAndPack(int x, int y, int z) {
return pack(x & LOCAL_MASK, y & LOCAL_MASK, z & LOCAL_MASK);
}
public static int pack(int x, int y, int z) {
return (x & LOCAL_MASK) | ((y & LOCAL_MASK) << 4) | ((z & LOCAL_MASK) << 8);
}
public static int unpackX(int packed) {
return packed & LOCAL_MASK;
}
public static int unpackY(int packed) {
return (packed >> 4) & LOCAL_MASK;
}
public static int unpackZ(int packed) {
return (packed >> 8) & LOCAL_MASK;
}
private BitSet getChunk(UUID world, int chunkX, int chunkY, int chunkZ) {
return chunks.get(new ChunkSectionLocatable.ImmutableChunkSectionLocatable(world, chunkX, chunkY, chunkZ));
}
private BitSet getOrCreateChunk(UUID world, int chunkX, int chunkY, int chunkZ) {
return chunks.computeIfAbsent(
new ChunkSectionLocatable.ImmutableChunkSectionLocatable(world, chunkX, chunkY, chunkZ),
ignored -> new BitSet(CHUNK_SIZE*CHUNK_SIZE*CHUNK_SIZE)
);
}
}
@@ -0,0 +1,54 @@
package games.cubi.raycastedantiesp.core.view;
import games.cubi.locatables.BlockLocatable;
import games.cubi.locatables.implementations.ImmutableBlockLocatable;
import games.cubi.raycastedantiesp.core.locatables.TileEntityLocatable;
import games.cubi.raycastedantiesp.core.utils.Clearable;
import java.util.BitSet;
import java.util.Collection;
import java.util.List;
import java.util.UUID;
public interface BlockView extends Clearable {
boolean isBlockOccluding(BlockLocatable location);
/**
* Constructs a new tile entity with the provided id and visibility, or updates the block id for existing tile entities.
*/
void updateOrInsertTileEntity(BlockLocatable location, int blockID, boolean visibleIfNew);
void removeTileEntity(BlockLocatable location);
TileEntityLocatable<?> getTrackedTileEntity(BlockLocatable location);
TileEntityLocatable<?> getTrackedTileEntity(ImmutableBlockLocatable location);
boolean isVisible(BlockLocatable location, int currentTick);
void setVisibility(BlockLocatable location, boolean visible, int currentTick);
Collection<BlockLocatable> getKnownTileEntities();
Collection<BlockLocatable> getNeedingRecheck(int recheckTicks, int currentTick);
boolean hasPendingTransitions();
List<BlockViewTransition> drainTransitions();
void upsertBlock(UUID world, int x, int y, int z, boolean occluding);
void removeChunk(UUID world, int chunkX, int chunkZ);
void removeChunkSection(UUID world, int chunkX, int chunkY, int chunkZ);
void replaceChunkSection(UUID world, int chunkX, int chunkY, int chunkZ, BitSet occludingBlocks);
default <T> T cast() {
return (T) this;
}
interface Factory {
BlockView createBlockView();
}
}
@@ -0,0 +1,11 @@
package games.cubi.raycastedantiesp.core.view;
import games.cubi.locatables.BlockLocatable;
// Used to cache visibility changes until the player's netty thread next processes them.
public record BlockViewTransition(Type type, BlockLocatable location) {
public enum Type {
SHOW,
HIDE,
}
}
@@ -0,0 +1,58 @@
package games.cubi.raycastedantiesp.core.view;
import games.cubi.raycastedantiesp.core.locatables.EntityLocatable;
import games.cubi.locatables.Locatable;
import games.cubi.raycastedantiesp.core.utils.Clearable;
import java.util.Collection;
import java.util.List;
import java.util.UUID;
public interface EntityView<T extends EntityLocatable<?, ?>> extends Clearable {
void insertEntity(T entity);
void removeEntity(int entityID, int currentTick);
void removeEntity(UUID entityUUID, int currentTick);
T getEntity(UUID entityUUID);
T getEntity(int entityID);
Locatable getLocation(UUID entityUUID);
int getEntityID(UUID entityUUID);
boolean exists(UUID entityUUID);
boolean exists(int entityID);
@Deprecated
boolean isVisible(UUID entityUUID, int currentTick);
boolean isVisible(UUID entityUUID);
boolean isVisible(int entityID);
void setVisibility(UUID entityUUID, boolean visible, int currentTick);
Collection<UUID> getKnownEntities();
Collection<UUID> getNeedingRecheck(int recheckTicks, int currentTick);
boolean hasPendingTransitions();
List<EntityViewTransition> drainTransitions();
boolean isPlayerView();
default <T> T cast() {
return (T) this;
}
String getStringDataForDebugging();
interface Factory {
EntityView<?> createEntityView();
}
}
@@ -0,0 +1,12 @@
package games.cubi.raycastedantiesp.core.view;
import java.util.UUID;
// Used to cache visibility changes until the player's netty thread next processes
public record EntityViewTransition(Type type, UUID targetUUID, int entityID) {
public enum Type {
SHOW,
HIDE,
FORGET,
}
}
@@ -0,0 +1,38 @@
package games.cubi.raycastedantiesp.core.view;
import games.cubi.logs.Logger;
public final class ViewRegistry {
private static EntityView.Factory entityViewFactory;
private static EntityView.Factory playerEntityViewFactory;
private static BlockView.Factory blockViewFactory;
private ViewRegistry() {}
public static void initialise(BlockView.Factory blockViewFactory1, EntityView.Factory entityViewFactory1, EntityView.Factory playerEntityViewFactory1) {
blockViewFactory = blockViewFactory1;
entityViewFactory = entityViewFactory1;
playerEntityViewFactory = playerEntityViewFactory1;
}
public static BlockView createBlockView() {
if (blockViewFactory == null) {
Logger.error(new IllegalStateException("Block view factory is null. Did you forget to initialise ViewRegistry?"), 1, ViewRegistry.class);
}
return blockViewFactory.createBlockView();
}
public static EntityView<?> createEntityView() {
if (entityViewFactory == null) {
Logger.error(new IllegalStateException("Entity view factory is null. Did you forget to initialise ViewRegistry?"), 1, ViewRegistry.class);
}
return entityViewFactory.createEntityView();
}
public static EntityView<?> createPlayerEntityView() {
if (playerEntityViewFactory == null) {
Logger.error(new IllegalStateException("Player entity view factory is null. Did you forget to initialise ViewRegistry?"), 1, ViewRegistry.class);
}
return playerEntityViewFactory.createEntityView();
}
}
@@ -0,0 +1,39 @@
package games.cubi.raycastedantiesp.core.view.controller;
import games.cubi.logs.Logger;
import games.cubi.raycastedantiesp.core.locatables.NettyEntityLocatable;
import games.cubi.raycastedantiesp.core.players.PlayerData;
import games.cubi.raycastedantiesp.core.utils.BaseEntitySpawnTask;
final class LeashReconciliationTask extends BaseEntitySpawnTask {
private final PlayerData playerData;
private final int leashedEntityID;
private final int leashingEntityID;
LeashReconciliationTask(PlayerData playerData, int leashedEntityID, int leashingEntityID, int submittedTick) {
super(submittedTick);
this.playerData = playerData;
this.leashedEntityID = leashedEntityID;
this.leashingEntityID = leashingEntityID;
}
@Override
public void run() {
NettyEntityLocatable<?,?> leashed = playerData.entityFromID(leashedEntityID);
if (leashed == null) {
Logger.error("Reconciliation fail: Attempted to reconcile leash for unknown leashed entity, leashedEntityId=" + leashedEntityID, 3, this.getClass());
return;
}
PacketEntityViewController.get().handleLeashEntityNow(leashed, leashingEntityID, playerData);
}
@Override
public String toString() {
return "LeashReconciliationTask{" +
"submittedTick=" + submittedTick +
", leashedEntityId=" + leashedEntityID +
", leashingEntityId=" + leashingEntityID +
", playerUUID=" + playerData.getPlayerUUID() +
'}';
}
}
@@ -0,0 +1,428 @@
package games.cubi.raycastedantiesp.core.view.controller;
import games.cubi.logs.Logger;
import games.cubi.raycastedantiesp.core.config.raycast.EntityConfig;
import games.cubi.raycastedantiesp.core.config.raycast.PlayerConfig;
import games.cubi.raycastedantiesp.core.config.raycast.RaycastConfig;
import games.cubi.raycastedantiesp.core.locatables.NettyEntityLocatable;
import games.cubi.raycastedantiesp.core.players.PlayerData;
import games.cubi.raycastedantiesp.core.players.PlayerRegistry;
import games.cubi.raycastedantiesp.core.utils.IntArrayList;
import games.cubi.raycastedantiesp.core.utils.Packet;
import games.cubi.raycastedantiesp.core.view.EntityView;
import java.util.ArrayList;
import java.util.UUID;
import static games.cubi.raycastedantiesp.core.locatables.NettyEntityLocatable.NO_LEASHER;
import static games.cubi.raycastedantiesp.core.locatables.NettyEntityLocatable.NO_VEHICLE;
/**
* @param <P> The platform's packet wrapper (PacketWrapper<?>)
*/
public abstract class PacketEntityViewController<P> {
private static PacketEntityViewController<?> SELF; //TODO Switch to LazyConstant once out of preview (see https://openjdk.org/jeps/526)
{
synchronized (PacketEntityViewController.class) {
if (SELF != null) {
throw new IllegalStateException("Multiple instances of PacketEventsEntityViewController created.");
}
SELF = this;
}
}
protected static PacketEntityViewController<?> get() {
return SELF;
}
protected EntityConfig entityConfig = null;
protected PlayerConfig playerConfig = null;
protected double hideOnSpawnEntityDistanceSquared = 0;
protected double hideOnSpawnPlayerDistanceSquared = 0;
protected void handlePlayPhaseLoginPacket(int entityID, UUID playerUUID, int currentTick) {
PlayerData playerData = PlayerRegistry.getInstance().getPlayerData(playerUUID);
playerData.playerView().insertEntity(createSelfEntity(playerData, entityID, playerUUID).cast());
}
protected PlayerData handleLoginPhaseLoginPacket(UUID playerUUID, int currentTick) {
return PlayerRegistry.getInstance().registerAndGetPlayer(playerUUID, currentTick);
}
protected abstract NettyEntityLocatable<?,?> createSelfEntity(PlayerData ownData, int entityID, UUID playerUUID);
/**
* @return Whether or not to cancel the packet event. <code>true</code> to cancel, <code>false</code> to do nothing.
*/
@Packet(Packet.Packets.SPAWN_ENTITY)
protected boolean handleEntitySpawn(P packet, int entityID, boolean isPlayer, PlayerData playerData, UUID world, int currentTick) {
boolean returnValue = handleEntitySpawn0(packet, isPlayer, playerData, world, currentTick);
playerData.nettyData().runPendingPostSpawnTaskForEntity(entityID);
return returnValue;
}
protected boolean handleEntitySpawn0(P packet, boolean isPlayer, PlayerData playerData, UUID world, int currentTick) {
if (world == null) {
Logger.error(new RuntimeException("World null when handling spawn entity packet, uuid=" + playerData.getPlayerUUID() + " tick=" + currentTick), 2, PacketEntityViewController.class);
return false;
}
NettyEntityLocatable<?,?> entity = processEntitySpawn(playerData, packet, world, currentTick);
if ((!isPlayer && entityConfig.enabled()) || isPlayer && playerConfig.enabled()) {
double distanceSquared = playerData.ownLocation().distanceSquared(entity);
if (distanceSquared > (isPlayer ? hideOnSpawnPlayerDistanceSquared : hideOnSpawnEntityDistanceSquared)) {
entity.setVisible(false);
entity.setClientVisible(false);
if (isPlayer) {
insertEntityToPlayerView(entity, playerData);
return true;
}
insertEntityToEntityView(entity, playerData);
return true;
}
} else {
entity.setClientVisible(true);
}
if (isPlayer) {
insertEntityToPlayerView(entity, playerData);
return false;
}
insertEntityToEntityView(entity, playerData);
return false;
}
@Packet(Packet.Packets.ENTITY_ANIMATION)
protected boolean handleEntityAnimation(int entityID, PlayerData playerData) {
return cancelIfEnabledAndHidden(entityID, playerData);
}
@Packet(Packet.Packets.ENTITY_EVENT)
protected boolean handleEntityEvent(int entityID, PlayerData playerData) {
return cancelIfEnabledAndHidden(entityID, playerData);
}
@Packet(Packet.Packets.HURT_ANIMATION)
protected boolean handleHurtAnimation(int entityID, PlayerData playerData) {
return cancelIfEnabledAndHidden(entityID, playerData);
}
/**
* @return Whether or not to cancel the packet event. <code>true</code> to cancel, <code>false</code> to do nothing.
*/
protected boolean handleRelativeMove(P packet, PlayerData playerData, int currentTick) {
int entityID = processRelativeMovePacket(packet, playerData, currentTick);
return cancelIfEnabledAndHidden(entityID, playerData);
}
/**
* @return Whether or not to cancel the packet event. <code>true</code> to cancel, <code>false</code> to do nothing.
*/
protected boolean handleRelativeMoveAndRotation(P packet, PlayerData playerData, int currentTick) {
int entityID = processRelativeMoveAndRotationPacket(packet, playerData, currentTick);
return cancelIfEnabledAndHidden(entityID, playerData);
}
/**
* @return Whether or not to cancel the packet event. <code>true</code> to cancel, <code>false</code> to do nothing.
*/
protected boolean handleTeleport(P packet, PlayerData playerData, int currentTick) {
int entityID = processTeleportPacket(packet, playerData, currentTick);
return cancelIfEnabledAndHidden(entityID, playerData);
}
/**
* @return Whether or not to cancel the packet event. <code>true</code> to cancel, <code>false</code> to do nothing.
*/
protected boolean handlePositionSync(P packet, PlayerData playerData, int currentTick) {
int entityID = processPositionSyncPacket(packet, playerData, currentTick);
return cancelIfEnabledAndHidden(entityID, playerData);
}
/**
* @return Whether or not to cancel the packet event. <code>true</code> to cancel, <code>false</code> to do nothing.
*/
protected boolean handleEntityRotation(P packet, PlayerData playerData, int currentTick) {
int entityID = processRotationPacket(packet, playerData, currentTick);
return cancelIfEnabledAndHidden(entityID, playerData);
}
/**
* @return Whether or not to cancel the packet event. <code>true</code> to cancel, <code>false</code> to do nothing.
*/
protected boolean handleEntityHeadLook(P packet, PlayerData playerData, int currentTick) {
int entityID = processHeadLookPacket(packet, playerData, currentTick);
return cancelIfEnabledAndHidden(entityID, playerData);
}
/**
* @return Whether or not to cancel the packet event. <code>true</code> to cancel, <code>false</code> to do nothing.
*/
protected boolean handleEntityMetadata(P packet, int entityID, PlayerData playerData, int currentTick) {
cachePacket(packet, entityID, playerData, currentTick);
return cancelIfEnabledAndHidden(entityID, playerData);
}
/**
* @return Whether or not to cancel the packet event. <code>true</code> to cancel, <code>false</code> to do nothing.
*/
protected boolean handleRemoveEntityEffect(P packet, int entityID, PlayerData playerData, int currentTick) {
cachePacket(packet, entityID, playerData, currentTick);
return cancelIfEnabledAndHidden(entityID, playerData);
}
/**
* @return Whether or not to cancel the packet event. <code>true</code> to cancel, <code>false</code> to do nothing.
*/
@Packet(Packet.Packets.ENTITY_EQUIPMENT)
protected boolean handleEntityEquipment(P packet, int entityID, PlayerData playerData, int currentTick) {
cachePacket(packet, entityID, playerData, currentTick);
return cancelIfEnabledAndHidden(entityID, playerData);
}
/**
* @return Whether or not to cancel the packet event. <code>true</code> to cancel, <code>false</code> to do nothing.
*/
protected boolean handleEntityVelocity(P packet, int entityID, PlayerData playerData, int currentTick) {
processEntityVelocityPacket(packet, playerData, currentTick);
cachePacket(packet, entityID, playerData, currentTick); //todo: may be wrong?
return cancelIfEnabledAndHidden(entityID, playerData);
}
/**
* @return Whether or not to cancel the packet event. <code>true</code> to cancel, <code>false</code> to do nothing.
*/
protected boolean handleEntityEffect(P packet, int entityID, PlayerData playerData, int currentTick) {
cachePacket(packet, entityID, playerData, currentTick);
return cancelIfEnabledAndHidden(entityID, playerData);
}
/**
* @return Whether or not to cancel the packet event. <code>true</code> to cancel, <code>false</code> to do nothing.
*/
protected boolean handleEntityPassengers(int entityID, int[] passengers, PlayerData playerData, int currentTick) {
NettyEntityLocatable<?,?> entity = playerData.entityFromID(entityID);
if (entity == null) {
queuePassengerRetry(playerData, entityID, entityID, passengers, currentTick);
return false;
}
return handleEntityPassengersNow(entity, passengers, playerData, currentTick);
}
//This (and leash handling) leaks some info to the client, as it will receive the passenger packet even if the passengers are auto-hidden once parsed, but as the packet doesn't include any location or type info, this shouldn't be too incriminating.
boolean handleEntityPassengersNow(NettyEntityLocatable<?,?> entity, int[] passengers, PlayerData playerData, int currentTick) {
int entityID = entity.entityID();
entity.setPassengerIDs(passengers);
int blockingEntityID = NO_VEHICLE;
for (int passengerID : passengers) {
NettyEntityLocatable<?,?> passenger = playerData.entityFromID(passengerID);
if (passenger == null) {
if (blockingEntityID == NO_VEHICLE) {
blockingEntityID = passengerID;
}
continue;
}
passenger.setVehicleID(entityID);
}
if (blockingEntityID != NO_VEHICLE) {
queuePassengerRetry(playerData, blockingEntityID, entityID, passengers, currentTick);
}
checkVehicle(entity, playerData);
if (cancelIfEnabledAndHidden(entityID, playerData)) return true;
boolean passengersNotVisible = false;
ArrayList<Integer> visiblePassengers = new ArrayList<>(passengers.length);
for (int passengerID : passengers) {
if (cancelIfEnabledAndHidden(passengerID, playerData)) {
passengersNotVisible = true;
}
else {
visiblePassengers.add(passengerID);
}
}
if (passengersNotVisible) {
//some passengers are hidden but others aren't. Cancel this packet and send another silently with just the visible passengers.
sendEntityPassengerPacket(entityID, visiblePassengers, playerData);
}
return passengersNotVisible;
}
private void queuePassengerRetry(PlayerData playerData, int queueEntityID, int vehicleEntityID, int[] passengers, int submittedTick) {
playerData.nettyData().addPostEntitySpawnTask(queueEntityID, new PassengerReconciliationTask(playerData, queueEntityID, vehicleEntityID, passengers, submittedTick));
}
private void checkVehicle(NettyEntityLocatable<?,?> entity, PlayerData playerData) {
int vehicleID = entity.vehicleID();
if (vehicleID >= 0) {
NettyEntityLocatable<?,?> vehicle = playerData.entityFromID(vehicleID);
if (vehicle == null) {
Logger.error(new RuntimeException("Found null vehicle when handling entity passengers packet, vehicleID=" + vehicleID + " for player: " + playerData.getPlayerUUID()), 2, PacketEntityViewController.class);
return;
}
if (cancelIfEnabledAndHidden(vehicleID, playerData)) {
//Vehicle is hidden, so this entity should be hidden as well. No need to check passengers.
return;
}
//Vehicle is visible, but this entity may not be.
if (cancelIfEnabledAndHidden(entity.entityID(), playerData)) {
return;
}
ArrayList<Integer> passengers = new ArrayList<>();
passengers.add(entity.entityID());
sendEntityPassengerPacket(vehicleID, passengers, playerData);
}
}
protected void handleDestroyEntities(int[] entityIDs, PlayerData playerData, int currentTick) {
for (int entityID : entityIDs) {
clearPendingHolderReference(entityID, playerData);
playerData.nettyData().removeUnresolvedLeashedEntityFromAll(entityID);
playerData.nettyData().clearPendingPostSpawnTasksForEntity(entityID);
EntityView<?> entityView = playerData.viewFromEntityID(entityID);
if (entityView == null) {
Logger.error("Could not find view for entity when processing destroy packet, id=" + entityID, 2, PacketEntityViewController.class);
continue;
}
Logger.debug("Removing entity from view due to destroy packet, entityID=" + entityID + " player=" + playerData.getPlayerUUID() + " tick=" + currentTick);
entityView.removeEntity(entityID, currentTick);
}
}
private void clearPendingHolderReference(int holderEntityID, PlayerData playerData) {
int[] pendingLeashedEntityIDs = playerData.nettyData().consumeUnresolvedLeashes(holderEntityID);
if (IntArrayList.isEmpty(pendingLeashedEntityIDs)) {
return;
}
for (int leashedEntityID : pendingLeashedEntityIDs) {
NettyEntityLocatable<?,?> leashedEntity = playerData.entityFromID(leashedEntityID);
if (leashedEntity != null && leashedEntity.leashingEntity() == holderEntityID) {
leashedEntity.setLeashingEntity(NO_LEASHER);
}
}
}
/**
* @return Whether or not to cancel the packet event. <code>true</code> to cancel, <code>false</code> to do nothing.
*/
protected boolean handleAttributeUpdate(P packet, int entityID, PlayerData playerData, int currentTick) {
cachePacket(packet, entityID, playerData, currentTick);
return cancelIfEnabledAndHidden(entityID, playerData);
}
/**
* @return Whether or not to cancel the packet event. <code>true</code> to cancel, <code>false</code> to do nothing.
*/
@Packet(Packet.Packets.LEASH_ENTITY)
protected boolean handleLeashEntity(int leashedEntity, int leashingEntity, PlayerData playerData, int currentTick) {
NettyEntityLocatable<?,?> leashed = playerData.entityFromID(leashedEntity);
if (leashed == null) {
playerData.nettyData().addPostEntitySpawnTask(leashedEntity, new LeashReconciliationTask(playerData, leashedEntity, leashingEntity, currentTick));
return false;
}
return handleLeashEntityNow(leashed, leashingEntity, playerData);
}
boolean handleLeashEntityNow(NettyEntityLocatable<?,?> leashedEntity, int leashingEntity, PlayerData playerData) {
//Note, leashing entity ID will be -1 to unleash. From testing it sometimes seems to be 0?
removeExistingLeashReference(leashedEntity.entityID(), leashedEntity, playerData);
if (leashingEntity == -1 || leashingEntity == 0) {
if (leashedEntity.leashingEntity() == NO_LEASHER) {
Logger.warning("Entity was already unleashing when handling leash entity packet, leashedEntityID=" + leashedEntity + " for player: " + playerData.getPlayerUUID(), 4, PacketEntityViewController.class);
return false;
}
leashedEntity.setLeashingEntity(NO_LEASHER);
return cancelIfEnabledAndHidden(leashedEntity, playerData);
}
else {
leashedEntity.setLeashingEntity(leashingEntity);
NettyEntityLocatable<?,?> leashing = playerData.entityFromID(leashingEntity);
if (leashing == null) {
playerData.nettyData().addUnresolvedLeash(leashingEntity, leashedEntity.entityID());
return cancelIfEnabledAndHidden(leashedEntity, playerData);
}
else {
leashing.addLeashedEntity(leashedEntity.entityID());
return cancelIfEnabledAndHidden(leashedEntity, playerData) || cancelIfEnabledAndHidden(leashingEntity, playerData);
}
}
}
private void removeExistingLeashReference(int leashedEntityID, NettyEntityLocatable<?,?> leashed, PlayerData playerData) {
int previousLeashingEntityID = leashed.leashingEntity();
if (previousLeashingEntityID == NO_LEASHER) {
return;
}
if (playerData.nettyData().removeUnresolvedLeash(previousLeashingEntityID, leashedEntityID)) {
return;
}
NettyEntityLocatable<?,?> previouslyLeashing = playerData.entityFromID(previousLeashingEntityID);
if (previouslyLeashing == null) {
Logger.warning("Found null previously leashing entity when handling leash entity packet, previouslyLeashingEntityID=" + previousLeashingEntityID + " for player: " + playerData.getPlayerUUID(), 5, PacketEntityViewController.class);
return;
}
previouslyLeashing.removeLeashedEntity(leashedEntityID);
}
protected RaycastConfig getCorrectConfig(EntityView<?> entityView) {
if (entityView.isPlayerView()) {
return playerConfig;
} else {
return entityConfig;
}
}
/**
* @return True if the packet should be suppressed
*/
protected boolean cancelIfEnabledAndHidden(int entityID, PlayerData playerData) {
EntityView<?> entityView = playerData.viewFromEntityID(entityID);
if (entityView == null) {
Logger.warning("Checked if packet for entity should be cancelled, but entity did not exist. ID: " + entityID + " for player: " + playerData.getPlayerUUID(), 6, PacketEntityViewController.class);
return false;
}
if (entityView.isVisible(entityID)) {
return false;
}
return getCorrectConfig(entityView).enabled(); // If this statement is reached, the entity should be hidden, so if the config is enabled it is hidden.
}
/**
* @return True if the packet should be suppressed
*/
protected boolean cancelIfEnabledAndHidden(NettyEntityLocatable<?,?> entity, PlayerData playerData) {
if (entity.visible()) {
return false;
}
return getCorrectConfig(playerData.viewFromEntityID(entity.entityID())).enabled(); // If this statement is reached, the entity should be hidden, so if the config is enabled it is hidden.
}
/**
* @return The created entity, with a default visibility of <code>true</code>. Does not insert the entity into any views, that is the responsibility of the caller.
*/
protected abstract NettyEntityLocatable<?,?> processEntitySpawn(PlayerData playerData, P packet, UUID world, int currentTick);
/** @return The entity ID of the entity */
protected abstract int processRelativeMovePacket(P packet, PlayerData playerData, int currentTick);
/** @return The entity ID of the entity */
protected abstract int processRelativeMoveAndRotationPacket(P packet, PlayerData playerData, int currentTick);
/** @return The entity ID of the entity */
protected abstract int processTeleportPacket(P packet, PlayerData playerData, int currentTick);
/** @return The entity ID of the entity */
protected abstract int processPositionSyncPacket(P packet, PlayerData playerData, int currentTick);
protected abstract void cachePacket(P packet, int entityID, PlayerData playerData, int currentTick);
/** @return The entity ID of the entity */
protected abstract int processRotationPacket(P packet, PlayerData playerData, int currentTick);
/** @return The entity ID of the entity */
protected abstract int processHeadLookPacket(P packet, PlayerData playerData, int currentTick);
/** @return The entity ID of the entity */
protected abstract int processEntityVelocityPacket(P packet, PlayerData playerData, int currentTick);
/**Silently sends the provided array of entities as passengers for the required vehicle.*/
protected abstract void sendEntityPassengerPacket(int vehicle, ArrayList<Integer> passengers, PlayerData playerData);
protected abstract void insertEntityToPlayerView(NettyEntityLocatable<?,?> entity, PlayerData playerData);
protected abstract void insertEntityToEntityView(NettyEntityLocatable<?,?> entity, PlayerData playerData);
}
@@ -0,0 +1,44 @@
package games.cubi.raycastedantiesp.core.view.controller;
import games.cubi.logs.Logger;
import games.cubi.raycastedantiesp.core.locatables.NettyEntityLocatable;
import games.cubi.raycastedantiesp.core.players.PlayerData;
import games.cubi.raycastedantiesp.core.utils.BaseEntitySpawnTask;
import java.util.Arrays;
final class PassengerReconciliationTask extends BaseEntitySpawnTask {
private final PlayerData playerData;
private final int queuedEntityId;
private final int vehicleEntityId;
private final int[] passengerIds;
PassengerReconciliationTask(PlayerData playerData, int queuedEntityId, int vehicleEntityId, int[] passengerIds, int submittedTick) {
super(submittedTick);
this.playerData = playerData;
this.queuedEntityId = queuedEntityId;
this.vehicleEntityId = vehicleEntityId;
this.passengerIds = passengerIds.clone();
}
@Override
public void run() {
NettyEntityLocatable<?,?> vehicle = playerData.entityFromID(vehicleEntityId);
if (vehicle == null) {
Logger.error("Reconciliation fail: Attempted to reconcile passengers for unknown vehicle, queuedEntityId=" + queuedEntityId + " vehicleEntityId=" + vehicleEntityId, 3, this.getClass());
return;
}
PacketEntityViewController.get().handleEntityPassengersNow(vehicle, passengerIds, playerData, submittedTick);
}
@Override
public String toString() {
return "PassengerReconciliationTask{" +
"submittedTick=" + submittedTick +
", queuedEntityId=" + queuedEntityId +
", vehicleEntityId=" + vehicleEntityId +
", passengerIds=" + Arrays.toString(passengerIds) +
", playerUUID=" + playerData.getPlayerUUID() +
'}';
}
}
@@ -0,0 +1,4 @@
short-git: ${short_git}
long-git: ${long_git}
build-time: ${build_time}
version: ${version}
+4
View File
@@ -0,0 +1,4 @@
group=games.cubi
org.gradle.configuration-cache=true
org.gradle.parallel=true
org.gradle.caching=true
Binary file not shown.
+1 -1
View File
@@ -1,6 +1,6 @@
distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
distributionUrl=https\://services.gradle.org/distributions/gradle-8.8-bin.zip
distributionUrl=https\://services.gradle.org/distributions/gradle-9.0-bin.zip
networkTimeout=10000
validateDistributionUrl=true
zipStoreBase=GRADLE_USER_HOME
Vendored Regular → Executable
+6 -7
View File
@@ -1,7 +1,7 @@
#!/bin/sh
#
# Copyright © 2015-2021 the original authors.
# Copyright © 2015 the original authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
@@ -15,6 +15,8 @@
# See the License for the specific language governing permissions and
# limitations under the License.
#
# SPDX-License-Identifier: Apache-2.0
#
##############################################################################
#
@@ -84,7 +86,7 @@ done
# shellcheck disable=SC2034
APP_BASE_NAME=${0##*/}
# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
APP_HOME=$( cd "${APP_HOME:-./}" > /dev/null && pwd -P ) || exit
APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit
# Use the maximum available, or set MAX_FD != -1 to use that value.
MAX_FD=maximum
@@ -112,7 +114,6 @@ case "$( uname )" in #(
NONSTOP* ) nonstop=true ;;
esac
CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
# Determine the Java command to use to start the JVM.
@@ -170,7 +171,6 @@ fi
# For Cygwin or MSYS, switch paths to Windows format before running java
if "$cygwin" || "$msys" ; then
APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
JAVACMD=$( cygpath --unix "$JAVACMD" )
@@ -203,15 +203,14 @@ fi
DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
# Collect all arguments for the java command:
# * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
# * DEFAULT_JVM_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
# and any embedded shellness will be escaped.
# * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
# treated as '${Hostname}' itself on the command line.
set -- \
"-Dorg.gradle.appname=$APP_BASE_NAME" \
-classpath "$CLASSPATH" \
org.gradle.wrapper.GradleWrapperMain \
-jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \
"$@"
# Stop when "xargs" is not available.
Vendored
+3 -2
View File
@@ -13,6 +13,8 @@
@rem See the License for the specific language governing permissions and
@rem limitations under the License.
@rem
@rem SPDX-License-Identifier: Apache-2.0
@rem
@if "%DEBUG%"=="" @echo off
@rem ##########################################################################
@@ -68,11 +70,10 @@ goto fail
:execute
@rem Setup the command line
set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
@rem Execute Gradle
"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %*
:end
@rem End local scope for the variables with windows NT shell
+43
View File
@@ -0,0 +1,43 @@
import java.time.Instant
plugins {
id("java")
}
group = "games.cubi.locatables"
version = "0.1.0"
val commitShort = providers.exec {
commandLine("git", "rev-parse", "--short=8", "HEAD")
}.standardOutput.asText.map { it.trim() }
val commitFull = providers.exec {
commandLine("git", "rev-parse", "HEAD")
}.standardOutput.asText.map { it.trim() }
val buildTime = providers.provider {
Instant.now().toString()
}
tasks {
processResources {
val gitProps = mapOf(
"short_git" to commitShort.get(),
"long_git" to commitFull.get(),
"build_time" to buildTime.get(),
"version" to version.toString()
)
// build-properties is not used by the locatables library itself, but is included in the jar so that platforms can access it.
filesMatching("build-properties/locatable-lib.yml") {
expand(gitProps)
}
}
}
repositories {
mavenCentral()
}
dependencies {
compileOnly(project(":logging"))
}
@@ -0,0 +1,49 @@
package games.cubi.locatables;
import games.cubi.locatables.implementations.MutableLocatableImpl;
public non-sealed interface BlockLocatable extends Locatable {
default MutableLocatable clonePlainAndCentreIfBlockLocation() {
return new MutableLocatableImpl(world(), blockX() + 0.5, blockY() + 0.5, blockZ() + 0.5);
}
default boolean isEqual(Object o) {
if (this == o) return true;
if (!(o instanceof BlockLocatable other)) return false;
return this.blockX() == other.blockX() && this.blockY() == other.blockY() && this.blockZ() == other.blockZ() && world().equals(other.world());
}
default int blockHash() {
int result = 17;
result = 31 * result + (this.world() != null ? this.world().hashCode() : 0);
result = 31 * result + this.blockX();
result = 31 * result + this.blockY();
result = 31 * result + this.blockZ();
return result;
}
@Override
default double x() {
return blockX();
}
@Override
default double y() {
return blockY();
}
@Override
default double z() {
return blockZ();
}
@Override
int blockX();
@Override
int blockY();
@Override
int blockZ();
}
@@ -0,0 +1,15 @@
package games.cubi.locatables;
import java.util.UUID;
public sealed interface ChunkLocatable permits ChunkLocatable.ImmutableChunkLocatable, ChunkSectionLocatable {
UUID world();
int chunkX();
int chunkZ();
record ImmutableChunkLocatable(UUID world, int chunkX, int chunkZ) implements ChunkLocatable {
public ImmutableChunkLocatable(Locatable locatable) {
this(locatable.world(), locatable.chunkX(), locatable.chunkZ());
}
}
}
@@ -0,0 +1,13 @@
package games.cubi.locatables;
import java.util.UUID;
public sealed interface ChunkSectionLocatable extends ChunkLocatable permits ChunkSectionLocatable.ImmutableChunkSectionLocatable, Locatable {
int chunkY();
record ImmutableChunkSectionLocatable(UUID world, int chunkX, int chunkY, int chunkZ) implements ChunkSectionLocatable {
public ImmutableChunkSectionLocatable(Locatable locatable) {
this(locatable.world(), locatable.chunkX(), locatable.chunkY(), locatable.chunkZ());
}
}
}
@@ -0,0 +1,11 @@
package games.cubi.locatables;
public non-sealed interface ImmutableLocatable extends Locatable {
default boolean isMutable() {
return false;
}
default MutableLocatable castToMutableOrNull() {
return null;
}
}
@@ -0,0 +1,203 @@
package games.cubi.locatables;
import games.cubi.locatables.implementations.*;
import java.util.UUID;
// A vector-like interface representing a location in a 3D space within a specific world.
public sealed interface Locatable extends ChunkSectionLocatable, StrictEquality permits MutableLocatable, ImmutableLocatable, BlockLocatable {
double x();
double y();
double z();
UUID world();
default int blockX() {
return (int) Math.floor(x());
}
default int blockY() {
return (int) Math.floor(y());
}
default int blockZ() {
return (int) Math.floor(z());
}
@Override
default int chunkX() {
return blockX() >> 4;
}
@Override
default int chunkZ() {
return blockZ() >> 4;
}
@Override
default int chunkY() {
return blockY() >> 4;
}
default double length() {
return Math.sqrt(lengthSquared());
}
default double lengthSquared() {
return x() * x() + y() * y() + z() * z();
}
default double distance(Locatable locatable) {
return Math.sqrt(distanceSquared(locatable));
}
default double distanceSquared(Locatable locatable) {
double dx = x() - locatable.x();
double dy = y() - locatable.y();
double dz = z() - locatable.z();
return dx * dx + dy * dy + dz * dz;
}
default double distanceSquared(double x, double y, double z) {
double dx = this.x() - x;
double dy = this.y() - y;
double dz = this.z() - z;
return dx * dx + dy * dy + dz * dz;
}
default MutableLocatable clonePlainAndCentreIfBlockLocation() {
return new MutableLocatableImpl(world(), x(), y(), z());
}
/**@return An array of the 3 coordinates, in the order [x,y,z]. This is used for atomic updates of all 3 coordinates.*/
default double[] getAtomicPositionArray() {
synchronized (this) {
return new double[]{x(), y(), z()};
}
}
LocatableType getType();
boolean isMutable();
MutableLocatable castToMutableOrNull(); // There shouldn't be a need for an equivalent of this method for immutable locatables as all of their methods are common to all Locatables
default boolean isEqualTo(Object thatOne) {
if (this == thatOne) return true;
if (!(thatOne instanceof Locatable that)) return false;
if (!(this.world().equals(that.world()))) return false;
if (Double.doubleToLongBits(this.x()) != Double.doubleToLongBits(that.x())) {
return false;
}
if (Double.doubleToLongBits(this.y()) != Double.doubleToLongBits(that.y())) {
return false;
}
if (Double.doubleToLongBits(this.z()) != Double.doubleToLongBits(that.z())) {
return false;
}
return true;
}
default int makeHash() {
int hash = 3;
hash = 19 * hash + this.world().hashCode();
hash = 19 * hash + Long.hashCode(Double.doubleToLongBits(x()));
hash = 19 * hash + Long.hashCode(Double.doubleToLongBits(y()));
hash = 19 * hash + Long.hashCode(Double.doubleToLongBits(z()));
return hash;
}
default String toStringForm() {
return getType()+
"{" +
"world=" + world() +
", x=" + x() +
", y=" + y() +
", z=" + z() +
'}';
}
enum LocatableType {
ThreadSafe,
NettyEntity,
NettyTileEntity,
MutableBlockVector,
ImmutableBlockLocation,
Immutable,
Mutable,
// implementations from other modules/projects should use the following
ExternalMutable,
ExternalImmutable,
ExternalMutableBlock,
ExternalImmutableBlock,
}
static Locatable convertLocatable(Locatable from, LocatableType to, boolean clone) {
switch (to) {
case ThreadSafe -> {
if ((from instanceof ThreadSafeLocatable) && !clone) return from;
return new ThreadSafeLocatable(from.world(), from.x(), from.y(), from.z());
}
case MutableBlockVector -> {
if ((from instanceof MutableBlockVector) && !clone) return from;
return new MutableBlockVector(from.world(), from.x(), from.y(), from.z());
}
case ImmutableBlockLocation -> {
if ((from instanceof ImmutableBlockLocatable) && !clone) return from;
return new ImmutableBlockLocatable(from.world(), from.x(), from.y(), from.z());
}
case Mutable -> {
if ((from instanceof MutableLocatableImpl) && !clone) return from;
return new MutableLocatableImpl(from.world(), from.x(), from.y(), from.z());
}
default -> {
return new MutableLocatableImpl(from.world(), from.x(), from.y(), from.z());
}
}
}
static Locatable copyOf(Locatable locatable) {
return convertLocatable(locatable, locatable.getType(), true);
}
static Locatable create(UUID world, double x, double y, double z, LocatableType type) {
switch (type) {
case ThreadSafe -> {
return new ThreadSafeLocatable(world, x, y, z);
}
case MutableBlockVector, ExternalMutableBlock -> {
return new MutableBlockVector(world, x, y, z);
}
case Mutable, ExternalMutable -> {
return new MutableLocatableImpl(world, x, y, z);
}
case ImmutableBlockLocation, ExternalImmutableBlock -> {
return new ImmutableBlockLocatable(world, x, y, z);
}
case Immutable, ExternalImmutable -> {
return new ImmutableLocatableImpl(world, x, y, z);
}
}
return null;
}
static <T extends Locatable> T create(UUID world, double x, double y, double z, Class<T> type) {
if (type == ThreadSafeLocatable.class) {
return (T) new ThreadSafeLocatable(world, x, y, z);
} else if (type == MutableBlockVector.class) {
return (T) new MutableBlockVector(world, x, y, z);
} else if (type == ImmutableBlockLocatable.class) {
return (T) new ImmutableBlockLocatable(world, x, y, z);
} else if (type == MutableLocatableImpl.class) {
return (T) new MutableLocatableImpl(world, x, y, z);
} else if (type == ImmutableLocatableImpl.class) {
return (T) new ImmutableLocatableImpl(world, x, y, z);
} else {
throw new IllegalArgumentException("Unsupported Locatable type: " + type.getName());
}
}
static Locatable create(UUID world, double x, double y, double z) {
return create(world, x, y, z, LocatableType.Mutable);
}
}
@@ -0,0 +1,85 @@
package games.cubi.locatables;
import java.util.UUID;
public non-sealed interface MutableLocatable extends Locatable {
MutableLocatable setX(double x);
MutableLocatable setY(double y);
MutableLocatable setZ(double z);
MutableLocatable setWorld(UUID world);
/**@return The same Locatable, with the same direction but a length of 1.*/
default MutableLocatable normalize() {
double length = length();
return scalarMultiply(1.0 / length);
}
/**@return The same Locatable, now mutated.*/
default MutableLocatable add(Locatable locatable) {
setX(x() + locatable.x());
setY(y() + locatable.y());
setZ(z() + locatable.z());
return this;
}
default MutableLocatable add(double x, double y, double z) {
setX(x() + x);
setY(y() + y);
setZ(z() + z);
return this;
}
/**@return The same Locatable, now mutated.*/
default MutableLocatable subtract(Locatable locatable) {
setX(x() - locatable.x());
setY(y() - locatable.y());
setZ(z() - locatable.z());
return this;
}
/**
* @param locatable The locatable to copy the position and world from.
* @return The same Locatable, now mutated to have the same position and world as the given locatable.
*/
default MutableLocatable set(Locatable locatable) {
setX(locatable.x());
setY(locatable.y());
setZ(locatable.z());
setWorld(locatable.world());
return this;
}
default MutableLocatable set(double x, double y, double z) {
setX(x);
setY(y);
setZ(z);
return this;
}
/**
* @return The same Locatable, now mutated to have the same position and world as the given values.
*/
default MutableLocatable set(double x, double y, double z, UUID world) {
setWorld(world);
setX(x);
setY(y);
setZ(z);
return this;
}
/**@return The same Locatable, now mutated.*/
default MutableLocatable scalarMultiply(double factor) {
setX(x() * factor);
setY(y() * factor);
setZ(z() * factor);
return this;
}
default boolean isMutable() {
return true;
}
default MutableLocatable castToMutableOrNull() {
return this;
}
}
@@ -0,0 +1,15 @@
package games.cubi.locatables;
public interface StrictEquality {
/**
* For use with classes of interfaces such as {@link games.cubi.locatables.Locatable}, where the interface contract specifies that all implementations must use interface-defined <code>equals</code> and <code>hashcode</code> methods for interchangeability in data structures. In this case, the default {@link Object#equals(Object)} method is no longer able to confirm genuine equality, as it only checks for interface field equality.
* <p>
* This method should check for more typical equality, meaning that all fields of the object are equal, and the classes of the two objects are the same. This is useful for debugging and testing, as it allows us to confirm that two objects are genuinely equal, rather than just being interchangeable in data structures.
* @param other The other object to compare to.
* @return <code>True</code> if the two objects are
* <p>- references to the same object, or
* <p>- different objects of the same class with equal fields.
* <p><code>False</code> otherwise.
*/
boolean strictlyEquals(Object other);
}
@@ -0,0 +1,40 @@
package games.cubi.locatables.implementations;
import games.cubi.locatables.ImmutableLocatable;
import games.cubi.locatables.BlockLocatable;
import java.util.UUID;
public record ImmutableBlockLocatable(UUID world, int blockX, int blockY, int blockZ) implements BlockLocatable, ImmutableLocatable {
public ImmutableBlockLocatable(UUID world, double x, double y, double z) {
this(world, (int) Math.floor(x), (int) Math.floor(y), (int) Math.floor(z));
}
@Override
public LocatableType getType() {
return LocatableType.ImmutableBlockLocation;
}
@Override
public boolean equals(Object o) {
return isEqual(o);
}
@Override
public int hashCode() {
return blockHash();
}
@Override
public String toString() {
return toStringForm();
}
@Override
public boolean strictlyEquals(Object other) {
if (this == other) return true;
if (!(other instanceof ImmutableBlockLocatable(UUID world1, int x, int y, int z))) return false;
return blockX == x && blockY == y && blockZ == z && world.equals(world1);
}
}
@@ -0,0 +1,38 @@
package games.cubi.locatables.implementations;
import games.cubi.locatables.ImmutableLocatable;
import java.util.UUID;
public record ImmutableLocatableImpl(UUID world, double x, double y, double z) implements ImmutableLocatable {
@Override
public LocatableType getType() {
return LocatableType.Immutable;
}
@Override
public boolean equals(Object o) {
return isEqualTo(o);
}
@Override
public int hashCode() {
return makeHash();
}
@Override
public String toString() {
return toStringForm();
}
@Override
public boolean strictlyEquals(Object other) {
if (this == other) return true;
if (!(other instanceof ImmutableLocatableImpl(UUID world1, double x1, double y1, double z1))) return false;
return this.world.equals(world1) &&
Double.doubleToLongBits(this.x) == Double.doubleToLongBits(x1) &&
Double.doubleToLongBits(this.y) == Double.doubleToLongBits(y1) &&
Double.doubleToLongBits(this.z) == Double.doubleToLongBits(z1);
}
}
@@ -0,0 +1,172 @@
package games.cubi.locatables.implementations;
import games.cubi.locatables.Locatable;
import games.cubi.locatables.MutableLocatable;
import games.cubi.locatables.BlockLocatable;
import java.util.UUID;
/**
* A mutable locatable representing a floating-point vector in a given world, akin to a MutableLocatableImpl. However, Object#equals and Object#hashCode are implemented as per BlockLocatable, meaning that they are equal if their blockX, blockY, blockZ and world are equal.
* <p>
* This allows them to be used as keys in hashmaps where they will be considered equal to AbstractBlockLocations with the same block coordinates and world, but they can also be mutated and have vector-like operations performed on them.
* <p>
* The object is named "Vector" to reflect the fact that it supports floating-point coordinates under the hood.
*/
public class MutableBlockVector implements BlockLocatable, MutableLocatable {
private UUID world;
private double mutableX;
private double mutableY;
private double mutableZ;
public MutableBlockVector(UUID world, double x, double y, double z) {
this.world = world;
this.mutableX = x;
this.mutableY = y;
this.mutableZ = z;
}
public MutableBlockVector(UUID world, int x, int y, int z) {
this.world = world;
this.mutableX = x;
this.mutableY = y;
this.mutableZ = z;
}
@Override
public LocatableType getType() {
return LocatableType.MutableBlockVector;
}
@Override
public double length() {
return Math.sqrt(lengthSquared());
}
@Override
public double lengthSquared() {
return mutableX*mutableX + mutableY*mutableY + mutableZ*mutableZ;
}
@Override
public MutableLocatable add(Locatable locatable) {
this.mutableX += locatable.x();
this.mutableY += locatable.y();
this.mutableZ += locatable.z();
return this;
}
@Override
public MutableLocatable subtract(Locatable locatable) {
this.mutableX -= locatable.x();
this.mutableY -= locatable.y();
this.mutableZ -= locatable.z();
return this;
}
@Override
public MutableLocatable scalarMultiply(double factor) {
this.mutableX *= factor;
this.mutableY *= factor;
this.mutableZ *= factor;
return this;
}
@Override
public UUID world() {
return world;
}
@Override
public int blockX() {
return (int) Math.floor(mutableX);
}
@Override
public int blockY() {
return (int) Math.floor(mutableY);
}
@Override
public int blockZ() {
return (int) Math.floor(mutableZ);
}
@Override
public double x() {
return mutableX;
}
@Override
public double y() {
return mutableY;
}
@Override
public double z() {
return mutableZ;
}
public void add(int dx, int dy, int dz) {
this.mutableX += dx;
this.mutableY += dy;
this.mutableZ += dz;
}
@Override
public MutableLocatable setX(double x) {
this.mutableX = x;
return this;
}
@Override
public MutableLocatable setY(double y) {
this.mutableY = y;
return this;
}
@Override
public MutableLocatable setZ(double z) {
this.mutableZ = z;
return this;
}
@Override
public MutableLocatable setWorld(UUID world) {
this.world = world;
return this;
}
/**
* This checks equality with AbstractBlockLocations, not Locatables. Use Locatable#isEqualTo for that. Thus, hashmap lookups are compatible with only AbstractBlockLocations, not Locatables.
*/
@Override
public boolean equals(Object o) {
return isEqual(o);
}
@Override
public int hashCode() {
return blockHash();
}
@Override
public String toString() {
return toStringForm();
}
@Override
public boolean strictlyEquals(Object other) {
if (this == other) return true;
if (!(other instanceof MutableBlockVector that)) return false;
if (!(this.world().equals(that.world()))) return false;
if (Double.doubleToLongBits(this.x()) != Double.doubleToLongBits(that.x())) {
return false;
}
if (Double.doubleToLongBits(this.y()) != Double.doubleToLongBits(that.y())) {
return false;
}
return Double.doubleToLongBits(this.z()) == Double.doubleToLongBits(that.z());
}
}
@@ -0,0 +1,97 @@
package games.cubi.locatables.implementations;
import games.cubi.locatables.MutableLocatable;
import java.util.UUID;
public class MutableLocatableImpl implements MutableLocatable {
private double x;
private double y;
private double z;
private UUID world;
public MutableLocatableImpl(UUID world, double x, double y, double z) {
this.world = world;
this.x = x;
this.y = y;
this.z = z;
}
@Override
public LocatableType getType() {
return LocatableType.Mutable;
}
@Override
public UUID world() {
return world;
}
@Override
public double x() {
return x;
}
@Override
public double y() {
return y;
}
@Override
public double z() {
return z;
}
@Override
public MutableLocatable setX(double x) {
this.x = x;
return this;
}
@Override
public MutableLocatable setY(double y) {
this.y = y;
return this;
}
@Override
public MutableLocatable setZ(double z) {
this.z = z;
return this;
}
public MutableLocatable setWorld(UUID world) {
this.world = world;
return this;
}
@Override
public boolean equals(Object o) {
return isEqualTo(o);
}
@Override
public int hashCode() {
return makeHash();
}
@Override
public String toString() {
return toStringForm();
}
@Override
public boolean strictlyEquals(Object other) {
if (this == other) return true;
if (!(other instanceof MutableLocatableImpl that)) return false;
if (!(this.world().equals(that.world()))) return false;
if (Double.doubleToLongBits(this.x()) != Double.doubleToLongBits(that.x())) {
return false;
}
if (Double.doubleToLongBits(this.y()) != Double.doubleToLongBits(that.y())) {
return false;
}
return Double.doubleToLongBits(this.z()) == Double.doubleToLongBits(that.z());
}
}
@@ -0,0 +1,328 @@
package games.cubi.locatables.implementations;
import games.cubi.locatables.Locatable;
import games.cubi.locatables.MutableLocatable;
import java.util.UUID;
import java.util.concurrent.locks.StampedLock;
public class ThreadSafeLocatable implements MutableLocatable {
private volatile UUID world;
private double x, y, z;
private final StampedLock lock = new StampedLock();
public ThreadSafeLocatable(UUID world, double x, double y, double z) {
this.world = world;
this.x = x; this.y = y; this.z = z;
}
/**
* Runs a write operation on x, y, z fields under a write lock.
*/
private void withWriteLock(Runnable body) {
long stamp = lock.writeLock();
try {
body.run();
} finally {
lock.unlockWrite(stamp);
}
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof Locatable that)) return false;
long stamp = lock.tryOptimisticRead();
UUID thatWorld = that.world();
double[] thatPos = that.getAtomicPositionArray();
boolean equal = this.world.equals(thatWorld) &&
Double.doubleToLongBits(this.x) == Double.doubleToLongBits(thatPos[0]) &&
Double.doubleToLongBits(this.y) == Double.doubleToLongBits(thatPos[1]) &&
Double.doubleToLongBits(this.z) == Double.doubleToLongBits(thatPos[2]);
if (!lock.validate(stamp)) {
// If the lock was invalid, we can't trust the result, so we have to retry with locks again
stamp = lock.readLock();
thatWorld = that.world();
thatPos = that.getAtomicPositionArray();
try {
equal = this.world.equals(thatWorld) &&
Double.doubleToLongBits(this.x) == Double.doubleToLongBits(thatPos[0]) &&
Double.doubleToLongBits(this.y) == Double.doubleToLongBits(thatPos[1]) &&
Double.doubleToLongBits(this.z) == Double.doubleToLongBits(thatPos[2]);
} finally {
lock.unlockRead(stamp);
}
}
return equal;
}
@Override
public int hashCode() {
long stamp = lock.tryOptimisticRead();
int hash = 3;
// while we could just grab the values, release the lock, and then calculate the hash, that would marginally increase ram use for a marginal performance gain and this looks neater
hash = 19 * hash + this.world.hashCode();
hash = 19 * hash + Long.hashCode(Double.doubleToLongBits(this.x));
hash = 19 * hash + Long.hashCode(Double.doubleToLongBits(this.y));
hash = 19 * hash + Long.hashCode(Double.doubleToLongBits(this.z));
if (!lock.validate(stamp)) {
stamp = lock.readLock();
try {
hash = 3;
hash = 19 * hash + this.world.hashCode();
hash = 19 * hash + Long.hashCode(Double.doubleToLongBits(this.x));
hash = 19 * hash + Long.hashCode(Double.doubleToLongBits(this.y));
hash = 19 * hash + Long.hashCode(Double.doubleToLongBits(this.z));
} finally {
lock.unlockRead(stamp);
}
}
return hash;
}
@Override
public String toString() {
// It's a string, who cares if it's not thread safe?
return toStringForm();
}
@Override
public LocatableType getType() {
return LocatableType.ThreadSafe;
}
@Override
public double length() {
return Math.sqrt(lengthSquared());
}
@Override
public double lengthSquared() {
long stamp = lock.tryOptimisticRead();
double result = x*x + y*y + z*z;
if (!lock.validate(stamp)) {
stamp = lock.readLock();
try {
result = x*x + y*y + z*z;
} finally {
lock.unlockRead(stamp);
}
}
return result;
}
/**
* @return Normalised internal vectors, may busy-wait if write access is locked
*/
@Override
public MutableLocatable normalize() {
withWriteLock(() -> {
double len = Math.sqrt(x*x + y*y + z*z);
x /= len; y /= len; z /= len;
});
return this;
}
@Override
public MutableLocatable add(Locatable locatable) {
double[] otherPosition = locatable.getAtomicPositionArray();
withWriteLock(() -> {
x += otherPosition[0];
y += otherPosition[1];
z += otherPosition[2];
});
return this;
}
@Override
public MutableLocatable add(double x, double y, double z) {
withWriteLock(() -> { this.x += x; this.y += y; this.z += z; });
return this;
}
@Override
public MutableLocatable subtract(Locatable locatable) {
double[] otherPosition = locatable.getAtomicPositionArray();
withWriteLock(() -> {
x -= otherPosition[0];
y -= otherPosition[1];
z -= otherPosition[2];
});
return this;
}
@Override
public MutableLocatable scalarMultiply(double factor) {
withWriteLock(() -> { x *= factor; y *= factor; z *= factor; });
return this;
}
@Override
public UUID world() {
long stamp = lock.tryOptimisticRead();
UUID result = world;
if (!lock.validate(stamp)) {
stamp = lock.readLock();
try {
result = world;
} finally {
lock.unlockRead(stamp);
}
}
return result;
}
@Override
public int blockX() {
return (int) Math.floor(x());
}
@Override
public int blockY() {
return (int) Math.floor(y());
}
@Override
public int blockZ() {
return (int) Math.floor(z());
}
@Override
public double x() {
long stamp = lock.tryOptimisticRead();
double result = x;
if (!lock.validate(stamp)) {
stamp = lock.readLock();
try {
result = x;
} finally {
lock.unlockRead(stamp);
}
}
return result;
}
@Override
public double y() {
long stamp = lock.tryOptimisticRead();
double result = y;
if (!lock.validate(stamp)) {
stamp = lock.readLock();
try {
result = y;
} finally {
lock.unlockRead(stamp);
}
}
return result;
}
@Override
public double z() {
long stamp = lock.tryOptimisticRead();
double result = z;
if (!lock.validate(stamp)) {
stamp = lock.readLock();
try {
result = z;
} finally {
lock.unlockRead(stamp);
}
}
return result;
}
@Override
public double[] getAtomicPositionArray() {
long stamp = lock.tryOptimisticRead();
double[] result = new double[]{x, y, z};
if (!lock.validate(stamp)) {
stamp = lock.readLock();
try {
result = new double[]{x, y, z};
} finally {
lock.unlockRead(stamp);
}
}
return result;
}
@Override
public MutableLocatable setX(double x) {
withWriteLock(() -> this.x = x);
return this;
}
@Override
public MutableLocatable setY(double y) {
withWriteLock(() -> this.y = y);
return this;
}
@Override
public MutableLocatable setZ(double z) {
withWriteLock(() -> this.z = z);
return this;
}
@Override
public MutableLocatable setWorld(UUID world) {
this.world = world;
return this;
}
@Override
public MutableLocatable set(Locatable locatable) {
double[] otherPosition = locatable.getAtomicPositionArray();
withWriteLock(() -> {
this.world = locatable.world(); // technically this could be racy, but the world shouldn't be changing often
this.x = otherPosition[0];
this.y = otherPosition[1];
this.z = otherPosition[2];
});
return this;
}
@Override
public MutableLocatable set(double x, double y, double z, UUID world) {
withWriteLock(() -> {
this.world = world;
this.x = x; this.y = y; this.z = z;
});
return this;
}
@Override
public boolean strictlyEquals(Object other) {
if (this == other) return true;
if (!(other instanceof ThreadSafeLocatable that)) return false;
long thisStamp = lock.tryOptimisticRead();
long thatStamp = that.lock.tryOptimisticRead();
boolean equal = this.world.equals(that.world) &&
Double.doubleToLongBits(this.x) == Double.doubleToLongBits(that.x) &&
Double.doubleToLongBits(this.y) == Double.doubleToLongBits(that.y) &&
Double.doubleToLongBits(this.z) == Double.doubleToLongBits(that.z);
if (!lock.validate(thisStamp) || !that.lock.validate(thatStamp)) {
// If either lock was invalid, we can't trust the result, so we have to retry with locks again
thisStamp = lock.readLock();
thatStamp = that.lock.readLock();
try {
equal = this.world.equals(that.world) &&
Double.doubleToLongBits(this.x) == Double.doubleToLongBits(that.x) &&
Double.doubleToLongBits(this.y) == Double.doubleToLongBits(that.y) &&
Double.doubleToLongBits(this.z) == Double.doubleToLongBits(that.z);
} finally {
lock.unlockRead(thisStamp);
that.lock.unlockRead(thatStamp);
}
}
return equal;
}
}
@@ -0,0 +1,4 @@
short-git: ${short_git}
long-git: ${long_git}
build-time: ${build_time}
version: ${version}
Submodule
+1
Submodule logging added at 02939225ba.
+25
View File
@@ -0,0 +1,25 @@
plugins {
id("java")
}
group = "games.cubi.raycastedantiesp.packetevents"
version = "unspecified"
repositories {
mavenCentral()
maven { url = uri("https://repo.codemc.io/repository/maven-releases/") }
maven { url = uri("https://repo.codemc.io/repository/maven-snapshots/") }
}
dependencies {
implementation(project(":locatable-lib"))
implementation(project(":logging"))
implementation(project(":core"))
compileOnly("com.github.retrooper:packetevents-api:2.12.0")
compileOnly("org.spongepowered:configurate-core:4.2.0")
}
java {
toolchain.languageVersion = JavaLanguageVersion.of(21)
}
@@ -0,0 +1,10 @@
package games.cubi.raycastedantiesp.packetevents;
import org.jetbrains.annotations.Contract;
public interface BlockInfoResolver {
@Contract(pure = true)
boolean isOccluding(int blockStateID);
@Contract(pure = true)
boolean isTileEntity(int blockStateID);
}
@@ -0,0 +1,32 @@
package games.cubi.raycastedantiesp.packetevents.config;
import games.cubi.raycastedantiesp.core.config.BlockProcessorConfig;
import games.cubi.raycastedantiesp.core.config.Config;
import games.cubi.raycastedantiesp.core.config.ConfigExtension;
import games.cubi.raycastedantiesp.core.config.ConfigLoadException;
import games.cubi.raycastedantiesp.core.config.ConfigReader;
import org.spongepowered.configurate.ConfigurationNode;
import java.util.List;
public record PacketEventsBlockProcessorConfig(List<Integer> tileEntityExemptedIds, List<Integer> tileEntityForceIncludedIds) implements Config {
public static final ConfigExtension<PacketEventsBlockProcessorConfig> EXTENSION = new ConfigExtension<>() {
@Override
public Class<PacketEventsBlockProcessorConfig> type() {
return PacketEventsBlockProcessorConfig.class;
}
@Override
public PacketEventsBlockProcessorConfig load(ConfigurationNode config, BlockProcessorConfig blockProcessorConfig) {
ConfigurationNode node = ConfigReader.node(config, "block-processor", "packetevents");
PacketEventsBlockProcessorConfig packetEventsConfig = new PacketEventsBlockProcessorConfig(
ConfigReader.integerList(ConfigReader.node(node, "tile-entity-exempted-ids"), "block-processor.packetevents.tile-entity-exempted-ids"),
ConfigReader.integerList(ConfigReader.node(node, "tile-entity-force-included-ids"), "block-processor.packetevents.tile-entity-force-included-ids")
);
if (!blockProcessorConfig.trackAllBlocks() && !packetEventsConfig.tileEntityForceIncludedIds().isEmpty()) {
throw new ConfigLoadException("block-processor.packetevents.tile-entity-force-included-ids must be empty when block-processor.track-all-blocks is false");
}
return packetEventsConfig;
}
};
}
@@ -0,0 +1,43 @@
package games.cubi.raycastedantiesp.packetevents.locatables;
import com.github.retrooper.packetevents.protocol.entity.type.EntityType;
import games.cubi.raycastedantiesp.core.locatables.NettyEntityLocatable;
import games.cubi.raycastedantiesp.core.players.PlayerData;
import games.cubi.raycastedantiesp.packetevents.replaydata.PacketEventsEntityReplayData;
import java.util.UUID;
public class PacketEventsEntity extends NettyEntityLocatable<EntityType, PacketEventsEntityReplayData> {
public PacketEventsEntity(PlayerData owningPlayer, UUID world, double x, double y, double z, int entityID, UUID entityUUID, boolean isSelfEntity, EntityType entityType, boolean visible) {
super(owningPlayer,world, x, y, z, entityID, entityUUID, isSelfEntity, entityType, visible);
}
private PacketEventsEntity(PlayerData selfData, int selfEntityID, UUID selfEntityUUID) {
super(selfData, selfEntityID, selfEntityUUID);
}
public static PacketEventsEntity createSelfEntity(PlayerData selfData, int selfEntityID, UUID selfEntityUUID) {
return new PacketEventsEntity(selfData, selfEntityID, selfEntityUUID);
}
@Override
public boolean strictlyEquals(Object other) {
if (this == other) return true;
if (!(other instanceof PacketEventsEntity that)) return false;
if (!this.equals(other)) return false;
if (entityID() != that.entityID()) return false;
if (!entityUUID().equals(that.entityUUID())) return false;
if (isSelfEntity() != that.isSelfEntity()) return false;
if (entityType() != that.entityType()) return false;
if (visible() != that.visible()) return false;
if (yaw() != that.yaw()) return false;
if (pitch() != that.pitch()) return false;
if (headYaw() != that.headYaw()) return false;
if (velocityX() != that.velocityX()) return false;
if (velocityY() != that.velocityY()) return false;
if (velocityZ() != that.velocityZ()) return false;
if (onGround() != that.onGround()) return false;
return entityData() == that.entityData();
}
}
@@ -0,0 +1,28 @@
package games.cubi.raycastedantiesp.packetevents.locatables;
import games.cubi.locatables.Locatable;
import games.cubi.raycastedantiesp.core.locatables.NettyTileEntity;
import games.cubi.raycastedantiesp.packetevents.replaydata.PacketEventsTileEntityReplayData;
import java.util.UUID;
public class PacketEventsTileEntity extends NettyTileEntity<PacketEventsTileEntityReplayData> {
public PacketEventsTileEntity(Locatable location, boolean visible, int lastChecked, int blockID) {
super(location, visible, lastChecked, blockID);
}
public PacketEventsTileEntity(UUID world, int x, int y, int z, boolean visible, int blockID) {
super(world, x, y, z, visible, blockID);
}
@Override
public boolean strictlyEquals(Object other) {
if (this == other) return true;
if (!(other instanceof PacketEventsTileEntity that)) return false;
if (!this.equals(that)) return false;
return this.visible() == that.visible() &&
this.lastChecked() == that.lastChecked() &&
this.blockID() == that.blockID() &&
((this.extraData() == null && that.extraData() == null) || (this.extraData() != null && this.extraData().equals(that.extraData())));
}
}
@@ -0,0 +1,47 @@
package games.cubi.raycastedantiesp.packetevents.replaydata;
import com.github.retrooper.packetevents.wrapper.PacketWrapper;
import com.github.retrooper.packetevents.wrapper.play.server.WrapperPlayServerPlayerInfoUpdate;
import games.cubi.raycastedantiesp.core.utils.Clearable;
import java.util.ArrayDeque;
import java.util.List;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;
public sealed interface PacketEventsEntityReplayData extends Clearable permits PacketEventsEntityReplayData.Impl {
void addPacket(PacketWrapper<?> packet);
/**
* @return The actual queue, do not modify.
*/
Queue<PacketWrapper<?>> getPackets();
static PacketEventsEntityReplayData create() {
return new Impl();
}
final class Impl implements PacketEventsEntityReplayData {
private final Queue<PacketWrapper<?>> packets = new ArrayDeque<>();
public Impl() {
}
public void addPacket(PacketWrapper<?> packet) {
packets.add(packet);
}
@Override
public Queue<PacketWrapper<?>> getPackets() {
return packets;
}
@Override
public void clear() {
packets.clear();
}
}
}
@@ -0,0 +1,29 @@
package games.cubi.raycastedantiesp.packetevents.replaydata;
import com.github.retrooper.packetevents.protocol.nbt.NBTCompound;
import com.github.retrooper.packetevents.protocol.world.blockentity.BlockEntityType;
import games.cubi.raycastedantiesp.core.utils.Clearable;
public final class PacketEventsTileEntityReplayData implements Clearable {
private volatile BlockEntityType blockEntityType;
private volatile NBTCompound nbt;
public BlockEntityType blockEntityType() {
return blockEntityType;
}
public NBTCompound nbt() {
return nbt == null ? null : nbt.copy();
}
public void setBlockEntityData(BlockEntityType blockEntityType, NBTCompound nbt) {
this.blockEntityType = blockEntityType;
this.nbt = nbt == null ? null : nbt.copy();
}
@Override
public void clear() {
blockEntityType = null;
nbt = null;
}
}
@@ -0,0 +1,20 @@
package games.cubi.raycastedantiesp.packetevents.view;
import games.cubi.locatables.BlockLocatable;
import games.cubi.locatables.implementations.ImmutableBlockLocatable;
import games.cubi.raycastedantiesp.core.view.AbstractBlockView;
import games.cubi.raycastedantiesp.packetevents.locatables.PacketEventsTileEntity;
import java.util.UUID;
public class PacketEventsBlockView extends AbstractBlockView<PacketEventsTileEntity> {
@Override
protected PacketEventsTileEntity createTrackedTileEntity(BlockLocatable location, int blockID, boolean visible) {
return new PacketEventsTileEntity(location, visible, 0, blockID);
}
@Override
protected PacketEventsTileEntity createTrackedTileEntity(UUID world, int x, int y, int z, int blockID) {
return new PacketEventsTileEntity(world, x, y, z, false, blockID);
}
}
@@ -0,0 +1,197 @@
package games.cubi.raycastedantiesp.packetevents.view;
import games.cubi.locatables.Locatable;
import games.cubi.logs.Logger;
import games.cubi.raycastedantiesp.core.view.EntityView;
import games.cubi.raycastedantiesp.core.view.EntityViewTransition;
import games.cubi.raycastedantiesp.packetevents.locatables.PacketEventsEntity;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedQueue;
public class PacketEventsEntityView implements EntityView<PacketEventsEntity> {
private final Map<UUID, PacketEventsEntity> entitiesByUUID = new ConcurrentHashMap<>();
private final Map<Integer, UUID> entityUUIDsByID = new ConcurrentHashMap<>();
private final ConcurrentLinkedQueue<EntityViewTransition> transitions = new ConcurrentLinkedQueue<>();
private final boolean isPlayerView;
public PacketEventsEntityView(boolean isPlayerView) {
this.isPlayerView = isPlayerView;
}
public static PacketEventsEntityView createPlayerView() {
return new PacketEventsEntityView(true);
}
public static PacketEventsEntityView createEntityView() {
return new PacketEventsEntityView(false);
}
@Override
public void insertEntity(PacketEventsEntity entity) {
if (entity == null || entity.entityUUID() == null) {
Logger.error(new RuntimeException("Attempted to insert null entity or entity with null UUID into EntityView"), 2, PacketEventsEntityView.class);
return;
}
entitiesByUUID.put(entity.entityUUID(), entity);
entityUUIDsByID.put(entity.entityID(), entity.entityUUID());
}
@Override
public void removeEntity(int entityID, int currentTick) {
UUID entityUUID = entityUUIDsByID.remove(entityID);
if (entityUUID == null) {
return;
}
PacketEventsEntity removed = entitiesByUUID.remove(entityUUID);
if (removed == null) {
return;
}
removed.clear();
}
@Override
public void removeEntity(UUID entityUUID, int currentTick) {
int entityID = getEntityID(entityUUID);
removeEntity(entityID, currentTick);
}
@Override
public PacketEventsEntity getEntity(UUID entityUUID) {
return entitiesByUUID.get(entityUUID);
}
@Override
public PacketEventsEntity getEntity(int entityID) {
return getTrackedEntity(entityID);
}
@Override
public boolean exists(UUID entityUUID) {
return entitiesByUUID.containsKey(entityUUID);
}
@Override
public boolean exists(int entityID) {
return entityUUIDsByID.containsKey(entityID);
}
@Override
public boolean isVisible(int entityID) {
PacketEventsEntity entity = getTrackedEntity(entityID);
assert entity != null;
return entity.visible();
}
@Override
public Locatable getLocation(UUID entityUUID) {
PacketEventsEntity entity = entitiesByUUID.get(entityUUID);
if (entity == null) {
return null;
}
return entity.clonePlainAndCentreIfBlockLocation().set(entity.x(), entity.y() + 0.5, entity.z(), entity.world());
}
@Override
public int getEntityID(UUID entityUUID) {
PacketEventsEntity entity = entitiesByUUID.get(entityUUID);
return entity == null ? -1 : entity.entityID();
}
@Override
public boolean isVisible(UUID entityUUID, int currentTick) {
return isVisible(entityUUID);
}
@Override
public boolean isVisible(UUID entityUUID) {
PacketEventsEntity entity = entitiesByUUID.get(entityUUID);
return entity == null || entity.visible();
}
@Override
public void setVisibility(UUID entityUUID, boolean visible, int currentTick) {
PacketEventsEntity existing = entitiesByUUID.get(entityUUID);
if (existing == null) {
Logger.debug("EntityView.setVisibility missing uuid=" + entityUUID
+ " requestedVisible=" + visible
+ " tick=" + currentTick);
return;
}
if (existing.isSelfEntity()) return;
if (existing.visible() != visible) {
transitions.add(new EntityViewTransition(
visible ? EntityViewTransition.Type.SHOW : EntityViewTransition.Type.HIDE,
existing.entityUUID(),
existing.entityID()
));
}
existing.setVisible(visible);
existing.setLastChecked(currentTick);
}
@Override
public Collection<UUID> getKnownEntities() {
return List.copyOf(entitiesByUUID.keySet());
}
@Override
public Collection<UUID> getNeedingRecheck(int recheckTicks, int currentTick) {
List<UUID> needingRecheck = new ArrayList<>();
for (PacketEventsEntity state : entitiesByUUID.values()) {
if (state.visible() && (currentTick - state.lastChecked()) < recheckTicks) {
continue;
}
needingRecheck.add(state.entityUUID());
}
return needingRecheck;
}
@Override
public boolean hasPendingTransitions() {
return !transitions.isEmpty();
}
@Override
public List<EntityViewTransition> drainTransitions() {
List<EntityViewTransition> drained = new ArrayList<>();
EntityViewTransition transition;
while ((transition = transitions.poll()) != null) {
drained.add(transition);
}
return drained;
}
@Override
public boolean isPlayerView() {
return isPlayerView;
}
@Override
public void clear() {
entitiesByUUID.clear();
entityUUIDsByID.clear();
transitions.clear();
}
private PacketEventsEntity getTrackedEntity(int entityID) {
UUID entityUUID = entityUUIDsByID.get(entityID);
return entityUUID == null ? null : entitiesByUUID.get(entityUUID);
}
public String getStringDataForDebugging() {
StringBuilder builder = new StringBuilder();
builder.append("EntityView isPlayerView=").append(isPlayerView).append("\n");
Set<Map.Entry<Integer, UUID>> entries = new HashSet<>(entityUUIDsByID.entrySet());
for (Map.Entry<Integer, UUID> entry : entries) {
PacketEventsEntity entity = entitiesByUUID.get(entry.getValue());
builder.append("EntityID=").append(entry.getKey())
.append(" UUID=").append(entry.getValue())
.append(" Entity=").append(entity)
.append("\n");
}
return builder.toString();
}
}
@@ -0,0 +1,41 @@
package games.cubi.raycastedantiesp.packetevents.viewcontrollers;
import com.github.retrooper.packetevents.wrapper.PacketWrapper;
import games.cubi.logs.Logger;
import games.cubi.raycastedantiesp.core.locatables.NettyEntityLocatable;
import games.cubi.raycastedantiesp.core.players.PlayerData;
import games.cubi.raycastedantiesp.core.utils.BaseEntitySpawnTask;
import games.cubi.raycastedantiesp.packetevents.locatables.PacketEventsEntity;
final class PECacheablePacketReconciliationTask extends BaseEntitySpawnTask {
private final PlayerData playerData;
private final int entityID;
private final PacketWrapper<?> packet;
PECacheablePacketReconciliationTask(PacketEventsEntityViewController controller, PlayerData playerData, int entityID, PacketWrapper<?> packet, int submittedTick) {
super(submittedTick);
this.playerData = playerData;
this.entityID = entityID;
this.packet = packet;
}
@Override
public void run() {
NettyEntityLocatable<?,?> entity = playerData.entityFromID(entityID);
if (entity == null) {
Logger.error("Reconciliation fail: Attempted to cache packet for unknown entity, id=" + entityID + " packet=" + packet.getClass().getSimpleName() + ".", 3, this.getClass());
return;
}
PacketEventsEntityViewController.get().ensureReplayData((PacketEventsEntity) entity).addPacket(packet);
}
@Override
public String toString() {
return "PECacheablePacketReconciliationTask{" +
"submittedTick=" + submittedTick +
", entityID=" + entityID +
", packetType=" + packet.getClass().getSimpleName() +
", playerUUID=" + playerData.getPlayerUUID() +
'}';
}
}
@@ -0,0 +1,417 @@
package games.cubi.raycastedantiesp.packetevents.viewcontrollers;
import com.github.retrooper.packetevents.PacketEvents;
import com.github.retrooper.packetevents.event.PacketListener;
import com.github.retrooper.packetevents.event.PacketSendEvent;
import com.github.retrooper.packetevents.protocol.packettype.PacketType;
import com.github.retrooper.packetevents.protocol.player.User;
import com.github.retrooper.packetevents.protocol.world.blockentity.BlockEntityType;
import com.github.retrooper.packetevents.protocol.world.blockentity.BlockEntityTypes;
import com.github.retrooper.packetevents.protocol.world.chunk.BaseChunk;
import com.github.retrooper.packetevents.protocol.world.chunk.Column;
import com.github.retrooper.packetevents.protocol.world.chunk.TileEntity;
import com.github.retrooper.packetevents.util.Vector3i;
import com.github.retrooper.packetevents.wrapper.play.server.*;
import games.cubi.locatables.BlockLocatable;
import games.cubi.locatables.Locatable;
import games.cubi.locatables.implementations.ImmutableBlockLocatable;
import games.cubi.logs.Logger;
import games.cubi.raycastedantiesp.core.config.ConfigManager;
import games.cubi.raycastedantiesp.core.config.raycast.TileEntityConfig;
import games.cubi.raycastedantiesp.core.players.PlayerData;
import games.cubi.raycastedantiesp.core.players.PlayerRegistry;
import games.cubi.raycastedantiesp.core.view.BlockView;
import games.cubi.raycastedantiesp.core.view.BlockViewTransition;
import games.cubi.raycastedantiesp.core.locatables.TileEntityLocatable;
import games.cubi.raycastedantiesp.packetevents.BlockInfoResolver;
import games.cubi.raycastedantiesp.packetevents.replaydata.PacketEventsTileEntityReplayData;
import java.util.*;
import java.util.function.IntSupplier;
import static games.cubi.raycastedantiesp.core.view.AbstractBlockView.CHUNK_SIZE;
import static games.cubi.raycastedantiesp.core.view.AbstractBlockView.pack;
public abstract class PacketEventsBlockViewController implements PacketListener {
private final BlockInfoResolver blockInfoResolver;
private final IntSupplier currentTickSupplier;
private final PacketEventsCommonViewController common;
private TileEntityConfig tileEntityConfig = null;
private int hideOnSpawnDistanceSquared = 0;
protected PacketEventsBlockViewController(BlockInfoResolver blockInfoResolver, IntSupplier currentTickSupplier) {
this.blockInfoResolver = blockInfoResolver;
this.currentTickSupplier = currentTickSupplier;
common = PacketEventsCommonViewController.get(currentTickSupplier);
}
protected abstract UUID resolveWorldUUID(User user);
protected abstract int getHiddenBlockId(int blockY);
public void removeViewer(UUID viewerUUID) {
}
@Override
public void onPacketSend(PacketSendEvent event) {
UUID viewerUUID = event.getUser().getUUID();
if (viewerUUID == null) {
return;
}
if (!(ConfigManager.get().getTileEntityConfig() == tileEntityConfig)) {
tileEntityConfig = ConfigManager.get().getTileEntityConfig();
hideOnSpawnDistanceSquared = tileEntityConfig.hideOnSpawnDistance() * tileEntityConfig.hideOnSpawnDistance();
}
PlayerData playerData = PlayerRegistry.getInstance().getPlayerData(viewerUUID);
if (playerData == null) {
return;
}
Locatable ownLocation = playerData.ownLocation();
UUID world = ownLocation != null ? ownLocation.world() : resolveWorldUUID(event.getUser());
int currentTick = currentTickSupplier.getAsInt();
handleBlockPackets(event, event.getUser(), playerData, world, currentTick);
if (playerData.blockView().hasPendingTransitions()) {
processTileEntityTransitions(event.getUser(), playerData.blockView());
}
//event.getUser().flushPackets();
}
private void handleBlockPackets(PacketSendEvent event, User viewer, PlayerData playerData, UUID world, int currentTick) {
if (world == null) {
return;
}
BlockView blockView = playerData.blockView();
if (event.getPacketType() == PacketType.Play.Server.UNLOAD_CHUNK) {
WrapperPlayServerUnloadChunk packet = new WrapperPlayServerUnloadChunk(event);
removeChunk(packet, blockView, world);
} else if (event.getPacketType() == PacketType.Play.Server.BLOCK_CHANGE) {
WrapperPlayServerBlockChange packet = new WrapperPlayServerBlockChange(event);
handleSingleBlockChange(event, viewer, playerData, world, packet, currentTick);
} else if (event.getPacketType() == PacketType.Play.Server.MULTI_BLOCK_CHANGE) {
WrapperPlayServerMultiBlockChange packet = new WrapperPlayServerMultiBlockChange(event);
handleMultiBlockChange(event, blockView, world, packet, playerData.ownLocation(), currentTick);
} else if (event.getPacketType() == PacketType.Play.Server.BLOCK_ENTITY_DATA) {
WrapperPlayServerBlockEntityData packet = new WrapperPlayServerBlockEntityData(event);
ImmutableBlockLocatable location = new ImmutableBlockLocatable(world, packet.getPosition().getX(), packet.getPosition().getY(), packet.getPosition().getZ());
TileEntityLocatable<PacketEventsTileEntityReplayData> tileEntity = getTrackedTileEntity(blockView, location);
if (tileEntity == null) {
Logger.warning("Received standalone block entity data for an uncached tile entity. Location: " + location.world() + " " + location.blockX() + "," + location.blockY() + "," + location.blockZ(), 3, PacketEventsBlockViewController.class);
return;
}
ensureTileReplayData(tileEntity).setBlockEntityData(packet.getBlockEntityType(), packet.getNBT());
if (!blockView.isVisible(location, currentTick)) {
event.setCancelled(true);
sendHiddenBlock(viewer, location);
}
} else if (event.getPacketType() == PacketType.Play.Server.CHUNK_DATA) {
WrapperPlayServerChunkData packet = new WrapperPlayServerChunkData(event);
Column column = ingestChunkAndSetTileEntitiesToHiddenBlocks(
playerData,
world,
packet.getColumn().getX(),
packet.getColumn().getZ(),
packet.getColumn(),
event.getUser().getMinWorldHeight() >> 4,
event
);
Column tileEntitiesRemoved;
if (column.hasBiomeData()) {
int[] biomeInts = column.getBiomeDataInts();
byte[] biomeBytes = column.getBiomeDataBytes();
if (biomeInts.length >= biomeBytes.length) {
tileEntitiesRemoved = new Column(column.getX(), column.getZ(), column.isFullChunk(), column.getChunks(), new TileEntity[0], column.getHeightMaps(), biomeInts);
}
else {
tileEntitiesRemoved = new Column(column.getX(), column.getZ(), column.isFullChunk(), column.getChunks(), new TileEntity[0], column.getHeightMaps(), biomeBytes);
}
}
else {
if (common.v_1_21_5_orAbove) tileEntitiesRemoved = new Column(column.getX(), column.getZ(), column.isFullChunk(), column.getChunks(), new TileEntity[0], column.getHeightmaps());
else tileEntitiesRemoved = new Column(column.getX(), column.getZ(), column.isFullChunk(), column.getChunks(), new TileEntity[0], column.getHeightMaps());
}
packet.setColumn(tileEntitiesRemoved);
event.markForReEncode(true);
} else if (event.getPacketType() == PacketType.Play.Server.MAP_CHUNK_BULK) {
WrapperPlayServerChunkDataBulk packet = new WrapperPlayServerChunkDataBulk(event);
throw new RuntimeException("I didn't think this packet existed. Please report this to the developer with details on how to reproduce it so it can be implemented");
}
}
private void removeChunk(WrapperPlayServerUnloadChunk packet, BlockView blockView, UUID world) {
blockView.removeChunk(world, packet.getChunkX(), packet.getChunkZ());
removeChunkTileEntities(blockView, world, packet.getChunkX(), packet.getChunkZ());
}
private void handleMultiBlockChange(PacketSendEvent event, BlockView blockView, UUID world, WrapperPlayServerMultiBlockChange packet, Locatable playerLocation, int currentTick) {
for (WrapperPlayServerMultiBlockChange.EncodedBlock change : packet.getBlocks()) {
int blockID = change.getBlockId();
boolean occluding = blockID != 0 && blockInfoResolver.isOccluding(blockID);
boolean tileEntity = blockInfoResolver.isTileEntity(blockID);
blockView.upsertBlock(world, change.getX(), change.getY(), change.getZ(), occluding);
ImmutableBlockLocatable location = new ImmutableBlockLocatable(world, change.getX(), change.getY(), change.getZ());
if (tileEntity) {
TileEntityLocatable<?> existing = blockView.getTrackedTileEntity(location);
boolean visibleIfNew = false;
if (existing == null) {
double distanceSquared = location.distanceSquared(playerLocation);
visibleIfNew = (distanceSquared <= hideOnSpawnDistanceSquared) && tileEntityConfig.enabled();
}
blockView.updateOrInsertTileEntity(location, blockID, visibleIfNew);
if (!blockView.isVisible(location, currentTick)) {
change.setBlockId(getHiddenBlockId(location.blockY()));
event.markForReEncode(true);
}
} else {
blockView.removeTileEntity(location);
}
}
}
private void processTileEntityTransitions(User viewer, BlockView blockView) {
for (BlockViewTransition transition : blockView.drainTransitions()) {
BlockLocatable location = transition.location();
TileEntityLocatable<PacketEventsTileEntityReplayData> state = getTrackedTileEntity(blockView, location);
switch (transition.type()) {
case HIDE -> viewer.writePacketSilently(new WrapperPlayServerBlockChange(
new Vector3i(location.blockX(), location.blockY(), location.blockZ()),
getHiddenBlockId(location.blockY())
));
case SHOW -> {
if (state == null || state.blockID() == 0) {
continue;
}
viewer.writePacketSilently(new WrapperPlayServerBlockChange(
new Vector3i(location.blockX(), location.blockY(), location.blockZ()),
state.blockID()
));
PacketEventsTileEntityReplayData replayData = ensureTileReplayData(state);
if (replayData.blockEntityType() != null && replayData.nbt() != null) {
viewer.writePacketSilently(buildBlockEntityDataPacket(location, replayData));
}
}
}
}
}
private void handleSingleBlockChange(PacketSendEvent event, User viewer, PlayerData playerData, UUID world, WrapperPlayServerBlockChange packet, int currentTick) {
int blockID = packet.getBlockId();
boolean occluding = blockID != 0 && blockInfoResolver.isOccluding(blockID);
boolean tileEntity = blockInfoResolver.isTileEntity(blockID);
Vector3i position = packet.getBlockPosition();
ImmutableBlockLocatable location = new ImmutableBlockLocatable(world, position.getX(), position.getY(), position.getZ());
playerData.blockView().upsertBlock(world, position.getX(), position.getY(), position.getZ(), occluding);
if (tileEntity) {
TileEntityLocatable<?> existing = playerData.blockView().getTrackedTileEntity(location);
boolean visibleIfNew = false;
if (existing == null) {
double distanceSquared = location.distanceSquared(playerData.ownLocation());
visibleIfNew = (distanceSquared <= hideOnSpawnDistanceSquared) && tileEntityConfig.enabled();
}
playerData.blockView().updateOrInsertTileEntity(location, blockID, visibleIfNew);
if (!playerData.blockView().isVisible(location, currentTick)) {
event.setCancelled(true);
sendHiddenBlock(viewer, location);
}
} else {
playerData.blockView().removeTileEntity(location);
}
}
private Column ingestChunkAndSetTileEntitiesToHiddenBlocks(
PlayerData playerData,
UUID worldID,
int chunkX,
int chunkZ,
Column column,
int minimumChunkSectionY,
PacketSendEvent event
) {
Map<Integer, BitSet> occludingBySectionY = new HashMap<>();
Map<Integer, Set<ImmutableBlockLocatable>> tileEntitiesBySectionY = new HashMap<>();
BlockView blockView = playerData.blockView();
BaseChunk[] sections = column.getChunks();
TileEntity[] chunkTileEntitiesData = column.getTileEntities();
for (int sectionIndex = 0; sectionIndex < sections.length; sectionIndex++) {
BaseChunk section = sections[sectionIndex];
if (section == null) {
continue;
}
int sectionY = minimumChunkSectionY + sectionIndex;
BitSet occluding = null;
Set<ImmutableBlockLocatable> tileEntities = tileEntitiesBySectionY.computeIfAbsent(sectionY, ignored -> new HashSet<>());
boolean chunkSectionHasOccluding = false;
for (int localX = 0; localX < 16; localX++) {
for (int localY = 0; localY < 16; localY++) {
for (int localZ = 0; localZ < 16; localZ++) {
int blockID = section.getBlockId(localX, localY, localZ);
if (blockID == 0) {
continue;
}
int blockX = (chunkX << 4) + localX;
int blockY = (sectionY << 4) + localY;
int blockZ = (chunkZ << 4) + localZ;
if (blockInfoResolver.isOccluding(blockID)) {
if (occluding == null) {
occluding = new BitSet(CHUNK_SIZE * CHUNK_SIZE * CHUNK_SIZE);
}
occluding.set(pack(localX, localY, localZ));
chunkSectionHasOccluding = true;
}
if (blockInfoResolver.isTileEntity(blockID)) {
ImmutableBlockLocatable location = new ImmutableBlockLocatable(worldID, blockX, blockY, blockZ);
tileEntities.add(location);
blockView.updateOrInsertTileEntity(location, blockID, false);
section.set(localX, localY, localZ, getHiddenBlockId(blockY));
}
}
}
}
if (chunkSectionHasOccluding) {
// skip empty sections to save memory
occludingBySectionY.put(sectionY, occluding);
}
}
if (chunkTileEntitiesData != null) {
for (TileEntity tileEntity : chunkTileEntitiesData) {
int blockX = (chunkX << 4) + tileEntity.getX();
int blockY = tileEntity.getY();
int blockZ = (chunkZ << 4) + tileEntity.getZ();
int sectionY = blockY >> 4;
ImmutableBlockLocatable location = new ImmutableBlockLocatable(worldID, blockX, blockY, blockZ);
tileEntitiesBySectionY.computeIfAbsent(sectionY, ignored -> new HashSet<>()).add(location);
TileEntityLocatable<PacketEventsTileEntityReplayData> state = getTrackedTileEntity(blockView, location);
if (state == null) {
Logger.warning("Received block entity data for a tile entity that wasn't in the chunk's tile entity list. Location: " + location.world() + " " + location.blockX() + "," + location.blockY() + "," + location.blockZ(), 3, PacketEventsBlockViewController.class);
int sectionIndex = sectionY - minimumChunkSectionY;
if (sectionIndex < 0 || sectionIndex >= sections.length) {
Logger.warning("Skipping uncached chunk block entity with out-of-bounds section index. Location: " + location.world() + " " + location.blockX() + "," + location.blockY() + "," + location.blockZ(), 3, PacketEventsBlockViewController.class);
continue;
}
BaseChunk sourceSection = sections[sectionIndex];
if (sourceSection == null) {
Logger.warning("Skipping uncached chunk block entity because its section data is missing. Location: " + location.world() + " " + location.blockX() + "," + location.blockY() + "," + location.blockZ(), 3, PacketEventsBlockViewController.class);
continue;
}
int blockID = sourceSection.getBlockId(tileEntity.getX(), blockY & 15, tileEntity.getZ());
if (blockID <= 0) {
Logger.warning("Skipping uncached chunk block entity because the recovered block state was air or invalid (" + blockID + "). Location: " + location.world() + " " + location.blockX() + "," + location.blockY() + "," + location.blockZ(), 3, PacketEventsBlockViewController.class);
continue;
}
if (!blockInfoResolver.isTileEntity(blockID)) {
Logger.warning("Recovered uncached chunk block entity from chunk sections with a non-tile-entity block state ID (" + blockID + "). Location: " + location.world() + " " + location.blockX() + "," + location.blockY() + "," + location.blockZ(), 3, PacketEventsBlockViewController.class);
}
blockView.updateOrInsertTileEntity(location, blockID, false);
state = getTrackedTileEntity(blockView, location);
if (state == null) {
Logger.warning("Skipping uncached chunk block entity because caching recovery failed. Location: " + location.world() + " " + location.blockX() + "," + location.blockY() + "," + location.blockZ(), 3, PacketEventsBlockViewController.class);
continue;
}
}
ensureTileReplayData(state).setBlockEntityData(packetTileEntityType(tileEntity), tileEntity.getNBT());
}
}
Set<Integer> sectionYs = new HashSet<>(tileEntitiesBySectionY.keySet());
sectionYs.addAll(occludingBySectionY.keySet());
for (int sectionY : sectionYs) {
BitSet occluding = occludingBySectionY.get(sectionY);
if (occluding != null) {
blockView.replaceChunkSection(worldID, chunkX, sectionY, chunkZ, occluding);
}
else {
blockView.removeChunkSection(worldID, chunkX, sectionY, chunkZ);
}
}
return column;
}
private void removeChunkTileEntities(BlockView blockView, UUID worldID, int chunkX, int chunkZ) {
for (BlockLocatable known : blockView.getKnownTileEntities()) {
if (!sameChunk(known, worldID, chunkX, chunkZ)) {
continue;
}
blockView.removeTileEntity(known);
}
}
private void sendHiddenBlock(User viewer, BlockLocatable location) {
viewer.writePacketSilently(new WrapperPlayServerBlockChange(
new Vector3i(location.blockX(), location.blockY(), location.blockZ()),
getHiddenBlockId(location.blockY())
));
}
private boolean sameChunk(BlockLocatable location, UUID worldID, int chunkX, int chunkZ) {
return location.world().equals(worldID) && location.chunkX() == chunkX && location.chunkZ() == chunkZ;
}
private boolean sameChunkSection(BlockLocatable location, UUID worldID, int chunkX, int chunkY, int chunkZ) {
return sameChunk(location, worldID, chunkX, chunkZ) && location.chunkY() == chunkY;
}
private WrapperPlayServerBlockEntityData copyBlockEntityDataPacket(WrapperPlayServerBlockEntityData packet) {
return new WrapperPlayServerBlockEntityData(
copyBlockVector(packet.getPosition()),
packet.getBlockEntityType(),
packet.getNBT()
);
}
private WrapperPlayServerBlockEntityData buildBlockEntityDataPacket(BlockLocatable location, PacketEventsTileEntityReplayData replayData) {
return new WrapperPlayServerBlockEntityData(
new Vector3i(location.blockX(), location.blockY(), location.blockZ()),
replayData.blockEntityType(),
replayData.nbt()
);
}
private BlockEntityType packetTileEntityType(TileEntity tileEntity) {
return BlockEntityTypes.getById(
PacketEvents.getAPI().getServerManager().getVersion().toClientVersion(),
tileEntity.getType()
);
}
private Vector3i copyBlockVector(Vector3i vector) {
return new Vector3i(vector.getX(), vector.getY(), vector.getZ());
}
@SuppressWarnings("unchecked")
private TileEntityLocatable<PacketEventsTileEntityReplayData> getTrackedTileEntity(BlockView blockView, BlockLocatable location) {
return (TileEntityLocatable<PacketEventsTileEntityReplayData>) blockView.getTrackedTileEntity(location);
}
private PacketEventsTileEntityReplayData ensureTileReplayData(TileEntityLocatable<PacketEventsTileEntityReplayData> tileEntity) {
PacketEventsTileEntityReplayData replayData = tileEntity.extraData();
if (replayData == null) {
replayData = new PacketEventsTileEntityReplayData();
tileEntity.setExtraData(replayData);
}
return replayData;
}
}
@@ -0,0 +1,33 @@
package games.cubi.raycastedantiesp.packetevents.viewcontrollers;
import com.github.retrooper.packetevents.PacketEvents;
import com.github.retrooper.packetevents.manager.server.ServerVersion;
import com.github.retrooper.packetevents.protocol.player.User;
import com.github.retrooper.packetevents.wrapper.PacketWrapper;
import java.util.function.IntSupplier;
public class PacketEventsCommonViewController {
private static PacketEventsCommonViewController INSTANCE;
private final IntSupplier currentTickSupplier;
public final boolean v_1_21_5_orAbove = PacketEvents.getAPI().getServerManager().getVersion().isNewerThanOrEquals(ServerVersion.V_1_21_5);
private PacketEventsCommonViewController(IntSupplier currentTick) {
this.currentTickSupplier = currentTick;
}
public static PacketEventsCommonViewController get(IntSupplier currentTick) {
if (INSTANCE == null) {
INSTANCE = new PacketEventsCommonViewController(currentTick);
}
return INSTANCE;
}
public void writeIfPresent(User viewer, PacketWrapper<?> packet) {
if (viewer == null || packet == null) {
return;
}
viewer.writePacketSilently(packet);
}
}
@@ -0,0 +1,662 @@
package games.cubi.raycastedantiesp.packetevents.viewcontrollers;
import com.github.retrooper.packetevents.PacketEvents;
import com.github.retrooper.packetevents.event.PacketListener;
import com.github.retrooper.packetevents.event.PacketSendEvent;
import com.github.retrooper.packetevents.protocol.entity.data.EntityData;
import com.github.retrooper.packetevents.protocol.entity.type.EntityType;
import com.github.retrooper.packetevents.protocol.entity.type.EntityTypes;
import com.github.retrooper.packetevents.protocol.packettype.PacketType;
import com.github.retrooper.packetevents.protocol.player.Equipment;
import com.github.retrooper.packetevents.protocol.player.User;
import com.github.retrooper.packetevents.protocol.teleport.RelativeFlag;
import com.github.retrooper.packetevents.util.Vector3d;
import com.github.retrooper.packetevents.wrapper.PacketWrapper;
import com.github.retrooper.packetevents.wrapper.play.server.*;
import games.cubi.raycastedantiesp.core.config.ConfigManager;
import games.cubi.locatables.Locatable;
import games.cubi.logs.Logger;
import games.cubi.raycastedantiesp.core.locatables.NettyEntityLocatable;
import games.cubi.raycastedantiesp.core.players.PlayerData;
import games.cubi.raycastedantiesp.core.players.PlayerRegistry;
import games.cubi.raycastedantiesp.core.utils.IntArrayList;
import games.cubi.raycastedantiesp.core.view.EntityView;
import games.cubi.raycastedantiesp.core.view.EntityViewTransition;
import games.cubi.raycastedantiesp.core.view.controller.PacketEntityViewController;
import games.cubi.raycastedantiesp.packetevents.locatables.PacketEventsEntity;
import games.cubi.raycastedantiesp.packetevents.replaydata.PacketEventsEntityReplayData;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.UUID;
import java.util.function.IntSupplier;
import static games.cubi.raycastedantiesp.core.locatables.NettyEntityLocatable.NO_LEASHER;
import static games.cubi.raycastedantiesp.core.locatables.NettyEntityLocatable.NO_VEHICLE;
public abstract class PacketEventsEntityViewController extends PacketEntityViewController<PacketWrapper<?>> implements PacketListener {
private final IntSupplier CURRENT_TICK_SUPPLIER;
private final PacketEventsCommonViewController COMMON;
private static PacketEventsEntityViewController SELF; //TODO Switch to LazyConstant once out of preview (see https://openjdk.org/jeps/526)
public static PacketEventsEntityViewController get() {
if (SELF == null) {
SELF = (PacketEventsEntityViewController) PacketEntityViewController.get();
}
return SELF;
}
protected PacketEventsEntityViewController(IntSupplier currentTickSupplier) {
this.CURRENT_TICK_SUPPLIER = currentTickSupplier;
COMMON = PacketEventsCommonViewController.get(currentTickSupplier);
}
protected abstract UUID resolveWorldUUID(User user);
public void removeViewer(UUID viewerUUID) {
}
@Override
public void onPacketSend(PacketSendEvent event) {
UUID viewerUUID = event.getUser().getUUID();
if (viewerUUID == null) {
return;
}
PlayerData playerData = PlayerRegistry.getInstance().getPlayerData(viewerUUID);
if (event.getPacketType() == PacketType.Login.Server.LOGIN_SUCCESS) {
handleLoginPhaseLoginPacket(viewerUUID, CURRENT_TICK_SUPPLIER.getAsInt());
return;
}
if (event.getPacketType() == PacketType.Play.Server.JOIN_GAME) {
WrapperPlayServerJoinGame packet = new WrapperPlayServerJoinGame(event);
handlePlayPhaseLoginPacket(packet.getEntityId(), viewerUUID, CURRENT_TICK_SUPPLIER.getAsInt());
}
if (playerData == null) {
return;
}
if (ConfigManager.get().getEntityConfig() != entityConfig) {
entityConfig = ConfigManager.get().getEntityConfig();
hideOnSpawnEntityDistanceSquared = entityConfig.hideOnSpawnDistance() * entityConfig.hideOnSpawnDistance();
}
if (ConfigManager.get().getPlayerConfig() != playerConfig) {
playerConfig = ConfigManager.get().getPlayerConfig();
hideOnSpawnPlayerDistanceSquared = playerConfig.hideOnSpawnDistance() * playerConfig.hideOnSpawnDistance();
}
Locatable ownLocation = playerData.ownLocation();
UUID world = ownLocation != null ? ownLocation.world() : resolveWorldUUID(event.getUser());
int currentTick = CURRENT_TICK_SUPPLIER.getAsInt();
handleEntityPackets(event, event.getUser(), playerData, world, currentTick);
if (playerData.entityView().hasPendingTransitions()) {
processEntityTransitions(viewerUUID, event.getUser(), cast(playerData.entityView()));
}
if (playerData.playerView().hasPendingTransitions()) {
processEntityTransitions(viewerUUID, event.getUser(), cast(playerData.playerView()));
}
//event.getUser().flushPackets();
playerData.nettyData().evictPendingPostSpawnTasksIfRequired(currentTick);
}
private void handleEntityPackets(PacketSendEvent event, User viewer, PlayerData playerData, UUID world, int currentTick) {
//code readability helper constant
final boolean REQUIRE_EVENT_CANCELLATION = true;
switch (event.getPacketType()) {
case PacketType.Play.Server.SPAWN_LIVING_ENTITY -> {
Logger.error("Received spawn living entity packet. This packet type should not be used in modern Minecraft versions, and its presence likely indicates a protocol mapping issue. Viewer=" + viewer.getUUID() + " tick=" + currentTick, 2, PacketEventsEntityViewController.class);
throw new RuntimeException("Spawn Living Entity packet appeared. This shouldn't exist");
//if (handleLivingEntitySpawn(new WrapperPlayServerSpawnLivingEntity(event), playerData, world, currentTick) == REQUIRE_EVENT_CANCELLATION)
// event.setCancelled(true);
}
case PacketType.Play.Server.SPAWN_ENTITY -> {
WrapperPlayServerSpawnEntity packet = new WrapperPlayServerSpawnEntity(event);
Logger.debug("Spawning entity for player " + viewer.getUUID() + " entity #" + packet.getEntityId() + " tick=" + currentTick + " type=" + packet.getEntityType().getName());
if (handleEntitySpawn(packet, packet.getEntityId(), packet.getEntityType().isInstanceOf(EntityTypes.PLAYER), playerData, world, currentTick) == REQUIRE_EVENT_CANCELLATION)
event.setCancelled(true);
}
case PacketType.Play.Server.ENTITY_ANIMATION -> {
if (handleEntityAnimation(new WrapperPlayServerEntityAnimation(event).getEntityId(), playerData) == REQUIRE_EVENT_CANCELLATION)
event.setCancelled(true);
}
case PacketType.Play.Server.ENTITY_STATUS -> {
if (handleEntityEvent(new WrapperPlayServerEntityStatus(event).getEntityId(), playerData) == REQUIRE_EVENT_CANCELLATION)
event.setCancelled(true);
}
case PacketType.Play.Server.HURT_ANIMATION -> {
if (handleHurtAnimation(new WrapperPlayServerHurtAnimation(event).getEntityId(), playerData) == REQUIRE_EVENT_CANCELLATION)
event.setCancelled(true);
}
case PacketType.Play.Server.SPAWN_PAINTING -> {
throw new RuntimeException("Spawn Painting packet appeared. This shouldn't exist");
//if (handlePaintingSpawn(new WrapperPlayServerSpawnPainting(event), playerData, world, currentTick) == REQUIRE_EVENT_CANCELLATION)
// event.setCancelled(true);
}
case PacketType.Play.Server.SPAWN_PLAYER -> {
Logger.error("Received spawn player entity packet. This packet type should not be used in modern Minecraft versions, and its presence likely indicates a protocol mapping issue. Viewer=" + viewer.getUUID() + " tick=" + currentTick, 2, PacketEventsEntityViewController.class);
throw new RuntimeException("Spawn Player packet appeared. This shouldn't exist");
//if (handlePlayerSpawn(new WrapperPlayServerSpawnPlayer(event), playerData, world, currentTick) == REQUIRE_EVENT_CANCELLATION)
// event.setCancelled(true);
}
case PacketType.Play.Server.ENTITY_RELATIVE_MOVE -> {
if (handleRelativeMove(new WrapperPlayServerEntityRelativeMove(event), playerData, currentTick) == REQUIRE_EVENT_CANCELLATION)
event.setCancelled(true);
}
case PacketType.Play.Server.ENTITY_RELATIVE_MOVE_AND_ROTATION -> {
if (handleRelativeMoveAndRotation(new WrapperPlayServerEntityRelativeMoveAndRotation(event), playerData, currentTick) == REQUIRE_EVENT_CANCELLATION)
event.setCancelled(true);
}
case PacketType.Play.Server.ENTITY_TELEPORT -> {
if (handleTeleport(new WrapperPlayServerEntityTeleport(event), playerData, currentTick) == REQUIRE_EVENT_CANCELLATION)
event.setCancelled(true);
}
case PacketType.Play.Server.ENTITY_POSITION_SYNC -> {
if (handlePositionSync(new WrapperPlayServerEntityPositionSync(event), playerData, currentTick) == REQUIRE_EVENT_CANCELLATION)
event.setCancelled(true);
}
case PacketType.Play.Server.ENTITY_ROTATION -> {
if (handleEntityRotation(new WrapperPlayServerEntityRotation(event), playerData, currentTick) == REQUIRE_EVENT_CANCELLATION)
event.setCancelled(true);
}
case PacketType.Play.Server.ENTITY_HEAD_LOOK -> {
if (handleEntityHeadLook(new WrapperPlayServerEntityHeadLook(event), playerData, currentTick) == REQUIRE_EVENT_CANCELLATION)
event.setCancelled(true);
}
case PacketType.Play.Server.ENTITY_METADATA -> {
WrapperPlayServerEntityMetadata packet = new WrapperPlayServerEntityMetadata(event);
if (handleEntityMetadata(packet, packet.getEntityId(), playerData, currentTick) == REQUIRE_EVENT_CANCELLATION)
event.setCancelled(true);
}
case PacketType.Play.Server.REMOVE_ENTITY_EFFECT -> {
WrapperPlayServerRemoveEntityEffect packet = new WrapperPlayServerRemoveEntityEffect(event);
if (handleRemoveEntityEffect(packet, packet.getEntityId(), playerData, currentTick) == REQUIRE_EVENT_CANCELLATION)
event.setCancelled(true);
}
case PacketType.Play.Server.ENTITY_EQUIPMENT -> {
WrapperPlayServerEntityEquipment packet = new WrapperPlayServerEntityEquipment(event);
if (handleEntityEquipment(packet, packet.getEntityId(), playerData, currentTick) == REQUIRE_EVENT_CANCELLATION)
event.setCancelled(true);
}
case PacketType.Play.Server.ENTITY_VELOCITY -> {
WrapperPlayServerEntityVelocity packet = new WrapperPlayServerEntityVelocity(event);
if (handleEntityVelocity(packet, packet.getEntityId(), playerData, currentTick) == REQUIRE_EVENT_CANCELLATION)
event.setCancelled(true);
}
case PacketType.Play.Server.ENTITY_EFFECT -> {
WrapperPlayServerEntityEffect packet = new WrapperPlayServerEntityEffect(event);
if (handleEntityEffect(packet, packet.getEntityId(), playerData, currentTick) == REQUIRE_EVENT_CANCELLATION)
event.setCancelled(true);
}
case PacketType.Play.Server.SET_PASSENGERS -> {
WrapperPlayServerSetPassengers packet = new WrapperPlayServerSetPassengers(event);
if (handleEntityPassengers(packet.getEntityId(), packet.getPassengers(), playerData, currentTick) == REQUIRE_EVENT_CANCELLATION)
event.setCancelled(true);
}
case PacketType.Play.Server.DESTROY_ENTITIES -> {
handleDestroyEntities(new WrapperPlayServerDestroyEntities(event).getEntityIds(), playerData, currentTick);
}
case PacketType.Play.Server.UPDATE_ATTRIBUTES -> {
WrapperPlayServerUpdateAttributes wrapper = new WrapperPlayServerUpdateAttributes(event);
if (handleAttributeUpdate(wrapper, wrapper.getEntityId(), playerData, currentTick) == REQUIRE_EVENT_CANCELLATION)
event.setCancelled(true);
}
case PacketType.Play.Server.ATTACH_ENTITY -> {
WrapperPlayServerAttachEntity wrapper = new WrapperPlayServerAttachEntity(event);
if (handleLeashEntity(wrapper.getAttachedId(), wrapper.getHoldingId(), playerData, currentTick) == REQUIRE_EVENT_CANCELLATION)
event.setCancelled(true);
}
default -> {}
}
}
protected NettyEntityLocatable<?,?> createSelfEntity(PlayerData ownData, int entityID, UUID playerUUID) {
return PacketEventsEntity.createSelfEntity(ownData, entityID, playerUUID);
}
@Override
protected @NotNull NettyEntityLocatable<?,?> processEntitySpawn(PlayerData playerData, PacketWrapper<?> packetWrapper, UUID world, int currentTick) {
WrapperPlayServerSpawnEntity packet = (WrapperPlayServerSpawnEntity) packetWrapper;
if (packet.getUUID().isEmpty()) {
Logger.errorAndReturn(new RuntimeException("Entity UUID null when handling spawn entity packet, id=" + packet.getEntityId() + " tick=" + currentTick), 2, PacketEventsEntityViewController.class);
return null;
}
UUID entityUUID = packet.getUUID().get();
PacketEventsEntity entity = trackEntitySpawn(playerData, entityUUID, packet.getEntityId(), world,
packet.getPosition().getX(), packet.getPosition().getY(), packet.getPosition().getZ(), packet.getEntityType());
Vector3d velocity = packet.getVelocity().orElseGet(Vector3d::zero);
entity.setEntityData(packet.getData())
.setYaw(packet.getYaw())
.setPitch(packet.getPitch())
.setHeadYaw(packet.getHeadYaw())
.setVelocity(velocity.getX(), velocity.getY(), velocity.getZ());
return entity;
}
@Override
protected int processRelativeMovePacket(PacketWrapper<?> packetWrapper, PlayerData playerData, int currentTick) {
WrapperPlayServerEntityRelativeMove packet = (WrapperPlayServerEntityRelativeMove) packetWrapper;
int entityID = packet.getEntityId();
NettyEntityLocatable<?,?> entity = playerData.entityFromID(entityID);
if (entity == null) {
Logger.error("Received relative move packet for unknown entity, id=" + entityID, 2, PacketEventsEntityViewController.class);
return entityID;
}
entity.add(packet.getDeltaX(), packet.getDeltaY(), packet.getDeltaZ());
entity.setOnGround(packet.isOnGround());
return entityID;
}
@Override
protected int processRelativeMoveAndRotationPacket(PacketWrapper<?> packet, PlayerData playerData, int currentTick) {
WrapperPlayServerEntityRelativeMoveAndRotation packetWrapper = (WrapperPlayServerEntityRelativeMoveAndRotation) packet;
int entityID = packetWrapper.getEntityId();
NettyEntityLocatable<?,?> entity = playerData.entityFromID(entityID);
if (entity == null) {
Logger.error("Received relative move and rotation packet for unknown entity, id=" + entityID, 2, PacketEventsEntityViewController.class);
return entityID;
}
entity.add(packetWrapper.getDeltaX(), packetWrapper.getDeltaY(), packetWrapper.getDeltaZ());
entity.setYaw(packetWrapper.getYaw()).setPitch(packetWrapper.getPitch()).setOnGround(packetWrapper.isOnGround());
return entityID;
}
@Override
protected int processTeleportPacket(PacketWrapper<?> packet, PlayerData playerData, int currentTick) {
WrapperPlayServerEntityTeleport packetWrapper = (WrapperPlayServerEntityTeleport) packet;
int entityID = packetWrapper.getEntityId();
NettyEntityLocatable<?,?> entity = playerData.entityFromID(entityID);
if (entity == null) {
Logger.error("Received teleport packet for unknown entity, id=" + entityID, 2, PacketEventsEntityViewController.class);
return entityID;
}
Vector3d position = packetWrapper.getPosition();
Vector3d velocity = packetWrapper.getDeltaMovement();
entity.set(position.getX(), position.getY(), position.getZ());
entity.setYaw(packetWrapper.getYaw()).setPitch(packetWrapper.getPitch()).setVelocity(velocity.x, velocity.y, velocity.z).setOnGround(packetWrapper.isOnGround());
return entityID;
}
@Override
protected int processPositionSyncPacket(PacketWrapper<?> packet, PlayerData playerData, int currentTick) {
WrapperPlayServerEntityPositionSync packetWrapper = (WrapperPlayServerEntityPositionSync) packet;
int entityID = packetWrapper.getId();
NettyEntityLocatable<?,?> entity = playerData.entityFromID(entityID);
if (entity == null) {
Logger.error("Received position sync packet for unknown entity, id=" + entityID, 2, PacketEventsEntityViewController.class);
return entityID;
}
Vector3d position = packetWrapper.getValues().getPosition();
Vector3d velocity = packetWrapper.getValues().getDeltaMovement();
entity.set(position.getX(), position.getY(), position.getZ());
entity.setYaw(packetWrapper.getValues().getYaw()).setPitch(packetWrapper.getValues().getPitch()).setVelocity(velocity.x, velocity.y, velocity.z).setOnGround(packetWrapper.isOnGround());
return entityID;
}
@Override
protected void cachePacket(PacketWrapper<?> packet, int entityID, PlayerData playerData, int currentTick) {
NettyEntityLocatable<?,?> entity = playerData.entityFromID(entityID);
if (entity == null) {
Logger.warning("Attempted to cache packet for unknown entity, id=" + entityID + " packet=" + packet.getClass().getSimpleName() + ". Queuing retry.", 6, PacketEventsEntityViewController.class);
playerData.nettyData().addPostEntitySpawnTask(entityID, new PECacheablePacketReconciliationTask(this, playerData, entityID, packet, currentTick));
return;
}
ensureReplayData((PacketEventsEntity) entity).addPacket(packet);
}
@Override
protected int processRotationPacket(PacketWrapper<?> packet, PlayerData playerData, int currentTick) {
WrapperPlayServerEntityRotation packetWrapper = (WrapperPlayServerEntityRotation) packet;
int entityID = packetWrapper.getEntityId();
NettyEntityLocatable<?,?> entity = playerData.entityFromID(entityID);
if (entity == null) {
Logger.error("Received rotation packet for unknown entity, id=" + entityID, 2, PacketEventsEntityViewController.class);
return entityID;
}
entity.setYaw(packetWrapper.getYaw()).setPitch(packetWrapper.getPitch()).setOnGround(packetWrapper.isOnGround());
return entityID;
}
@Override
protected int processHeadLookPacket(PacketWrapper<?> packet, PlayerData playerData, int currentTick) {
WrapperPlayServerEntityHeadLook packetWrapper = (WrapperPlayServerEntityHeadLook) packet;
int entityID = packetWrapper.getEntityId();
NettyEntityLocatable<?,?> entity = playerData.entityFromID(entityID);
if (entity == null) {
Logger.error("Received head look packet for unknown entity, id=" + entityID, 2, PacketEventsEntityViewController.class);
return entityID;
}
entity.setHeadYaw(packetWrapper.getHeadYaw());
return entityID;
}
@Override
protected int processEntityVelocityPacket(PacketWrapper<?> packet, PlayerData playerData, int currentTick) {
WrapperPlayServerEntityVelocity packetWrapper = (WrapperPlayServerEntityVelocity) packet;
int entityID = packetWrapper.getEntityId();
NettyEntityLocatable<?,?> entity = playerData.entityFromID(entityID);
if (entity == null) {
Logger.error("Received velocity packet for unknown entity, id=" + entityID, 2, PacketEventsEntityViewController.class);
return entityID;
}
entity.setVelocity(packetWrapper.getVelocity().getX(), packetWrapper.getVelocity().getY(), packetWrapper.getVelocity().getZ());
return entityID;
}
@Override
protected void sendEntityPassengerPacket(int vehicle, ArrayList<Integer> passengers, PlayerData playerData) {
NettyEntityLocatable<?,?> entity = playerData.entityFromID(vehicle);
if (entity == null) {
Logger.error("Attempted to send passenger packet for unknown entity, id=" + vehicle, 2, PacketEventsEntityViewController.class);
return;
}
WrapperPlayServerSetPassengers packet = new WrapperPlayServerSetPassengers(vehicle, passengers.stream().mapToInt(Integer::intValue).toArray());
Object channel = PacketEvents.getAPI().getProtocolManager().getChannel(playerData.getPlayerUUID());
PacketEvents.getAPI().getProtocolManager().getUser(channel).writePacketSilently(packet);
}
private PacketEventsEntity trackEntitySpawn(PlayerData playerData, UUID entityUUID, int entityID, UUID world, double x, double y, double z, EntityType entityType) {
PacketEventsEntity entity = new PacketEventsEntity(playerData, world, x, y, z, entityID, entityUUID, false, entityType, true /*default value as this is handled in PacketEntityViewController*/);
ensureReplayData(entity);
return entity;
}
private void processEntityTransitions(UUID viewerUUID, User viewer, EntityView<PacketEventsEntity> entityView) {
for (EntityViewTransition transition : entityView.drainTransitions()) {
PacketEventsEntity entity = getTrackedEntity(entityView, transition.targetUUID());
switch (transition.type()) {
case HIDE -> {
if (entity != null && entity.clientVisible() && entity.entityID() >= 0) {
viewer.writePacketSilently(new WrapperPlayServerDestroyEntities(entity.entityID()));
entity.setClientVisible(false);
}
}
case SHOW -> {
if (entity == null || entity.isSelfEntity()) {
Logger.warning("PacketEvents.processEntityTransitions show-skipped viewer=" + viewerUUID
+ " target=" + transition.targetUUID()
+ " reason="
+ (entity == null ? "missing-entity" : "self-entity"), 2, PacketEventsEntityViewController.class);
continue;
}
PacketEventsEntityReplayData replayData = ensureReplayData(entity);
sendEntityShow(viewer, PlayerRegistry.getInstance().getPlayerData(viewerUUID), entity, replayData);
entity.setClientVisible(true);
}
}
}
}
private PacketWrapper<?> buildSpawnPacket(PacketEventsEntity entity) {
if (entity.isSelfEntity()) {
Logger.errorAndReturn(new RuntimeException("Should not build spawn packet for self entity"), 1, PacketEventsEntityViewController.class);
return null;
}
return new WrapperPlayServerSpawnEntity(
entity.entityID(),
Optional.of(entity.entityUUID()),
entity.entityType(),
new Vector3d(entity.x(), entity.y(), entity.z()),
entity.pitch(),
entity.yaw(),
entity.headYaw(),
entity.entityData(),
Optional.of(new Vector3d(entity.velocityX(), entity.velocityY(), entity.velocityZ()))
);
}
private WrapperPlayServerSetPassengers buildPassengersPacket(@Nullable NettyEntityLocatable<?,?> entity, PlayerData playerData) {
if (entity == null) {
return null;
}
int[] passengerIDs = entity.passengerIDs();
if (passengerIDs == null || passengerIDs.length == 0) {
return null;
}
ArrayList<Integer> visiblePassengerIDs = new ArrayList<>();
for (int passengerID : passengerIDs) {
NettyEntityLocatable<?,?> passenger = playerData.entityFromID(passengerID);
if (passenger != null && passenger.visible()) {
visiblePassengerIDs.add(passengerID);
}
}
return new WrapperPlayServerSetPassengers(entity.entityID(), visiblePassengerIDs.stream().mapToInt(Integer::intValue).toArray());
}
private @Nullable WrapperPlayServerAttachEntity[] buildLeashPackets(PacketEventsEntity entity, PlayerData playerData) {
int[] leashedIDs = entity.leashedEntityIDsOrNull();
int leashingID = entity.leashingEntity();
WrapperPlayServerAttachEntity leashingShow = null;
if (leashingID != NO_LEASHER) {
NettyEntityLocatable<?,?> leashHolder = playerData.entityFromID(leashingID);
if (leashHolder != null && leashHolder.visible()) {
leashingShow = new WrapperPlayServerAttachEntity(entity.entityID(), leashingID, true);
}
}
if (leashedIDs == null || leashedIDs.length == 0) {
return leashingShow == null ? null : new WrapperPlayServerAttachEntity[]{leashingShow};
}
WrapperPlayServerAttachEntity[] packets = new WrapperPlayServerAttachEntity[leashedIDs.length + (leashingShow == null ? 0 : 1)];
int index = 0;
if (leashingShow != null) {
packets[0] = leashingShow;
index = 1;
}
for (int leashedID : leashedIDs) {
NettyEntityLocatable<?,?> leashHolder = playerData.entityFromID(leashedID);
if (leashHolder != null && leashHolder.visible()) {
packets[index] = new WrapperPlayServerAttachEntity(leashedID, entity.entityID(), true);
index++;
}
}
return packets;
}
private WrapperPlayServerEntityEffect copyEffectPacket(WrapperPlayServerEntityEffect effect) {
WrapperPlayServerEntityEffect copy = new WrapperPlayServerEntityEffect(
effect.getEntityId(),
effect.getPotionType(),
effect.getEffectAmplifier(),
effect.getEffectDurationTicks(),
buildEffectFlags(effect.isAmbient(), effect.isVisible(), effect.isShowIcon())
);
copy.setFactorData(effect.getFactorData());
return copy;
}
private WrapperPlayServerEntityMetadata copyEntityMetadataPacket(WrapperPlayServerEntityMetadata packet) {
return new WrapperPlayServerEntityMetadata(
packet.getEntityId(),
copyEntityMetadata(packet.getEntityMetadata())
);
}
private WrapperPlayServerEntityEquipment copyEntityEquipmentPacket(WrapperPlayServerEntityEquipment packet) {
return new WrapperPlayServerEntityEquipment(
packet.getEntityId(),
copyEquipment(packet.getEquipment())
);
}
private WrapperPlayServerEntityVelocity copyEntityVelocityPacket(WrapperPlayServerEntityVelocity packet) {
return new WrapperPlayServerEntityVelocity(
packet.getEntityId(),
new Vector3d(packet.getVelocity().getX(), packet.getVelocity().getY(), packet.getVelocity().getZ())
);
}
private WrapperPlayServerRemoveEntityEffect copyRemoveEntityEffectPacket(WrapperPlayServerRemoveEntityEffect packet) {
return new WrapperPlayServerRemoveEntityEffect(
packet.getEntityId(),
packet.getPotionType()
);
}
private List<EntityData<?>> copyEntityMetadata(List<EntityData<?>> metadata) {
return metadata == null ? List.of() : List.copyOf(metadata);
}
private List<Equipment> copyEquipment(List<Equipment> equipment) {
return equipment == null ? List.of() : List.copyOf(equipment);
}
private byte buildEffectFlags(boolean ambient, boolean visible, boolean showIcon) {
byte flags = 0;
if (ambient) {
flags |= 1;
}
if (visible) {
flags |= 2;
}
if (showIcon) {
flags |= 4;
}
return flags;
}
@SuppressWarnings("unchecked")
public <T> T cast(Object value) {
return (T) value;
}
private PacketEventsEntity getTrackedEntity(EntityView<PacketEventsEntity> entityView, UUID entityUUID) {
return entityView.getEntity(entityUUID);
}
private PacketEventsEntity getTrackedEntity(EntityView<PacketEventsEntity> entityView, int entityID) {
return entityView.getEntity(entityID);
}
PacketEventsEntityReplayData ensureReplayData(PacketEventsEntity entity) {
PacketEventsEntityReplayData replayData = entity.packetReplayData();
if (replayData == null) {
replayData = PacketEventsEntityReplayData.create();
entity.setPacketReplayData(replayData);
}
return replayData;
}
private void sendEntityShow(User viewer, PlayerData data, PacketEventsEntity entity, PacketEventsEntityReplayData replayData) {
viewer.writePacketSilently(buildSpawnPacket(entity));
sendEntityAbsoluteCorrection(viewer, entity);
for (PacketWrapper<?> cachedPacket : replayData.getPackets()) {
if (cachedPacket.getClass() == WrapperPlayServerEntityMetadata.class) {
WrapperPlayServerEntityMetadata metadataPacket = copyEntityMetadataPacket((WrapperPlayServerEntityMetadata) cachedPacket);
viewer.writePacketSilently(metadataPacket);
} else if (cachedPacket.getClass() == WrapperPlayServerEntityEquipment.class) {
WrapperPlayServerEntityEquipment equipmentPacket = copyEntityEquipmentPacket((WrapperPlayServerEntityEquipment) cachedPacket);
viewer.writePacketSilently(equipmentPacket);
} else if (cachedPacket.getClass() == WrapperPlayServerEntityVelocity.class) {
WrapperPlayServerEntityVelocity velocityPacket = copyEntityVelocityPacket((WrapperPlayServerEntityVelocity) cachedPacket);
viewer.writePacketSilently(velocityPacket);
} else if (cachedPacket.getClass() == WrapperPlayServerEntityEffect.class) {
viewer.writePacketSilently(copyEffectPacket((WrapperPlayServerEntityEffect) cachedPacket));
} else if (cachedPacket.getClass() == WrapperPlayServerRemoveEntityEffect.class) {
viewer.writePacketSilently(copyRemoveEntityEffectPacket((WrapperPlayServerRemoveEntityEffect) cachedPacket));
} else if (cachedPacket.getClass() == WrapperPlayServerUpdateAttributes.class) {
WrapperPlayServerUpdateAttributes existing = (WrapperPlayServerUpdateAttributes) cachedPacket;
WrapperPlayServerUpdateAttributes copy = new WrapperPlayServerUpdateAttributes(existing.getEntityId(), existing.getProperties());
viewer.writePacketSilently(copy);
}
else {
Logger.warning("Unsupported cached packet type for replay: " + cachedPacket.getClass().getName(), 2, PacketEventsEntityViewController.class);
}
}
COMMON.writeIfPresent(viewer, buildPassengersPacket(entity, data));
if (entity.vehicleID() != NO_VEHICLE) {
COMMON.writeIfPresent(viewer, buildPassengersPacket(data.entityFromID(entity.vehicleID()), data));
}
WrapperPlayServerAttachEntity[] leashPackets = buildLeashPackets(entity, data);
if (leashPackets == null) return;
for (WrapperPlayServerAttachEntity leashPacket : leashPackets) {
if (leashPacket != null) {
viewer.writePacketSilently(leashPacket);
}
}
}
private void sendEntityAbsoluteCorrection(User viewer, PacketEventsEntity entity) {
if (entity.entityID() < 0) {
return;
}
viewer.writePacketSilently(new WrapperPlayServerEntityTeleport(
entity.entityID(),
new Vector3d(entity.x(), entity.y(), entity.z()),
new Vector3d(entity.velocityX(), entity.velocityY(), entity.velocityZ()),
entity.yaw(),
entity.pitch(),
RelativeFlag.NONE,
entity.onGround()
));
viewer.writePacketSilently(new WrapperPlayServerEntityHeadLook(entity.entityID(), entity.headYaw()));
}
protected void insertEntityToPlayerView(NettyEntityLocatable<?,?> entity, PlayerData playerData) {
playerData.playerView().insertEntity(entity.cast());
reconcileUnresolvedLeashes(entity, playerData);
}
protected void insertEntityToEntityView(NettyEntityLocatable<?,?> entity, PlayerData playerData) {
playerData.entityView().insertEntity(entity.cast()); //todo: no need to put here, move to abstract packet view controller
reconcileUnresolvedLeashes(entity, playerData);
}
private void reconcileUnresolvedLeashes(NettyEntityLocatable<?,?> insertedEntity, PlayerData playerData) {
int[] pendingLeashedEntityIDs = playerData.nettyData().consumeUnresolvedLeashes(insertedEntity.entityID());
if (IntArrayList.isEmpty(pendingLeashedEntityIDs)) {
return;
}
for (int leashedEntityID : pendingLeashedEntityIDs) {
NettyEntityLocatable<?,?> leashedEntity = playerData.entityFromID(leashedEntityID);
if (leashedEntity == null || leashedEntity.leashingEntity() != insertedEntity.entityID()) {
continue;
}
insertedEntity.addLeashedEntity(leashedEntityID);
}
if (!insertedEntity.clientVisible()) {
return;
}
WrapperPlayServerAttachEntity[] leashPackets = buildLeashPackets((PacketEventsEntity) insertedEntity, playerData);
if (leashPackets == null) {
return;
}
Object channel = PacketEvents.getAPI().getProtocolManager().getChannel(playerData.getPlayerUUID());
User viewer = PacketEvents.getAPI().getProtocolManager().getUser(channel);
for (WrapperPlayServerAttachEntity leashPacket : leashPackets) {
if (leashPacket != null) {
viewer.writePacketSilently(leashPacket);
}
}
}
}
+148
View File
@@ -0,0 +1,148 @@
import java.time.Instant
import org.gradle.jvm.toolchain.JavaToolchainService
plugins {
id("java-library")
id("io.papermc.paperweight.userdev") version "2.0.0-beta.21"
id("xyz.jpenilla.run-paper") version "3.0.2"
id("com.gradleup.shadow") version "9.4.0"
}
repositories {
mavenCentral()
maven { url = uri("https://repo.codemc.io/repository/maven-releases/") }
maven { url = uri("https://repo.codemc.io/repository/maven-snapshots/") }
maven { url = uri("https://eldonexus.de/repository/maven-public/") }
}
dependencies {
paperweight.paperDevBundle("1.21.11-R0.1-SNAPSHOT")
//paperweight.paperDevBundle("26.1.2.build.+")
compileOnly("com.github.retrooper:packetevents-spigot:2.12.0")
compileOnly("org.spongepowered:configurate-core:4.2.0")
compileOnly("org.spongepowered:configurate-yaml:4.2.0")
compileOnly("net.strokkur.commands:annotations-paper:2.1.2")
annotationProcessor("net.strokkur.commands:processor-paper:2.1.2")
implementation("org.jetbrains:annotations:24.0.1")
implementation(project(":locatable-lib"))
implementation(project(":logging"))
implementation(project(":core"))
implementation(project(":packetevents"))
}
java {
toolchain.languageVersion = JavaLanguageVersion.of(21)
}
val javaToolchainService = project.extensions.getByType(JavaToolchainService::class.java)
group = "games.cubi.raycastedantiesp.paper"
val platformPaperVersion: String = "0.4.7-SNAPSHOT"
val coreVersion = project(":core").version.toString()
val commitShort = providers.exec {
commandLine("git", "rev-parse", "--short=8", "HEAD")
}.standardOutput.asText.map { it.trim() }
val commitFull = providers.exec {
commandLine("git", "rev-parse", "HEAD")
}.standardOutput.asText.map { it.trim() }
val buildTime = providers.provider {
Instant.now().toString().replace(":", "-") // Replace colons to avoid issues in file names on some platforms
}
val isRelease = gradle.startParameter.taskNames.any {
it.contains("buildRelease")
}
fun getVersionString(): String {
if (isRelease) {
val paperVersion = platformPaperVersion.substringBefore("-") // Remove any suffixes like "-SNAPSHOT"
return "${coreVersion}-Paper-${paperVersion}-RELEASE"
} else {
return "${coreVersion}-Paper-${platformPaperVersion}+build-${buildTime.get()}+git-${commitShort.get()}"
}
}
fun getBasicVersionString(): String {
return if (isRelease) {
platformPaperVersion.substringBefore("-") // Remove any suffixes like "-SNAPSHOT"
} else {
platformPaperVersion
}
}
version = getVersionString()
tasks {
runServer {
// Configure the Minecraft version for our task.
// This is the only required configuration besides applying the plugin.
// Your plugin's jar (or shadowJar if present) will be used automatically.
javaLauncher = javaToolchainService.launcherFor {
//languageVersion.set(paperRunJavaVersion.map(JavaLanguageVersion::of))
languageVersion.set(JavaLanguageVersion.of(25))
}
minecraftVersion("26.1.2")
//minecraftVersion("1.21.11")
jvmArgs("-Xms4G", "-Xmx4G", "-Dcom.mojang.eula.agree=true")
}
processResources {
val props = mapOf("version" to version.toString())
inputs.properties(props)
filesMatching("plugin.yml") {
expand(props)
}
val gitProps = mapOf(
"short_git" to commitShort.get(),
"long_git" to commitFull.get(),
"build_time" to buildTime.get(),
"version" to getBasicVersionString()
)
inputs.properties(gitProps)
filesMatching("build-properties/platform.yml") {
expand(gitProps)
}
}
}
tasks.shadowJar {
dependencies {
include(project(":logging"))
include(project(":locatable-lib"))
include(project(":core"))
include(project(":packetevents"))
}
archiveBaseName.set("RaycastedAntiESP")
archiveClassifier.set("")
}
tasks.jar {
archiveBaseName.set("Incorrectly-Compiled-Without-ShadowJar")
}
// This is the task to run to test if changes to the plugin are working
tasks.register("buildSnapshot") {
group = "raycasted anti-esp" //Not caps sensitive so using spacing and hyphen
description = "Builds a snapshot version of the plugin with git and build-time metadata included in the file name."
dependsOn("shadowJar")
}
tasks.register("buildRelease") {
group = "raycasted anti-esp"
description = "Builds a release version of the plugin with a clean version number (no git or build-time metadata) included in the file name."
dependsOn("shadowJar")
}
tasks.register("runPaper") {
// alias for runServer to put it in the same group as the build tasks
group = "raycasted anti-esp"
description = "Runs a Paper server with the plugin loaded for testing purposes."
dependsOn("runServer")
}
@@ -0,0 +1,117 @@
package games.cubi.raycastedantiesp.paper;
import com.destroystokyo.paper.event.server.ServerTickEndEvent;
import com.destroystokyo.paper.event.server.ServerTickStartEvent;
import games.cubi.logs.Logger;
import games.cubi.raycastedantiesp.core.players.PlayerRegistry;
import games.cubi.raycastedantiesp.paper.engine.PaperSimpleEngine;
import games.cubi.raycastedantiesp.core.players.PlayerData;
import games.cubi.raycastedantiesp.paper.utils.PaperListener;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.player.PlayerChangedWorldEvent;
import org.bukkit.event.player.PlayerJoinEvent;
import org.bukkit.event.player.PlayerMoveEvent;
import org.bukkit.event.player.PlayerQuitEvent;
import org.bukkit.event.player.PlayerRespawnEvent;
import org.bukkit.event.player.PlayerTeleportEvent;
import java.util.function.IntSupplier;
import static games.cubi.raycastedantiesp.paper.UpdateChecker.checkForUpdates;
public class EventListener extends PaperListener {
private final RaycastedAntiESP plugin;
private final PaperSimpleEngine engine;
private final IntSupplier currentTickSupplier;
private static EventListener instance = null;
private EventListener(RaycastedAntiESP plugin, PaperSimpleEngine engine, IntSupplier currentTickSupplier) {
this.plugin = plugin;
this.engine = engine;
this.currentTickSupplier = currentTickSupplier;
}
public static EventListener initialise(RaycastedAntiESP plugin, PaperSimpleEngine engine, IntSupplier currentTickSupplier) {
if (instance == null) {
instance = new EventListener(plugin, engine, currentTickSupplier);
}
return instance;
}
@EventHandler(priority = EventPriority.MONITOR)
public void onPlayerDisconnect(PlayerQuitEvent e) {
PlayerRegistry.getInstance().unregisterPlayer(e.getPlayer().getUniqueId());
}
@EventHandler(priority = EventPriority.LOWEST) //Runs first
public void onPlayerJoin(PlayerJoinEvent e) {
Player player = e.getPlayer();
if (player.hasPermission("raycastedantiesp.updatecheck")) { //todo: centralise permission strings to prevent issues when perm names are changed
checkForUpdates(plugin, player);
}
boolean hasBypassPermission = player.hasPermission("raycastedantiesp.bypass");
PlayerData playerData = PlayerRegistry.getInstance().getPlayerData(player.getUniqueId());
if (playerData == null) {
Logger.warning("Failed to load player data for " + player.getName() + " (" + player.getUniqueId() + "). Attempting to reconstruct.", 3, EventListener.class);
playerData = PlayerRegistry.getInstance().registerAndGetPlayerIfAbsent(player.getUniqueId(), hasBypassPermission, currentTickSupplier.getAsInt());
}
playerData.setBypassPermission(hasBypassPermission);
updateOwnLocation(playerData, player.getEyeLocation());
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onPlayerMove(PlayerMoveEvent event) {
PlayerData playerData = PlayerRegistry.getInstance().getPlayerData(event.getPlayer().getUniqueId());
if (playerData == null) return;
updateOwnLocation(playerData, event.getPlayer().getEyeLocation());
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onPlayerTeleport(PlayerTeleportEvent event) {
updateOwnLocation(event.getPlayer(), event.getTo());
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onPlayerChangedWorld(PlayerChangedWorldEvent event) {
updateOwnLocation(event.getPlayer(), event.getPlayer().getLocation());
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onPlayerRespawn(PlayerRespawnEvent event) {
updateOwnLocation(event.getPlayer(), event.getRespawnLocation());
}
@EventHandler(priority = EventPriority.LOWEST) //Runs first
public void serverTickStartEvent(ServerTickStartEvent event) {
Bukkit.getAsyncScheduler().runNow(plugin, task -> engine.tick());
}
@EventHandler(priority = EventPriority.MONITOR) //Runs last
public void serverTickStopEvent(ServerTickEndEvent event) {
}
private void updateOwnLocation(PlayerData playerData, Location location) {
if (playerData == null || location == null || location.getWorld() == null) {
return;
}
playerData.updateOwnLocation(location.getWorld().getUID(), location.getX(), location.getY(), location.getZ());
}
private void updateOwnLocation(Player player, Location location) {
PlayerData playerData = PlayerRegistry.getInstance().getPlayerData(player.getUniqueId());
if (playerData == null || location == null) {
return;
}
Location eyeLocation = location.clone().add(0, player.getEyeHeight(), 0);
updateOwnLocation(playerData, eyeLocation);
}
}
@@ -0,0 +1,239 @@
package games.cubi.raycastedantiesp.paper;
import games.cubi.logs.CheckPreviousLogForError;
import games.cubi.logs.PlatformLogger;
import games.cubi.raycastedantiesp.core.config.ConfigManager;
import games.cubi.raycastedantiesp.core.config.DebugConfig;
import org.bukkit.Bukkit;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Range;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.ConcurrentLinkedDeque;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
public class PaperLoggerAdapter implements PlatformLogger {
/**
* Set this to true to send logs to the file regardless of the log level.
*/
private static final boolean LOG_TO_FILE = false;
/*
* If too many logs queue up before clear() is called, flush them anyway.
* This avoids unbounded memory growth.
*/
private static final int MAX_QUEUED_MESSAGES_BEFORE_FLUSH = 128;
private final java.util.logging.Logger logger;
private final Path logFilePath;
private final ConcurrentLinkedDeque<String> queuedFileMessages = new ConcurrentLinkedDeque<>();
private final AtomicInteger queuedFileMessageCount = new AtomicInteger(0);
/*
* Prevents two threads from flushing the queue to the file at the same time.
*/
private final AtomicBoolean writingToFile = new AtomicBoolean(false);
protected PaperLoggerAdapter(java.util.logging.Logger logger, Path logFilePath) {
this.logger = Objects.requireNonNull(logger, "logger");
this.logFilePath = Objects.requireNonNull(logFilePath, "logFilePath");
if (LOG_TO_FILE) {
try {
Path parent = logFilePath.getParent();
if (parent != null) {
Files.createDirectories(parent);
}
if (!Files.exists(logFilePath)) {
Files.createFile(logFilePath);
}
} catch (IOException exception) {
throw new IllegalStateException("Could not initialise log file at " + logFilePath, exception);
}
}
}
/*
* Logging severity is from 0-10. If the configured severity is 0, no logs will be sent. If 1, only most important logs.
*
* Therefore, logs with level of 1 are most important and 10 least.
*
* Note that by default the log levels are at 5, so any logs which should appear normally should be at 1-5. Additionally, loggers which fire several times a tick should be at 10, once a tick at 9, and loggers firing frequently at 6-8
* */
private int getLevel(Level severity, DebugConfig debug) {
return switch (severity) {
case INFO -> debug.getInfoLevel();
case WARN -> debug.getWarnLevel();
case ERROR -> debug.getErrorLevel();
default -> 1;
};
}
private DebugConfig.Severity getDebugSeverity(Level severity) {
return switch (severity) {
case INFO -> DebugConfig.Severity.INFO;
case WARN -> DebugConfig.Severity.WARN;
case ERROR -> DebugConfig.Severity.ERROR;
default -> DebugConfig.Severity.ERROR;
};
}
/**
* Logs a warning message and serves as an early return. Nothing called after this method will be executed.
* @param throwable The throwable to log, used for the included stack trace. The message of the throwable will be used as the warning message
* @throws CheckPreviousLogForError Always throws this to allow for early return from functions after logging an error
* **/
@Override
public void warningAndReturn(Throwable throwable, @Range(from = 1, to = 10) int level, Class<?>... source) {
warning(PlatformLogger.processThrowable(throwable), level, source);
throw earlyReturn;
}
@Override
public void warning(Throwable throwable, @Range(from = 1, to = 10) int level, Class<?>... source) {
warning(PlatformLogger.processThrowable(throwable), level, source);
}
@Deprecated @Override
public void debug(String message) {
forwardLog(message, Level.INFO, 10);
}
@Override
public void error(Throwable throwable, @Range(from = 1, to = 10) int level, Class<?>... source) {
error(PlatformLogger.processThrowable(throwable), level, source);
}
@Override
public void error(String message, Throwable throwable, @Range(from = 1, to = 10) int level, Class<?>... source) {
error(PlatformLogger.processThrowable(throwable, message), level, source);
}
@Override
public void info(String message, @Range(from = 1, to = 10) int level, @NotNull Class<?>... source) {
forwardLog(message, Level.INFO, level, source);
}
@Override
public void warning(String message, @Range(from = 1, to = 10) int level, Class<?>... source) {
forwardLog(message, Level.WARN, level, source);
}
@Override
public void error(String message, @Range(from = 1, to = 10) int level, Class<?>... source) {
forwardLog(message, Level.ERROR, level, source);
}
private void forwardLog(String message, Level severity, int level, Class<?>... source) {
ConfigManager configManager = RaycastedAntiESP.getConfigManager();
if (LOG_TO_FILE) {
queueFileLog(PlatformLogger.constructFileLogMessage(message, severity, level, source), severity);
}
if (configManager != null && configManager.getDebugConfig() != null) {
DebugConfig debug = configManager.getDebugConfig();
if (debug.isExempted(getDebugSeverity(severity), source)) {
return;
}
if (getLevel(severity, debug) < level) {
return;
}
}
message = source != null ? PlatformLogger.constructMessage(message, source) : message;
switch (severity) {
case INFO:
logger.info(message);
break;
case WARN:
logger.warning(message);
break;
case ERROR:
logger.severe(message);
break;
default:
logger.severe(message + "| Additionally, severity " + severity + " is not supported by the logger.");
break;
}
}
private void queueFileLog(String message, Level severity) {
queuedFileMessages.addLast(message);
int queuedMessages = queuedFileMessageCount.incrementAndGet();
if (queuedMessages >= MAX_QUEUED_MESSAGES_BEFORE_FLUSH) {
flushToFile();
}
}
/**
* Flushes queued log messages to the log file asynchronously.
*/
public void flushToFile() {
if (!LOG_TO_FILE) {
return;
}
Bukkit.getAsyncScheduler().runNow(RaycastedAntiESP.get(), (ignored) -> {
if (!writingToFile.compareAndSet(false, true)) return;
try {
forceFlushToFileNow();
} finally {
writingToFile.set(false);
}
});
}
/**
* Flushes queued log messages to the log file immediately, on the calling thread. Should only be used directly before shutdown to ensure all logs are flushed, or via <code>flushToFile()</code>.
*/
public void forceFlushToFileNow() {
List<String> drainedMessages = new ArrayList<>();
String message;
while ((message = queuedFileMessages.pollFirst()) != null) {
queuedFileMessageCount.decrementAndGet();
drainedMessages.add(message);
}
if (drainedMessages.isEmpty()) {
return;
}
try {
Files.write(
logFilePath,
drainedMessages,
StandardCharsets.UTF_8,
StandardOpenOption.CREATE,
StandardOpenOption.APPEND
);
} catch (IOException exception) {
/*
* Put the messages back at the front of the queue so they are not lost.
* Reverse order is needed because addFirst() is used.
*/
for (int index = drainedMessages.size() - 1; index >= 0; index--) {
queuedFileMessages.addFirst(drainedMessages.get(index));
queuedFileMessageCount.incrementAndGet();
}
/*
* Last-resort console error. Without this, file logging failures are silent.
*/
logger.severe("Failed to write queued log messages to " + logFilePath + ": " + exception.getMessage());
}
}
}
@@ -0,0 +1,27 @@
package games.cubi.raycastedantiesp.paper;
import games.cubi.locatables.Locatable;
import games.cubi.raycastedantiesp.core.raycast.ParticleSpawner;
import org.bukkit.Bukkit;
import org.bukkit.Color;
import org.bukkit.Particle;
import java.util.Objects;
public class PaperParticleSpawner implements ParticleSpawner {
public void spawnParticleAt(Locatable locatable, Colour colour) {
Objects.requireNonNull(Bukkit.getWorld(locatable.world())).spawnParticle(Particle.DUST, locatable.x(), locatable.y(), locatable.z(), 0, toBukkitDust(colour));
}
private static final Particle.DustOptions RED_DUST = new Particle.DustOptions(Color.RED, 1);
private static final Particle.DustOptions GREEN_DUST = new Particle.DustOptions(Color.GREEN, 1);
private static final Particle.DustOptions BLUE_DUST = new Particle.DustOptions(Color.BLUE, 1);
private static Particle.DustOptions toBukkitDust(Colour colour) {
return switch (colour) {
case RED -> RED_DUST;
case GREEN -> GREEN_DUST;
case BLUE -> BLUE_DUST;
};
}
}
Loaded 100 of 125 files, more files were not shown because too many files have changed in this diff. Show more