Compare commits

..
Author SHA1 Message Date
Cubicake e1f70a296c WIP, still broken. Don't fork based off of this branch 2025-07-18 11:55:05 +09:30
Cubicake 3eccd69669 Tidy up 2025-07-15 16:30:33 +09:30
Cubicake 9f27f1c58f Store entities 2025-07-15 14:48:53 +09:30
12 changed files with 249 additions and 174 deletions

No files matched your search

+1 -3
View File
@@ -1,13 +1,11 @@
# User-specific stuff
.idea/
README.md
*.md
*.iml
*.ipr
*.iws
README.md
# IntelliJ
out/
+1 -1
View File
@@ -1,4 +1,4 @@
Latest version: v1.6.0
Latest version: v1.5.1
The latest version can currently only be found on Modrinth https://modrinth.com/plugin/raycasted-entity-occlusions/
+3 -9
View File
@@ -3,7 +3,7 @@ plugins {
}
group = 'games.cubi'
version = '1.6.0'
version = '1.6.0-dev-1'
repositories {
mavenCentral()
@@ -21,8 +21,8 @@ repositories {
}
dependencies {
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
compileOnly("io.papermc.paper:paper-api:1.21.4-R0.1-SNAPSHOT")
compileOnly("com.github.retrooper:packetevents-spigot:2.8.0")
}
def targetJavaVersion = 21
@@ -50,10 +50,4 @@ processResources {
filesMatching('plugin.yml') {
expand props
}
}
jar {
manifest {
attributes "paperweight-mappings-namespace": "mojang"
}
}
@@ -1,52 +0,0 @@
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");
}
}
@@ -1,33 +1,28 @@
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 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.ArrayList;
import java.util.HashSet;
import java.util.*;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ConcurrentHashMap;
import java.util.Set;
import java.util.List;
import java.util.function.Consumer;
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;
@@ -54,20 +49,30 @@ public class Engine {
visible = v;
}
}
private static class PlayerInfo {
final Player player;
final Location location;
final Location predLoc;
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);
}
}
PlayerInfo(Player p, Location loc, Location pred) {
player = p;
location = loc;
predLoc = pred;
}
}
List<RayJob> jobs = new ArrayList<>();
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();
@@ -76,12 +81,20 @@ public class Engine {
// getPredictedLocation returns null if insufficient data or too slow
predEye = tracker.getPredictedLocation(p);
}
asyncScheduler.runNow(plugin, raycastEntitiesAroundPlayer(p, eye, predEye));
}
for (Entity e : p.getNearbyEntities(cfg.searchRadius, cfg.searchRadius, cfg.searchRadius)) {
// ----- 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()))) {
p.showEntity(plugin, e);
//TODO: Add to result that player should be shown
continue;
}
@@ -91,16 +104,22 @@ public class Engine {
p.showEntity(plugin, e);
} else if (dist > cfg.raycastRadius) {
p.hideEntity(plugin, e);
} else if (!p.canSee(e) || plugin.tick % cfg.recheckInterval == 0) {
} 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));
}
}
}
// ----- 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())) {
@@ -143,7 +162,7 @@ public class Engine {
if (cfg.checkTileEntities) {
for (Player p : Bukkit.getOnlinePlayers()) {
if (p.hasPermission("raycastedentityocclusions.bypass")) continue;
World world = p.getWorld();
String world = p.getWorld().getName();
//get player's chunk location
int chunkX = p.getLocation().getBlockX() >> 4;
int chunkZ = p.getLocation().getBlockZ() >> 4;
@@ -36,6 +36,7 @@ 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();
@@ -7,13 +7,10 @@ import org.bukkit.Particle;
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) {
Particle.DustOptions dustRed = null;
Particle.DustOptions dustGreen = null;
if (debug) {
dustRed = new Particle.DustOptions(org.bukkit.Color.RED, 1f);
dustGreen = new Particle.DustOptions(org.bukkit.Color.GREEN, 1f);
}
double total = start.distance(end);
double traveled = 0;
Location curr = start.clone();
@@ -28,12 +25,12 @@ public class RaycastUtil {
if (mat.isOccluding()) {
maxOccluding--;
if (debug) {
start.getWorld().spawnParticle(Particle.DUST, curr, 1, dustRed);
start.getWorld().spawnParticle(Particle.DUST, curr, 1, DUST_RED);
}
if (maxOccluding < 1) return false;
}
else if (debug) {
start.getWorld().spawnParticle(Particle.DUST, curr, 1, dustGreen);
start.getWorld().spawnParticle(Particle.DUST, curr, 1, DUST_GREEN);
}
}
return true;
@@ -7,6 +7,7 @@ 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;
@@ -20,10 +21,12 @@ 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;
@@ -46,7 +49,8 @@ public class RaycastedEntityOcclusion extends JavaPlugin implements CommandExecu
snapMgr = new ChunkSnapshotManager(this);
tracker = new MovementTracker(this, cfg);
commands = new CommandsManager(this, cfg);
new UpdateChecker(this);
updateChecker = new UpdateChecker(this);
entitySnapshotManager = new EntitySnapshotManager();
getServer().getPluginManager().registerEvents(new EventListener(this, snapMgr, cfg), this);
//Brigadier API
LiteralCommandNode<CommandSourceStack> buildCommand = commands.registerCommand();
@@ -72,7 +76,7 @@ public class RaycastedEntityOcclusion extends JavaPlugin implements CommandExecu
@Override
public void run() {
tick++;
Engine.runEngine(cfg, snapMgr, tracker, RaycastedEntityOcclusion.this);
Engine.runEngine(cfg, snapMgr, tracker, entitySnapshotManager, RaycastedEntityOcclusion.this);
Engine.runTileEngine(cfg, snapMgr, tracker, RaycastedEntityOcclusion.this);
}
}.runTaskTimer(this, 0L, 1L);
@@ -83,7 +87,7 @@ public class RaycastedEntityOcclusion extends JavaPlugin implements CommandExecu
if (packetEventsPresent && Bukkit.getPluginManager().isPluginEnabled("packetevents")) {
cfg.setPacketEventsPresent(true);
packetProcessor = new PacketProcessor(RaycastedEntityOcclusion.this);
Logger.info("PacketEvents is enabled, enabling packet-based tablist modification.");
getLogger().info("PacketEvents is enabled, enabling packet-based tablist modification.");
}
}
}.runTaskLater(this, 1L);
@@ -1,29 +1,19 @@
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.*;
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.*;
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 Map<Location, Material> delta = new ConcurrentHashMap<>();
public final Set<Location> tileEntities = ConcurrentHashMap.newKeySet();
public long lastRefresh;
public int minHeight;
@@ -35,17 +25,15 @@ public class ChunkSnapshotManager {
}
}
private static final ConcurrentHashMap<String, Data> dataMap = new ConcurrentHashMap<>();
private final Map<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);
dataMap.put(key(c), takeSnapshot(c, System.currentTimeMillis()));
}
}
@@ -59,43 +47,38 @@ public class ChunkSnapshotManager {
if (now - e.getValue().lastRefresh >= cfg.snapshotRefreshInterval * 1000L && chunksRefreshed < chunksToRefreshMaximum) {
chunksRefreshed++;
String key = e.getKey();
//String[] parts = key.split(":");
Chunk c = getKeyChunk(key);
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) {
Logger.info("ChunkSnapshotManager: Refreshed " + chunksRefreshed + " chunks out of " + chunksToRefreshMaximum + " maximum.");
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) {
snapshotChunk(c);
dataMap.put(key(c), takeSnapshot(c, System.currentTimeMillis()));
}
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);
Bukkit.getLogger().info("ChunkSnapshotManager: Block change at " + loc + " to " + m);
}
Data d = dataMap.get(key(loc.getChunk()));
if (d != null) {
@@ -106,7 +89,7 @@ public class ChunkSnapshotManager {
loc = loc.clone().add(0.5, 0.5, 0.5);
if (data instanceof TileState) {
if (cfg.debugMode){
Logger.info("ChunkSnapshotManager: Tile entity at " + loc);
Bukkit.getLogger().info("ChunkSnapshotManager: Tile entity at " + loc);
}
d.tileEntities.add(loc);
} else {
@@ -141,35 +124,16 @@ public class ChunkSnapshotManager {
return data;
}
public String key(Chunk c) {
private 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));
Data d = dataMap.get(key(loc.getChunk()));
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);
//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();
@@ -188,8 +152,8 @@ public class ChunkSnapshotManager {
}
//get TileEntity Locations in chunk
public Set<Location> getTileEntitiesInChunk(World world, int x, int z) {
Data d = dataMap.get(key(world, x, z));
public Set<Location> getTileEntitiesInChunk(String worldName, int x, int z) {
Data d = dataMap.get(worldName + ":" + x + ":" + z);
if (d == null) {
return Collections.emptySet();
}
@@ -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();
}
}
@@ -4,9 +4,9 @@ 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.entity.Player;
import org.bukkit.event.EventHandler;
@@ -15,6 +15,7 @@ import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URL;
import java.util.concurrent.CompletableFuture;
import java.util.function.Supplier;
public class UpdateChecker {
@@ -22,6 +23,7 @@ public class UpdateChecker {
public UpdateChecker(RaycastedEntityOcclusion plugin) {
this.plugin = plugin;
plugin.getLogger().info("Checking for updates...");
checkForUpdates(plugin, Bukkit.getConsoleSender());
}
@@ -55,9 +57,12 @@ public class UpdateChecker {
}
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 {
@@ -67,7 +72,7 @@ public class UpdateChecker {
}).exceptionally(ex -> {
// Handle error (e.g., log the exception)
Bukkit.getScheduler().runTask(plugin, () -> {
Logger.warning("Failed to fetch version: " + ex.getMessage());
plugin.getLogger().warning("Failed to fetch version: " + ex.getMessage());
});
return null;
});
-3
View File
@@ -16,8 +16,5 @@ permissions:
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