Repo-Mirror/craft-engine
9
0
Fork 0
mirror of https://github.com/Xiao-MoMi/craft-engine.git synced 2025-12-31 21:06:31 +00:00
Code Issues Releases Activity

refactor(bukkit): 移除最大可见家具数量的限制功能

Browse Source
This commit is contained in:
jhqwqmc
2025-05-23 04:49:42 +08:00
parent 768b5de5ba
commit 35c4e22f20
12 changed files with 20 additions and 379 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
core/src/main/java/net/momirealms/craftengine/core/plugin/CraftEngine.java
View File

@@ -132,9 +132,6 @@ public abstract class CraftEngine implements Plugin {
long time1 = System.currentTimeMillis();
// firstly reload main config
this.config.load();
for (Player player : this.networkManager().onlineUsers()) {
player.setMaxVisibleFurniture(Config.maxVisibleFurniture(), false);
}
// reset debugger
this.debugger = Config.debug() ? (s) -> logger.info("[Debug] " + s.get()) : (s) -> {};
// now we reload the translations

12
core/src/main/java/net/momirealms/craftengine/core/plugin/config/Config.java
View File

@@ -110,8 +110,6 @@ public class Config {
protected Map<String, String> furniture$handle_invalid_furniture_on_chunk_load$mapping;
protected boolean furniture$hide_base_entity;
protected ColliderType furniture$collision_entity_type;
protected boolean furniture$max_visible_furniture_enable;
protected int furniture$max_visible_furniture_amount;
protected boolean block$sound_system$enable;
protected boolean block$simplify_adventure_break_check;
@@ -302,8 +300,6 @@ public class Config {
furniture$handle_invalid_furniture_on_chunk_load$mapping = builder.build();
furniture$hide_base_entity = config.getBoolean("furniture.hide-base-entity", true);
furniture$collision_entity_type = ColliderType.valueOf(config.getString("furniture.collision-entity-type", "interaction").toUpperCase(Locale.ENGLISH));
furniture$max_visible_furniture_enable = config.getBoolean("furniture.max-visible-furniture.enable", false);
furniture$max_visible_furniture_amount = config.getInt("furniture.max-visible-furniture.amount", 100);
// block
block$sound_system$enable = config.getBoolean("block.sound-system.enable", true);
@@ -421,14 +417,6 @@ public class Config {
return instance.resource_pack$supported_version$min;
}
public static boolean enableMaxVisibleFurniture() {
return instance.furniture$max_visible_furniture_enable;
}
public static int maxVisibleFurniture() {
return instance.furniture$max_visible_furniture_amount;
}
public static float packMaxVersion() {
return instance.resource_pack$supported_version$max;
}

5
core/src/main/java/net/momirealms/craftengine/core/plugin/network/NetWorkUser.java
View File

@@ -2,7 +2,6 @@ package net.momirealms.craftengine.core.plugin.network;
import io.netty.channel.Channel;
import net.momirealms.craftengine.core.plugin.Plugin;
import net.momirealms.craftengine.core.util.DynamicPriorityTracker;
import net.momirealms.craftengine.core.util.Key;
import org.jetbrains.annotations.ApiStatus;
@@ -44,10 +43,6 @@ public interface NetWorkUser {
Map<Integer, EntityPacketHandler> entityPacketHandlers();
DynamicPriorityTracker visualFurnitureView();
void setMaxVisibleFurniture(int maxVisibleFurniture, boolean fromCommand);
boolean clientModEnabled();
void setClientModState(boolean enable);

194
core/src/main/java/net/momirealms/craftengine/core/util/DynamicPriorityTracker.java
View File

@@ -1,194 +0,0 @@
package net.momirealms.craftengine.core.util;
import net.momirealms.craftengine.core.plugin.config.Config;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.ReentrantLock;
public class DynamicPriorityTracker {
public static class Element {
private final int entityId;
private volatile double distance;
private final Object removePacket;
public Element(int entityId, double distance, Object removePacket) {
this.entityId = entityId;
this.distance = distance;
this.removePacket = removePacket;
}
public int entityId() {
return entityId;
}
public double distance() {
return distance;
}
public void setDistance(double distance) {
this.distance = distance;
}
public Object removePacket() {
return removePacket;
}
@Override
public String toString() {
return "Element{" +
"entityId=" + entityId +
", distance=" + distance +
", removePacket=" + removePacket +
'}';
}
}
public static class UpdateResult {
private final List<Element> entered = new ArrayList<>();
private final List<Element> exited = new ArrayList<>();
public List<Element> getEntered() {
return entered;
}
public List<Element> getExited() {
return exited;
}
void addEntered(Element e) {
entered.add(e);
}
void addExited(Element e) {
exited.add(e);
}
@Override
public String toString() {
return "UpdateResult{" +
"entered=" + entered +
", exited=" + exited +
'}';
}
}
private Integer maxVisibleFurniture;
private final PriorityQueue<Element> maxHeap;
private final Map<Integer, Element> elementMap = new ConcurrentHashMap<>();
private final Set<Integer> inHeapSet = ConcurrentHashMap.newKeySet();
private final ReentrantLock heapLock = new ReentrantLock();
public DynamicPriorityTracker() {
this.maxVisibleFurniture = Config.maxVisibleFurniture();
this.maxHeap = new PriorityQueue<>((a, b) -> Double.compare(b.distance, a.distance));
}
public void setMaxVisibleFurniture(int maxVisibleFurniture) {
this.maxVisibleFurniture = maxVisibleFurniture;
}
public UpdateResult addOrUpdateElement(Element newElement) {
UpdateResult result = new UpdateResult();
heapLock.lock();
try {
Element existing = elementMap.get(newElement.entityId);
if (existing != null) {
return handleExistingElement(existing, newElement, result);
} else {
return handleNewElement(newElement, result);
}
} finally {
heapLock.unlock();
}
}
private UpdateResult handleNewElement(Element newElement, UpdateResult result) {
elementMap.put(newElement.entityId, newElement);
if (maxHeap.size() < maxVisibleFurniture) {
maxHeap.offer(newElement);
inHeapSet.add(newElement.entityId);
result.addEntered(newElement);
} else if (maxHeap.peek() != null && newElement.distance < maxHeap.peek().distance) {
Element removed = maxHeap.poll();
inHeapSet.remove(removed.entityId);
result.addExited(removed);
maxHeap.offer(newElement);
inHeapSet.add(newElement.entityId);
result.addEntered(newElement);
}
return result;
}
private UpdateResult handleExistingElement(Element existing, Element newElement, UpdateResult result) {
existing.setDistance(newElement.distance);
boolean wasInHeap = inHeapSet.contains(existing.entityId);
boolean nowInHeap = checkIfShouldBeInHeap(existing.distance);
if (wasInHeap) {
maxHeap.remove(existing);
maxHeap.offer(existing);
} else if (nowInHeap) {
if (maxHeap.size() < maxVisibleFurniture) {
maxHeap.offer(existing);
inHeapSet.add(existing.entityId);
result.addEntered(existing);
} else if (maxHeap.peek() != null && existing.distance < maxHeap.peek().distance) {
Element removed = maxHeap.poll();
inHeapSet.remove(removed.entityId);
result.addExited(removed);
maxHeap.offer(existing);
inHeapSet.add(existing.entityId);
result.addEntered(existing);
}
}
return result;
}
private boolean checkIfShouldBeInHeap(double distance) {
if (maxHeap.size() < maxVisibleFurniture) return true;
return maxHeap.peek() != null && distance < maxHeap.peek().distance;
}
public int getTotalMembers() {
heapLock.lock();
try {
return elementMap.size();
} finally {
heapLock.unlock();
}
}
public List<Element> getAllElements() {
heapLock.lock();
try {
return List.copyOf(elementMap.values());
} finally {
heapLock.unlock();
}
}
public void removeByEntityId(int entityId) {
heapLock.lock();
try {
Element removed = elementMap.remove(entityId);
if (removed != null) {
maxHeap.remove(removed);
inHeapSet.remove(entityId);
}
} finally {
heapLock.unlock();
}
}
@Override
public String toString() {
return "DynamicPriorityTracker{" +
"maxHeap=" + maxHeap +
", elementMap=" + elementMap +
", inHeapSet=" + inHeapSet +
", heapLock=" + heapLock +
'}';
}
}