Compare commits

..
116 Commits
Author SHA1 Message Date
Cubicake 9d0f1163e7 Remove use of brigadier redirects [Todo: Pull change to main] 2025-11-12 13:38:17 +10:30
Cubicake eda3fd12f2 Lower minimum version to v1.20.6 2025-11-12 13:37:46 +10:30
Cubicake fb3e1d24f3 Make Async 2025-11-12 13:37:31 +10:30
Cubicake f4878c5afa Make Async 2025-11-12 08:50:39 +10:30
Cubicake 40b99d5c43 Clean up 2025-11-08 16:36:33 +10:30
Cubicake e448e18472 Support lower versions 2025-11-08 16:36:24 +10:30
Cubicake d806ae3c0b Support lower versions 2025-10-21 19:49:51 +10:30
Cubicake 34fe60a7ae Merge remote-tracking branch 'origin/main'
# Conflicts:
#	src/main/java/games/cubi/raycastedEntityOcclusion/Snapshot/ChunkSnapshotManager.java
2025-10-21 19:42:12 +10:30
Cubicake 0ff67e11a7 Improve Regex to handle suffixes ie v1.6.3-beta 2025-10-21 19:38:34 +10:30
Cubicake 98eaf72cae Part of the snapshot changes 2025-10-21 19:37:55 +10:30
Cubicake e5c7f6ef90 Comment 2025-10-21 19:37:27 +10:30
Cubicake da73bb26ec Temporary BlockLocation changes (v1.7.x already has a better system) 2025-10-21 19:37:04 +10:30
Cubicake bd57a9b72c Version bump 2025-10-21 19:36:26 +10:30
Cubicake 116f5e8e03 IntelliJ is having a fit 2025-10-18 16:04:25 +10:30
Cubicake bcfdd731e2 IntelliJ is having a fit 2025-10-18 15:59:17 +10:30
Cubicake e83ec5e6a2 Investigating a bug where tile entities being removed is not properly handled 2025-10-18 15:55:49 +10:30
Cubicake 2b48e7e8d2 Investigating a bug where tile entities being removed is not properly handled 2025-10-18 15:50:37 +10:30
Cubicake 7f1a284eae Remove unused import 2025-10-17 09:56:48 +10:30
Cubicake 87aba0e2b5 Fix minor bug with better version checking 2025-10-16 12:38:43 +10:30
Cubicake d46d63668b Implement better version checking 2025-10-16 12:08:49 +10:30
Cubicake 83a278b00a Add run-paper plugin, bump version number 2025-10-16 12:08:12 +10:30
Cubicake c1e0db5613 Merge remote-tracking branch 'origin/main' 2025-10-16 11:08:23 +10:30
Cubicake 34db141f08 Re-enable logging, clean up Logger.java 2025-10-16 11:08:07 +10:30
Cubicake a68bcfdbf5 Update README with dependencies and known issues 2025-10-02 21:43:39 -04:00
Cubicake 77825067de Create FUNDING.yml 2025-09-18 21:22:52 +09:30
Cubicake 085fa59e42 Disable logging temp 2025-09-05 10:00:32 +09:30
Cubicake 2db88a4498 lazy load debug particles 2025-09-03 09:00:29 +09:30
Cubicake e9935f0350 Update latest version to v1.6.1 2025-08-26 08:42:50 +09:30
Cubicake 8d39fa5427 Bump version 2025-08-13 10:55:53 +09:30
Cubicake b958d0dc46 Make intellij shut up 2025-08-12 12:05:36 +09:30
Cubicake e9adb65690 Instead of throwing an error, try and fx the situation. 2025-08-12 12:03:16 +09:30
Cubicake 6a289c81a9 Check world so that distance check doesn't error 2025-08-12 10:40:05 +09:30
Cubicake 34b04ff059 Include update link in update checker 2025-08-11 21:17:52 +09:30
Cubicake 1a73c2509a Fix the previous commit 2025-08-11 20:49:45 +09:30
Cubicake e3731f76f0 Debug mode logging 2025-08-11 20:49:14 +09:30
Cubicake bd1f6ad482 Don't spawn a new thread for each tile entity update 2025-08-11 20:36:26 +09:30
Cubicake 951e4f4ad9 Fix change delta being ignored 2025-08-11 20:28:22 +09:30
Cubicake 114746aeaf Resolves #11 2025-08-11 20:08:06 +09:30
Cubicake 9dc9652917 Use snapshotChunk 2025-08-11 18:03:29 +09:30
Cubicake b97f675159 Bump version 2025-08-11 18:03:08 +09:30
Cubicake f5e16fc75d Resolves #10
OMFG I hate myself
2025-08-11 18:02:48 +09:30
Cubicake c228cef24a Merge remote-tracking branch 'origin/main' 2025-08-09 16:19:36 +09:30
Cubicake 098aab5e31 Don't hardcode plugin name 2025-08-09 16:19:20 +09:30
Cubicake 31b500bc7b Fix bug in issue #9 2025-08-04 11:35:13 +09:30
Cubicake d5e3281cf2 new config layout, to replace config.yml at a later date 2025-08-04 11:33:47 +09:30
Cubicake 98dbefd576 For future packet handling 2025-08-04 11:33:17 +09:30
Cubicake 4dce9b3278 WIP improved debugging 2025-08-04 11:32:45 +09:30
Cubicake d5bf02b4ea Merge remote-tracking branch 'origin/main' 2025-07-27 18:52:36 +09:30
Cubicake ed98e2abeb Update README.md 2025-07-27 17:39:13 +09:30
Cubicake 9a07bd0119 v1.6.0 release 2025-07-27 17:21:42 +09:30
Cubicake 74aca26910 Update .gitignore 2025-07-27 16:32:49 +09:30
Cubicake 25f5652a12 Kinda crappy way to hopefully fix the missing snapshots while I work on a more permanant fix 2025-07-27 16:08:40 +09:30
Cubicake 7679f08d06 Use the new logger to format messages 2025-07-27 16:07:26 +09:30
Cubicake 7ad99917d1 Might use this later? 2025-07-27 16:06:44 +09:30
Cubicake ce56eb316e Might use this later? 2025-07-27 16:06:39 +09:30
Cubicake 74426d80af Mark as mojmapped 2025-07-27 16:06:13 +09:30
Cubicake fdb1f567ac Snapshot changes 2025-07-26 16:26:14 +09:30
Cubicake e823f7a2f7 Move string operations to their own methods 2025-07-26 16:25:15 +09:30
Cubicake 7c1f7fd2a6 Version bump 2025-07-25 20:35:25 +09:30
Cubicake c26e6a1623 Oops forgot to pass config to movement tracker 2025-07-25 20:35:16 +09:30
Cubicake 8155903342 More readable imports 2025-07-25 20:32:53 +09:30
Cubicake f2ade6b0b8 Merge remote-tracking branch 'origin/main' 2025-07-25 20:31:26 +09:30
Cubicake f486d1fc2e Stop intellij from complaining 2025-07-25 20:30:09 +09:30
Cubicake 50eeab8cfe Bump api version 2025-07-25 20:26:37 +09:30
Cubicake 4009fe6d02 Use built in bukkit chunk keys instead of making custom ones 2025-07-25 20:26:25 +09:30
Cubicake b7e6fa9c5f Stop using * imports, use plugin logger, use built in bukkit chunk keys instead of making custom ones, hopefully fix chunks not being snapshotted. 2025-07-25 20:25:44 +09:30
Cubicake dcc986c232 Stop using * imports 2025-07-23 13:47:52 +09:30
Cubicake 95cea9f875 Stop using * imports 2025-07-23 13:47:20 +09:30
Cubicake 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
24 changed files with 1231 additions and 441 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']
+3 -1
View File
@@ -1,11 +1,13 @@
# User-specific stuff
.idea/
README.md
*.md
*.iml
*.ipr
*.iws
README.md
# IntelliJ
out/
-41
View File
@@ -1,41 +0,0 @@
Latest version: v1.4.1
The latest version can currently only be found on Modrinth https://modrinth.com/plugin/raycasted-entity-occlusion/
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
EVERYTHING BELOW IS OUT OF DATE, READ THE CHANGELOG FOR v1.4.1 https://modrinth.com/plugin/raycasted-entity-occlusions/version/1.4.1
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.
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.
+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.4.2'
version = '1.6.4'
repositories {
mavenCentral()
@@ -15,10 +16,23 @@ 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.20.6-R0.1-SNAPSHOT")
compileOnly("com.github.retrooper:packetevents-spigot:2.8.0")
}
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.20.6")
}
}
def targetJavaVersion = 21
@@ -46,4 +60,10 @@ processResources {
filesMatching('plugin.yml') {
expand props
}
}
jar {
manifest {
attributes "paperweight-mappings-namespace": "mojang"
}
}
@@ -1,109 +0,0 @@
package games.cubi.raycastedEntityOcclusion;
import org.bukkit.Chunk;
import org.bukkit.ChunkSnapshot;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.World;
import org.bukkit.plugin.Plugin;
import org.bukkit.scheduler.BukkitRunnable;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
public class ChunkSnapshotManager {
public static class Data {
public final ChunkSnapshot snapshot;
public final Map<Location, Material> delta = new ConcurrentHashMap<>();
public long lastRefresh;
public Data(ChunkSnapshot snapshot, long time) {
this.snapshot = snapshot;
this.lastRefresh = time;
}
}
private final Map<String, Data> dataMap = new ConcurrentHashMap<>();
public ChunkSnapshotManager(RaycastedEntityOcclusion plugin, int refreshIntervalSecs) {
ConfigManager cfg = plugin.getConfigManager();
//get loaded chunks and add them to dataMap
for (World w : plugin.getServer().getWorlds()) {
for (Chunk c : w.getLoadedChunks()) {
dataMap.put(key(c), takeSnapshot(c, System.currentTimeMillis()));
}
}
new BukkitRunnable() {
@Override
public void run() {
long now = System.currentTimeMillis();
int chunksRefreshed = 0;
for (Map.Entry<String, Data> e : dataMap.entrySet()) {
if (now - e.getValue().lastRefresh >= refreshIntervalSecs * 1000L) {
if (cfg.debugMode) {
chunksRefreshed++;
}
String key = e.getKey();
String[] parts = key.split(":");
World w = plugin.getServer().getWorld(parts[0]);
if (w == null) {
plugin.getLogger().warning("ChunkSnapshotManager: World " + parts[0] + " not found. Please report this on our discord (discord.cubi.games)'");
continue;
}
Chunk c = w.getChunkAt(
Integer.parseInt(parts[1]),
Integer.parseInt(parts[2])
);
e.setValue(takeSnapshot(c, now));
}
}
if (cfg.debugMode) {
plugin.getLogger().info("ChunkSnapshotManager: Refreshed " + chunksRefreshed + " chunks.");
}
}
}.runTaskTimerAsynchronously(plugin, refreshIntervalSecs * 5L, refreshIntervalSecs * 5L /* This runs 4 times per refreshInterval, spreading out the refreshes */);
}
public void onChunkLoad(Chunk c) {
dataMap.put(key(c), takeSnapshot(c, System.currentTimeMillis()));
}
public void onChunkUnload(Chunk c) {
dataMap.remove(key(c));
}
// Used by SnapshotListener to update the delta map when a block is placed or broken
public void onBlockChange(Location loc, Material m) {
Data d = dataMap.get(key(loc.getChunk()));
if (d != null) {
d.delta.put(loc, m);
}
}
private Data takeSnapshot(Chunk c, long now) {
return new Data(c.getChunkSnapshot(), now);
}
private String key(Chunk c) {
return c.getWorld().getName() + ":" + c.getX() + ":" + c.getZ();
}
public Material getMaterialAt(Location loc) {
Data d = dataMap.get(key(loc.getChunk()));
if (d == null) {
Chunk c = loc.getChunk();
dataMap.put(key(c), takeSnapshot(c, System.currentTimeMillis()));
System.err.println("ChunkSnapshotManager: No snapshot for " + loc.getChunk()+ " Please report this on our discord (discord.cubi.games)'");
return loc.getBlock().getType();
}
Material dm = d.delta.get(loc);
if (dm != null) {
return dm;
}
int x = loc.getBlockX() & 0xF;
int y = loc.getBlockY();
int z = loc.getBlockZ() & 0xF;
return d.snapshot.getBlockType(x, y, z);
}
}
@@ -3,6 +3,7 @@ package games.cubi.raycastedEntityOcclusion;
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;
@@ -19,9 +20,9 @@ public class CommandsManager {
this.cfg = cfg;
}
public LiteralCommandNode<CommandSourceStack> registerCommand() {
public LiteralCommandNode<CommandSourceStack> registerCommand(String commandName) {
//run help command if no context provided
LiteralCommandNode<CommandSourceStack> buildCommand = Commands.literal("raycastedentityocclusions")
LiteralCommandNode<CommandSourceStack> buildCommand = Commands.literal(commandName)
.requires(sender -> sender.getSender().hasPermission("raycastedentityocclusions.command"))
.executes(context -> {
helpCommand(context);
@@ -78,12 +79,19 @@ public class CommandsManager {
)
)
)
/*.then(Commands.literal("test")
.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;
}
@@ -98,10 +106,6 @@ public class CommandsManager {
return Command.SINGLE_SUCCESS;
}
private void testCommand(CommandContext<CommandSourceStack> context) {
CommandSender sender = context.getSource().getSender();
sender.sendRichMessage("This is a test command for use in development. It does nothing on publicly released versions (unless I have forgotten to remove the tests).");
//sender.sendMessage(new UpdateChecker(plugin).hasNewUpdate());
private void testCommand(CommandContext<CommandSourceStack> context) throws CommandSyntaxException {
}
}
@@ -15,7 +15,23 @@ public class ConfigManager {
public boolean cullPlayers;
public boolean onlyCullSneakingPlayers;
public int recheckInterval;
public boolean checkTileEntities;
public int tileEntityRecheckInterval;
public FileConfiguration cfg;
public boolean packetEventsPresent = false;
public static final int SNAPSHOT_REFRESH_INTERVAL_DEFAULT = 60;
public static final int ENGINE_MODE_DEFAULT = 1;
public static final int MAX_OCCLUDING_COUNT_DEFAULT = 3;
public static final boolean DEBUG_MODE_DEFAULT = false;
public static final int ALWAYS_SHOW_RADIUS_DEFAULT = 16;
public static final int RAYCAST_RADIUS_DEFAULT = 48;
public static final int SEARCH_RADIUS_DEFAULT = 48;
public static final boolean CULL_PLAYERS_DEFAULT = false;
public static final boolean ONLY_CULL_SNEAKING_PLAYERS_DEFAULT = false;
public static final int RECHECK_INTERVAL_DEFAULT = 50;
public static final boolean CHECK_TILE_ENTITIES_DEFAULT = true;
public static final int TILE_ENTITY_RECHECK_INTERVAL_DEFAULT = 0;
public ConfigManager(JavaPlugin plugin) {
this.plugin = plugin;
@@ -27,29 +43,34 @@ public class ConfigManager {
plugin.reloadConfig();
cfg = plugin.getConfig();
snapshotRefreshInterval = cfg.getInt("snapshot-refresh-interval", 60);
engineMode = cfg.getInt("engine-mode", 1);
maxOccludingCount = cfg.getInt("max-occluding-count", 3);
debugMode = cfg.getBoolean("debug-mode", false);
snapshotRefreshInterval = cfg.getInt("snapshot-refresh-interval", SNAPSHOT_REFRESH_INTERVAL_DEFAULT);
engineMode = cfg.getInt("engine-mode", ENGINE_MODE_DEFAULT);
maxOccludingCount = cfg.getInt("max-occluding-count", MAX_OCCLUDING_COUNT_DEFAULT);
debugMode = cfg.getBoolean("debug-mode", DEBUG_MODE_DEFAULT);
alwaysShowRadius = cfg.getInt("always-show-radius", 8);
raycastRadius = cfg.getInt("raycast-radius", 48);
searchRadius = cfg.getInt("search-radius", 48);
cullPlayers = cfg.getBoolean("cull-players", false);
onlyCullSneakingPlayers = cfg.getBoolean("only-cull-sneaking-players", false);
recheckInterval = cfg.getInt("recheck-interval", 20);
alwaysShowRadius = cfg.getInt("always-show-radius", ALWAYS_SHOW_RADIUS_DEFAULT);
raycastRadius = cfg.getInt("raycast-radius", RAYCAST_RADIUS_DEFAULT);
searchRadius = cfg.getInt("search-radius", SEARCH_RADIUS_DEFAULT);
cullPlayers = cfg.getBoolean("cull-players", CULL_PLAYERS_DEFAULT);
onlyCullSneakingPlayers = cfg.getBoolean("only-cull-sneaking-players", ONLY_CULL_SNEAKING_PLAYERS_DEFAULT);
recheckInterval = cfg.getInt("recheck-interval", RECHECK_INTERVAL_DEFAULT);
checkTileEntities = cfg.getBoolean("check-tile-entities", CHECK_TILE_ENTITIES_DEFAULT);
tileEntityRecheckInterval = cfg.getInt("tile-entity-recheck-interval", TILE_ENTITY_RECHECK_INTERVAL_DEFAULT);
// Write defaults if missing
cfg.addDefault("snapshot-refresh-interval", 60);
cfg.addDefault("engine-mode", 1);
cfg.addDefault("max-occluding-count", 3);
cfg.addDefault("debug-mode", false);
cfg.addDefault("always-show-radius", 8);
cfg.addDefault("raycast-radius", 48);
cfg.addDefault("search-radius", 48);
cfg.addDefault("cull-players", false);
cfg.addDefault("only-cull-sneaking-players", false);
cfg.addDefault("recheck-interval", 20);
cfg.addDefault("snapshot-refresh-interval", SNAPSHOT_REFRESH_INTERVAL_DEFAULT);
cfg.addDefault("engine-mode", ENGINE_MODE_DEFAULT);
cfg.addDefault("max-occluding-count", MAX_OCCLUDING_COUNT_DEFAULT);
cfg.addDefault("debug-mode", DEBUG_MODE_DEFAULT);
cfg.addDefault("always-show-radius", ALWAYS_SHOW_RADIUS_DEFAULT);
cfg.addDefault("raycast-radius", RAYCAST_RADIUS_DEFAULT);
cfg.addDefault("search-radius", SEARCH_RADIUS_DEFAULT);
cfg.addDefault("cull-players", CULL_PLAYERS_DEFAULT);
cfg.addDefault("only-cull-sneaking-players", ONLY_CULL_SNEAKING_PLAYERS_DEFAULT);
cfg.addDefault("recheck-interval", RECHECK_INTERVAL_DEFAULT);
cfg.addDefault("check-tile-entities", CHECK_TILE_ENTITIES_DEFAULT);
cfg.addDefault("tile-entity-recheck-interval", TILE_ENTITY_RECHECK_INTERVAL_DEFAULT);
cfg.options().copyDefaults(true);
plugin.saveConfig();
}
@@ -84,4 +105,7 @@ public class ConfigManager {
1 = success
*/
}
public void setPacketEventsPresent(boolean present) {
this.packetEventsPresent = present;
}
}
@@ -1,105 +0,0 @@
package games.cubi.raycastedEntityOcclusion;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.Particle;
import org.bukkit.entity.Entity;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
public class Engine {
private static class RayJob {
final UUID playerId, entityId;
final Location start, predictedStart, end;
RayJob(UUID p, UUID e, Location s, Location pred, Location t) {
playerId = p;
entityId = e;
start = s;
predictedStart = pred;
end = t;
}
}
private static class RayResult {
final UUID playerId, entityId;
final boolean visible;
RayResult(UUID p, UUID e, boolean v) {
playerId = p;
entityId = e;
visible = v;
}
}
public static void runEngine(ConfigManager cfg, ChunkSnapshotManager snapMgr, MovementTracker tracker, RaycastedEntityOcclusion plugin) {
// ----- PHASE 1: SYNC GATHER -----
List<RayJob> jobs = new ArrayList<>();
for (Player p : Bukkit.getOnlinePlayers()) {
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) {
// player can see entity, no need to raycast
}
else {
// schedule for async raycast (with or without predEye)
jobs.add(new RayJob(p.getUniqueId(), e.getUniqueId(), eye, predEye, target));
}
}
}
// ----- PHASE 2: ASYNC RAYCASTS -----
Bukkit.getScheduler().runTaskAsynchronously(plugin, () -> {
List<RayResult> results = new ArrayList<>(jobs.size());
for (RayJob job : jobs) {
// 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(org.bukkit.Color.BLUE,1f));
}
vis = RaycastUtil.raycast(job.predictedStart, job.end, cfg.maxOccludingCount, cfg.debugMode, snapMgr);
}
results.add(new RayResult(job.playerId, job.entityId, vis));
}
// ----- PHASE 3: SYNC APPLY -----
Bukkit.getScheduler().runTask(plugin, () -> {
for (RayResult r : results) {
Player p = Bukkit.getPlayer(r.playerId);
Entity ent = Bukkit.getEntity(r.entityId);
if (p != null && ent != null) {
if (r.visible) p.showEntity(plugin, ent);
else p.hideEntity(plugin, ent);
}
}
});
});
}
}
@@ -0,0 +1,86 @@
package games.cubi.raycastedEntityOcclusion;
import games.cubi.raycastedEntityOcclusion.Packets.PacketProcessor;
import games.cubi.raycastedEntityOcclusion.Snapshot.ChunkSnapshotManager;
import org.bukkit.Bukkit;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.block.BlockBreakEvent;
import org.bukkit.event.block.BlockBurnEvent;
import org.bukkit.event.block.BlockPlaceEvent;
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.raycastedEntityOcclusion.UpdateChecker.checkForUpdates;
public class EventListener implements Listener {
private final ChunkSnapshotManager manager;
private final ConfigManager config;
private PacketProcessor packetProcessor;
private final RaycastedEntityOcclusion plugin;
public EventListener(RaycastedEntityOcclusion plugin, ChunkSnapshotManager mgr, ConfigManager cfg) {
this.manager = mgr;
this.config = cfg;
this.plugin = plugin;
//load packet processor after 2 ticks in a bukkit runnable to ensure the plugin is fully loaded
Bukkit.getScheduler().runTaskLater(plugin, () -> {
if (config.packetEventsPresent) {
packetProcessor = plugin.getPacketProcessor();
} else {
packetProcessor = null;
}
}, 2L);
}
// Snapshot events
@EventHandler
public void onChunkLoad(ChunkLoadEvent e) {
manager.onChunkLoad(e.getChunk());
}
@EventHandler
public void onChunkUnload(ChunkUnloadEvent e) {
manager.onChunkUnload(e.getChunk());
}
public static final int BREAK = 1; public static final int PLACE = 2;
@EventHandler
public void onPlace(BlockPlaceEvent e) {
manager.onBlockChange(e.getBlock().getLocation(), e.getBlock().getType(), PLACE);
}
@EventHandler
public void onBreak(BlockBreakEvent e) {
manager.onBlockChange(e.getBlock().getLocation(), Material.AIR, BREAK);
}
@EventHandler
public void onBurn(BlockBurnEvent e) {
manager.onBlockChange(e.getBlock().getLocation(), Material.AIR, BREAK);
}
// 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
public void onPlayerDisconnect(PlayerQuitEvent e) {
if (config.packetEventsPresent && packetProcessor != null) {
UUID player = e.getPlayer().getUniqueId();
packetProcessor.sendPlayerInfoRemovePacket(player);
}
}
@EventHandler
public void onPlayerJoin(org.bukkit.event.player.PlayerJoinEvent event) {
if (event.getPlayer().hasPermission("raycastedentityocclusions.updatecheck")) {
Player sender = event.getPlayer();
checkForUpdates(plugin, sender);
}
}
}
@@ -0,0 +1,58 @@
package games.cubi.raycastedEntityOcclusion;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.minimessage.MiniMessage;
import org.bukkit.plugin.java.JavaPlugin;
import org.jetbrains.annotations.Range;
public class Logger {
private final static String PREFIX = "<hover:show_text:'Raycasted Entity Occlusions'><click:suggest_command:'/reo'><grey>[<gold>REO<grey>]</click></hover><reset> ";
private final static String PREFIX_WARNING = "<hover:show_text:'Raycasted Entity Occlusions'><click:suggest_command:'/reo'><grey>[<gold>REO<grey>]</click></hover> <yellow><hover:show_text:'<yellow>Something went wrong'>[Warning]</hover> ";
private final static String PREFIX_ERROR = "<hover:show_text:'Raycasted Entity Occlusions'><click:suggest_command:'/reo'><grey>[<gold>REO<grey>]</click></hover> <red><hover:show_text:'<red>Something went wrong'>[Error]</hover> ";
private static JavaPlugin plugin = null;
private enum Level {
INFO,
WARN,
ERROR
}
public static void info(String message) {
forwardLog(/*PREFIX+*/message, Level.INFO);
}
public static void warning(String message) {
forwardLog(/* PREFIX_WARNING + */ message, Level.WARN);
}
public static void error(String message) {
forwardLog(/* PREFIX_ERROR+ */ message, Level.ERROR);
}
public static void debug(String message, @Range(from = 1, to = 10) int level) {
int debugLevel = 2; // TODO: grab real debug level from config
if (debugLevel <= level) {
forwardLog(message, Level.INFO);
}
}
private static void forwardLog(String message, Level severity) {
if (plugin == null) {
plugin = JavaPlugin.getProvidingPlugin(Logger.class);
}
Component messageComponent = MiniMessage.miniMessage().deserialize(message);
switch (severity) {
case INFO:
plugin.getComponentLogger().info(messageComponent);
break;
case WARN:
plugin.getComponentLogger().warn(messageComponent);
break;
case ERROR:
plugin.getComponentLogger().error(messageComponent);
break;
default:
plugin.getComponentLogger().error("{} | Additionally, severity {} is not supported by the logger.", messageComponent, severity);
}
}
}
@@ -0,0 +1,41 @@
package games.cubi.raycastedEntityOcclusion.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.raycastedEntityOcclusion.RaycastedEntityOcclusion;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import java.util.List;
import java.util.UUID;
public class PacketProcessor {
private final RaycastedEntityOcclusion plugin;
private final UUID key;
public PacketProcessor(RaycastedEntityOcclusion plugin) {
this.plugin = plugin;
key = UUID.randomUUID();
}
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.raycastedEntityOcclusion.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.raycastedEntityOcclusion.RaycastedEntityOcclusion;
public class PacketsListener implements PacketListener {
private RaycastedEntityOcclusion plugin;
private PacketProcessor packetProcessor;
public PacketsListener(RaycastedEntityOcclusion 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 = plugin.getPacketProcessor();
}
}
}
@@ -0,0 +1,13 @@
package games.cubi.raycastedEntityOcclusion.Packets;
import com.github.retrooper.packetevents.PacketEvents;
import com.github.retrooper.packetevents.event.PacketListenerPriority;
import games.cubi.raycastedEntityOcclusion.RaycastedEntityOcclusion;
public class Registrar {
public Registrar(RaycastedEntityOcclusion plugin) {
// Register the packet listener
PacketEvents.getAPI().getEventManager().registerListener(new PacketsListener(plugin), PacketListenerPriority.NORMAL);
}
}
@@ -0,0 +1,269 @@
package games.cubi.raycastedEntityOcclusion.Raycast;
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 Engine {
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 final 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;
Location playerLoc = p.getLocation();
//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;
if (!loc.getWorld().equals(playerLoc.getWorld())) continue;
double distSquared = loc.distanceSquared(playerLoc);
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 {
//Logger.warning("Tried to show tile entity at " + location + " to "+p.getName()+" but it was not a TileState! Block type: " + block.getType()+". Removing from the list of tile entities.");
canSeeTileEntity.remove(location);
plugin.getChunkSnapshotManager().removeTileEntity(location);
}
});
}
public static void syncToggleTileEntity(Player p, Location loc, boolean show, RaycastedEntityOcclusion plugin) {
if (show) {
showTileEntity(p, loc, plugin);
} else {
hideTileEntity(p, loc, plugin);
}
}
}
@@ -1,9 +1,10 @@
package games.cubi.raycastedEntityOcclusion;
package games.cubi.raycastedEntityOcclusion.Raycast;
import games.cubi.raycastedEntityOcclusion.ConfigManager;
import games.cubi.raycastedEntityOcclusion.RaycastedEntityOcclusion;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.entity.Player;
import org.bukkit.plugin.Plugin;
import org.bukkit.scheduler.BukkitRunnable;
import java.util.ArrayDeque;
@@ -14,16 +15,18 @@ import java.util.concurrent.ConcurrentHashMap;
public class MovementTracker {
private final Map<Player, Deque<Location>> history = new ConcurrentHashMap<>();
public MovementTracker(Plugin plugin) {
public MovementTracker(RaycastedEntityOcclusion plugin, ConfigManager config) {
new BukkitRunnable() {
@Override
public void run() {
for (Player p : Bukkit.getOnlinePlayers()) {
history.computeIfAbsent(p, k -> new ArrayDeque<>(5));
Deque<Location> dq = history.get(p);
if (dq.size() >= 5) dq.removeFirst();
if (config.engineMode == 2) {
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().clone());
dq.addLast(p.getEyeLocation());
}
}
}
}.runTaskTimer(plugin, 1L, 1L);
@@ -37,6 +40,7 @@ public class MovementTracker {
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();
@@ -1,21 +1,27 @@
package games.cubi.raycastedEntityOcclusion;
package games.cubi.raycastedEntityOcclusion.Raycast;
import games.cubi.raycastedEntityOcclusion.Snapshot.ChunkSnapshotManager;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.Particle;
import org.bukkit.util.Vector;
public class RaycastUtil {
public static boolean raycast(Location start, Location end, int maxOccluding, boolean debug, ChunkSnapshotManager snap) {
Particle.DustOptions dustRed = null;
Particle.DustOptions dustGreen = null;
if (debug) {
static Particle.DustOptions dustRed = null;
static Particle.DustOptions dustGreen = null;
private static void initDebugParticles() {
if (dustRed == null) {
dustRed = new Particle.DustOptions(org.bukkit.Color.RED, 1f);
}
if (dustGreen == null) {
dustGreen = new Particle.DustOptions(org.bukkit.Color.GREEN, 1f);
}
}
public static boolean raycast(Location start, Location end, int maxOccluding, boolean debug, ChunkSnapshotManager snap) {
initDebugParticles();
if (!start.getWorld().equals(end.getWorld())) return false;
double total = start.distance(end);
double traveled = 0;
Location curr = start.clone();
@@ -24,7 +30,9 @@ public class RaycastUtil {
curr.add(dir);
traveled += 1;
Material mat = snap.getMaterialAt(curr);
//System.out.println(curr + " " + mat);
if (mat == null) {
continue;
}
if (mat.isOccluding()) {
maxOccluding--;
if (debug) {
@@ -2,67 +2,105 @@ package games.cubi.raycastedEntityOcclusion;
import com.mojang.brigadier.Command;
import com.mojang.brigadier.tree.LiteralCommandNode;
import games.cubi.raycastedEntityOcclusion.Packets.PacketProcessor;
import games.cubi.raycastedEntityOcclusion.Packets.Registrar;
import games.cubi.raycastedEntityOcclusion.Raycast.Engine;
import games.cubi.raycastedEntityOcclusion.Raycast.MovementTracker;
import games.cubi.raycastedEntityOcclusion.Snapshot.ChunkSnapshotManager;
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.Location;
import org.bukkit.Particle;
import org.bukkit.command.CommandExecutor;
import org.bukkit.entity.Entity;
import org.bukkit.entity.Player;
import org.bukkit.plugin.Plugin;
import org.bukkit.plugin.java.JavaPlugin;
import org.bukkit.scheduler.BukkitRunnable;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import games.cubi.raycastedEntityOcclusion.bStats.MetricsCollector;
public class RaycastedEntityOcclusion extends JavaPlugin implements CommandExecutor {
private ConfigManager cfg;
private ChunkSnapshotManager snapMgr;
private MovementTracker tracker;
private CommandsManager commands;
private boolean packetEventsPresent = false;
private PacketProcessor packetProcessor = null;
private static RaycastedEntityOcclusion instance;
public int tick = 0;
@Override
public void onLoad() {
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 = new ConfigManager(this);
snapMgr = new ChunkSnapshotManager(this, cfg.snapshotRefreshInterval);
tracker = new MovementTracker(this);
snapMgr = new ChunkSnapshotManager(this);
tracker = new MovementTracker(this, cfg);
commands = new CommandsManager(this, cfg);
getServer().getPluginManager().registerEvents(new SnapshotListener(snapMgr), this);
new UpdateChecker(this);
getServer().getPluginManager().registerEvents(new EventListener(this, snapMgr, cfg), this);
//Brigadier API
LiteralCommandNode<CommandSourceStack> buildCommand = commands.registerCommand();
this.getLifecycleManager().registerEventHandler(LifecycleEvents.COMMANDS, commands -> {
commands.registrar().register(buildCommand);
this.getLifecycleManager().registerEventHandler(LifecycleEvents.COMMANDS, commandRegistrar -> {
commandRegistrar.registrar().register(commands.registerCommand("raycastedentityocclusions"));
//alias "reo"
commands.registrar().register(Commands.literal("reo")
.requires(sender -> sender.getSender().hasPermission("raycastedentityocclusions.command"))
.executes(context -> {
new CommandsManager(this, cfg).helpCommand(context);
return Command.SINGLE_SUCCESS;
})
.redirect(buildCommand).build());
commandRegistrar.registrar().register(commands.registerCommand("reo"));
});
//bStats
int pluginId = 24553;
new Metrics(this, pluginId);
new MetricsCollector(this, cfg);
// TODO: Move this somewhere else, the main class should be cleaner
new BukkitRunnable() {
@Override
public void run() {
tick++;
Engine.runEngine(cfg, snapMgr, tracker, RaycastedEntityOcclusion.this);
Engine.runTileEngine(cfg, snapMgr, tracker, RaycastedEntityOcclusion.this);
}
}.runTaskTimer(this, 0L, 1L);
new BukkitRunnable() {
@Override
public void run() {
if (packetEventsPresent && Bukkit.getPluginManager().isPluginEnabled("packetevents")) {
cfg.setPacketEventsPresent(true);
packetProcessor = new PacketProcessor(RaycastedEntityOcclusion.this);
Logger.info("PacketEvents is enabled, enabling packet-based tablist modification.");
}
}
}.runTaskLater(this, 1L);
}
public ConfigManager getConfigManager() {
return cfg;
}
public ChunkSnapshotManager getChunkSnapshotManager() {
return snapMgr;
}
public MovementTracker getMovementTracker() {
return tracker;
}
public CommandsManager getCommandsManager() {
return commands;
}
public PacketProcessor getPacketProcessor() {
return packetProcessor;
}
public static RaycastedEntityOcclusion getInstance() {
return instance;
}
}
@@ -0,0 +1,277 @@
package games.cubi.raycastedEntityOcclusion.Snapshot;
import games.cubi.raycastedEntityOcclusion.ConfigManager;
import games.cubi.raycastedEntityOcclusion.EventListener;
import games.cubi.raycastedEntityOcclusion.Logger;
import games.cubi.raycastedEntityOcclusion.Raycast.Engine;
import games.cubi.raycastedEntityOcclusion.RaycastedEntityOcclusion;
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.HashSet;
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;
public ChunkSnapshotManager(RaycastedEntityOcclusion plugin) {
cfg = plugin.getConfigManager();
//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.snapshotRefreshInterval * 1000L && chunksRefreshed < chunksToRefreshMaximum) {
chunksRefreshed++;
String key = e.getKey();
snapshotChunk(key);
}
}
if (cfg.debugMode) {
Logger.info("ChunkSnapshotManager: Refreshed " + chunksRefreshed + " chunks out of " + chunksToRefreshMaximum + " maximum.");
}
}
}.runTaskTimerAsynchronously(plugin, cfg.snapshotRefreshInterval * 2L, cfg.snapshotRefreshInterval * 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) {
//if (cfg.debugMode) {
//Logger.info("ChunkSnapshotManager: Taking snapshot of chunk " + c.getWorld().getName() + ":" + c.getX() + ":" + c.getZ());
//}
Bukkit.getScheduler().runTaskAsynchronously(RaycastedEntityOcclusion.getInstance(), () -> {
dataMap.put(key(c), takeSnapshot(c, System.currentTimeMillis()));
});
}
public void snapshotChunk(String key) {
snapshotChunk(getKeyChunk(key));
}
public void removeChunkSnapshot(Chunk c) {
if (cfg.debugMode) {
Logger.info("ChunkSnapshotManager: Removing snapshot of chunk " + c.getWorld().getName() + ":" + c.getX() + ":" + c.getZ());
}
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, int change) {
if (cfg.debugMode) {
Logger.info("ChunkSnapshotManager: Block change at " + loc + " to " + m);
}
ChunkData d = dataMap.get(key(loc.getChunk()));
if (d != null) {
d.delta.put(BlockLocation.fromLocation(loc), m);
if (cfg.checkTileEntities) {
// Check if the block is a tile entity
BlockState data = loc.getBlock().getState();
if (data instanceof TileState) {
if (cfg.debugMode) {
Logger.info("ChunkSnapshotManager: Tile entity at " + loc);
}
if (change == EventListener.PLACE) {
d.tileEntities.add(BlockLocation.fromLocation(loc));
}
if (change == EventListener.BREAK) {
d.tileEntities.remove(BlockLocation.fromLocation(loc));
}
}
}
}
else {Logger.error("Data map value empty, ignoring block update!");}
}
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.checkTileEntities) {
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(BlockLocation.fromValues(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)");
Engine.syncRecheck.add(chunk);
return loc.getBlock().getType();
}
double yLevel = loc.getY();
if (yLevel < d.minHeight || yLevel > d.maxHeight) {
return null;
}
Material dm = d.delta.get(BlockLocation.fromLocation(loc));
if (dm != null) {
if (cfg.debugMode) Logger.info("Using delta");
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.toLocations(d.tileEntities);
}
public void removeTileEntity(Location loc) {
Chunk c = loc.getChunk();
ChunkData d = dataMap.get(key(c));
if (d != null) {
d.tileEntities.remove(BlockLocation.fromLocation(loc));
if (cfg.debugMode) {
Logger.info("ChunkSnapshotManager: Removed tile entity at " + loc);
}
} else {
Logger.error("ChunkSnapshotManager: No snapshot for " + c + " when removing tile entity at " + loc);
}
}
public int getNumberOfCachedChunks() {
return dataMap.size();
//created to use in a debug command maybe
}
private static class BlockLocation {
private final Location location;
private final int hashCode;
private BlockLocation(Location location) {
this.location = location.toCenterLocation();
this.location.setPitch(0);
this.location.setYaw(0);
hashCode = calculateHashCode();
}
static BlockLocation fromLocation(Location loc) {
return new BlockLocation(loc);
}
static BlockLocation fromValues(World world, double x, double y, double z) {
return new BlockLocation(new Location(world, x, y, z));
}
static Location toLocation(BlockLocation blockLocation) {
return blockLocation.location.clone();
}
static Set<Location> toLocations(Set<BlockLocation> blockLocations) {
Set<Location> locations = new HashSet<>();
for (BlockLocation bl : blockLocations) {
locations.add(toLocation(bl));
}
return locations;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof BlockLocation)) return false;
Location other = ((BlockLocation) o).location;
return (this.location.getX() == other.getX()) && (this.location.getY() == other.getY()) && (this.location.getZ() == other.getZ()) && (this.location.getWorld().equals(other.getWorld()));
}
private int calculateHashCode() {
int result = 17;
result = 31 * result + location.getBlockX();
result = 31 * result + location.getBlockY();
result = 31 * result + location.getBlockZ();
return 31 * result + location.getWorld().getUID().hashCode();
}
@Override
public int hashCode() {
return hashCode;
}
}
}
@@ -1,44 +0,0 @@
package games.cubi.raycastedEntityOcclusion;
import org.bukkit.Material;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.block.BlockBreakEvent;
import org.bukkit.event.block.BlockBurnEvent;
import org.bukkit.event.block.BlockPlaceEvent;
import org.bukkit.event.world.ChunkLoadEvent;
import org.bukkit.event.world.ChunkUnloadEvent;
public class SnapshotListener implements Listener {
private final ChunkSnapshotManager manager;
public SnapshotListener(ChunkSnapshotManager mgr) {
this.manager = mgr;
}
@EventHandler
public void onChunkLoad(ChunkLoadEvent e) {
manager.onChunkLoad(e.getChunk());
}
@EventHandler
public void onChunkUnload(ChunkUnloadEvent e) {
manager.onChunkUnload(e.getChunk());
}
@EventHandler
public void onPlace(BlockPlaceEvent e) {
manager.onBlockChange(e.getBlock().getLocation(), e.getBlock().getType());
}
@EventHandler
public void onBreak(BlockBreakEvent e) {
manager.onBlockChange(e.getBlock().getLocation(), Material.AIR);
}
@EventHandler
public void onBurn(BlockBurnEvent e) {
manager.onBlockChange(e.getBlock().getLocation(), Material.AIR);
}
// 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 solutioon please let me know.
}
@@ -1,88 +1,110 @@
package games.cubi.raycastedEntityOcclusion;
import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import org.bukkit.Bukkit;
import org.bukkit.event.EventHandler;
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.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.net.URLConnection;
import java.util.concurrent.CompletableFuture;
public class UpdateChecker {
/*private final RaycastedEntityOcclusion plugin;
private final RaycastedEntityOcclusion plugin;
public UpdateChecker(RaycastedEntityOcclusion plugin) {
this.plugin = plugin;
checkForUpdates();
checkForUpdates(plugin, Bukkit.getConsoleSender());
}
public void checkForUpdates() {
public static CompletableFuture<String> fetchFeaturedVersion(RaycastedEntityOcclusion plugin) {
CompletableFuture<String> future = new CompletableFuture<>();
Bukkit.getScheduler().runTaskAsynchronously(plugin, () -> {
if (hasNewUpdate() != null) {
plugin.getLogger().info("A new version of RaycastedEntityOcclusions is available! ");
plugin.getLogger().info("Please update to the latest version for the best experience.");
} else {
plugin.getLogger().info("You are using the latest version of RaycastedEntityOcclusions.");
final String url = "https://api.modrinth.com/v2/project/bCjNZu0C/version";
try (final InputStreamReader reader = new InputStreamReader(new URL(url).openConnection().getInputStream())) {
final JsonArray array = new JsonArray();
array.add(new BufferedReader(reader).readLine());
StringBuilder sb = new StringBuilder();
for (int i = 0; i < array.size(); i++) {
sb.append(array.get(i).getAsString());
}
String apiData = sb.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 e) {
future.completeExceptionally(new IllegalStateException("Unable to fetch latest version", e));
}
});
return future;
}
public String hasNewUpdate() {
try {
String versionUrl = "https://example.com/version.txt";
URL url = new URI(versionUrl).toURL();
URLConnection conn = url.openConnection();
conn.setConnectTimeout(500); // 5s connect timeout
conn.setReadTimeout(500); // 5s read timeout
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;
try (BufferedReader reader = new BufferedReader(
new InputStreamReader(conn.getInputStream()))) {
String version = reader.readLine();
if (version == null) {
plugin.getLogger().warning("Could not check for updates: version is null");
return null;
}
String currentVersion = plugin.getDescription().getVersion();
if (!currentVersion.equals(version)) {
return version;
}
return null;
private static int checkIfLaterThan(String currentVersion, String fetchedVersion) {
String[] currentParts = currentVersion.replace("v", "").split("[.-]");
String[] fetchedParts = fetchedVersion.replace("v", "").split("[.-]");
}
catch (Exception e) {
plugin.getLogger().warning("Could not check for updates: " + e.getMessage());
return null;
}
} catch (IOException e) {
plugin.getLogger().warning("Could not check for updates: " + e.getMessage());
return null;
} catch (URISyntaxException e) {
throw new RuntimeException(e);
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;
}
//on join
@EventHandler
public void onPlayerJoin(org.bukkit.event.player.PlayerJoinEvent event) {
if (event.getPlayer().hasPermission("raycastedentityocclusions.updatecheck")) {
Bukkit.getScheduler().runTaskAsynchronously(plugin, () -> {
String newVersion = hasNewUpdate();
if (newVersion != null) {
event.getPlayer().sendRichMessage("<#FF00FF>A new version of <green>RaycastedEntityOcclusions<#FF00FF> is available! \n" +
"\n" +
"<white>Please update to the latest version for the best experience.\n" +
"\n" +
"<blue><aqua><u><click:open_url:'https://modrinth.com/plugin/raycasted-entity-occlusions/versions'>Click here to download</click></u></aqua></blue>");
} else {
event.getPlayer().sendMessage("<green>You are using the latest version of RaycastedEntityOcclusions.");
public static void checkForUpdates(RaycastedEntityOcclusion 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 -> {
// Handle error (e.g., log the exception)
Bukkit.getScheduler().runTask(plugin, () -> {
Logger.warning("Failed to fetch version: " + ex.getMessage());
});
return null;
});
}
*/
}
@@ -1,4 +1,4 @@
package games.cubi.raycastedEntityOcclusion;
package games.cubi.raycastedEntityOcclusion.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.
@@ -0,0 +1,157 @@
package games.cubi.raycastedEntityOcclusion.bStats;
import games.cubi.raycastedEntityOcclusion.ConfigManager;
import games.cubi.raycastedEntityOcclusion.RaycastedEntityOcclusion;
import org.bukkit.Bukkit;
import org.bukkit.World;
import java.util.ArrayList;
import java.util.List;
public class MetricsCollector {
private final RaycastedEntityOcclusion plugin;
private final Metrics metrics;
private final ConfigManager config;
private List<Integer> playersOnline = new ArrayList<>();
private List<Integer> entities = new ArrayList<>();
public MetricsCollector(RaycastedEntityOcclusion plugin, ConfigManager config) {
this.plugin = plugin;
int pluginId = 24553;
metrics = new Metrics(plugin, pluginId);
this.config = config;
registerCustomMetrics();
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+";
}
}
}
+16 -8
View File
@@ -1,10 +1,18 @@
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
always-show-radius: 8 # radius to always show entities
raycast-radius: 82 # beyond this, entities auto-hide
search-radius: 82 # search radius for entities
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
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: 20 # ticks between forced rechecks for visible entities
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 -3
View File
@@ -1,11 +1,23 @@
name: RaycastedEntityOcclusions
version: ${version}
main: games.cubi.raycastedEntityOcclusion.RaycastedEntityOcclusion
api-version: '1.21'
prefix: EntityOcclusions
api-version: '1.20.6'
prefix: REO
authors: [ _Cubicake ]
load: STARTUP
website: https://cubi.games
permissions:
raycastedentityocclusions.command:
description: Permission to use the RaycastedEntityOcclusions command
default: op
default: op
raycastedentityocclusions.bypass:
description: Permission to bypass all checks
default: false
raycastedentityocclusions.updatecheck:
description: Permission to check for plugin updates
default: op
raycastedentityocclusions.receivelogmessages:
description: Permission to receive log messages which are sent to the console
default: false
softdepend:
- packetevents