Compare commits

...
69 Commits
Author SHA1 Message Date
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
23 changed files with 1050 additions and 421 deletions

No files matched your search

+3 -1
View File
@@ -1,11 +1,13 @@
# User-specific stuff
.idea/
README.md
*.md
*.iml
*.ipr
*.iws
README.md
# IntelliJ
out/
+15 -35
View File
@@ -1,41 +1,21 @@
Latest version: v1.4.1
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
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.
- 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.
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
- If cull-player is set to true any culled players will be removed from tablist. Potential solutions are being investigated, suggestions are welcome.
+12 -2
View File
@@ -3,7 +3,7 @@ plugins {
}
group = 'games.cubi'
version = '1.4.2'
version = '1.6.0'
repositories {
mavenCentral()
@@ -15,10 +15,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") //Latest is 2.9.4, but using 2.8.0 api still works and allows for compatibility with older versions
}
def targetJavaVersion = 21
@@ -46,4 +50,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;
@@ -10,6 +11,8 @@ import net.kyori.adventure.text.minimessage.MiniMessage;
import org.bukkit.command.CommandSender;
import org.bukkit.configuration.ConfigurationSection;
public class CommandsManager {
private final RaycastedEntityOcclusion plugin;
private final ConfigManager cfg;
@@ -78,12 +81,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 +108,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.Collections;
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());
}
@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 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,52 @@
package games.cubi.raycastedEntityOcclusion;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.minimessage.MiniMessage;
import org.bukkit.plugin.java.JavaPlugin;
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);
}
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);
}
//Bukkit.getConsoleSender().sendRichMessage(message);
//Bukkit.broadcast(MiniMessage.miniMessage().deserialize(message), "raycastedentityocclusions.receivelogmessages");
}
}
@@ -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,29 @@
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) {
if (packetProcessor == null) {
// Initialize the PacketProcessor if it hasn't been initialized yet since the initialization of the PacketsListener is on load, not on enable.
packetProcessor = plugin.getPacketProcessor();
}
packetProcessor.processPlayerInfoRemovePacket(event);
}
}
}
@@ -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,232 @@
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.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;
public class Engine {
public static ConcurrentHashMap<Location, Set<Player>> canSeeTileEntity = new ConcurrentHashMap<>();
public static Set<Chunk> syncRecheck = ConcurrentHashMap.newKeySet();
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;
}
}
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);
}
}
}
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);
}
}
}
});
});
}
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) {
hideTileEntity(p, loc);
continue;
}
if (distSquared < cfg.alwaysShowRadius * cfg.alwaysShowRadius) {
showTileEntity(p, loc);
continue;
}
boolean result = RaycastUtil.raycast(p.getEyeLocation(), loc, cfg.maxOccludingCount, cfg.debugMode, snapMgr);
if (cfg.engineMode == 2) {
Location predEye = tracker.getPredictedLocation(p);
if (predEye != null) {
boolean result2 = RaycastUtil.raycast(predEye, loc, cfg.maxOccludingCount, cfg.debugMode, snapMgr);
if (result2) {
result = true;
}
}
}
syncToggleTileEntity(p, loc, result, plugin);
if (result) {
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);
}
}
}
}
});
}
}
}
public static void hideTileEntity(Player p, Location location) {
if (p.hasPermission("raycastedentityocclusions.bypass")) return;
BlockData fake;
if (location.getBlockY() < 0) {
fake = Material.DEEPSLATE.createBlockData();
}
else {
fake = Material.STONE.createBlockData();
}
p.sendBlockChange(location, fake);
}
public static void showTileEntity(Player p, Location location) {
Block block = location.getBlock();
BlockData data = block.getBlockData();
p.sendBlockChange(location, data);
}
public static void syncToggleTileEntity(Player p, Location loc, boolean bool, RaycastedEntityOcclusion plugin) {
Bukkit.getScheduler().runTask(plugin, () -> {
if (bool) {
showTileEntity(p, loc);
} else {
hideTileEntity(p, loc);
}
});
}
}
@@ -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,13 +1,11 @@
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;
@@ -24,7 +22,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,38 +2,52 @@ 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;
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() {
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();
@@ -50,19 +64,45 @@ public class RaycastedEntityOcclusion extends JavaPlugin implements CommandExecu
});
//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;
}
}
@@ -0,0 +1,204 @@
package games.cubi.raycastedEntityOcclusion.Snapshot;
import games.cubi.raycastedEntityOcclusion.ConfigManager;
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.Set;
import java.util.Map;
import java.util.Collections;
import java.util.concurrent.ConcurrentHashMap;
public class ChunkSnapshotManager {
public static class Data {
public final ChunkSnapshot snapshot;
public final ConcurrentHashMap<Location, Material> delta = new ConcurrentHashMap<>();
public final Set<Location> tileEntities = ConcurrentHashMap.newKeySet();
public long lastRefresh;
public int minHeight;
public int maxHeight;
public Data(ChunkSnapshot snapshot, long time) {
this.snapshot = snapshot;
this.lastRefresh = time;
}
}
private static final ConcurrentHashMap<String, Data> dataMap = new ConcurrentHashMap<>();
private final ConfigManager cfg;
private final RaycastedEntityOcclusion plugin;
public ChunkSnapshotManager(RaycastedEntityOcclusion plugin) {
cfg = plugin.getConfigManager();
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, Data> e : dataMap.entrySet()) {
if (now - e.getValue().lastRefresh >= cfg.snapshotRefreshInterval * 1000L && chunksRefreshed < chunksToRefreshMaximum) {
chunksRefreshed++;
String key = e.getKey();
//String[] parts = key.split(":");
Chunk c = getKeyChunk(key);
e.setValue(takeSnapshot(c, now));
}
}
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());
}
dataMap.put(key(c), takeSnapshot(c, System.currentTimeMillis()));
}
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) {
if (cfg.debugMode) {
Logger.info("ChunkSnapshotManager: Block change at " + loc + " to " + m);
}
Data d = dataMap.get(key(loc.getChunk()));
if (d != null) {
d.delta.put(loc, m);
if (cfg.checkTileEntities) {
// 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) {
if (cfg.debugMode){
Logger.info("ChunkSnapshotManager: Tile entity at " + loc);
}
d.tileEntities.add(loc);
} else {
d.tileEntities.remove(loc);
}
}
}
}
private Data takeSnapshot(Chunk c, long now) {
World w = c.getWorld();
Data data = new Data(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(new Location(w, x+ chunkX +0.5, y+0.5, z + chunkZ+0.5));
}
}
}
}
}
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 + ":" + 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();
Data 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(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);
}
//get TileEntity Locations in chunk
public Set<Location> getTileEntitiesInChunk(World world, int x, int z) {
Data d = dataMap.get(key(world, x, z));
if (d == null) {
return Collections.emptySet();
}
return d.tileEntities;
}
public int getNumberOfCachedChunks() {
return dataMap.size();
//created to use in a debug command maybe
}
}
@@ -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,75 @@
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.command.CommandSender;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
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/raycasted-entity-occlusions/version?featured=true";
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
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;
}
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);
}
}
//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>");
public static void checkForUpdates(RaycastedEntityOcclusion plugin, CommandSender audience) {
fetchFeaturedVersion(plugin).thenAccept(version -> {
// This runs synchronously when the version is fetched
Bukkit.getScheduler().runTask(plugin, () -> {
if (plugin.getDescription().getVersion().equals(version)) {
audience.sendRichMessage("<green>You are using the latest version of Raycasted Entity Occlusions.");
} else {
event.getPlayer().sendMessage("<green>You are using the latest version of RaycastedEntityOcclusions.");
audience.sendRichMessage("<red>You are not using the latest version of Raycasted Entity Occlusions. Please update to <green>v" + version);
}
});
}
}).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.
+14 -2
View File
@@ -2,10 +2,22 @@ name: RaycastedEntityOcclusions
version: ${version}
main: games.cubi.raycastedEntityOcclusion.RaycastedEntityOcclusion
api-version: '1.21'
prefix: EntityOcclusions
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