mirror of
https://github.com/Cubicake/RaycastedAntiESP.git
synced 2026-11-17 06:26:04 -05:00
Compare commits
57
Commits
v1.4.1
...
EntitySnapshot
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
e1f70a296c | ||
|
|
3eccd69669 | ||
|
|
9f27f1c58f | ||
|
|
6e8d47b96e | ||
|
|
f04b79bb4a | ||
|
|
bf17a65246 | ||
|
|
3d4702e520 | ||
|
|
266302f09c | ||
|
|
ac130a739e | ||
|
|
dcc316e7e7 | ||
|
|
754214fa8d | ||
|
|
a6f47f137c | ||
|
|
97e43e65f8 | ||
|
|
ef81d97eef | ||
|
|
36d75c8933 | ||
|
|
b37f8465aa | ||
|
|
3d34992fcc | ||
|
|
4602dde7df | ||
|
|
a81d5caa45 | ||
|
|
7ef25e5dc3 | ||
|
|
529ab3f583 | ||
|
|
951883cb1b | ||
|
|
08113b57ba | ||
|
|
63e9c8bea1 | ||
|
|
1d14468924 | ||
|
|
5378fd5907 | ||
|
|
5e8d8bb43e | ||
|
|
da5c68b07c | ||
|
|
0f9af7c217 | ||
|
|
1fd227e8ba | ||
|
|
e4c653fe6a | ||
|
|
f2dc9f7d18 | ||
|
|
8998338563 | ||
|
|
361bbf84bc | ||
|
|
384393358c | ||
|
|
9c2d542f3c | ||
|
|
ab930c4c30 | ||
|
|
1f64514366 | ||
|
|
398592225e | ||
|
|
a95b79d428 | ||
|
|
67c9758a96 | ||
|
|
f555249cc9 | ||
|
|
5e4bc1f0fb | ||
|
|
53d49cf542 | ||
|
|
9b34fa51a0 | ||
|
|
573d8331dc | ||
|
|
333b211b00 | ||
|
|
81718b8848 | ||
|
|
6084a373c8 | ||
|
|
f22f6db331 | ||
|
|
4c7733420f | ||
|
|
88c004997d | ||
|
|
8eb18e8793 | ||
|
|
f56a4e147b | ||
|
|
651668b62e | ||
|
|
1e4f45d4ee | ||
|
|
0bab09e26b |
No files matched your search
@@ -1,41 +1,21 @@
|
||||
Latest version: v1.4.1
|
||||
Latest version: v1.5.1
|
||||
|
||||
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.
|
||||
+5
-1
@@ -3,7 +3,7 @@ plugins {
|
||||
}
|
||||
|
||||
group = 'games.cubi'
|
||||
version = '1.4.1'
|
||||
version = '1.6.0-dev-1'
|
||||
|
||||
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("com.github.retrooper:packetevents-spigot:2.8.0")
|
||||
}
|
||||
|
||||
def targetJavaVersion = 21
|
||||
|
||||
@@ -1,87 +0,0 @@
|
||||
package games.cubi.raycastedEntityOcclusion;
|
||||
|
||||
import org.bukkit.Chunk;
|
||||
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 Material[][][] snapshot;
|
||||
public final Map<Location, Material> delta = new ConcurrentHashMap<>();
|
||||
public long lastRefresh;
|
||||
public Data(Material[][][] snap, long time) {
|
||||
this.snapshot = snap;
|
||||
this.lastRefresh = time;
|
||||
}
|
||||
}
|
||||
|
||||
private final Map<String, Data> map = new ConcurrentHashMap<>();
|
||||
|
||||
public ChunkSnapshotManager(Plugin plugin, int refreshIntervalSecs) {
|
||||
new BukkitRunnable() {
|
||||
@Override
|
||||
public void run() {
|
||||
long now = System.currentTimeMillis();
|
||||
for (Map.Entry<String, Data> e : map.entrySet()) {
|
||||
if (now - e.getValue().lastRefresh >= refreshIntervalSecs*1000L) {
|
||||
String key = e.getKey();
|
||||
String[] parts = key.split(":");
|
||||
World w = plugin.getServer().getWorld(parts[0]);
|
||||
Chunk c = w.getChunkAt(Integer.parseInt(parts[1]), Integer.parseInt(parts[2]));
|
||||
e.setValue(takeSnapshot(c, now));
|
||||
}
|
||||
}
|
||||
}
|
||||
}.runTaskTimer(plugin, refreshIntervalSecs*20L, refreshIntervalSecs*20L);
|
||||
}
|
||||
|
||||
public void onChunkLoad(Chunk c) {
|
||||
map.put(key(c), takeSnapshot(c, System.currentTimeMillis()));
|
||||
}
|
||||
|
||||
public void onChunkUnload(Chunk c) {
|
||||
map.remove(key(c));
|
||||
}
|
||||
|
||||
public void onBlockChange(Location loc, Material m) {
|
||||
Data d = map.get(key(loc.getChunk()));
|
||||
if (d != null) d.delta.put(loc, m);
|
||||
}
|
||||
|
||||
private Data takeSnapshot(Chunk c, long now) {
|
||||
World w = c.getWorld();
|
||||
int height = w.getMaxHeight();
|
||||
Material[][][] arr = new Material[16][height][16];
|
||||
for (int x = 0; x < 16; x++) {
|
||||
for (int z = 0; z < 16; z++) {
|
||||
for (int y = 0; y < height; y++) {
|
||||
arr[x][y][z] = c.getBlock(x, y, z).getType();
|
||||
}
|
||||
}
|
||||
}
|
||||
return new Data(arr, now);
|
||||
}
|
||||
|
||||
|
||||
private String key(Chunk c) {
|
||||
return c.getWorld().getName()+":"+c.getX()+":"+c.getZ();
|
||||
}
|
||||
|
||||
public Material getMaterialAt(Location loc) {
|
||||
Data d = map.get(key(loc.getChunk()));
|
||||
if (d == null) 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[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;
|
||||
}
|
||||
}
|
||||
@@ -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,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,251 @@
|
||||
package games.cubi.raycastedEntityOcclusion.Raycast;
|
||||
|
||||
|
||||
import games.cubi.raycastedEntityOcclusion.Snapshot.ChunkSnapshotManager;
|
||||
import games.cubi.raycastedEntityOcclusion.ConfigManager;
|
||||
import games.cubi.raycastedEntityOcclusion.RaycastedEntityOcclusion;
|
||||
|
||||
import games.cubi.raycastedEntityOcclusion.Snapshot.EntitySnapshotManager;
|
||||
import io.papermc.paper.threadedregions.scheduler.AsyncScheduler;
|
||||
import io.papermc.paper.threadedregions.scheduler.ScheduledTask;
|
||||
import org.bukkit.*;
|
||||
import org.bukkit.block.Block;
|
||||
import org.bukkit.block.data.BlockData;
|
||||
import org.bukkit.entity.Entity;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.bukkit.scheduler.BukkitTask;
|
||||
|
||||
import java.util.*;
|
||||
import java.util.concurrent.CompletableFuture;
|
||||
import java.util.concurrent.ConcurrentHashMap;
|
||||
import java.util.function.Consumer;
|
||||
|
||||
public class Engine {
|
||||
|
||||
public static ConcurrentHashMap<Location, Set<Player>> canSeeTileEntity = new ConcurrentHashMap<>();
|
||||
|
||||
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 PlayerInfo {
|
||||
final Player player;
|
||||
final Location location;
|
||||
final Location predLoc;
|
||||
|
||||
PlayerInfo(Player p, Location loc, Location pred) {
|
||||
player = p;
|
||||
location = loc;
|
||||
predLoc = pred;
|
||||
}
|
||||
}
|
||||
|
||||
private static Consumer<ScheduledTask> raycastEntitiesAroundPlayer(Player player, Location eye, Location predEye){
|
||||
|
||||
return task -> { /* This is needed for it to return, idk why*/ };
|
||||
}
|
||||
|
||||
Map<UUID, RayResult> results = new ConcurrentHashMap<>();
|
||||
|
||||
public static void runEngine(ConfigManager cfg, ChunkSnapshotManager snapMgr, MovementTracker tracker, EntitySnapshotManager entitySnapshotManager, RaycastedEntityOcclusion plugin) {
|
||||
// ----- PHASE 1: SYNC GATHER -----
|
||||
List<PlayerInfo> info = new ArrayList<>();
|
||||
// TODO: Store players in EntitySnapshotManager and use that to avoid iterating through all players every tick
|
||||
AsyncScheduler asyncScheduler = plugin.getServer().getAsyncScheduler();
|
||||
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);
|
||||
}
|
||||
asyncScheduler.runNow(plugin, raycastEntitiesAroundPlayer(p, eye, predEye));
|
||||
}
|
||||
|
||||
// ----- PHASE 2: ASYNC RAYCASTS -----
|
||||
Bukkit.getScheduler().runTaskAsynchronously(plugin, () -> {
|
||||
List<RayResult> results = new ArrayList<>();
|
||||
|
||||
|
||||
|
||||
for (Entity e : entitySnapshotManager.getBukkitEntitiesNear(eye, cfg.searchRadius, cfg.searchRadius, cfg.searchRadius)) {
|
||||
if (e == p) continue;
|
||||
// Cull-players logic
|
||||
if (e instanceof Player pl && (!cfg.cullPlayers || (cfg.onlyCullSneakingPlayers && !pl.isSneaking()))) {
|
||||
//TODO: Add to result that player should be shown
|
||||
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, e, eye, predEye, target));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
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;
|
||||
String world = p.getWorld().getName();
|
||||
//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);
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
+13
-8
@@ -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);
|
||||
@@ -33,10 +36,12 @@ public class MovementTracker {
|
||||
* Predicts location 5 ticks ahead based on last 5 ticks. Returns null if insufficient or too slow.
|
||||
*/
|
||||
public Location getPredictedLocation(Player p) {
|
||||
//TODO: Make the predicted location incorporate ping
|
||||
Deque<Location> dq = history.get(p);
|
||||
if (dq == null || dq.size() < 5) return null;
|
||||
Location old = dq.peekFirst();
|
||||
Location now = dq.peekLast();
|
||||
if (old == null || now == null) return null;
|
||||
double dx = now.getX() - old.getX();
|
||||
double dy = now.getY() - old.getY();
|
||||
double dz = now.getZ() - old.getZ();
|
||||
+10
-5
@@ -1,12 +1,15 @@
|
||||
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.entity.Player;
|
||||
import org.bukkit.util.Vector;
|
||||
|
||||
public class RaycastUtil {
|
||||
private static final Particle.DustOptions DUST_RED = new Particle.DustOptions(org.bukkit.Color.RED, 1f);
|
||||
private static final Particle.DustOptions DUST_GREEN = new Particle.DustOptions(org.bukkit.Color.GREEN, 1f);;
|
||||
|
||||
public static boolean raycast(Location start, Location end, int maxOccluding, boolean debug, ChunkSnapshotManager snap) {
|
||||
double total = start.distance(end);
|
||||
double traveled = 0;
|
||||
@@ -16,16 +19,18 @@ 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) {
|
||||
start.getWorld().spawnParticle(Particle.DUST, curr, 1, new Particle.DustOptions(org.bukkit.Color.RED,1f));
|
||||
start.getWorld().spawnParticle(Particle.DUST, curr, 1, DUST_RED);
|
||||
}
|
||||
if (maxOccluding < 1) return false;
|
||||
}
|
||||
else if (debug) {
|
||||
start.getWorld().spawnParticle(Particle.DUST, curr, 1, new Particle.DustOptions(org.bukkit.Color.GREEN,1f));
|
||||
start.getWorld().spawnParticle(Particle.DUST, curr, 1, DUST_GREEN);
|
||||
}
|
||||
}
|
||||
return true;
|
||||
@@ -2,37 +2,56 @@ 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 games.cubi.raycastedEntityOcclusion.Snapshot.EntitySnapshotManager;
|
||||
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.command.CommandSender;
|
||||
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 EntitySnapshotManager entitySnapshotManager;
|
||||
private MovementTracker tracker;
|
||||
private CommandsManager commands;
|
||||
private boolean packetEventsPresent = false;
|
||||
private PacketProcessor packetProcessor = null;
|
||||
private UpdateChecker updateChecker;
|
||||
|
||||
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);
|
||||
|
||||
updateChecker = new UpdateChecker(this);
|
||||
entitySnapshotManager = new EntitySnapshotManager();
|
||||
getServer().getPluginManager().registerEvents(new EventListener(this, snapMgr, cfg), this);
|
||||
//Brigadier API
|
||||
LiteralCommandNode<CommandSourceStack> buildCommand = commands.registerCommand();
|
||||
|
||||
@@ -49,105 +68,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, entitySnapshotManager, RaycastedEntityOcclusion.this);
|
||||
Engine.runTileEngine(cfg, snapMgr, tracker, RaycastedEntityOcclusion.this);
|
||||
}
|
||||
}.runTaskTimer(this, 0L, 1L);
|
||||
|
||||
new BukkitRunnable() {
|
||||
@Override
|
||||
public void run() {
|
||||
runEngine();
|
||||
if (packetEventsPresent && Bukkit.getPluginManager().isPluginEnabled("packetevents")) {
|
||||
cfg.setPacketEventsPresent(true);
|
||||
packetProcessor = new PacketProcessor(RaycastedEntityOcclusion.this);
|
||||
getLogger().info("PacketEvents is enabled, enabling packet-based tablist modification.");
|
||||
}
|
||||
}
|
||||
}.runTaskTimer(this, 0L, 1L);
|
||||
}.runTaskLater(this, 1L);
|
||||
}
|
||||
|
||||
|
||||
// --- helper to hold one ray job ---
|
||||
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;
|
||||
}
|
||||
public ConfigManager getConfigManager() {
|
||||
return cfg;
|
||||
}
|
||||
|
||||
// --- helper to hold one ray result ---
|
||||
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 ChunkSnapshotManager getChunkSnapshotManager() {
|
||||
return snapMgr;
|
||||
}
|
||||
|
||||
private void runEngine() {
|
||||
// ----- 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(this, e);
|
||||
continue;
|
||||
}
|
||||
|
||||
Location target = e.getLocation().add(0, e.getHeight() / 2, 0).clone();
|
||||
double dist = eye.distance(target);
|
||||
if (dist <= cfg.alwaysShowRadius) {
|
||||
p.showEntity(this, e);
|
||||
} else if (dist > cfg.raycastRadius) {
|
||||
p.hideEntity(this, e);
|
||||
} 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(this, () -> {
|
||||
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(this, () -> {
|
||||
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(this, ent);
|
||||
else p.hideEntity(this, ent);
|
||||
}
|
||||
}
|
||||
});
|
||||
});
|
||||
public MovementTracker getMovementTracker() {
|
||||
return tracker;
|
||||
}
|
||||
public CommandsManager getCommandsManager() {
|
||||
return commands;
|
||||
}
|
||||
public PacketProcessor getPacketProcessor() {
|
||||
return packetProcessor;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,168 @@
|
||||
package games.cubi.raycastedEntityOcclusion.Snapshot;
|
||||
|
||||
import games.cubi.raycastedEntityOcclusion.ConfigManager;
|
||||
import games.cubi.raycastedEntityOcclusion.RaycastedEntityOcclusion;
|
||||
import org.bukkit.*;
|
||||
import org.bukkit.block.BlockState;
|
||||
import org.bukkit.block.TileState;
|
||||
import org.bukkit.scheduler.BukkitRunnable;
|
||||
|
||||
import java.util.*;
|
||||
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 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 final Map<String, Data> 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()) {
|
||||
dataMap.put(key(c), takeSnapshot(c, System.currentTimeMillis()));
|
||||
}
|
||||
}
|
||||
|
||||
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(":");
|
||||
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 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) {
|
||||
dataMap.put(key(c), takeSnapshot(c, System.currentTimeMillis()));
|
||||
}
|
||||
|
||||
public void onChunkUnload(Chunk c) {
|
||||
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) {
|
||||
Bukkit.getLogger().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){
|
||||
Bukkit.getLogger().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;
|
||||
}
|
||||
|
||||
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())); infinite loop
|
||||
System.err.println("ChunkSnapshotManager: No snapshot for " + c+ " Please report this on our discord (discord.cubi.games)'");
|
||||
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(String worldName, int x, int z) {
|
||||
Data d = dataMap.get(worldName + ":" + 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
|
||||
}
|
||||
|
||||
}
|
||||
+148
@@ -0,0 +1,148 @@
|
||||
package games.cubi.raycastedEntityOcclusion.Snapshot;
|
||||
|
||||
import org.bukkit.Location;
|
||||
import org.bukkit.World;
|
||||
import org.bukkit.entity.Entity;
|
||||
import org.bukkit.entity.Player;
|
||||
|
||||
import javax.annotation.Nullable;
|
||||
import java.util.*;
|
||||
import java.util.concurrent.ConcurrentHashMap;
|
||||
|
||||
|
||||
public class EntitySnapshotManager {
|
||||
|
||||
public static class EntityData {
|
||||
|
||||
//Entity data for a single entity in a world.
|
||||
|
||||
private volatile Location location;
|
||||
/** Player UUID → can-see flag (true/false). Absence = NOT_SET. */
|
||||
private final Map<UUID, Boolean> visibility = new ConcurrentHashMap<>();
|
||||
|
||||
public EntityData(Location initial) {
|
||||
this.location = initial.clone();
|
||||
}
|
||||
|
||||
/* ---- location ---- */
|
||||
public Location getLocation() { return location.clone(); }
|
||||
public void setLocation(Location loc) { this.location = loc.clone(); }
|
||||
|
||||
/* ---- visibility ---- */
|
||||
public void setVisibleFor(UUID playerId, boolean canSee) {
|
||||
visibility.put(playerId, canSee);
|
||||
}
|
||||
public void clearVisibility(UUID playerId) { visibility.remove(playerId); }
|
||||
|
||||
public Boolean getVisibility(UUID playerId) {
|
||||
return visibility.get(playerId); // may be null
|
||||
}
|
||||
}
|
||||
|
||||
// Cache: world-name → (entity-UUID → data)
|
||||
private final Map<String, Map<UUID, EntityData>> cache = new ConcurrentHashMap<>();
|
||||
|
||||
public void addEntity(Entity entity) {
|
||||
Objects.requireNonNull(entity, "EntitySnapshotManager: Cannot add null entity");
|
||||
cache.computeIfAbsent(entity.getWorld().getName(),
|
||||
w -> new ConcurrentHashMap<>())
|
||||
.putIfAbsent(entity.getUniqueId(),
|
||||
new EntityData(entity.getLocation()));
|
||||
}
|
||||
|
||||
public void removeEntity(Entity entity) {
|
||||
Map<UUID, EntityData> entitiesInWorld = cache.get(entity.getWorld().getName());
|
||||
if (entitiesInWorld != null) {
|
||||
entitiesInWorld.remove(entity.getUniqueId());
|
||||
if (entitiesInWorld.isEmpty()) cache.remove(entity.getWorld().getName());
|
||||
}
|
||||
}
|
||||
|
||||
/** Updates (or inserts) the latest location for the entity. */
|
||||
public void updateLocation(Entity entity) {
|
||||
cache.computeIfAbsent(entity.getWorld().getName(),
|
||||
w -> new ConcurrentHashMap<>())
|
||||
.compute(entity.getUniqueId(), (id, data) -> {
|
||||
if (data == null) return new EntityData(entity.getLocation());
|
||||
data.setLocation(entity.getLocation());
|
||||
return data;
|
||||
});
|
||||
}
|
||||
|
||||
// put anywhere inside EntitySnapshotManager
|
||||
public @Nullable Location getLocation(Entity entity) {
|
||||
Map<UUID, EntityData> entitiesInWorld = cache.get(entity.getWorld().getName());
|
||||
if (entitiesInWorld == null) return null;
|
||||
EntityData data = entitiesInWorld.get(entity.getUniqueId());
|
||||
return (data == null) ? null : data.getLocation();
|
||||
}
|
||||
|
||||
|
||||
/* ---- visibility helpers ---- */
|
||||
public void setVisibility(Entity entity, Player player, boolean canSee) {
|
||||
Map<UUID, EntityData> entitiesInWorld = cache.get(entity.getWorld().getName());
|
||||
if (entitiesInWorld != null) {
|
||||
EntityData d = entitiesInWorld.get(entity.getUniqueId());
|
||||
if (d != null) d.setVisibleFor(player.getUniqueId(), canSee);
|
||||
}
|
||||
}
|
||||
|
||||
public void clearVisibility(Entity entity, Player player) {
|
||||
Map<UUID, EntityData> entitiesInWorld = cache.get(entity.getWorld().getName());
|
||||
if (entitiesInWorld != null) {
|
||||
EntityData d = entitiesInWorld.get(entity.getUniqueId());
|
||||
if (d != null) d.clearVisibility(player.getUniqueId());
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
public Boolean getVisibility(Entity entity, Player player) {
|
||||
Map<UUID, EntityData> entitiesInWorld = cache.get(entity.getWorld().getName());
|
||||
if (entitiesInWorld == null) return null;
|
||||
EntityData d = entitiesInWorld.get(entity.getUniqueId());
|
||||
return (d == null) ? null : d.getVisibility(player.getUniqueId());
|
||||
}
|
||||
|
||||
/* ---- miscellaneous ---- */
|
||||
public Collection<EntityData> getEntitiesInWorld(World world) {
|
||||
Map<UUID, EntityData> entitiesInWorld = cache.get(world.getName());
|
||||
return (entitiesInWorld == null) ? Collections.emptyList() : entitiesInWorld.values();
|
||||
}
|
||||
|
||||
public List<Entity> getBukkitEntitiesNear(Location origin, int radiusX, int radiusY, int radiusZ) {
|
||||
|
||||
World world = origin.getWorld();
|
||||
Map<UUID, EntityData> entitiesInWorld = cache.get(world.getName());
|
||||
if (entitiesInWorld == null || entitiesInWorld.isEmpty()) {
|
||||
return Collections.emptyList();
|
||||
}
|
||||
|
||||
double ox = origin.getX(), oy = origin.getY(), oz = origin.getZ();
|
||||
double minX = ox - radiusX, maxX = ox + radiusX;
|
||||
double minY = oy - radiusY, maxY = oy + radiusY;
|
||||
double minZ = oz - radiusZ, maxZ = oz + radiusZ;
|
||||
|
||||
List<Entity> result = new ArrayList<>();
|
||||
for (Map.Entry<UUID, EntityData> entry : entitiesInWorld.entrySet()) {
|
||||
EntityData data = entry.getValue();
|
||||
Location loc = data.getLocation();
|
||||
double x = loc.getX(), y = loc.getY(), z = loc.getZ();
|
||||
|
||||
if (x < minX || x > maxX || y < minY || y > maxY || z < minZ || z > maxZ) {
|
||||
|
||||
Entity live = world.getEntity(entry.getKey());
|
||||
if (live != null) {
|
||||
if (!live.isDead()) {
|
||||
result.add(live);
|
||||
}
|
||||
else removeEntity(live);
|
||||
}
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
public int size() {
|
||||
return cache.values().stream().mapToInt(Map::size).sum();
|
||||
}
|
||||
}
|
||||
@@ -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) {
|
||||
if (!e.isNewChunk()) 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,80 @@
|
||||
package games.cubi.raycastedEntityOcclusion;
|
||||
|
||||
|
||||
import com.google.gson.JsonArray;
|
||||
import com.google.gson.JsonObject;
|
||||
import com.google.gson.JsonParser;
|
||||
import net.kyori.adventure.audience.Audience;
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.command.CommandSender;
|
||||
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;
|
||||
import java.util.function.Supplier;
|
||||
|
||||
|
||||
public class UpdateChecker {
|
||||
/*private final RaycastedEntityOcclusion plugin;
|
||||
private final RaycastedEntityOcclusion plugin;
|
||||
|
||||
public UpdateChecker(RaycastedEntityOcclusion plugin) {
|
||||
this.plugin = plugin;
|
||||
checkForUpdates();
|
||||
plugin.getLogger().info("Checking for updates...");
|
||||
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) {
|
||||
//plugin.getLogger().info("Fetching latest version from Modrinth...");
|
||||
fetchFeaturedVersion(plugin).thenAccept(version -> {
|
||||
//plugin.getLogger().info("Latest version fetched: " + version);
|
||||
// This runs synchronously when the version is fetched
|
||||
Bukkit.getScheduler().runTask(plugin, () -> {
|
||||
//plugin.getLogger().info("Checking if current version matches the latest version...");
|
||||
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, () -> {
|
||||
plugin.getLogger().warning("Failed to fetch version: " + ex.getMessage());
|
||||
});
|
||||
return null;
|
||||
});
|
||||
}
|
||||
*/
|
||||
}
|
||||
+1
-1
@@ -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+";
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,10 +1,18 @@
|
||||
snapshot-refresh-interval: 60 # seconds between chunk snapshot refresh
|
||||
engine-mode: 1 # 1 = straight-line; 2 = predictive
|
||||
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.
|
||||
@@ -2,10 +2,19 @@ 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
|
||||
softdepend:
|
||||
- packetevents
|
||||
Reference in new issue
Block a user