Compare commits

...
109 Commits
Author SHA1 Message Date
Cubicake 0823dc9a83 Modrinth is deprecating the featured tag 2025-10-24 12:11:54 +10:30
Cubicake 36a44c9e0d Merge v1.6.3 changes 2025-10-22 11:38:19 +10:30
Cubicake 29f7ec211a Merge v1.6.3 changes 2025-10-22 11:30:08 +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 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 9ca8b4ee3a Rename plugin 2025-09-20 16:11:34 +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 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 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 7e0725c538 Merge changes from v1.6.x branch 2025-08-12 21:04:36 +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 87cd59b346 Pull changes from main 2025-07-27 16:45:57 +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
49 changed files with 3822 additions and 402 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']
+4
View File
@@ -1,10 +1,14 @@
# User-specific stuff
.idea/
README.md
*.md
*.iml
*.ipr
*.iws
# IntelliJ
out/
# mpeltonen/sbt-idea plugin
+657 -17
View File
@@ -1,21 +1,661 @@
MIT License
GNU AFFERO GENERAL PUBLIC LICENSE
Version 3, 19 November 2007
Copyright (c) 2025 Cubicake
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.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
Preamble
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
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 SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
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/>.
+18 -33
View File
@@ -1,39 +1,24 @@
Latest version: v1.2.2
Latest version: v1.6.0
The latest version can currently only be found on Modrinth https://modrinth.com/plugin/raycasted-entity-occlusion/
The latest version can currently only be found on Modrinth https://modrinth.com/plugin/raycasted-entity-occlusions/
This is an 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 supported versions are 1.21.x PaperMC and Pufferfish. Other server versions and software may work too.
This is a simple server-side plugin for PaperMC (May also work with Spigot, this is untested) that hides/culls entities from players if they do not have line-of-sight. All raycasts are run async to reduce performance impact.
Use cases:
- 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
Default Config:
- AlwaysShowRadius: 8
- RaycastRadius: 48
- SearchRadius: 52
- MoreChecks: false
- OccludePlayers: false
- RecheckInterval: 20
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 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 run the raycast every {RecheckInterval} ticks to reduce performance impact.
MoreChecks toggles between two raycasting modes. By default (MoreChecks = false) the plugin runs one raycast from the center of each mob to the player. This means that if the center of the mob is hidden but some parts should be visible, the player won't be able to see the mob at all. Enabling MoreChecks runs a raycast from the top, bottom, left and right of the entity to the player.
OccludePlayers toggles whether players will be checked. Enabling this prevents ESP mods from revealing players.
- 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:
- 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 MoreChecks on
- If OccludePlayers is set to true any occluded players will be removed from tablist
- When updating the plugin to a version with more config versions, no checks are performed to detect this and add the new configs to config.yml. This means that the config file will be missing several options. (This is an issue when updating to v1.1.0 or v1.2.0). To fix, just copy the new config options from the Default Config section above.
- 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.
+22 -2
View File
@@ -1,9 +1,10 @@
plugins {
id 'java'
id("xyz.jpenilla.run-paper") version "2.3.1"
}
group = 'games.cubi'
version = '1.3.0-dev'
version = '1.7.0-pre-alpha'
repositories {
mavenCentral()
@@ -15,10 +16,14 @@ repositories {
name = "sonatype"
url = "https://oss.sonatype.org/content/groups/public/"
}
maven { url = uri("https://repo.codemc.io/repository/maven-releases/") }
maven { url = uri("https://repo.codemc.io/repository/maven-snapshots/") }
}
dependencies {
compileOnly("io.papermc.paper:paper-api:1.21.4-R0.1-SNAPSHOT")
compileOnly("io.papermc.paper:paper-api:1.21.8-R0.1-SNAPSHOT")
compileOnly("com.github.retrooper:packetevents-spigot:2.8.0")
}
def targetJavaVersion = 21
@@ -46,4 +51,19 @@ processResources {
filesMatching('plugin.yml') {
expand props
}
}
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.
minecraftVersion("1.21.8")
}
}
jar {
manifest {
attributes "paperweight-mappings-namespace": "mojang"
}
}
@@ -0,0 +1,115 @@
package games.cubi.raycastedAntiESP;
import com.mojang.brigadier.Command;
import com.mojang.brigadier.arguments.StringArgumentType;
import com.mojang.brigadier.context.CommandContext;
import com.mojang.brigadier.exceptions.CommandSyntaxException;
import com.mojang.brigadier.tree.LiteralCommandNode;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import io.papermc.paper.command.brigadier.Commands;
import net.kyori.adventure.text.minimessage.MiniMessage;
import org.bukkit.command.CommandSender;
import org.bukkit.configuration.ConfigurationSection;
import games.cubi.raycastedAntiESP.config.ConfigManager;
public class CommandsManager {
private final RaycastedAntiESP plugin;
private final ConfigManager cfg;
public CommandsManager(RaycastedAntiESP plugin, ConfigManager cfg) {
this.plugin = plugin;
this.cfg = cfg;
}
public LiteralCommandNode<CommandSourceStack> registerCommand() {
//run help command if no context provided
LiteralCommandNode<CommandSourceStack> buildCommand = Commands.literal("raycastedantiesp")
.requires(sender -> sender.getSender().hasPermission("raycastedantiesp.command"))
.executes(context -> {
helpCommand(context);
return Command.SINGLE_SUCCESS;
})
.then(Commands.literal("help")
.executes(context -> helpCommand(context)))
.then(Commands.literal("reload")
.executes(context -> {
cfg.load();
context.getSource().getSender().sendMessage("[RaycastedAntiESP] Config reloaded.");
return Command.SINGLE_SUCCESS;
}))
.then(Commands.literal("config-values")
.executes(context -> {
CommandSender sender = context.getSource().getSender();
//dynamic config values
sender.sendMessage("[RaycastedAntiESP] Config values: ");
ConfigurationSection root = cfg.getConfigFile().getConfigurationSection("");
for (String path : root.getKeys(true)) {
Object val = cfg.getConfigFile().get(path);
if (val instanceof ConfigurationSection) continue;
sender.sendMessage(MiniMessage.miniMessage().deserialize("<green>" + path + "<gray> = <white>" + val));
}
return Command.SINGLE_SUCCESS;
}))
.then(Commands.literal("set")
.executes(context -> {
CommandSender sender = context.getSource().getSender();
sender.sendRichMessage("<red>Usage: /raycastedantiesp set <key> <value>");;
return 0;
})
.then(Commands.argument("key", StringArgumentType.string())
.then(Commands.argument("value", StringArgumentType.string())
.executes(context -> {
CommandSender sender = context.getSource().getSender();
String key = StringArgumentType.getString(context, "key");
String value = StringArgumentType.getString(context, "value");
int result = cfg.setConfigValue(key, value);
if (result == -1) {
sender.sendRichMessage("<red>Invalid inputs");
} else if (result == 0) {
//Integer value out of bounds 0 - 256
sender.sendRichMessage("<red>Invalid value for <white>" + key + "<red>, must be between 0 and 256");
}
else {
sender.sendRichMessage("<white>Set <green>" + key + "<white> to <green>" + value);
}
return 0;
})
)
)
)
.then(Commands.literal("test")
.executes(context -> {
testCommand(context);
return Command.SINGLE_SUCCESS;
})
)
.then(Commands.literal("check-for-updates")
.executes(context -> {
CommandSender sender = context.getSource().getSender();
UpdateChecker.checkForUpdates(plugin, sender);
return Command.SINGLE_SUCCESS;
})
)
.build();
return buildCommand;
}
public int helpCommand(CommandContext<CommandSourceStack> context) {
CommandSender sender = context.getSource().getSender();
sender.sendRichMessage("<white>RaycastedAntiESP <yellow>v" + plugin.getDescription().getVersion());
sender.sendRichMessage("<white>Commands:");
sender.sendRichMessage("<green>/raycastedantiesp reload <gray>- Reloads the config");
sender.sendRichMessage("<green>/raycastedantiesp config-values <gray>- Shows all config values");
sender.sendRichMessage("<green>/raycastedantiesp set <key> <value> <gray>- Sets a config value");
return Command.SINGLE_SUCCESS;
}
private void testCommand(CommandContext<CommandSourceStack> context) throws CommandSyntaxException {
}
}
@@ -0,0 +1,150 @@
package games.cubi.raycastedAntiESP;
import com.destroystokyo.paper.event.server.ServerTickStartEvent;
import games.cubi.raycastedAntiESP.packets.PacketProcessor;
import games.cubi.raycastedAntiESP.snapshot.ChunkSnapshotManager;
import games.cubi.raycastedAntiESP.data.DataHolder;
import games.cubi.raycastedAntiESP.config.ConfigManager;
import games.cubi.raycastedAntiESP.utils.Enums;
import io.papermc.paper.event.entity.EntityMoveEvent;
import io.papermc.paper.event.player.PlayerTrackEntityEvent;
import org.bukkit.Bukkit;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.block.BlockBreakEvent;
import org.bukkit.event.block.BlockBurnEvent;
import org.bukkit.event.block.BlockExplodeEvent;
import org.bukkit.event.block.BlockPlaceEvent;
import org.bukkit.event.player.PlayerJoinEvent;
import org.bukkit.event.player.PlayerQuitEvent;
import org.bukkit.event.world.ChunkLoadEvent;
import org.bukkit.event.world.ChunkUnloadEvent;
import java.util.UUID;
import static games.cubi.raycastedAntiESP.UpdateChecker.checkForUpdates;
public class EventListener implements Listener {
private final ChunkSnapshotManager manager;
private final ConfigManager config;
private PacketProcessor packetProcessor;
private final RaycastedAntiESP plugin;
private static EventListener instance = null;
private EventListener(RaycastedAntiESP plugin, ChunkSnapshotManager mgr, ConfigManager cfg) {
this.manager = mgr;
this.config = cfg;
this.plugin = plugin;
//load packet processor after a tick in a bukkit runnable to ensure the plugin is fully loaded TODO: All schedulers should migrate to paper/folia scheduler, also this should be moved somewhere else, maybe when the config gets the update it passes it on?
Bukkit.getScheduler().runTaskLater(plugin, () -> {
if (DataHolder.isPacketEventsPresent()) {
packetProcessor = RaycastedAntiESP.getPacketProcessor();
} else {
packetProcessor = null;
}
}, 1L);
}
public static EventListener getInstance(RaycastedAntiESP plugin, ChunkSnapshotManager mgr, ConfigManager cfg) {
if (instance == null) {
instance = new EventListener(plugin, mgr, cfg);
}
return instance;
}
// Snapshot events
@EventHandler(ignoreCancelled = true, priority = EventPriority.MONITOR)
public void onChunkLoad(ChunkLoadEvent e) {
manager.onChunkLoad(e.getChunk());
}
@EventHandler(ignoreCancelled = true, priority = EventPriority.MONITOR)
public void onChunkUnload(ChunkUnloadEvent e) {
manager.onChunkUnload(e.getChunk());
}
@EventHandler(ignoreCancelled = true, priority = EventPriority.MONITOR)
public void onPlace(BlockPlaceEvent e) {
manager.onBlockChange(e.getBlock().getLocation(), e.getBlock().getType(), Enums.BlockChangeType.BROKEN);
}
@EventHandler(ignoreCancelled = true, priority = EventPriority.MONITOR)
public void onBreak(BlockBreakEvent e) {
manager.onBlockChange(e.getBlock().getLocation(), Material.AIR, Enums.BlockChangeType.BROKEN);
}
@EventHandler(ignoreCancelled = true, priority = EventPriority.MONITOR)
public void onBurn(BlockBurnEvent e) {
manager.onBlockChange(e.getBlock().getLocation(), Material.AIR, Enums.BlockChangeType.BROKEN);
}
@EventHandler(ignoreCancelled = true, priority = EventPriority.MONITOR)
public void onExplode(BlockExplodeEvent e) {
manager.onBlockChange(e.getBlock().getLocation(), e.getBlock().getType(), Enums.BlockChangeType.BROKEN);
}
// These events do not cover all cases, but I can't be bothered to figure out a better solution rn. Frequent snapshot refreshes is the solution. If anyone has a solution please let me know.
@EventHandler(priority = EventPriority.MONITOR)
public void onPlayerDisconnect(PlayerQuitEvent e) {
if (DataHolder.isPacketEventsPresent() && packetProcessor != null) {
UUID player = e.getPlayer().getUniqueId();
packetProcessor.sendPlayerInfoRemovePacket(player);
}
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onPlayerJoin(PlayerJoinEvent event) {
Player player = event.getPlayer();
if (player.hasPermission("raycastedentityocclusions.updatecheck")) {
checkForUpdates(plugin, player);
}
DataHolder.players().registerPlayer(player.getUniqueId(), player.hasPermission("raycastedentityocclusions.bypass"));
}
@EventHandler(priority = EventPriority.LOWEST) //Runs first
public void serverTickStartEvent(ServerTickStartEvent event) {
DataHolder.incrementTick();
//TODO: connect this to new engine
}
@EventHandler(priority = EventPriority.MONITOR) //Runs last
public void serverTickStopEvent(ServerTickStartEvent event) {
DataHolder.incrementTick();
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onEntityMove(EntityMoveEvent event) {
DataHolder.entityLocation().queueEntityLocationUpdate(event.getEntity().getUniqueId(), event.getTo().add(0,event.getEntity().getHeight()/2,0));
}
@EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
public void onPlayerTrackEntity(PlayerTrackEntityEvent event) {
UUID entityUUID = event.getEntity().getUniqueId();
Player player = event.getPlayer();
UUID playerUUID = player.getUniqueId();
if (DataHolder.entityVisibility().entityVisibilityShouldChange(entityUUID, playerUUID)) return; // The player is meant to see the entity, do nothing
event.setCancelled(true);
DataHolder.entityVisibility().hideEntity(entityUUID, player);
DataHolder.players().getPlayerData(playerUUID).addEntity(entityUUID);
}
@EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
public void onPlayerUntrackEntity(PlayerTrackEntityEvent event) {
UUID entityUUID = event.getEntity().getUniqueId();
Player player = event.getPlayer();
UUID playerUUID = player.getUniqueId();
if (DataHolder.entityVisibility().entityVisibilityShouldChange(entityUUID, playerUUID)) return; // State change was triggered by us, do nothing
DataHolder.players().getPlayerData(playerUUID).removeEntity(entityUUID); // Remove entity from player's data as they are no longer tracking it, so no more raycasts are needed
}
}
@@ -0,0 +1,144 @@
package games.cubi.raycastedAntiESP;
import games.cubi.raycastedAntiESP.config.DebugConfig;
import games.cubi.raycastedAntiESP.utils.CheckPreviousLogForError;
import org.jetbrains.annotations.Range;
import java.io.BufferedWriter;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.StandardOpenOption;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.locks.ReentrantLock;
public class Logger {
/*
* 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 3, so any logs which should appear normally should be at 1-3. Additionally, loggers which fire every tick (or more often) should be at 10, and loggers firing frequently at 7-9
* */
private static final CheckPreviousLogForError earlyReturn = new CheckPreviousLogForError();
private enum Level {
INFO,
WARN,
ERROR
}
private static int getLevel(Level severity, DebugConfig debug) {
return switch (severity) {
case INFO -> debug.getInfoLevel();
case WARN -> debug.getWarnLevel();
case ERROR -> debug.getErrorLevel();
default -> 1;
};
}
/**
* 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
* **/
public static void warningAndReturn(Throwable throwable) {
warning(processThrowable(throwable), 1);
throw earlyReturn;
}
public static void error(Throwable throwable) {
error(processThrowable(throwable), 1);
}
/**
* Logs an error message including stack trace 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 error message
* @throws CheckPreviousLogForError Always throws this to allow for early return from functions after logging an error
* **/
public static void errorAndReturn(Throwable throwable) {
error(processThrowable(throwable), 1);
throw earlyReturn;
}
private static String processThrowable(Throwable throwable) {
StackTraceElement[] thrown = throwable.getStackTrace();
StringBuilder message = new StringBuilder(throwable.getMessage() != null ? throwable.getMessage() : "No error message set");
for (int i = 0; i < Math.min(3, thrown.length); i++) {
StackTraceElement element = thrown[i];
message.append(" at ").append(element.toString());
}
return message.toString();
}
public static void info(String message, @Range(from = 1, to = 10) int level) {
forwardLog(message, Level.INFO, level);
}
public static void warning(String message, @Range(from = 1, to = 10) int level) {
forwardLog(message, Level.WARN, level);
}
public static void error(String message, @Range(from = 1, to = 10) int level) {
forwardLog(message, Level.ERROR, level);
}
private static void forwardLog(String message, Level severity, int level) {
DebugConfig debug = RaycastedAntiESP.getConfigManager().getDebugConfig();
if (debug.logToFile()) logToFile(message);
if (getLevel(severity, debug) < level) {
return;
}
switch (severity) {
case INFO:
RaycastedAntiESP.logger().info(message);
case WARN:
RaycastedAntiESP.logger().warning(message);
case ERROR:
RaycastedAntiESP.logger().severe(message);
default:
RaycastedAntiESP.logger().severe(message + "| Additionally, severity " + severity + " is not supported by the logger.");
}
}
private static final AtomicReference<ConcurrentLinkedQueue<String>> logBuffer = new AtomicReference<>(new ConcurrentLinkedQueue<String>());
private static final String logName = System.currentTimeMillis()+""; // Unique and new logs will have larger numbers
private static final ReentrantLock flushLock = new ReentrantLock();
private static void logToFile(String line) {
if (line == null) return;
logBuffer.get().offer(line);
}
public static void flush() {
flushLock.lock();
try {
// Atomically swap buffers so producers can keep logging without blocking on I/O.
ConcurrentLinkedQueue<String> toWrite = logBuffer.getAndSet(new ConcurrentLinkedQueue<>());
if (toWrite.isEmpty()) return;
try (BufferedWriter w = Files.newBufferedWriter(
RaycastedAntiESP.get().getDataFolder().toPath().resolve("logs").resolve( logName +".log"),
StandardCharsets.UTF_8,
StandardOpenOption.CREATE,
StandardOpenOption.WRITE,
StandardOpenOption.APPEND)) {
String s;
while ((s = toWrite.poll()) != null) {
w.write(s);
w.newLine(); // ensure each entry is on its own line
}
} catch (IOException e) {
errorAndReturn(e);
}
} finally {
flushLock.unlock();
}
}
}
@@ -0,0 +1,129 @@
package games.cubi.raycastedAntiESP;
import com.mojang.brigadier.Command;
import com.mojang.brigadier.tree.LiteralCommandNode;
import games.cubi.raycastedAntiESP.engine.Engine;
import games.cubi.raycastedAntiESP.packets.PacketProcessor;
import games.cubi.raycastedAntiESP.packets.Registrar;
import games.cubi.raycastedAntiESP.raycast.MovementTracker;
import games.cubi.raycastedAntiESP.snapshot.ChunkSnapshotManager;
import games.cubi.raycastedAntiESP.config.ConfigManager;
import games.cubi.raycastedAntiESP.data.DataHolder;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import io.papermc.paper.command.brigadier.Commands;
import io.papermc.paper.plugin.lifecycle.event.types.LifecycleEvents;
import org.bukkit.Bukkit;
import org.bukkit.command.CommandExecutor;
import org.bukkit.plugin.Plugin;
import org.bukkit.plugin.java.JavaPlugin;
import org.bukkit.scheduler.BukkitRunnable;
import games.cubi.raycastedAntiESP.bStats.MetricsCollector;
public final class RaycastedAntiESP extends JavaPlugin implements CommandExecutor {
private static ConfigManager cfg;
private static ChunkSnapshotManager snapMgr;
private static MovementTracker tracker;
private static CommandsManager commands;
private static Engine engine;
private boolean packetEventsPresent = false; // Don't use this to check if PacketEvents is present, use DataHolder's packetevents field instead. This just checks if its present, not if its enabled/functional
private static PacketProcessor packetProcessor = null;
private static RaycastedAntiESP instance;
private static java.util.logging.Logger logger;
public int tick = 0;
@Override
public void onLoad() {
logger = getLogger();
Plugin packetEvents = Bukkit.getPluginManager().getPlugin("packetevents");
if (packetEvents != null) {
packetEventsPresent = true;
getLogger().info("PacketEvents detected.");
new Registrar(this);
} else {
getLogger().info("PacketEvents not detected, disabling packet-based tablist modification. Don't worry, the plugin will still work without it.");
}
}
@Override
public void onEnable() {
instance = this;
cfg = ConfigManager.initiateConfigManager(this);
snapMgr = new ChunkSnapshotManager(this, cfg);
tracker = new MovementTracker(this, cfg);
commands = new CommandsManager(this, cfg);
UpdateChecker.checkForUpdates(this, Bukkit.getConsoleSender());
getServer().getPluginManager().registerEvents(EventListener.getInstance(this, snapMgr, cfg), this);
//Brigadier API
LiteralCommandNode<CommandSourceStack> buildCommand = commands.registerCommand();
this.getLifecycleManager().registerEventHandler(LifecycleEvents.COMMANDS, commands -> {
commands.registrar().register(buildCommand);
//alias "antiesp"
commands.registrar().register(Commands.literal("antiesp")
.requires(sender -> sender.getSender().hasPermission("raycastedantiesp.command"))
.executes(context -> {
new CommandsManager(this, cfg).helpCommand(context);
return Command.SINGLE_SUCCESS;
})
.redirect(buildCommand).build());
});
//bStats
new MetricsCollector(this, cfg);
// TODO: Move this somewhere else, the main class should be cleaner
new BukkitRunnable() {
@Override
public void run() {
tick++; /*
EngineOld.runEngine(cfg, snapMgr, tracker, RaycastedEntityOcclusion.this);
EngineOld.runTileEngine(cfg, snapMgr, tracker, RaycastedEntityOcclusion.this);*/
}
}.runTaskTimer(this, 0L, 1L);
new BukkitRunnable() {
@Override
public void run() {
if (packetEventsPresent && Bukkit.getPluginManager().isPluginEnabled("packetevents")) {
DataHolder.setPacketEventsPresent();
packetProcessor = new PacketProcessor(RaycastedAntiESP.get());
Logger.info("PacketEvents is enabled, enabling packet-based tablist modification.", 3);
}
}
}.runTaskLater(this, 1L);
}
@Override
public void onDisable() {
Logger.flush();
}
public static ConfigManager getConfigManager() {
return cfg;
}
public static ChunkSnapshotManager getChunkSnapshotManager() {
return snapMgr;
}
public static MovementTracker getMovementTracker() {
return tracker;
}
public static CommandsManager getCommandsManager() {
return commands;
}
public static PacketProcessor getPacketProcessor() {
return packetProcessor;
}
public static Engine getEngine() {
return engine;
}
public static RaycastedAntiESP get() {
return instance;
}
public static java.util.logging.Logger logger() {
return logger;
}
}
@@ -0,0 +1,100 @@
package games.cubi.raycastedAntiESP;
import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import org.bukkit.Bukkit;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URISyntaxException;
import java.net.URI;
import java.util.concurrent.CompletableFuture;
public class UpdateChecker {
private static CompletableFuture<String> fetchFeaturedVersion(RaycastedAntiESP plugin) {
CompletableFuture<String> future = new CompletableFuture<>();
Bukkit.getScheduler().runTaskAsynchronously(plugin, () -> {
final String url = "https://api.modrinth.com/v2/project/bCjNZu0C/version?version_type=release";
try (final InputStreamReader reader = new InputStreamReader(new URI(url).toURL().openConnection().getInputStream())) {
final JsonArray array = new JsonArray();
array.add(new BufferedReader(reader).readLine());
StringBuilder stringBuilder = new StringBuilder();
for (int i = 0; i < array.size(); i++) {
stringBuilder.append(array.get(i).getAsString());
}
String apiData = stringBuilder.toString();
JsonArray jsonArray = JsonParser.parseString(apiData).getAsJsonArray();
JsonObject firstObject = jsonArray.get(0).getAsJsonObject();
String versionNumber = firstObject.get("version_number").getAsString();
future.complete(versionNumber);
} catch (IOException | URISyntaxException e) {
future.completeExceptionally(new IllegalStateException("Unable to fetch latest version", e));
}
});
return future;
}
private static final int INVALID_VERSION_FORMAT = -2; private static final int CURRENT_IS_OLDER = -1; private static final int VERSIONS_ARE_EQUAL = 0; private static final int CURRENT_IS_NEWER = 1;
private static int checkIfLaterThan(String currentVersion, String fetchedVersion) {
String[] currentParts = currentVersion.replace("v", "").split("\\.");
String[] fetchedParts = fetchedVersion.replace("v", "").split("\\.");
if (currentParts.length < 3 || fetchedParts.length < 3) {
return INVALID_VERSION_FORMAT;
}
int majorVersionDifference = Integer.parseInt(currentParts[0]) - Integer.parseInt(fetchedParts[0]);
if (majorVersionDifference == VERSIONS_ARE_EQUAL) {
int minorVersionDifference = Integer.parseInt(currentParts[1]) - Integer.parseInt(fetchedParts[1]);
if (minorVersionDifference == VERSIONS_ARE_EQUAL) {
int patchVersionDifference = Integer.parseInt(currentParts[2]) - Integer.parseInt(fetchedParts[2]);
return patchVersionDifference;
}
return minorVersionDifference;
}
return majorVersionDifference;
}
public static void checkForUpdates(RaycastedAntiESP plugin, CommandSender audience) {
fetchFeaturedVersion(plugin).thenAccept(version -> {
// This runs synchronously when the version is fetched
Bukkit.getScheduler().runTask(plugin, () -> {
int versionCheck = checkIfLaterThan(plugin.getDescription().getVersion(), version);
if (versionCheck == VERSIONS_ARE_EQUAL) {
audience.sendRichMessage("<green>You are using the latest version of Raycasted Entity Occlusions.");
}
if (versionCheck == CURRENT_IS_OLDER) {
audience.sendRichMessage("<red>You are not using the latest version of Raycasted Entity Occlusions. Please update to <green>v" + version+".");
if (audience instanceof Player) audience.sendRichMessage("\n" + "<hover:show_text:'https://modrinth.com/project/bCjNZu0C/versions'><aqua><u><click:open_url:'https://modrinth.com/project/bCjNZu0C/versions'>Click here to download it.</click></u></aqua></hover>");
}
if (versionCheck == CURRENT_IS_NEWER) {
audience.sendRichMessage("<yellow>You are using a development build of Raycasted Entity Occlusions. The latest stable version is <green>v" + version + "<yellow>.");
}
if (versionCheck == INVALID_VERSION_FORMAT) {
audience.sendRichMessage("<red>Unable to check for updates, invalid version format.");
}
});
}).exceptionally(ex -> {
Logger.error(ex);
return null;
});
}
}
@@ -1,4 +1,4 @@
package games.cubi.raycastedEntityOcclusion;
package games.cubi.raycastedAntiESP.bStats;
/*
* This Metrics class was auto-generated and can be copied into your project if you are
* not using a build tool like Gradle or Maven for dependency management.
@@ -13,6 +13,7 @@ package games.cubi.raycastedEntityOcclusion;
*
* Violations will result in a ban of your plugin and account from bStats.
*/
// Note: I'm using the autogenerated class instead of using Gradle because it didn't work and this did and I can't be bothered to figure out why
import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
@@ -0,0 +1,157 @@
package games.cubi.raycastedAntiESP.bStats;
import games.cubi.raycastedAntiESP.config.ConfigManager;
import games.cubi.raycastedAntiESP.RaycastedAntiESP;
import java.util.ArrayList;
import java.util.List;
public class MetricsCollector {
private final RaycastedAntiESP plugin;
private final Metrics metrics;
private final ConfigManager config;
private List<Integer> playersOnline = new ArrayList<>();
private List<Integer> entities = new ArrayList<>();
public MetricsCollector(RaycastedAntiESP plugin, ConfigManager config) {
this.plugin = plugin;
int pluginId = 24553;
metrics = new Metrics(plugin, pluginId);
this.config = config;/*
registerCustomMetrics();
TODO: Re-enable metrics
plugin.getServer().getScheduler().runTaskTimer(plugin, this::collectMetrics, 0L, 6000L); // 6000 ticks = 5 minutes*/
}
/*
public void registerCustomMetrics() {
metrics.addCustomChart(new Metrics.SimplePie("max_occluding_count", () -> String.valueOf(config.maxOccludingCount)));
metrics.addCustomChart(new Metrics.SimplePie("cull_players", this::getCullPlayersStatus));
metrics.addCustomChart(new Metrics.SimplePie("raycast_radius", () -> getRoundedValue(config.raycastRadius, ConfigManager.RAYCAST_RADIUS_DEFAULT)));
metrics.addCustomChart(new Metrics.SimplePie("search_radius", () -> getRoundedValue(config.searchRadius, ConfigManager.SEARCH_RADIUS_DEFAULT)));
metrics.addCustomChart(new Metrics.SimplePie("always_show_radius", () -> getRoundedValue(config.alwaysShowRadius, ConfigManager.ALWAYS_SHOW_RADIUS_DEFAULT)));
metrics.addCustomChart(new Metrics.SimplePie("engine_mode", () -> String.valueOf(config.engineMode)));
metrics.addCustomChart(new Metrics.SimplePie("snapshot_refresh_interval", () -> getRoundedValue(config.snapshotRefreshInterval, ConfigManager.SNAPSHOT_REFRESH_INTERVAL_DEFAULT)));
metrics.addCustomChart(new Metrics.SimplePie("entity_recheck_interval", () -> getRoundedValue(config.recheckInterval, ConfigManager.RECHECK_INTERVAL_DEFAULT)));
metrics.addCustomChart(new Metrics.SimplePie("tile_entity_recheck_interval", this::tileEntityCheckStatus));
metrics.addCustomChart(new Metrics.SimplePie("server_size", this::getPlayersOnline));
metrics.addCustomChart(new Metrics.SimplePie("entities", this::getEntities));
}
public String getCullPlayersStatus() {
if (config.cullPlayers) {
if (config.onlyCullSneakingPlayers) {
return "Sneaking";
} else {
return "Always";
}
} else {
return "Never";
}
}
public String tileEntityCheckStatus() {
if (config.checkTileEntities) {
return getRoundedValue(config.tileEntityRecheckInterval, ConfigManager.TILE_ENTITY_RECHECK_INTERVAL_DEFAULT);
} else {
return "Disabled";
}
}
public String getRoundedValue(int value, int defaultValue) {
if (value == defaultValue) {
return defaultValue + ".0";
} else {
int roundedValue = Math.round(value / 5.0f) * 5;
return String.valueOf(roundedValue);
}
}
public void collectMetrics() {
playersOnline.add(Bukkit.getServer().getOnlinePlayers().size());
// TODO: Cache all entities in Engine, and also use that here
int totalEntities = 0;
for (World world : Bukkit.getWorlds()) {
totalEntities += world.getEntities().size();
}
entities.add(totalEntities);
}
public String getPlayersOnline() {
if (playersOnline == null) {
return "Null";
}
int averaged = (int) playersOnline.stream()
.mapToInt(Integer::intValue)
.average()
.orElse(-1);
playersOnline.clear();
if (averaged < 0) {
return "Null";
} else if (averaged < 4) {
return String.valueOf(averaged);
} else if (averaged < 7) {
return "4-6";
} else if (averaged < 11) {
return "7-10";
} else if (averaged < 16) {
return "11-15";
} else if (averaged < 26) {
return "15-25";
} else if (averaged < 40) {
return "26-40";
} else if (averaged < 71) {
return "41-70";
} else if (averaged < 101) {
return "71-100";
} else if (averaged < 201) {
return "101-200";
} else if (averaged < 301) {
return "201-300";
} else if (averaged < 501) {
return "301-500";
} else {
return "500+";
}
}
public String getEntities() {
if (entities == null) {
return "Null";
}
int averaged = (int) entities.stream()
.mapToInt(Integer::intValue)
.average()
.orElse(-1);
entities.clear();
if (averaged < 0) {
return "Null";
} else if (averaged < 21) {
return "0-20";
} else if (averaged < 51) {
return "21-50";
} else if (averaged < 101) {
return "51-100";
} else if (averaged < 301) {
return "101-300";
} else if (averaged < 501) {
return "301-500";
} else if (averaged < 1001) {
return "501-1000";
} else if (averaged < 2001) {
return "1001-2000";
} else if (averaged < 5000) {
return "2001-5000";
} else {
return "5000+";
}
}
*/
}
@@ -0,0 +1,202 @@
package games.cubi.raycastedAntiESP.config;
import games.cubi.raycastedAntiESP.Logger;
import games.cubi.raycastedAntiESP.RaycastedAntiESP;
import org.bukkit.Material;
import org.bukkit.configuration.file.FileConfiguration;
import java.util.List;
public class ConfigManager {
private static ConfigManager instance;
private final RaycastedAntiESP plugin;
private FileConfiguration config;
// Config objects
private PlayerConfig playerConfig;
private EntityConfig entityConfig;
private TileEntityConfig tileEntityConfig;
private SnapshotConfig snapshotConfig;
private DebugConfig debugConfig;
// Default config objects TODO: Keep these here or move into individual config classes?
private static final PlayerConfig DEFAULT_PLAYER_CONFIG = new PlayerConfig(1, 3, 16, 48, 50, true, true);
private static final EntityConfig DEFAULT_ENTITY_CONFIG = new EntityConfig( 1, 3, 16, 48, 50, true);
private static final TileEntityConfig DEFAULT_TILE_ENTITY_CONFIG = new TileEntityConfig(1, 3, 16, 48, 0, true, List.of(Material.BEACON));
private static final SnapshotConfig DEFAULT_SNAPSHOT_CONFIG = new SnapshotConfig(60, 0, false);
private static final DebugConfig DEFAULT_DEBUG_CONFIG = new DebugConfig(3, 3, 3, false, false, false);
private int maxEngineMode;
private ConfigManager(RaycastedAntiESP plugin) {
this.plugin = plugin;
load();
}
public static ConfigManager initiateConfigManager(RaycastedAntiESP plugin) {
if (instance == null) {
if (isNotOnMainThread()) return null;
instance = new ConfigManager(plugin);
}
return instance;
}
public static ConfigManager get() {
if (instance == null) Logger.errorAndReturn(new RuntimeException("ConfigManager accessed before being initiated. Please report this to the plugin developer."));
return instance;
}
/**
* Load or reload the configuration from file
*/
public void load() {
//check that we are on the main bukkit thread to prevent concurrency issues
if (isNotOnMainThread()) return;
plugin.saveDefaultConfig();
plugin.reloadConfig();
config = plugin.getConfig();
// Set defaults if they don't exist
setDefaults();
// Load config objects
playerConfig = PlayerConfig.getFromConfig(config, getDefaultPlayerConfig());
entityConfig = EntityConfig.getFromConfig(config, getDefaultEntityConfig());
tileEntityConfig = TileEntityConfig.getFromConfig(config, getDefaultTileEntityConfig());
snapshotConfig = SnapshotConfig.getFromConfig(config, getDefaultSnapshotConfig());
debugConfig = DebugConfig.getFromConfig(config, getDefaultDebugConfig());
// Save any new defaults that were added
plugin.saveConfig();
maxEngineMode = calculateMaxEngineMode();
}
/**
* Set default values in the configuration file if they don't exist
*/
private void setDefaults() {
config.addDefault("config-version", "1.0");
PlayerConfig.setDefaults(config, getDefaultPlayerConfig());
EntityConfig.setDefaults(config, getDefaultEntityConfig());
TileEntityConfig.setDefaults(config, getDefaultTileEntityConfig());
SnapshotConfig.setDefaults(config, getDefaultSnapshotConfig());
DebugConfig.setDefaults(config, getDefaultDebugConfig());
config.options().copyDefaults(true);
plugin.saveConfig();
}
/**
* Update a single config value both in memory and in the file
* @param path The config path (e.g., "player.enabled")
* @param rawValue The raw string value to set
* @return 1 for success, 0 for out of range, -1 for invalid input TODO: This is currently broken, and even if it worked it doesn't handle setting lists
*/
public int setConfigValue(String path, String rawValue) {
if (!config.contains(path)) {
return -1; // Path doesn't exist
}
Object currentValue = config.get(path);
Object parsedValue;
try {
if (currentValue instanceof Boolean) {
String lower = rawValue.toLowerCase();
if (!lower.equals("true") && !lower.equals("false")) {
return -1;
}
parsedValue = Boolean.parseBoolean(lower);
} else if (currentValue instanceof Integer) {
int intVal = Integer.parseInt(rawValue);
if (intVal < 0 || intVal > 255) {
return 0;
}
parsedValue = intVal;
} else {
return -1;
}
} catch (NumberFormatException e) {
return -1;
}
// Update the config file
config.set(path, parsedValue);
plugin.saveConfig();
// Reload to update the config objects
load();
return 1;
}
private int calculateMaxEngineMode() {
//return the highest engine mode listed
int maxMode = 0;
if (playerConfig.getEngineMode() > maxMode) maxMode = playerConfig.getEngineMode();
if (entityConfig.getEngineMode() > maxMode) maxMode = entityConfig.getEngineMode();
if (tileEntityConfig.getEngineMode() > maxMode) maxMode = tileEntityConfig.getEngineMode();
return maxMode;
}
private static boolean isNotOnMainThread() {
if (RaycastedAntiESP.get().getServer().isPrimaryThread()) {
return false;
}
Logger.error(new RuntimeException("ConfigManager attempted to be accessed off the main thread. Please report this to the plugin developer."));
return true;
}
public static PlayerConfig getDefaultPlayerConfig() {
return DEFAULT_PLAYER_CONFIG;
}
public static EntityConfig getDefaultEntityConfig() {
return DEFAULT_ENTITY_CONFIG;
}
public static TileEntityConfig getDefaultTileEntityConfig() {
return DEFAULT_TILE_ENTITY_CONFIG;
}
public static SnapshotConfig getDefaultSnapshotConfig() {
return DEFAULT_SNAPSHOT_CONFIG;
}
public static DebugConfig getDefaultDebugConfig() {
return DEFAULT_DEBUG_CONFIG;
}
// Getters for current config objects
public PlayerConfig getPlayerConfig() {
return playerConfig;
}
public EntityConfig getEntityConfig() {
return entityConfig;
}
public TileEntityConfig getTileEntityConfig() {
return tileEntityConfig;
}
public SnapshotConfig getSnapshotConfig() {
return snapshotConfig;
}
public DebugConfig getDebugConfig() {
return debugConfig;
}
public FileConfiguration getConfigFile() {
return config;
}
public int getEngineMode() {
return maxEngineMode;
}
}
@@ -0,0 +1,76 @@
package games.cubi.raycastedAntiESP.config;
import org.bukkit.configuration.file.FileConfiguration;
public class DebugConfig {
private static final String PATH = "debug";
private final byte infoLevel;
private final byte warnLevel;
private final byte errorLevel;
private final boolean debugParticles;
private final boolean timings;
private final boolean logToFile;
public DebugConfig(byte infoLevel, byte warnLevel, byte errorLevel, boolean debugParticles, boolean timings, boolean logToFile) {
this.infoLevel = infoLevel;
this.warnLevel = warnLevel;
this.errorLevel = errorLevel;
this.debugParticles = debugParticles;
this.timings = timings;
this.logToFile = logToFile;
}
public DebugConfig(int infoLevel, int warnLevel, int errorLevel, boolean debugParticles, boolean timings, boolean logToFile) {
this.infoLevel = (byte) infoLevel;
this.warnLevel = (byte) warnLevel;
this.errorLevel = (byte) errorLevel;
this.debugParticles = debugParticles;
this.timings = timings;
this.logToFile = logToFile;
}
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 logToFile() {
return logToFile;
}
static DebugConfig getFromConfig(FileConfiguration config, DebugConfig defaults) {
return new DebugConfig(
(byte) config.getInt(PATH+".info-level", defaults.getInfoLevel()),
(byte) config.getInt(PATH+".warn-level", defaults.getWarnLevel()),
(byte) config.getInt(PATH+".error-level", defaults.getErrorLevel()),
config.getBoolean(PATH+".particles", defaults.showDebugParticles()),
config.getBoolean(PATH+".timings", defaults.recordTimings()),
config.getBoolean(PATH+".log-to-file", defaults.logToFile())
);
}
static void setDefaults(FileConfiguration config, DebugConfig defaults) {
config.addDefault(PATH+".info-level", defaults.getInfoLevel());
config.addDefault(PATH+".warn-level", defaults.getWarnLevel());
config.addDefault(PATH+".error-level", defaults.getErrorLevel());
config.addDefault(PATH+".particles", defaults.showDebugParticles());
config.addDefault(PATH+".timings", defaults.recordTimings());
config.addDefault(PATH+".log-to-file", defaults.logToFile());
}
}
@@ -0,0 +1,31 @@
package games.cubi.raycastedAntiESP.config;
import org.bukkit.configuration.file.FileConfiguration;
public class EntityConfig extends RaycastConfig {
public static final String PATH = "entity";
public EntityConfig(byte engineMode, byte maxOccludingCount, short alwaysShowRadius, short raycastRadius, short visibleRecheckInterval, boolean enabled) {
super(engineMode, maxOccludingCount, alwaysShowRadius, raycastRadius, visibleRecheckInterval, enabled);
}
public EntityConfig(int engineMode, int maxOccludingCount, int alwaysShowRadius, int raycastRadius, int visibleRecheckInterval, boolean enabled) {
super(engineMode, maxOccludingCount, alwaysShowRadius, raycastRadius, visibleRecheckInterval, enabled);
}
public EntityConfig(boolean enabled) {
super(enabled);
}
public EntityConfig(RaycastConfig superConfig) {
super(superConfig);
}
public static EntityConfig getFromConfig(FileConfiguration config, EntityConfig defaults) {
return new EntityConfig(RaycastConfig.getFromConfig(config, PATH, defaults));
}
public static void setDefaults(FileConfiguration config, EntityConfig defaults) {
RaycastConfig.setDefaults(config, PATH, defaults);
}
}
@@ -0,0 +1,41 @@
package games.cubi.raycastedAntiESP.config;
import org.bukkit.configuration.file.FileConfiguration;
public class PlayerConfig extends RaycastConfig {
public static final String PATH = "player";
private final boolean onlyCullWhileSneaking;
public PlayerConfig(byte engineMode, byte maxOccludingCount, short alwaysShowRadius, short raycastRadius, short visibleRecheckInterval, boolean enabled, boolean onlyCullWhileSneaking) {
super(engineMode, maxOccludingCount, alwaysShowRadius, raycastRadius, visibleRecheckInterval, enabled);
this.onlyCullWhileSneaking = onlyCullWhileSneaking;
}
public PlayerConfig(int engineMode, int maxOccludingCount, int alwaysShowRadius, int raycastRadius, int visibleRecheckInterval, boolean enabled, boolean onlyCullWhileSneaking) {
super(engineMode, maxOccludingCount, alwaysShowRadius, raycastRadius, visibleRecheckInterval, enabled);
this.onlyCullWhileSneaking = onlyCullWhileSneaking;
}
public PlayerConfig(boolean enabled) {
super(enabled);
this.onlyCullWhileSneaking = false;
}
public PlayerConfig(RaycastConfig superConfig, boolean onlyCullWhileSneaking) {
super(superConfig);
this.onlyCullWhileSneaking = onlyCullWhileSneaking;
}
public boolean onlyCullWhileSneaking() {
return onlyCullWhileSneaking;
}
public static PlayerConfig getFromConfig(FileConfiguration config, PlayerConfig defaults) {
return new PlayerConfig(RaycastConfig.getFromConfig(config, PATH, defaults), config.getBoolean(PATH+".only-cull-while-sneaking", defaults.onlyCullWhileSneaking()));
}
public static void setDefaults(FileConfiguration config, PlayerConfig defaults) {
RaycastConfig.setDefaults(config, PATH, defaults);
config.addDefault(PATH+".only-cull-while-sneaking", defaults.onlyCullWhileSneaking());
}
}
@@ -0,0 +1,94 @@
package games.cubi.raycastedAntiESP.config;
import org.bukkit.configuration.file.FileConfiguration;
public class RaycastConfig {
private final byte engineMode;
private final byte maxOccludingCount;
private final short alwaysShowRadius;
private final short raycastRadius;
private final short visibleRecheckInterval;
private final boolean enabled;
public RaycastConfig(byte engineMode, byte maxOccludingCount, short alwaysShowRadius, short raycastRadius, short visibleRecheckInterval, boolean enabled) {
this.engineMode = engineMode;
this.maxOccludingCount = maxOccludingCount;
this.alwaysShowRadius = alwaysShowRadius;
this.raycastRadius = raycastRadius;
this.visibleRecheckInterval = visibleRecheckInterval;
this.enabled = enabled;
}
public RaycastConfig(int engineMode, int maxOccludingCount, int alwaysShowRadius, int raycastRadius, int visibleRecheckInterval, boolean enabled) {
this.engineMode = (byte) engineMode;
this.maxOccludingCount = (byte) maxOccludingCount;
this.alwaysShowRadius = (short) alwaysShowRadius;
this.raycastRadius = (short) raycastRadius;
this.visibleRecheckInterval = (short) visibleRecheckInterval;
this.enabled = enabled;
}
public RaycastConfig(boolean enabled) {
this.enabled = enabled;
if (enabled) throw new IllegalArgumentException("Abstract config created without parameters while enabled");
engineMode = -1; maxOccludingCount = -1; alwaysShowRadius = 48; raycastRadius = -1; visibleRecheckInterval = -1;
}
public RaycastConfig(RaycastConfig other) {
// This is unhinged but also the simplest way I can think of to do this
this.engineMode = other.engineMode;
this.maxOccludingCount = other.maxOccludingCount;
this.alwaysShowRadius = other.alwaysShowRadius;
this.raycastRadius = other.raycastRadius;
this.visibleRecheckInterval = other.visibleRecheckInterval;
this.enabled = other.enabled;
}
static RaycastConfig getFromConfig(FileConfiguration config, String path, RaycastConfig defaults) {
return new RaycastConfig(
config.getInt(path+".engine-mode", defaults.getEngineMode()),
config.getInt(path+".max-occluding-count", defaults.getMaxOccludingCount()),
config.getInt(path+".always-show-radius", defaults.getAlwaysShowRadius()),
config.getInt(path+".raycast-radius", defaults.getRaycastRadius()),
config.getInt(path+".visible-recheck-interval", defaults.getVisibleRecheckInterval()),
config.getBoolean(path+".enabled", defaults.isEnabled())
);
}
static void setDefaults(FileConfiguration config, String path, RaycastConfig defaults) {
config.addDefault(path+".enabled", defaults.isEnabled());
config.addDefault(path+".engine-mode", defaults.getEngineMode());
config.addDefault(path+".max-occluding-count", defaults.getMaxOccludingCount());
config.addDefault(path+".always-show-radius", defaults.getAlwaysShowRadius());
config.addDefault(path+".raycast-radius", defaults.getRaycastRadius());
config.addDefault(path+".visible-recheck-interval", defaults.getVisibleRecheckInterval());
}
public byte getEngineMode() {
return engineMode;
}
public byte getMaxOccludingCount() {
return maxOccludingCount;
}
public short getAlwaysShowRadius() {
return alwaysShowRadius;
}
public short getRaycastRadius() {
return raycastRadius;
}
public short getVisibleRecheckInterval() {
return visibleRecheckInterval;
}
public int getVisibleRecheckIntervalSeconds() {
return (visibleRecheckInterval * 20);
}
public boolean isEnabled() { return enabled; }
}
@@ -0,0 +1,52 @@
package games.cubi.raycastedAntiESP.config;
import org.bukkit.configuration.file.FileConfiguration;
public class SnapshotConfig {
private static final String PATH = "snapshot";
private final short worldSnapshotRefreshInterval;
private final int entityLocationRefreshInterval;
private final boolean performUnsafeWorldSnapshots;
public SnapshotConfig(short worldRefresh, int entityRefresh, boolean doUnsafeWorldSnapshots) {
worldSnapshotRefreshInterval = worldRefresh;
entityLocationRefreshInterval = entityRefresh;
performUnsafeWorldSnapshots = doUnsafeWorldSnapshots;
}
public SnapshotConfig(int worldRefresh, int entityRefresh, boolean doUnsafeWorldSnapshots) {
worldSnapshotRefreshInterval = (short) worldRefresh;
entityLocationRefreshInterval = entityRefresh;
performUnsafeWorldSnapshots = doUnsafeWorldSnapshots;
}
public short getWorldSnapshotRefreshInterval() {
return worldSnapshotRefreshInterval;
}
public int getEntityLocationRefreshInterval() {
return entityLocationRefreshInterval;
}
public int getEntityLocationRefreshIntervalTicks() {
return getEntityLocationRefreshInterval();
}
public boolean performUnsafeWorldSnapshots() {
return performUnsafeWorldSnapshots;
}
static SnapshotConfig getFromConfig(FileConfiguration config, SnapshotConfig defaults) {
return new SnapshotConfig(
config.getInt(PATH+".world-refresh-interval", defaults.getWorldSnapshotRefreshInterval()),
config.getInt(PATH+".entity-location-refresh-interval", defaults.getEntityLocationRefreshInterval()),
config.getBoolean(PATH+".perform-unsafe-async-world-snapshots", defaults.performUnsafeWorldSnapshots())
);
}
static void setDefaults(FileConfiguration config, SnapshotConfig defaults) {
config.addDefault(PATH+".world-refresh-interval", defaults.getWorldSnapshotRefreshInterval());
config.addDefault(PATH+".entity-location-refresh-interval", defaults.getEntityLocationRefreshInterval());
config.addDefault(PATH+".perform-unsafe-world-snapshots", defaults.performUnsafeWorldSnapshots());
}
}
@@ -0,0 +1,68 @@
package games.cubi.raycastedAntiESP.config;
import games.cubi.raycastedAntiESP.Logger;
import org.bukkit.Material;
import org.bukkit.configuration.file.FileConfiguration;
import java.util.ArrayList;
import java.util.List;
public class TileEntityConfig extends RaycastConfig {
private static final String PATH = "tile-entity";
private final List<Material> exemptedBlocks; // This list is immutable
public TileEntityConfig(byte engineMode, byte maxOccludingCount, short alwaysShowRadius, short raycastRadius, short visibleRecheckInterval, boolean enabled, List<Material> exemptedBlocks) {
super(engineMode, maxOccludingCount, alwaysShowRadius, raycastRadius, visibleRecheckInterval, enabled);
this.exemptedBlocks = List.copyOf(exemptedBlocks);
}
public TileEntityConfig(int engineMode, int maxOccludingCount, int alwaysShowRadius, int raycastRadius, int visibleRecheckInterval, boolean enabled, List<Material> exemptedBlocks) {
super(engineMode, maxOccludingCount, alwaysShowRadius, raycastRadius, visibleRecheckInterval, enabled);
this.exemptedBlocks = List.copyOf(exemptedBlocks);
}
public TileEntityConfig(boolean enabled, List<Material> exemptedBlocks) {
super(enabled);
this.exemptedBlocks = List.copyOf(exemptedBlocks);
}
public TileEntityConfig(RaycastConfig superConfig,List<Material> exemptedBlocks) {
super(superConfig);
this.exemptedBlocks = List.copyOf(exemptedBlocks);
}
@Override
public int getVisibleRecheckIntervalSeconds() {
return super.getVisibleRecheckInterval();
}
public List<Material> getExemptedBlocks() {
return exemptedBlocks; // Immutable list
}
public static TileEntityConfig getFromConfig(FileConfiguration config, TileEntityConfig defaults) {
return new TileEntityConfig(RaycastConfig.getFromConfig(config, PATH, defaults), getMaterialList(config));
}
private static List<Material> getMaterialList(FileConfiguration config) {
List<String> materialNames = config.getStringList(PATH);
ArrayList<Material> materials = new ArrayList<>();
for (String name : materialNames) {
if (name == null) continue;
Material m = Material.matchMaterial(name);
if (m != null) {
materials.add(m);
} else {
Logger.error("Invalid material in config 'whitelisted-materials': " + name,1);
}
}
return List.copyOf(materials);
}
public static void setDefaults(FileConfiguration config, TileEntityConfig defaults) {
RaycastConfig.setDefaults(config, PATH, defaults);
config.addDefault(PATH+".exempted-blocks", defaults.getExemptedBlocks().stream().map(Material::name).toList());
}
}
@@ -0,0 +1,46 @@
package games.cubi.raycastedAntiESP.data;
public class DataHolder {
private static boolean packetEventsPresent;
private static int tick = 0;
private static final EntityLocationService entityLocationService;
private static final EntityVisibilityChangeCache entityVisibilityChangeCache;
private static final PlayerRegistry playerRegistry;
static {
entityLocationService = EntityLocationService.getInstance();
entityVisibilityChangeCache = EntityVisibilityChangeCache.getInstance();
playerRegistry = PlayerRegistry.getInstance();
}
public static EntityLocationService entityLocation() {
return entityLocationService;
}
public static EntityVisibilityChangeCache entityVisibility() {
return entityVisibilityChangeCache;
}
public static PlayerRegistry players() {
return playerRegistry;
}
public static boolean isPacketEventsPresent() {
return packetEventsPresent;
}
public static void setPacketEventsPresent() {
packetEventsPresent = true;
}
/**
* This counter increments twice per server tick, so a normal server will experience 40 TPS
* **/
public static int getTick() {
return tick;
}
/**
* This method should ONLY be called on the tick start and stop events
* **/
public static void incrementTick() {
tick++;
}
}
@@ -0,0 +1,69 @@
package games.cubi.raycastedAntiESP.data;
import games.cubi.raycastedAntiESP.utils.EntityLocationPair;
import games.cubi.raycastedAntiESP.utils.ThreadSafeLoc;
import org.bukkit.Location;
import org.bukkit.util.Vector;
import java.util.HashMap;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedQueue;
public class EntityLocationService {
private static EntityLocationService instance;
private EntityLocationService() {}
public static EntityLocationService getInstance() {
if (instance == null) {
instance = new EntityLocationService();
}
return instance;
}
/**UUID -> Entity UUID, QuantisedLocation -> Entity Location*/
private final ConcurrentLinkedQueue<EntityLocationPair> entityLocProcessingQueue = new ConcurrentLinkedQueue<>();
public void queueEntityLocationUpdate(UUID entityUUID, Location location) {
entityLocProcessingQueue.add(new EntityLocationPair(entityUUID, location));
}
private volatile ConcurrentHashMap<UUID, ThreadSafeLoc> entityLocationMap = new ConcurrentHashMap<>();
public void updateEntireEntityLocationMap(HashMap<UUID, ThreadSafeLoc> newLocations) {
entityLocationMap = new ConcurrentHashMap<>(newLocations);
}
private void setOrUpdateEntityLocation(UUID entityUUID, Vector location, UUID world) {
entityLocationMap.compute(entityUUID, (uuid, oldLoc) -> {
if (oldLoc == null) return new ThreadSafeLoc(location, world);
while (!oldLoc.update(location)) {
Thread.onSpinWait(); //doesn't actually sleep the thread, just indicates that this thread should be deprioritized. Once the write lock is released it should write nearly immediately
}
return oldLoc;
});
}
private void setOrUpdateEntityLocation(UUID entityUUID, Location location) {
setOrUpdateEntityLocation(entityUUID, location.toVector(), location.getWorld().getUID());
}
// Run this async
public void processEntityLocationQueue() {
while (!entityLocProcessingQueue.isEmpty()) {
EntityLocationPair entityLocationPair = entityLocProcessingQueue.poll();
if (entityLocationPair == null) return;
setOrUpdateEntityLocation(entityLocationPair.entity(), entityLocationPair.loc());
}
}
public ThreadSafeLoc getEntityLocation(UUID entityUUID) {
return entityLocationMap.get(entityUUID);
}
public HashMap<UUID, ThreadSafeLoc> getCopyOfEntityLocationMap() {
return new HashMap<>(entityLocationMap);
}
}
@@ -0,0 +1,108 @@
package games.cubi.raycastedAntiESP.data;
import games.cubi.raycastedAntiESP.RaycastedAntiESP;
import org.bukkit.Bukkit;
import org.bukkit.entity.Entity;
import org.bukkit.entity.Player;
import java.util.HashMap;
import java.util.Objects;
import java.util.UUID;
import java.util.concurrent.ConcurrentLinkedQueue;
public class EntityVisibilityChangeCache {
private static EntityVisibilityChangeCache instance;
private EntityVisibilityChangeCache() {}
public static EntityVisibilityChangeCache getInstance() {
if (instance == null) {
instance = new EntityVisibilityChangeCache();
}
return instance;
}
private record PlayerEntityPair(UUID playerUUID, UUID entityUUID) {}
private final HashMap<PlayerEntityPair, Long> visibilityStatusChange = new HashMap<>(); // Should only ever be accessed from main thread
private record ShowOrHideEntityToPlayer (UUID entityUUID, UUID playerUUID, boolean show) {}
private final ConcurrentLinkedQueue<ShowOrHideEntityToPlayer> entityVisibilityProcessingQueue = new ConcurrentLinkedQueue<>();
public void showEntity(UUID entityUUID, Player player) {
Entity entity = Bukkit.getEntity(entityUUID);
Objects.requireNonNull(entity);
showEntity(entity, entityUUID, player);
}
public void showEntity(Entity entity, Player player) {
showEntity(entity, entity.getUniqueId(), player);
}
public void showEntity(Entity entity, UUID entityUUID, Player player) {
addToVisibilityChangeCache(entityUUID, player.getUniqueId());
player.showEntity(RaycastedAntiESP.get(), entity);
}
public void showEntityAsync(UUID entityUUID, UUID playerUUID) {
addToVisibilityChangeCache(entityUUID, playerUUID);
addToEntityVisibilityProcessingQueue(entityUUID, playerUUID, true);
}
public void hideEntityAsync(UUID entityUUID, UUID playerUUID) {
addToVisibilityChangeCache(entityUUID, playerUUID);
addToEntityVisibilityProcessingQueue(entityUUID, playerUUID, false);
}
private void addToEntityVisibilityProcessingQueue(UUID entityUUID, UUID playerUUID, boolean show) {
entityVisibilityProcessingQueue.add(new ShowOrHideEntityToPlayer(entityUUID, playerUUID, show));
}
private void processEntityVisibilityProcessingQueue() {
while (!entityVisibilityProcessingQueue.isEmpty()) {
ShowOrHideEntityToPlayer task = entityVisibilityProcessingQueue.poll();
if (task == null) return;
Entity entity = Bukkit.getEntity(task.entityUUID());
Player player = Bukkit.getPlayer(task.playerUUID());
if (entity == null || player == null) continue; // Entity or player might have logged out or despawned
if (task.show()) {
player.showEntity(RaycastedAntiESP.get(), entity);
} else {
player.hideEntity(RaycastedAntiESP.get(), entity);
}
}
}
public void hideEntity(UUID entityUUID, Player player) {
Entity entity = Bukkit.getEntity(entityUUID);
Objects.requireNonNull(entity);
hideEntity(entity, entityUUID, player);
}
public void hideEntity(Entity entity, Player player) {
hideEntity(entity, entity.getUniqueId(), player);
}
public void hideEntity(Entity entity, UUID entityUUID, Player player) {
addToVisibilityChangeCache(entityUUID, player.getUniqueId());
player.hideEntity(RaycastedAntiESP.get(), entity);
}
private void addToVisibilityChangeCache(UUID entityUUID, UUID playerUUID) {
synchronized (visibilityStatusChange) {
visibilityStatusChange.put(new PlayerEntityPair(playerUUID, entityUUID), System.currentTimeMillis());
}
}
public boolean entityVisibilityShouldChange(UUID entityUUID, UUID playerUUID) {
synchronized (visibilityStatusChange) {
return visibilityStatusChange.remove(new PlayerEntityPair(playerUUID, entityUUID)) != null;
}
}
public void cleanShouldShowEntityCache() {
long currentTime = System.currentTimeMillis();
synchronized (visibilityStatusChange) {
visibilityStatusChange.entrySet().removeIf(entry -> currentTime - entry.getValue() > 1000); // Remove entries older than 1 second
}
}
}
@@ -0,0 +1,38 @@
package games.cubi.raycastedAntiESP.data;
import games.cubi.raycastedAntiESP.utils.PlayerData;
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 registerPlayer(UUID playerUUID, boolean bypass) {
playerDataMap.putIfAbsent(playerUUID, new PlayerData(playerUUID, bypass));
}
public PlayerData getPlayerData(UUID playerUUID) {
return playerDataMap.get(playerUUID);
}
/**
* @return Live, mutable collection of all PlayerData instances.
* **/
public Collection<PlayerData> getAllPlayerData() {
return playerDataMap.values();
}
}
@@ -0,0 +1,133 @@
package games.cubi.raycastedAntiESP.engine;
public class Engine {}
/*
import games.cubi.raycastedEntityOcclusion.ConfigManager;
import games.cubi.raycastedEntityOcclusion.RaycastedEntityOcclusion;
import games.cubi.raycastedEntityOcclusion.Utils.*;
import io.papermc.paper.threadedregions.scheduler.AsyncScheduler;
import io.papermc.paper.threadedregions.scheduler.EntityScheduler;
import io.papermc.paper.threadedregions.scheduler.GlobalRegionScheduler;
import io.papermc.paper.threadedregions.scheduler.ScheduledTask;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.World;
import org.bukkit.entity.Entity;
import org.bukkit.entity.Player;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Consumer;
public class Engine {
//TODO: Maybe store the data somewhere else? Could rework chunk storage to be general data storage
public ConcurrentHashMap<UUID, PlayerData> playerDataMap = new ConcurrentHashMap<>();
private final AsyncScheduler asyncScheduler;
@SuppressWarnings("FieldCanBeLocal")
private final GlobalRegionScheduler globalScheduler; //TODO: Note that the use of the global scheduler here probs isn't actually done in a folia compat way
private final RaycastedEntityOcclusion plugin;
private final ConfigManager config;
public Engine(RaycastedEntityOcclusion plugin, ConfigManager cfg) {
this.plugin = plugin;
this.config = cfg;
asyncScheduler = plugin.getServer().getAsyncScheduler();
globalScheduler = plugin.getServer().getGlobalRegionScheduler();
globalScheduler.runAtFixedRate(plugin, syncCollectDataFromBukkit(), 1, 1);
}
public void registerPlayer(UUID playerUUID, boolean bypass) {
playerDataMap.putIfAbsent(playerUUID, new PlayerData(playerUUID, bypass));
}
private Consumer<ScheduledTask> syncCollectDataFromBukkit() {
// UUID:World UUID -> UUID:Entity UUID -> QuantisedLocation
HashMap<UUID, HashMap<UUID, QuantisedLocation>> worldEntities = new HashMap<>();
for (World world : Bukkit.getWorlds()) {
HashMap<UUID, QuantisedLocation> entitiesInWorld = new HashMap<>();
for (Entity entity : world.getEntities()) {
if (entity instanceof Player) continue; // Skip players, they are handled separately
entitiesInWorld.put(entity.getUniqueId(), new QuantisedLocation(entity.getLocation(), entity.getHeight()));
}
worldEntities.put(world.getUID(), entitiesInWorld);
}
HashMap<UUID, QuantisedLocation> players = new HashMap<>();
for (Player player : Bukkit.getOnlinePlayers()) {
players.put(player.getUniqueId(), new QuantisedLocation(player.getLocation(), player.getEyeHeight()));
}
//TODO: This is old
HashMap<UUID, HashMap<UUID, Location>> gatheredData = new HashMap<>();
for (UUID playerUUID : playerDataMap.keySet()) {
PlayerData data = playerDataMap.get(playerUUID);
if (data.hasBypassPermission()) continue;
Map<UUID, Boolean> entities = data.getEntityVisibilityMap();
Map<BlockLocation, Long> tileEntities = data.getSeenTileEntitiesMap();
HashMap<UUID, Location> entitiesToCheck = new HashMap<>();
data.incrementTicksSinceVisibleEntityRecheck();
if (data.getTicksSinceVisibleEntityRecheck() >= config.recheckInterval) {
data.resetTicksSinceVisibleEntityRecheck();
for (UUID entityUUID : entities.keySet()) {
entitiesToCheck.putIfAbsent(entityUUID, Bukkit.getEntity(entityUUID).getLocation());
}
}
else {
for (Map.Entry<UUID, Boolean> entry : entities.entrySet()) {
if (!entry.getValue()) {
UUID uuid = entry.getKey();
entitiesToCheck.putIfAbsent(uuid, Bukkit.getEntity(uuid).getLocation());
}
}
}
entitiesToCheck.put(playerUUID, Bukkit.getPlayer(playerUUID).getLocation()); //used to pass in player location
gatheredData.put(playerUUID, entitiesToCheck);
}
asyncScheduler.runNow(plugin, processData(gatheredData));
return task -> {};
}
private Consumer<ScheduledTask> processData(HashMap<UUID, HashMap<UUID, Location>> gatheredData) {
HashMap<LocationPair, Subscribers> raycastResultSubscription = new HashMap<>();
for (Map.Entry<UUID, HashMap<UUID, Location>> data : gatheredData.entrySet()) {
UUID player = data.getKey();
HashMap<UUID, Location> entityLocations = data.getValue();
QuantisedLocation playerLoc = new QuantisedLocation(entityLocations.get(player));
for (Map.Entry<UUID, Location> entity : entityLocations.entrySet()) {
QuantisedLocation entityLoc = new QuantisedLocation(entity.getValue());
if (!playerLoc.isWithinRadius(entityLoc, config.raycastRadius)) continue;
LocationPair locationPair = LocationPair.of(playerLoc, entityLoc);
if (raycastResultSubscription.containsKey(locationPair)) {
raycastResultSubscription.get(locationPair).addSubscriberWithEntity(player, entity.getKey());
}
else {
raycastResultSubscription.put(locationPair, new Subscribers(player, entity.getKey()));
}
}
}
return task -> {};
}
}
*/
@@ -0,0 +1,98 @@
package games.cubi.raycastedAntiESP.engine;
import games.cubi.raycastedAntiESP.Logger;
import games.cubi.raycastedAntiESP.config.*;
import games.cubi.raycastedAntiESP.RaycastedAntiESP;
import games.cubi.raycastedAntiESP.data.DataHolder;
import games.cubi.raycastedAntiESP.utils.PlayerData;
import games.cubi.raycastedAntiESP.utils.ThreadSafeLoc;
import io.papermc.paper.threadedregions.scheduler.AsyncScheduler;
import io.papermc.paper.threadedregions.scheduler.ScheduledTask;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.World;
import org.bukkit.entity.Entity;
import org.bukkit.scheduler.BukkitScheduler;
import java.util.HashMap;
import java.util.UUID;
import java.util.concurrent.TimeUnit;
public class EngineNewer {
private final AsyncScheduler asyncScheduler;
private final BukkitScheduler bukkitScheduler;
private final RaycastedAntiESP plugin;
private final ConfigManager config;
public EngineNewer(RaycastedAntiESP plugin, ConfigManager cfg) {
this.plugin = plugin;
this.config = cfg;
asyncScheduler = plugin.getServer().getAsyncScheduler();
bukkitScheduler = plugin.getServer().getScheduler();
forceEntityLocationUpdate();
processEntityMovements(null); //first one will run on main thread but it shouldn't have to do much anyways
clearOldCacheEntries();
flushLogCache(null);
}
public void tick() {
for (PlayerData playerData : DataHolder.players().getAllPlayerData()) {
if (playerData.hasBypassPermission()) continue;
ThreadSafeLoc playerLocation = DataHolder.entityLocation().getEntityLocation(playerData.getPlayerUUID());
if (playerLocation == null) Logger.errorAndReturn(new RuntimeException("wtf"));
}
}
private void /*TODO: return the subscriber list*/ createSubscriberList() {
for (PlayerData playerData : DataHolder.players().getAllPlayerData()) {
if (playerData.hasBypassPermission()) continue;
ThreadSafeLoc playerLocation = DataHolder.entityLocation().getEntityLocation(playerData.getPlayerUUID());
if (playerLocation == null) Logger.errorAndReturn(new RuntimeException("Player location missing for " + playerData.getPlayerUUID()));
boolean checkEntities = config.getEntityConfig().isEnabled();
boolean checkBlocks = config.getTileEntityConfig().isEnabled();
boolean checkPlayers = config.getPlayerConfig().isEnabled();
}
}
private void forceEntityLocationUpdate() {
int recheckInterval = ConfigManager.get().getSnapshotConfig().getEntityLocationRefreshInterval();
if (recheckInterval <= 0) {
bukkitScheduler.runTaskLater(plugin, this::forceEntityLocationUpdate, 20 * 30); // Check again in 30 secs if config has changed
return;
}
HashMap<UUID, ThreadSafeLoc> entities = new HashMap<>();
for (World world : Bukkit.getWorlds()) {
for (Entity entity : world.getEntities()) {
entities.put(entity.getUniqueId(), new ThreadSafeLoc(entity.getLocation(), entity.getHeight()));
}
}
DataHolder.entityLocation().updateEntireEntityLocationMap(entities);
bukkitScheduler.runTaskLater(plugin, this::forceEntityLocationUpdate, recheckInterval);
}
private void processEntityMovements(ScheduledTask scheduledTask) {
DataHolder.entityLocation().processEntityLocationQueue();
asyncScheduler.runDelayed(plugin, this::processEntityMovements, 15, TimeUnit.MILLISECONDS);
}
private void clearOldCacheEntries() {
DataHolder.entityVisibility().cleanShouldShowEntityCache();
bukkitScheduler.runTaskLater(plugin, this::clearOldCacheEntries, 20 * 120);
}
private void flushLogCache(ScheduledTask scheduledTask) {
if (config.getDebugConfig().logToFile()) {
Logger.flush();
}
asyncScheduler.runDelayed(plugin, this::flushLogCache, 2, TimeUnit.SECONDS);
}
}
@@ -0,0 +1,38 @@
package games.cubi.raycastedAntiESP.packets;
import com.github.retrooper.packetevents.PacketEvents;
import com.github.retrooper.packetevents.event.PacketSendEvent;
import com.github.retrooper.packetevents.manager.player.PlayerManager;
import com.github.retrooper.packetevents.wrapper.play.server.WrapperPlayServerPlayerInfoRemove;
import games.cubi.raycastedAntiESP.RaycastedAntiESP;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import java.util.List;
import java.util.UUID;
public class PacketProcessor {
private final UUID key = new UUID(0, 0); // Plugins can flag their packets with this UUID;
public PacketProcessor(RaycastedAntiESP plugin) {
}
public void processPlayerInfoRemovePacket(PacketSendEvent event) {
WrapperPlayServerPlayerInfoRemove removePacket = new WrapperPlayServerPlayerInfoRemove(event);
List<UUID> playersBeingRemoved = removePacket.getProfileIds();
if (playersBeingRemoved.size() != 2) {
event.setCancelled(true);
return;
}
if (!playersBeingRemoved.contains(key)) {
event.setCancelled(true);
}
}
public void sendPlayerInfoRemovePacket(UUID uuid) {
WrapperPlayServerPlayerInfoRemove removePacket = new WrapperPlayServerPlayerInfoRemove(uuid, key);
PlayerManager playerManager = PacketEvents.getAPI().getPlayerManager();
for (Player player : Bukkit.getOnlinePlayers()) {
playerManager.sendPacket(player, removePacket);
}
}
}
@@ -0,0 +1,31 @@
package games.cubi.raycastedAntiESP.packets;
import com.github.retrooper.packetevents.event.PacketListener;
import com.github.retrooper.packetevents.event.PacketSendEvent;
import com.github.retrooper.packetevents.protocol.packettype.PacketType;
import games.cubi.raycastedAntiESP.RaycastedAntiESP;
public class PacketsListener implements PacketListener {
private RaycastedAntiESP plugin;
private PacketProcessor packetProcessor;
public PacketsListener(RaycastedAntiESP plugin) {
// This is run on load, not on enable.
this.plugin = plugin;
}
@Override
public void onPacketSend(PacketSendEvent event) {
if (event.getPacketType() == PacketType.Play.Server.PLAYER_INFO_REMOVE) {
initializePacketProcessor();
packetProcessor.processPlayerInfoRemovePacket(event);
}
}
private void initializePacketProcessor() {
if (packetProcessor == null) {
packetProcessor = RaycastedAntiESP.getPacketProcessor();
}
}
}
@@ -0,0 +1,14 @@
package games.cubi.raycastedAntiESP.packets;
import com.github.retrooper.packetevents.PacketEvents;
import com.github.retrooper.packetevents.event.PacketListenerPriority;
import games.cubi.raycastedAntiESP.RaycastedAntiESP;
// This only exists because you can't import packetevents api if it doesn't exist, and therefore the main class cant import it
public class Registrar {
public Registrar(RaycastedAntiESP plugin) {
// Register the packet listener
PacketEvents.getAPI().getEventManager().registerListener(new PacketsListener(plugin), PacketListenerPriority.NORMAL);
}
}
@@ -0,0 +1,264 @@
package games.cubi.raycastedAntiESP.raycast;
public class EngineOld {}
/*
import games.cubi.raycastedEntityOcclusion.Logger;
import games.cubi.raycastedEntityOcclusion.Snapshot.ChunkSnapshotManager;
import games.cubi.raycastedEntityOcclusion.ConfigManager;
import games.cubi.raycastedEntityOcclusion.RaycastedEntityOcclusion;
import org.bukkit.Location;
import org.bukkit.Particle;
import org.bukkit.Bukkit;
import org.bukkit.World;
import org.bukkit.Color;
import org.bukkit.Chunk;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.block.BlockState;
import org.bukkit.block.TileState;
import org.bukkit.block.data.BlockData;
import org.bukkit.entity.Entity;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.concurrent.ConcurrentHashMap;
import java.util.Set;
import java.util.List;
import java.util.concurrent.ConcurrentLinkedQueue;
public class EngineOld {
public static ConcurrentHashMap<Location, Set<Player>> canSeeTileEntity = new ConcurrentHashMap<>();
public static Set<Chunk> syncRecheck = ConcurrentHashMap.newKeySet();
private final static BlockData STONE = Material.STONE.createBlockData();
private final static BlockData DEEPSLATE = Material.DEEPSLATE.createBlockData();
private static class RayJob {
final Player player;
final Entity target;
final Location start, predictedStart, end;
RayJob(Player p, Entity e, Location s, Location pred, Location t) {
player = p;
target = e;
start = s;
predictedStart = pred;
end = t;
}
}
private static class RayResult {
final Player player;
final Entity target;
final boolean visible;
RayResult(Player p, Entity e, boolean v) {
player = p;
target = e;
visible = v;
}
}
private static class TileResult {
final Player player;
final Location loc;
final boolean visible;
TileResult(Player p, Location location, boolean v) {
player = p;
loc = location;
visible = v;
}
}
public static void runEngine(ConfigManager cfg, ChunkSnapshotManager snapMgr, MovementTracker tracker, RaycastedEntityOcclusion plugin) {
// ----- PHASE 1: SYNC GATHER -----
if (!syncRecheck.isEmpty()) {
Logger.warning(syncRecheck.size() + " chunks failed to snapshot asynchronously, rechecking them now.");
for (Chunk c : syncRecheck) {
if (c.isLoaded()) {
plugin.getChunkSnapshotManager().snapshotChunk(c);
syncRecheck.remove(c);
Logger.info("Successfully rechecked chunk " + c.getX() + ", " + c.getZ() + " in world " + c.getWorld().getName());
}
}
}
List<RayJob> jobs = new ArrayList<>();
for (Player p : Bukkit.getOnlinePlayers()) {
if (p.hasPermission("raycastedentityocclusions.bypass")) continue;
Location eye = p.getEyeLocation().clone();
Location predEye = null;
if (cfg.engineMode == 2) {
// getPredictedLocation returns null if insufficient data or too slow
predEye = tracker.getPredictedLocation(p);
}
for (Entity e : p.getNearbyEntities(cfg.searchRadius, cfg.searchRadius, cfg.searchRadius)) {
if (e == p) continue;
// Cull-players logic
if (e instanceof Player pl && (!cfg.cullPlayers || (cfg.onlyCullSneakingPlayers && !pl.isSneaking()))) {
p.showEntity(plugin, e);
continue;
}
Location target = e.getLocation().add(0, e.getHeight() / 2, 0).clone();
double dist = eye.distance(target);
if (dist <= cfg.alwaysShowRadius) {
p.showEntity(plugin, e);
} else if (dist > cfg.raycastRadius) {
p.hideEntity(plugin, e);
} else if (!p.canSee(e) || plugin.tick % cfg.recheckInterval == 0) {
// schedule for async raycast (with or without predEye)
jobs.add(new RayJob(p, e, eye, predEye, target));
}
}
}
// ----- PHASE 2: ASYNC RAYCASTS -----
Bukkit.getScheduler().runTaskAsynchronously(plugin, () -> {
List<RayResult> results = new ArrayList<>(jobs.size());
for (RayJob job : jobs) {
// if the player is not in the same world as the target, skip
if (!job.player.getWorld().equals(job.target.getWorld())) {
continue;
}
// first cast from real eye
boolean vis = RaycastUtil.raycast(job.start, job.end, cfg.maxOccludingCount, cfg.debugMode, snapMgr);
// if that fails and we have a predEye, cast again from predicted
if (!vis && job.predictedStart != null) {
if (cfg.debugMode) {
job.predictedStart.getWorld().spawnParticle(Particle.DUST, job.predictedStart, 1, new Particle.DustOptions(Color.BLUE, 1f));
}
vis = RaycastUtil.raycast(job.predictedStart, job.end, cfg.maxOccludingCount, cfg.debugMode, snapMgr);
}
results.add(new RayResult(job.player, job.target, vis));
}
// ----- PHASE 3: SYNC APPLY -----
Bukkit.getScheduler().runTask(plugin, () -> {
for (RayResult r : results) {
Player p = r.player;
Entity ent = r.target;
if (p != null && ent != null) {
boolean currentState = p.canSee(ent);
if (currentState == r.visible) continue;
if (r.visible) p.showEntity(plugin, ent);
else {
p.hideEntity(plugin, ent);
}
}
}
});
});
}
private static ConcurrentLinkedQueue<TileResult> results = new ConcurrentLinkedQueue<>();
public static void runTileEngine(ConfigManager cfg, ChunkSnapshotManager snapMgr, MovementTracker tracker, RaycastedEntityOcclusion plugin) {
if (cfg.checkTileEntities) {
for (Player p : Bukkit.getOnlinePlayers()) {
if (p.hasPermission("raycastedentityocclusions.bypass")) continue;
World world = p.getWorld();
//get player's chunk location
int chunkX = p.getLocation().getBlockX() >> 4;
int chunkZ = p.getLocation().getBlockZ() >> 4;
//async run with vars passed in
Bukkit.getScheduler().runTaskAsynchronously(plugin, () -> {
int chunksRadius = (cfg.searchRadius + 15) / 16;
HashSet<Location> tileEntities = new HashSet<>();
for (int x = (-chunksRadius/2)+chunkX; x <= chunksRadius+chunkX; x++) {
for (int z = (-chunksRadius/2)+chunkZ; z <= chunksRadius+chunkZ; z++) {
tileEntities.addAll(snapMgr.getTileEntitiesInChunk(world, x, z));
}
}
for (Location loc : tileEntities) {
Set<Player> seen = canSeeTileEntity.get(loc);
if (seen != null && seen.contains(p)) {
if (cfg.tileEntityRecheckInterval == 0) continue;
if (plugin.tick % (cfg.tileEntityRecheckInterval*20) != 0) continue;
}
if (snapMgr.getMaterialAt(loc).equals(Material.BEACON)) continue;
double distSquared = loc.distanceSquared(p.getLocation());
if (distSquared > cfg.searchRadius * cfg.searchRadius) {
results.add(new TileResult(p, loc,false));
continue;
}
if (distSquared < cfg.alwaysShowRadius * cfg.alwaysShowRadius) {
results.add(new TileResult(p, loc,true));
continue;
}
boolean visible = RaycastUtil.raycast(p.getEyeLocation(), loc, cfg.maxOccludingCount, cfg.debugMode, snapMgr);
if (cfg.engineMode == 2 && !visible) {
Location predEye = tracker.getPredictedLocation(p);
if (predEye != null) {
boolean result2 = RaycastUtil.raycast(predEye, loc, cfg.maxOccludingCount, cfg.debugMode, snapMgr);
if (result2) {
visible = true;
}
}
}
if (visible) {
canSeeTileEntity.computeIfAbsent(loc, k -> ConcurrentHashMap.newKeySet()).add(p);
} else {
Set<Player> seenPlayers = canSeeTileEntity.get(loc);
if (seenPlayers != null) {
seenPlayers.remove(p);
if (seenPlayers.isEmpty()) {
canSeeTileEntity.remove(loc);
}
}
}
results.add(new TileResult(p, loc, visible));
}
});
}
for (TileResult r : results) {
Player p = r.player;
Location loc = r.loc;
boolean visible = r.visible;
syncToggleTileEntity(p, loc, visible, plugin);
results.remove(r);
}
}
}
public static void hideTileEntity(Player p, Location location, RaycastedEntityOcclusion plugin) {
Bukkit.getScheduler().runTask(plugin, () -> {
if (p.hasPermission("raycastedentityocclusions.bypass")) return;
if (location.getBlockY() < 0) p.sendBlockChange(location, DEEPSLATE);
else p.sendBlockChange(location, STONE);
});
}
public static void showTileEntity(Player p, Location location, RaycastedEntityOcclusion plugin) {
Bukkit.getScheduler().runTask(plugin, () -> {
Block block = location.getBlock();
BlockState data = block.getState();
if (data instanceof TileState tileData) {
p.sendBlockChange(location, block.getBlockData());
p.sendBlockUpdate(location, tileData);
}
else throw new RuntimeException("Attempting to show a block which isn't a tile entity");
});
}
public static void syncToggleTileEntity(Player p, Location loc, boolean show, RaycastedEntityOcclusion plugin) {
if (show) {
showTileEntity(p, loc, plugin);
} else {
hideTileEntity(p, loc, plugin);
}
}
}*/
@@ -0,0 +1,50 @@
package games.cubi.raycastedAntiESP.raycast;
import games.cubi.raycastedAntiESP.config.ConfigManager;
import games.cubi.raycastedAntiESP.RaycastedAntiESP;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.entity.Player;
import java.util.ArrayDeque;
import java.util.Deque;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
public class MovementTracker {
private final Map<Player, Deque<Location>> history = new ConcurrentHashMap<>(); //TODO: Queue makes more sense than deque, also this should be moved elsewhere
public MovementTracker(RaycastedAntiESP plugin, ConfigManager config) {
Bukkit.getScheduler().scheduleSyncRepeatingTask(plugin, updateLocationHistory(config), 1L, 1L);
}
private Runnable updateLocationHistory(ConfigManager config) {
if (config.getEngineMode() != 2) return () -> {};
for (Player p : Bukkit.getOnlinePlayers()) {
history.computeIfAbsent(p, k -> new ArrayDeque<>(5));
Deque<Location> dq = history.get(p);
if (dq.size() >= 5) dq.removeFirst();
dq.addLast(p.getEyeLocation());
}
return () -> {};
}
/**
* Predicts location 5 ticks ahead based on last 5 ticks. Returns null if insufficient or too slow.
*/
public Location getPredictedLocation(Player p) {
Deque<Location> dq = history.get(p);
if (dq == null || dq.size() < 5) return null;
Location old = dq.peekFirst();
Location now = dq.peekLast();
if (old == null || now == null) return null;
double dx = now.getX() - old.getX();
double dy = now.getY() - old.getY();
double dz = now.getZ() - old.getZ();
double speed = Math.sqrt(dx*dx + dy*dy + dz*dz) / 5.0;
if (speed < 0.1) return null;
return now.clone().add(dx*2, dy, dz*2);
}
}
@@ -0,0 +1,98 @@
package games.cubi.raycastedAntiESP.raycast;
import games.cubi.raycastedAntiESP.snapshot.ChunkSnapshotManager;
import games.cubi.raycastedAntiESP.utils.LocationPair;
import org.bukkit.Color;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.Particle;
import org.bukkit.util.Vector;
public class RaycastUtil {
public static boolean raycastLocationPair(LocationPair locationPair, int maxOccluding, boolean debug, ChunkSnapshotManager snap) {
//These locations do not need to be cloned because .toLocation creates a new location object. We can mutate it freely
Location currentA = locationPair.first().toLocation();
Location currentB = locationPair.second().toLocation();
Particle.DustOptions dustRed = null;
Particle.DustOptions dustGreen = null;
Particle.DustOptions dustBlue = null;
if (debug) {
dustRed = new Particle.DustOptions(Color.RED,1f);
dustGreen = new Particle.DustOptions(Color.GREEN,1f);
dustBlue = new Particle.DustOptions(Color.BLUE,1f);
}
double total = currentA.distance(currentB);
double traveledA = 0;
double traveledB = 0;
Vector dirA = currentB.toVector().subtract(currentA.toVector()).normalize();
Vector dirB = currentA.toVector().subtract(currentB.toVector()).normalize();
// Walk from each end until the cursors meet in the middle
while (traveledA + traveledB < total) {
/* --- step from A ---> B --- */
currentA.add(dirA);
traveledA += 1;
Material matA = snap.getMaterialAt(currentA);
if (matA != null && matA.isOccluding()) {
maxOccluding--;
if (debug) currentA.getWorld().spawnParticle(Particle.DUST, currentA, 1, dustRed);
} else if (debug) {
currentA.getWorld().spawnParticle(Particle.DUST, currentA, 1, dustGreen);
}
if (maxOccluding < 1) return false;
/* --- step from B ---> A --- */
if (traveledA + traveledB >= total) break; // already overlapped
currentB.add(dirB);
traveledB += 1;
Material matB = snap.getMaterialAt(currentB);
if (matB != null && matB.isOccluding()) {
maxOccluding--;
if (debug) currentB.getWorld().spawnParticle(Particle.DUST, currentB, 1, dustRed);
} else if (debug) {
currentB.getWorld().spawnParticle(Particle.DUST, currentB, 1, dustBlue);
}
if (maxOccluding < 1) return false;
}
return true;
}
public static boolean raycast(Location start, Location end, int maxOccluding, boolean debug, ChunkSnapshotManager snap) {
Particle.DustOptions dustRed = null;
Particle.DustOptions dustGreen = null;
if (debug) {
dustRed = new Particle.DustOptions(org.bukkit.Color.RED, 1f);
dustGreen = new Particle.DustOptions(org.bukkit.Color.GREEN, 1f);
}
double total = start.distance(end);
double traveled = 0;
Location curr = start.clone();
Vector dir = end.toVector().subtract(start.toVector()).normalize();
while (traveled < total) {
curr.add(dir);
traveled += 1;
Material mat = snap.getMaterialAt(curr);
if (mat == null) {
continue;
}
if (mat.isOccluding()) {
maxOccluding--;
if (debug) {
start.getWorld().spawnParticle(Particle.DUST, curr, 1, dustRed);
}
if (maxOccluding < 1) return false;
}
else if (debug) {
start.getWorld().spawnParticle(Particle.DUST, curr, 1, dustGreen);
}
}
return true;
}
}
@@ -0,0 +1,203 @@
package games.cubi.raycastedAntiESP.snapshot;
import games.cubi.raycastedAntiESP.config.ConfigManager;
import games.cubi.raycastedAntiESP.Logger;
import games.cubi.raycastedAntiESP.RaycastedAntiESP;
import games.cubi.raycastedAntiESP.utils.BlockLocation;
import games.cubi.raycastedAntiESP.utils.Enums;
import org.bukkit.Material;
import org.bukkit.World;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.Chunk;
import org.bukkit.ChunkSnapshot;
import org.bukkit.block.BlockState;
import org.bukkit.block.TileState;
import org.bukkit.scheduler.BukkitRunnable;
import java.util.Set;
import java.util.Map;
import java.util.Collections;
import java.util.concurrent.ConcurrentHashMap;
public class ChunkSnapshotManager {
private static class ChunkData {
public final ChunkSnapshot snapshot;
public final ConcurrentHashMap<BlockLocation, Material> delta = new ConcurrentHashMap<>();
public final Set<BlockLocation> tileEntities = ConcurrentHashMap.newKeySet();
public long lastRefresh;
public int minHeight;
public int maxHeight;
public ChunkData(ChunkSnapshot snapshot, long time) {
this.snapshot = snapshot;
this.lastRefresh = time;
}
}
private static final ConcurrentHashMap<String, ChunkData> dataMap = new ConcurrentHashMap<>();
private final ConfigManager cfg;
private final RaycastedAntiESP plugin;
public ChunkSnapshotManager(RaycastedAntiESP plugin, ConfigManager config) {
cfg = config;
this.plugin = plugin;
//get loaded chunks and add them to dataMap
for (World w : plugin.getServer().getWorlds()) {
for (Chunk c : w.getLoadedChunks()) {
snapshotChunk(c);
}
}
new BukkitRunnable() {
@Override
public void run() {
long now = System.currentTimeMillis();
int chunksRefreshed = 0;
int chunksToRefreshMaximum = getNumberOfCachedChunks() / 3;
for (Map.Entry<String, ChunkData> e : dataMap.entrySet()) {
if (now - e.getValue().lastRefresh >= cfg.getSnapshotConfig().getWorldSnapshotRefreshInterval() * 1000L && chunksRefreshed < chunksToRefreshMaximum) {
chunksRefreshed++;
String key = e.getKey();
snapshotChunk(key);
}
}
Logger.info("ChunkSnapshotManager: Refreshed " + chunksRefreshed + " chunks out of " + chunksToRefreshMaximum + " maximum.", 10);
}
}.runTaskTimerAsynchronously(plugin, cfg.getSnapshotConfig().getWorldSnapshotRefreshInterval() * 2L, cfg.getSnapshotConfig().getWorldSnapshotRefreshInterval() * 2L /* This runs 10 times per refreshInterval, spreading out the refreshes */);
}
public void onChunkLoad(Chunk c) {
snapshotChunk(c);
}
public void onChunkUnload(Chunk c) {
removeChunkSnapshot(c);
}
public void snapshotChunk(Chunk c) {
Logger.info("ChunkSnapshotManager: Taking snapshot of chunk " + c.getWorld().getName() + ":" + c.getX() + ":" + c.getZ(),10);
dataMap.put(key(c), takeSnapshot(c, System.currentTimeMillis()));
}
public void snapshotChunk(String key) {
snapshotChunk(getKeyChunk(key));
}
public void removeChunkSnapshot(Chunk c) {
Logger.info("ChunkSnapshotManager: Removing snapshot of chunk " + c.getWorld().getName() + ":" + c.getX() + ":" + c.getZ(), 9);
dataMap.remove(key(c));
}
// Used by EventListener to update the delta map when a block is placed or broken
public void onBlockChange(Location loc, Material m, Enums.BlockChangeType type) {
Logger.info("ChunkSnapshotManager: Block change at " + loc + " to " + m, 9);
ChunkData d = dataMap.get(key(loc.getChunk()));
if (d == null) {
Logger.error("Data map value empty, ignoring block update!",2);
return;
}
BlockLocation location = new BlockLocation(loc);
d.delta.put(location, m);
if (cfg.getTileEntityConfig().isEnabled()) {
// Check if the block is a tile entity
BlockState data = loc.getBlock().getState();
loc = loc.clone().add(0.5, 0.5, 0.5);
if (data instanceof TileState) {
Logger.info("ChunkSnapshotManager: Tile entity at " + loc, 8);
if (type == Enums.BlockChangeType.PLACED) {
d.tileEntities.add(location);
} else if (type == Enums.BlockChangeType.BROKEN) {
d.tileEntities.remove(location);
}
}
}
else {Logger.error("Data map value empty, ignoring block update!", 2);}
}
private ChunkData takeSnapshot(Chunk c, long now) {
World w = c.getWorld();
ChunkData data = new ChunkData(c.getChunkSnapshot(), now);
int chunkX = c.getX() * 16;
int chunkZ = c.getZ() * 16;
int minHeight = w.getMinHeight();
int maxHeight = w.getMaxHeight();
data.maxHeight = maxHeight;
data.minHeight = minHeight;
if (cfg.getTileEntityConfig().isEnabled()) {
for (int x = 0; x < 16; x++) {
for (int y = minHeight; y < maxHeight; y++) {
for (int z = 0; z < 16; z++) {
BlockState bs = data.snapshot.getBlockData(x, y, z).createBlockState();
if (bs instanceof TileState) {
data.tileEntities.add(new BlockLocation(w, x+ chunkX, y, z + chunkZ));
}
}
}
}
}
return data;
}
public String key(Chunk c) {
return c.getWorld().getName() + ":" + c.getX() + ":" + c.getZ();
}
public String key(World world, int x, int z) {
return world.getName() + ":" + x + ":" + z;
}
public int getKeyX(String key) {
String[] parts = key.split(":");
return Integer.parseInt(parts[1]);
}
public int getKeyZ(String key) {
String[] parts = key.split(":");
return Integer.parseInt(parts[2]);
}
public World getKeyWorld(String key) {
String[] parts = key.split(":");
return Bukkit.getWorld(parts[0]);
}
public Chunk getKeyChunk(String key) {
return getKeyWorld(key).getChunkAt(getKeyX(key), getKeyZ(key));
}
public Material getMaterialAt(Location loc) {
Chunk chunk = loc.getChunk();
ChunkData d = dataMap.get(key(chunk));
if (d == null) {
Chunk c = loc.getChunk();
Logger.error("ChunkSnapshotManager: No snapshot for " + c+ " If this error persists, please report this on our discord (discord.cubi.games)", 3);
//EngineOld.syncRecheck.add(chunk); TODO reenable
return loc.getBlock().getType();
}
double yLevel = loc.getY();
if (yLevel < d.minHeight || yLevel > d.maxHeight) {
return null;
}
Material dm = d.delta.get(new BlockLocation(loc));
if (dm != null) {
Logger.info("Using delta", 9);
return dm;
}
int x = loc.getBlockX() & 0xF;
int y = loc.getBlockY();
int z = loc.getBlockZ() & 0xF;
return d.snapshot.getBlockType(x, y, z);
}
//get TileEntity Locations in chunk
public Set<Location> getTileEntitiesInChunk(World world, int x, int z) {
ChunkData d = dataMap.get(key(world, x, z));
if (d == null) {
return Collections.emptySet();
}
return BlockLocation.toCentredLocations(d.tileEntities);
}
public int getNumberOfCachedChunks() {
return dataMap.size();
//created to use in a info command maybe
}
}
@@ -0,0 +1,73 @@
package games.cubi.raycastedAntiESP.utils;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.World;
import java.util.HashSet;
import java.util.Objects;
import java.util.Set;
import java.util.UUID;
public class BlockLocation {
private final UUID world;
private final int x;
private final int y;
private final int z;
public BlockLocation(World world, double x, double y, double z) {
this.world = world.getUID();
this.x = (int) Math.floor(x);
this.y = (int) Math.floor(y);
this.z = (int) Math.floor(z);
}
public BlockLocation(Location loc) {
this.world = loc.getWorld().getUID();
this.x = (int) Math.floor(loc.getX());
this.y = (int) Math.floor(loc.getY());
this.z = (int) Math.floor(loc.getZ());
}
public int getX() {
return x;
}
public int getY() {
return y;
}
public int getZ() {
return z;
}
public Location toCentredLocation() {
return new Location(Bukkit.getWorld(world), x + 0.5, y + 0.5, z + 0.5);
}
public static Location toCentredLocation(BlockLocation blockLocation) {
return new Location(Bukkit.getWorld(blockLocation.world), blockLocation.x + 0.5, blockLocation.y + 0.5, blockLocation.z + 0.5);
}
public static Set<Location> toCentredLocations(Set<BlockLocation> blockLocations) {
Set<Location> locations = new HashSet<>();
for (BlockLocation bl : blockLocations) {
locations.add(BlockLocation.toCentredLocation(bl));
}
return locations;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof BlockLocation other)) return false;
return x == other.x && y == other.y && z == other.z && world.equals(other.world);
}
@Override
public int hashCode() {
return Objects.hash(world, x, y, z);
}
}
@@ -0,0 +1,8 @@
package games.cubi.raycastedAntiESP.utils;
//Paper always prints the name of the exception being thrown, even if the message is empty. So, the name of this class will point the user to the actual error message
public class CheckPreviousLogForError extends RuntimeException {
public CheckPreviousLogForError() {
super("",null, false, false);
}
}
@@ -0,0 +1,7 @@
package games.cubi.raycastedAntiESP.utils;
import org.bukkit.Location;
import java.util.UUID;
public record EntityLocationPair(UUID entity, Location loc) {
}
@@ -0,0 +1,8 @@
package games.cubi.raycastedAntiESP.utils;
public class Enums {
public enum BlockChangeType {
PLACED,
BROKEN
}
}
@@ -0,0 +1,44 @@
package games.cubi.raycastedAntiESP.utils;
import java.util.Objects;
public final class LocationPair {
private final QuantisedLocation loc1;
private final QuantisedLocation loc2; // canonical ordering: loc1 ≤ loc2 by hash
private LocationPair(QuantisedLocation p, QuantisedLocation e) {
this.loc1 = p;
this.loc2 = e;
}
public static LocationPair of(QuantisedLocation a, QuantisedLocation b) {
if (!a.world().equals(b.world()))
throw new IllegalArgumentException("Locations are in different worlds");
// choose a deterministic order so (A,B)==(B,A) TODO: More perf optimal way than hashing? Or maybe just make sure this is ran async? Or is hashing fine perf wise?
if (a.hashCode() <= b.hashCode()) {
return new LocationPair(a, b);
}
else return new LocationPair(b, a);
}
public QuantisedLocation first() {
return loc1;
}
public QuantisedLocation second() {
return loc2;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof LocationPair lp)) return false;
return loc1.equals(lp.loc1) && loc2.equals(lp.loc2);
}
@Override
public int hashCode() {
return Objects.hash(loc1, loc2);
}
}
@@ -0,0 +1,107 @@
package games.cubi.raycastedAntiESP.utils;
import games.cubi.raycastedAntiESP.data.DataHolder;
import org.bukkit.Location;
import org.bukkit.entity.Player;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;
public class PlayerData {
private record EntityVisibilityAndLastCheckTime(boolean visible, int lastChecked) {
public EntityVisibilityAndLastCheckTime(boolean visible) {
this(visible, DataHolder.getTick());
}
}
// Maps must be thread-safe as their values will be updated while async engine jobs are running, but UUID is probably fine.
private final UUID playerUUID;
private boolean hasBypassPermission;
// UUID = Entity UUID, Boolean = if it is visible to the player. False = hidden
private final ConcurrentHashMap<UUID, EntityVisibilityAndLastCheckTime> entityVisibility = new ConcurrentHashMap<>();
// Location, time in millis TODO: Is it necessary to store the time as a long? Do we even need a recheck interval at all?
private final ConcurrentHashMap<BlockLocation, Long> seenTileEntities = new ConcurrentHashMap<>();
public PlayerData(UUID playerUUID, boolean hasBypassPermission) {
this.playerUUID = playerUUID;
this.hasBypassPermission = hasBypassPermission;
}
public PlayerData(Player player) {
this.playerUUID = player.getUniqueId();
this.hasBypassPermission = player.hasPermission("raycastedentityocclusions.bypass");
}
public UUID getPlayerUUID() {
return playerUUID;
}
/**
* Adds the provided set of entity UUIDs to the entity visibility map with a default visibility of false (not visible). If an entity UUID already exists in the map, it will not be modified.
* **/
public void addEntities(Set<UUID> entityUUIDs) {
for (UUID entityUUID : entityUUIDs) {
entityVisibility.putIfAbsent(entityUUID, new EntityVisibilityAndLastCheckTime(false));
}
}
public void addEntity(UUID entityUUID) {
entityVisibility.putIfAbsent(entityUUID, new EntityVisibilityAndLastCheckTime(false)); // Default to hidden if not already present
}
public void setEntityVisibility(UUID entityUUID, boolean visible) {
entityVisibility.put(entityUUID, new EntityVisibilityAndLastCheckTime(visible)); // This can be used for both adding new entries and updating visibility
}
public boolean isEntityVisible(UUID entityUUID) {
return entityVisibility.getOrDefault(entityUUID, new EntityVisibilityAndLastCheckTime(true)).visible;
//Default to true as entities are visible unless explicitly hidden
}
public void removeEntity(UUID entityUUID) {
entityVisibility.remove(entityUUID);
}
public Map<BlockLocation, Long> getSeenTileEntitiesMap() {
return new HashMap<>(seenTileEntities);
}
public void addSeenTileEntity(BlockLocation tileEntityLocation) {
seenTileEntities.put(tileEntityLocation, System.currentTimeMillis());
}
public void addSeenTileEntity(Location tileEntityLocation) {
seenTileEntities.put(new BlockLocation(tileEntityLocation), System.currentTimeMillis());
}
public void removeSeenTileEntity(BlockLocation tileEntityLocation) {
seenTileEntities.remove(tileEntityLocation); // This method should never actually be called, but it's here for completeness
}
public void removeSeenTileEntity(Location tileEntityLocation) {
seenTileEntities.remove(new BlockLocation(tileEntityLocation)); // This method should never actually be called, but it's here for completeness
}
public boolean hasSeenTileEntity(BlockLocation tileEntityLocation) {
return seenTileEntities.containsKey(tileEntityLocation);
}
public boolean hasSeenTileEntity(Location tileEntityLocation) {
return seenTileEntities.containsKey(new BlockLocation(tileEntityLocation));
}
public boolean hasBypassPermission() {
return hasBypassPermission;
}
public void setBypassPermission(boolean hasBypassPermission) {
this.hasBypassPermission = hasBypassPermission;
}
}
@@ -0,0 +1,87 @@
package games.cubi.raycastedAntiESP.utils;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.util.Vector;
import java.util.Objects;
import java.util.UUID;
public class QuantisedLocation {
// One decimal place quantisation. This means that the coordinates are rounded to the nearest 0.1 block, and since integers are used this works up to 200m blocks away (integer limit/10)
// Note that the last digit of the integer is the tenths place, so 123456789 represents 12345678.9 in real coordinates.
private final int x;
private final int y;
private final int z;
private final UUID world;
public QuantisedLocation(Location location) {
this.x = (int) Math.floor(location.getX() * 10);
this.y = (int) Math.floor(location.getY() * 10);
this.z = (int) Math.floor(location.getZ() * 10);
this.world = location.getWorld().getUID();
}
public QuantisedLocation(Location location, double height) {
this.x = (int) Math.floor(location.getX() * 10);
this.y = (int) Math.floor(location.getY()+(height/2) * 10);
this.z = (int) Math.floor(location.getZ() * 10);
this.world = location.getWorld().getUID();
}
public Location toLocation() {
return new Location(Bukkit.getWorld(world), (x / 10.0)+0.05, (y / 10.0)+0.05, (z / 10.0)+0.05);
}
public ThreadSafeLoc toThreadSafeLoc() {
return new ThreadSafeLoc(this);
}
public Vector toNewVector() {
return new Vector((x / 10.0)+0.05, (y / 10.0)+0.05, (z / 10.0)+0.05);
}
public boolean isWithinRadius(QuantisedLocation other, double radius) {
if (!this.world.equals(other.world)) {
throw new IllegalArgumentException("Cannot calculate distance between different worlds.");
}
int dx = this.x - other.x;
int dy = this.y - other.y;
int dz = this.z - other.z;
// Convert radius (in blocks) to squared distance in quantised units (tenths of blocks).
double radiusSquared = radius * radius * 100; // (radius * 10)²
int distanceSquared = dx * dx + dy * dy + dz * dz;
return distanceSquared <= radiusSquared;
}
public double realX() {
return (x / 10.0) + 0.05;
}
public double realY() {
return (y / 10.0) + 0.05;
}
public double realZ() {
return (z / 10.0) + 0.05;
}
public UUID world() {
return world;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof QuantisedLocation other)) return false;
return x == other.x && y == other.y && z == other.z && world.equals(other.world);
}
@Override
public int hashCode() {
return Objects.hash(world, x, y, z);
}
}
@@ -0,0 +1,33 @@
package games.cubi.raycastedAntiESP.utils;
import java.util.*;
public class Subscribers {
//First UUID are the players, second uuid are the entities tied to their subscription
private final HashMap<UUID, Set<UUID>> subscribers = new HashMap<>();
public Subscribers(UUID player, Set<UUID> entities) {
subscribers.putIfAbsent(player, entities);
}
public Subscribers(UUID player, UUID entity) {
addSubscriberWithEntity(player, entity);
}
public Subscribers() {}
public void addSubscriberWithEntity(UUID player, UUID entity) {
// if 'player' is not already in the map, create a new HashSet<>()
subscribers
.computeIfAbsent(player, k -> new HashSet<>())
.add(entity);
}
public Set<UUID> getEntities(UUID player) {
return subscribers.getOrDefault(player, Collections.emptySet());
}
public Set<UUID> getPlayers() {
return subscribers.keySet();
}
}
@@ -0,0 +1,124 @@
package games.cubi.raycastedAntiESP.utils;
import games.cubi.raycastedAntiESP.Logger;
import org.bukkit.Location;
import org.bukkit.util.Vector;
import java.util.Objects;
import java.util.UUID;
import java.util.concurrent.atomic.AtomicBoolean;
public class ThreadSafeLoc //TBH I still don't even know if this is needed
{
private final UUID world;
private final Vector vector1;
private final Vector vector2;
private volatile byte pointer = 1;
private final AtomicBoolean writeLock = new AtomicBoolean(false);
public ThreadSafeLoc(Vector vec, UUID world) {
writeLock.set(true);
this.world = world;
vector1 = vec.clone(); //clone to ensure a new vector
writeLock.set(false);
vector2 = vector1.clone();
}
public ThreadSafeLoc(Location loc) {
this(loc.toVector(), loc.getWorld().getUID());
}
public ThreadSafeLoc(Location loc, double height) {
this(loc.add(0, height/2, 0).toVector(), loc.getWorld().getUID());
}
public ThreadSafeLoc(QuantisedLocation loc) {
this(new Vector(loc.realX(), loc.realY(), loc.realZ()), loc.world());
}
/**This returns the actual vector, so make sure it is cloned before use*/
private Vector getPointedVector() {
if (pointer == 1) return vector1;
return vector2;
}
public Vector getPointedVectorClone() {
return getPointedVector().clone();
}
/**Returns a clone of the vector*/
public Vector read() {
return getPointedVector().clone();
}
/**Returns the X value of the vector*/
public double readX() {
return getPointedVector().getX();
}
/**Returns the Y value of the vector*/
public double readY() {
return getPointedVector().getY();
}
/**Returns the Z value of the vector*/
public double readZ() {
return getPointedVector().getZ();
}
public UUID readWorld() { return world; }
public boolean update(Vector newVec) {
if (writeLock.compareAndSet(false, true)) {
try {
pointer = 2;
overwriteVector(vector1, newVec);
pointer = 1;
overwriteVector(vector2, vector1);
return true;
} finally {
boolean sanityCheck = writeLock.compareAndSet(true, false);
if (!sanityCheck) Logger.errorAndReturn(new RuntimeException("ThreadSafeLoc lost thread lock during operation"));
}
}
else return false;
}
public boolean updateDelta(Vector delta) {
if (writeLock.compareAndSet(false, true)) {
try {
pointer = 2;
vector1.add(delta);
pointer = 1;
overwriteVector(vector2, vector1);
return true;
} finally {
boolean sanityCheck = writeLock.compareAndSet(true, false);
if (!sanityCheck) Logger.errorAndReturn(new RuntimeException("ThreadSafeLoc lost thread lock during operation"));
}
}
else return false;
}
/**
* Overwrites the first object with the x,y,z values of the second object to avoid creating new vector objects
@param object the vector being overwritten
@param newVec the source of the x,y,z values
@return the overwritten vector (same as object param)
* **/
@SuppressWarnings("UnusedReturnValue")
private Vector overwriteVector(Vector object, Vector newVec) {
object.setX(newVec.getX()).setY(newVec.getY()).setZ(newVec.getZ());
return object;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof ThreadSafeLoc other)) return false;
return world.equals(other.world) && this.getPointedVector().equals(other.getPointedVector());
}
@Override
public int hashCode() {
return Objects.hash(world, getPointedVector());
}
}
@@ -1,168 +0,0 @@
package games.cubi.raycastedEntityOcclusion;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.World;
import org.bukkit.entity.Entity;
import org.bukkit.entity.Player;
import org.bukkit.plugin.Plugin;
import org.bukkit.scheduler.BukkitRunnable;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
public class CheckEntityVisibility {
RaycastedEntityOcclusion plugin;
private int alwaysShowRadius;
private int raycastRadius;
private int searchRadius;
private boolean moreChecks;
private boolean occludePlayers;
private int recheckInterval;
private int tickCounter = 0;
//ConcurrentHashMap allows for Thread-safe operations. Don't use regular hashmaps
private final Map<Player, Set<Entity>> entitiesToShow = new ConcurrentHashMap<>();
private final Map<Player, Set<Entity>> entitiesToHide = new ConcurrentHashMap<>();
public CheckEntityVisibility(RaycastedEntityOcclusion plugin) {
this.plugin = plugin;
this.alwaysShowRadius = plugin.alwaysShowRadius;
this.raycastRadius = plugin.raycastRadius;
this.searchRadius = plugin.searchRadius;
this.moreChecks = plugin.moreChecks;
this.occludePlayers = plugin.occludePlayers;
this.recheckInterval = plugin.recheckInterval;
new BukkitRunnable() {
@Override
public void run() {
entitiesToShow.clear();
entitiesToHide.clear();
for (Player player : Bukkit.getOnlinePlayers()) {
runVisibilityCheck(player);
}
applyVisibilityChanges();
tickCounter++;
if (tickCounter > 1000000) {
tickCounter = 0;
}
}
}.runTaskTimer(plugin, 0L, 1L);
}
public void updateConfigValues() {
this.alwaysShowRadius = plugin.alwaysShowRadius;
this.raycastRadius = plugin.raycastRadius;
this.searchRadius = plugin.searchRadius;
this.moreChecks = plugin.moreChecks;
this.occludePlayers = plugin.occludePlayers;
this.recheckInterval = plugin.recheckInterval;
}
public void runVisibilityCheck(Player player) {
World world = player.getWorld();
List<Entity> nearbyEntities = player.getNearbyEntities(searchRadius, searchRadius, searchRadius);
for (Entity entity : nearbyEntities) {
if (world != player.getWorld()) {
return;
}
if (entity instanceof Player && !occludePlayers) {
continue;
}
double distance = player.getLocation().distance(entity.getLocation());
if (distance <= alwaysShowRadius) {
// Always show entities within this radius
addEntityToShow(player, entity);
continue;
}
if (distance > raycastRadius) {
// Hide entities outside the raycast radius
addEntityToHide(player, entity);
continue;
}
Boolean canSee = player.canSee(entity);
int check = tickCounter % recheckInterval;
//plugin.getLogger().info("check: " + check + " cansee " + canSee);
if (!canSee || check == 0) {
//check whether to run intensive or light checks
Double height = entity.getHeight();
if (moreChecks) {
Double width = entity.getWidth();
Location checkOne = entity.getLocation().add(0, height - 0.01, 0);
Location checkTwo = entity.getLocation().add(0, 0.01, 0);
Location checkThree = entity.getLocation().add(width / 2, height / 2, 0);
Location checkFour = entity.getLocation().add(-width / 2, height / 2, 0);
Raycast.asyncRaycast(player.getEyeLocation(), checkOne, plugin, canSeePlayer -> {
if (canSeePlayer) {
addEntityToShow(player, entity);
} else {
Raycast.asyncRaycast(player.getEyeLocation(), checkTwo, plugin, canSeePlayer2 -> {
if (canSeePlayer2) addEntityToShow(player, entity);
else {
Raycast.asyncRaycast(player.getEyeLocation(), checkThree, plugin, canSeePlayer3 -> {
if (canSeePlayer3) addEntityToShow(player, entity);
else {
Raycast.asyncRaycast(player.getEyeLocation(), checkFour, plugin, canSeePlayer4 -> {
if (canSeePlayer4) addEntityToShow(player, entity);
else addEntityToHide(player, entity);
});
}
});
}
});
}
});
} else {
Location entityLocation = entity.getLocation().add(0, height / 2, 0);
Raycast.asyncRaycast(player.getEyeLocation(), entityLocation, plugin, canSeePlayer -> {
if (canSeePlayer) {
addEntityToShow(player, entity);
} else {
addEntityToHide(player, entity);
}
});
}
}
}
}
private void addEntityToShow(Player player, Entity entity) {
entitiesToShow.computeIfAbsent(player, k -> ConcurrentHashMap.newKeySet()).add(entity);
entitiesToHide.computeIfAbsent(player, k -> ConcurrentHashMap.newKeySet()).remove(entity);
}
private void addEntityToHide(Player player, Entity entity) {
entitiesToHide.computeIfAbsent(player, k -> ConcurrentHashMap.newKeySet()).add(entity);
entitiesToShow.computeIfAbsent(player, k -> ConcurrentHashMap.newKeySet()).remove(entity);
}
private void applyVisibilityChanges() {
for (Map.Entry<Player, Set<Entity>> entry : entitiesToShow.entrySet()) {
Player player = entry.getKey();
for (Entity entity : entry.getValue()) {
if (entity instanceof Player p) {
player.showPlayer(plugin, p);
}
else player.showEntity(plugin, entity);
}
}
for (Map.Entry<Player, Set<Entity>> entry : entitiesToHide.entrySet()) {
Player player = entry.getKey();
for (Entity entity : entry.getValue()) {
if (entity instanceof Player p) {
player.hidePlayer(plugin, p);
}
else player.hideEntity(plugin, entity);
}
}
}
}
@@ -1,32 +0,0 @@
package games.cubi.raycastedEntityOcclusion;
import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
public class CommandHandler implements CommandExecutor {
RaycastedEntityOcclusion plugin;
public CommandHandler(RaycastedEntityOcclusion plugin) {
this.plugin = plugin;
}
@Override
public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
if (args.length != 0 && args[0].equalsIgnoreCase("reload")) {
plugin.loadConfig();
plugin.getCheckEntityVisibility().updateConfigValues();
sender.sendMessage("RaycastedEntityOcclusion config reloaded.");
return true;
}
sender.sendMessage("RaycastedEntityOcclusion v" + plugin.getDescription().getVersion());
sender.sendMessage("AlwaysShowRadius: " + plugin.alwaysShowRadius);
sender.sendMessage("RaycastRadius: " + plugin.raycastRadius);
sender.sendMessage("SearchRadius: " + plugin.searchRadius);
sender.sendMessage("MoreChecks: " + plugin.moreChecks);
sender.sendMessage("OccludePlayers: " + plugin.occludePlayers);
sender.sendMessage("RecheckInterval: " + plugin.recheckInterval);
return true;
}
}
@@ -1,72 +0,0 @@
package games.cubi.raycastedEntityOcclusion;
import org.bukkit.*;
import org.bukkit.block.Block;
import org.bukkit.entity.Player;
import org.bukkit.scheduler.BukkitRunnable;
import org.bukkit.util.RayTraceResult;
import org.bukkit.util.Vector;
public class Raycast {
public static void asyncRaycast(Location start, Location end, RaycastedEntityOcclusion plugin, RaycastCallback callback) {
new BukkitRunnable() {
@Override
public void run() {
Vector direction = end.toVector().subtract(start.toVector()).normalize();
double distance = start.distance(end);
// Perform the ray trace
RayTraceResult result = start.getWorld().rayTraceBlocks(start, direction, distance,
FluidCollisionMode.NEVER, // Ignore fluids
true, // Pass through transparent blocks
// Check if the block is occluding
(block) -> isOccluding(block.getType())
);
// Check if the ray hit a solid block or reached the player
if (result == null || result.getHitBlock() == null) {
// No solid block was hit, so the ray reached the player
callback.onResult(true);
} else {
// A solid block was hit
callback.onResult(false);
//plugin.getLogger().info("Raycast hit a solid block: " + result.getHitBlock().getType() + " at " + result.getHitBlock().getLocation());
}
}
}.runTaskAsynchronously(plugin);
}
public interface RaycastCallback {
void onResult(boolean canSeePlayer);
}
private static boolean isOccluding(Material material) {
return material.isOccluding();
}
public static boolean syncRaycast(Location start, Location end, RaycastedEntityOcclusion plugin) {
Vector direction = end.toVector().subtract(start.toVector()).normalize();
double distance = start.distance(end);
// Perform the ray trace
RayTraceResult result = start.getWorld().rayTraceBlocks(start, direction, distance,
FluidCollisionMode.NEVER, // Ignore fluids
true, // Pass through transparent blocks
// Check if the block is occluding
(block) -> isOccluding(block.getType())
);
// Check if the ray hit a solid block or reached the player
if (result == null || result.getHitBlock() == null) {
// No solid block was hit, so the ray reached the player
return true;
} else {
// A solid block was hit
return false;
//plugin.getLogger().info("Raycast hit a solid block: " + result.getHitBlock().getType() + " at " + result.getHitBlock().getLocation());
}
}
}
@@ -1,59 +0,0 @@
package games.cubi.raycastedEntityOcclusion;
import org.bukkit.configuration.file.FileConfiguration;
import org.bukkit.plugin.java.JavaPlugin;
public final class RaycastedEntityOcclusion extends JavaPlugin {
public int alwaysShowRadius;
public int raycastRadius;
public int searchRadius;
public boolean moreChecks;
public boolean occludePlayers;
public int recheckInterval;
public int tickCounter = 0;
public RaycastedEntityOcclusion plugin = this;
public CheckEntityVisibility checkEntityVisibility;
@Override
public void onEnable() {
loadConfig();
int pluginId = 24553;
new Metrics(this, pluginId);
checkEntityVisibility = new CheckEntityVisibility(plugin);
getCommand("raycastedentityocclusion").setExecutor(new CommandHandler(plugin));
}
@Override
public void onDisable() {
// Plugin shutdown logic
}
public void loadConfig() {
saveDefaultConfig();
reloadConfig();
FileConfiguration config = getConfig();
alwaysShowRadius = config.getInt("AlwaysShowRadius", 4);
raycastRadius = config.getInt("RaycastRadius", 64);
searchRadius = config.getInt("SearchRadius", 72);
moreChecks = config.getBoolean("MoreChecks", false);
occludePlayers = config.getBoolean("OccludePlayers", false);
recheckInterval = config.getInt("RecheckInterval", 10);
getLogger().info("AlwaysShowRadius: " + alwaysShowRadius);
getLogger().info("RaycastRadius: " + raycastRadius);
getLogger().info("SearchRadius: " + searchRadius);
getLogger().info("MoreChecks: " + moreChecks);
getLogger().info("OccludePlayers: " + occludePlayers);
getLogger().info("RecheckInterval: " + recheckInterval);
}
public CheckEntityVisibility getCheckEntityVisibility() {
return checkEntityVisibility;
}
}
+30
View File
@@ -0,0 +1,30 @@
config-version: 1.0 # Do not change this value, it is used internally by the plugin to determine if the config is up to date.
checks:
entities:
enabled: true
max-occluding-count: 3
raycast-radius: 48
always-show-radius: 16 # radius to always show entities
recheck-interval: 50 # ticks between forced rechecks for visible entities
engine-mode: 1 # 1 = straight-line; 2 = predictive and straight-line
tile-entities:
enabled: true
max-occluding-count: 3
raycast-radius: 48
always-show-radius: 16
recheck-interval: 0 # seconds between forced rechecks for visible tile entities. If set to 0, they will never be rechecked.
engine-mode: 1 # 1 = straight-line; 2 = predictive and straight-line
players:
enabled: false
only-cull-sneaking: false
max-occluding-count: 3
raycast-radius: 48
always-show-radius: 16
recheck-interval: 50 # ticks between forced rechecks for visible players
engine-mode: 1 # 1 = straight-line; 2 = predictive and straight-line
snapshots:
chunk-refresh-interval: 60 # seconds between chunk snapshot refresh, won't change without restart
debug:
log-level: 1 # Scale from 0-10, where larger numbers mean more verbose logging and 0 disables logging
particles: false # enable debug particles
-6
View File
@@ -1,6 +0,0 @@
AlwaysShowRadius: 8
RaycastRadius: 48
SearchRadius: 52
MoreChecks: false #This will enable more raycasts per mob, increasing performance hit but showing partially visible mobs
OccludePlayers: false #Enabling this will make the plugin cull hidden players alongside entities
RecheckInterval: 20 #Time in ticks between rechecking visible mobs
+19
View File
@@ -0,0 +1,19 @@
snapshot-refresh-interval: 60 # seconds between chunk snapshot refresh, won't change without restart
engine-mode: 1 # 1 = straight-line; 2 = predictive and straight-line
max-occluding-count: 3 # blocks before blocking
debug-mode: false # enable debug particles and more verbose logging
debug-level: 1 # Higher level results in more verbose logs. 0-10
always-show-radius: 16 # radius to always show entities
raycast-radius: 48 # beyond this, entities auto-hide
search-radius: 48 # search radius for entities
cull-players: false # cull hidden players as well as other entities
only-cull-sneaking-players: false # only cull sneaking players (requires cull-players)
recheck-interval: 50 # ticks between forced rechecks for visible entities
check-tile-entities: true # check tile entities for occlusion
tile-entity-recheck-interval: 0 # seconds between forced rechecks for visible tile entities. If set to 0, they will never be rechecked.
+15 -12
View File
@@ -1,17 +1,20 @@
name: RaycastedEntityOcclusion
name: RaycastedAntiESP
version: ${version}
main: games.cubi.raycastedEntityOcclusion.RaycastedEntityOcclusion
main: games.cubi.raycastedAntiESP.RaycastedAntiESP
api-version: '1.21'
prefix: EntityOcclusion
prefix: RaycastedAntiESP
authors: [ _Cubicake ]
load: STARTUP
website: https://cubi.games
commands:
raycastedentityocclusion:
description: RaycastedEntityOcclusion command
usage: /<command>
permission: raycastedentityocclusion.command
aliases: [reo]
permissions:
raycastedentityocclusion.command:
description: Permission to use the RaycastedEntityOcclusion command
default: op
raycastedantiesp.command:
description: Permission to use the /RaycastedAntiESP command
default: op
raycastedantiesp.bypass:
description: Permission to bypass all checks. A restart is needed to apply this permission.
default: false
raycastedantiesp.updatecheck:
description: Permission to check for plugin updates
default: op
softdepend:
- packetevents