import com.irtimaled.bbor.common.MathHelper;
import com.irtimaled.bbor.common.models.AbstractBoundingBox;
import com.irtimaled.bbor.common.models.BoundingBoxCuboid;
+import com.irtimaled.bbor.common.models.DimensionId;
import org.lwjgl.opengl.GL11;
import java.util.HashMap;
return boundingBox.intersectsBounds(minX, minZ, maxX, maxZ);
}
- public static void render(int dimensionId) {
+ public static void render(DimensionId dimensionId) {
if (!active) return;
Set<AbstractBoundingBox> boundingBoxes = getBoundingBoxes(dimensionId);
GL11.glEnable(GL11.GL_TEXTURE_2D);
}
- private static Set<AbstractBoundingBox> getBoundingBoxes(int dimensionId) {
+ private static Set<AbstractBoundingBox> getBoundingBoxes(DimensionId dimensionId) {
Set<AbstractBoundingBox> boundingBoxes = new HashSet<>();
for (IBoundingBoxProvider<?> provider : providers) {
if (provider.canProvide(dimensionId)) {
package com.irtimaled.bbor.client;
import com.irtimaled.bbor.common.BoundingBoxCache;
+import com.irtimaled.bbor.common.models.DimensionId;
import java.util.function.Function;
-public interface GetCache extends Function<Integer, BoundingBoxCache> {
+public interface GetCache extends Function<DimensionId, BoundingBoxCache> {
}
import com.irtimaled.bbor.client.models.Point;
import com.irtimaled.bbor.common.models.Coords;
+import com.irtimaled.bbor.common.models.DimensionId;
import net.minecraft.client.entity.player.ClientPlayerEntity;
public class Player {
private static double y;
private static double z;
private static double activeY;
- private static int dimensionId;
+ private static DimensionId dimensionId;
public static void setPosition(double partialTicks, ClientPlayerEntity player) {
x = player.lastTickPosX + (player.posX - player.lastTickPosX) * partialTicks;
y = player.lastTickPosY + (player.posY - player.lastTickPosY) * partialTicks;
z = player.lastTickPosZ + (player.posZ - player.lastTickPosZ) * partialTicks;
- dimensionId = player.dimension.getId();
+ dimensionId = DimensionId.from(player.dimension);
}
static void setActiveY() {
return configMaxY;
}
- public static int getDimensionId() {
+ public static DimensionId getDimensionId() {
return dimensionId;
}
package com.irtimaled.bbor.client.events;
import com.irtimaled.bbor.common.models.AbstractBoundingBox;
+import com.irtimaled.bbor.common.models.DimensionId;
import java.util.Set;
public class AddBoundingBoxReceived {
- private final int dimensionId;
+ private final DimensionId dimensionId;
private final AbstractBoundingBox key;
private final Set<AbstractBoundingBox> boundingBoxes;
- public AddBoundingBoxReceived(int dimensionId, AbstractBoundingBox key, Set<AbstractBoundingBox> boundingBoxes) {
+ public AddBoundingBoxReceived(DimensionId dimensionId, AbstractBoundingBox key, Set<AbstractBoundingBox> boundingBoxes) {
this.dimensionId = dimensionId;
this.key = key;
this.boundingBoxes = boundingBoxes;
}
- public int getDimensionId() {
+ public DimensionId getDimensionId() {
return dimensionId;
}
import com.irtimaled.bbor.client.providers.SlimeChunkProvider;
import com.irtimaled.bbor.common.EventBus;
import com.irtimaled.bbor.common.TypeHelper;
+import com.irtimaled.bbor.common.models.DimensionId;
import com.mojang.brigadier.CommandDispatcher;
import com.mojang.brigadier.exceptions.CommandSyntaxException;
import net.minecraft.client.Minecraft;
public static void render(float partialTicks, ClientPlayerEntity player) {
Player.setPosition(partialTicks, player);
- ClientRenderer.render(player.dimension.getId());
+ ClientRenderer.render(DimensionId.from(player.dimension));
}
public static boolean interceptChatMessage(String message) {
import com.irtimaled.bbor.common.EventBus;
import com.irtimaled.bbor.common.events.StructuresLoaded;
+import com.irtimaled.bbor.common.models.DimensionId;
import net.minecraft.nbt.CompoundNBT;
import net.minecraft.nbt.ListNBT;
import net.minecraft.util.math.ChunkPos;
import java.util.*;
class NBTStructureLoader {
- private final int dimensionId;
+ private final DimensionId dimensionId;
private final Set<String> loadedChunks = new HashSet<>();
private LegacyStructureDataUtil legacyStructureDataUtil = null;
private File chunkSaveLocation = null;
private ChunkLoader chunkLoader;
- NBTStructureLoader(int dimensionId, SaveHandler saveHandler, File worldDirectory) {
+ NBTStructureLoader(DimensionId dimensionId, SaveHandler saveHandler, File worldDirectory) {
this.dimensionId = dimensionId;
this.configure(saveHandler, worldDirectory);
}
void clear() {
+ this.legacyStructureDataUtil = null;
this.saveHandler = null;
this.chunkSaveLocation = null;
this.loadedChunks.clear();
this.chunkLoader.close();
} catch (IOException ignored) {
}
+ this.chunkLoader = null;
}
void configure(SaveHandler saveHandler, File worldDirectory) {
this.saveHandler = saveHandler;
if (worldDirectory != null) {
- this.chunkSaveLocation = new File(DimensionType.getById(dimensionId).getDirectory(worldDirectory), "region");
+ this.chunkSaveLocation = new File(dimensionId.getDimensionType().getDirectory(worldDirectory), "region");
this.chunkLoader = new ChunkLoader(this.chunkSaveLocation);
}
}
private LegacyStructureDataUtil getLegacyStructureDataUtil() {
if (this.legacyStructureDataUtil == null) {
File dataFolder = new File(DimensionType.OVERWORLD.getDirectory(this.saveHandler.getWorldDirectory()), "data");
- this.legacyStructureDataUtil = LegacyStructureDataUtil.func_215130_a(DimensionType.getById(dimensionId),
+ this.legacyStructureDataUtil = LegacyStructureDataUtil.func_215130_a(dimensionId.getDimensionType(),
new DimensionSavedDataManager(dataFolder, this.saveHandler.getFixer()));
}
return this.legacyStructureDataUtil;
package com.irtimaled.bbor.client.interop;
import com.irtimaled.bbor.client.Player;
+import com.irtimaled.bbor.common.models.DimensionId;
import net.minecraft.client.Minecraft;
import net.minecraft.world.storage.SaveFormat;
import net.minecraft.world.storage.SaveHandler;
import java.util.Map;
public class SaveGameStructureLoader {
- private static final Map<Integer, NBTStructureLoader> nbtStructureLoaders = new HashMap<>();
+ private static final Map<DimensionId, NBTStructureLoader> nbtStructureLoaders = new HashMap<>();
private static SaveHandler saveHandler = null;
private static File worldDirectory = null;
saveHandler = saveLoader.getSaveLoader(fileName, null);
worldDirectory = saveLoader.func_215781_c().resolve(fileName).toFile();
- for (int dimensionId : nbtStructureLoaders.keySet()) {
+ for (DimensionId dimensionId : nbtStructureLoaders.keySet()) {
NBTStructureLoader dimensionProcessor = getNBTStructureLoader(dimensionId);
dimensionProcessor.configure(saveHandler, worldDirectory);
}
dimensionProcessor.loadStructures(chunkX, chunkZ);
}
- private static NBTStructureLoader getNBTStructureLoader(int dimensionId) {
+ private static NBTStructureLoader getNBTStructureLoader(DimensionId dimensionId) {
return nbtStructureLoaders.computeIfAbsent(dimensionId,
id -> new NBTStructureLoader(id, saveHandler, worldDirectory));
}
import com.irtimaled.bbor.client.models.BoundingBoxBeacon;
import com.irtimaled.bbor.common.BoundingBoxType;
import com.irtimaled.bbor.common.models.Coords;
+import com.irtimaled.bbor.common.models.DimensionId;
import net.minecraft.tileentity.BeaconTileEntity;
public class BeaconProvider implements IBoundingBoxProvider<BoundingBoxBeacon> {
@Override
- public boolean canProvide(int dimensionId) {
+ public boolean canProvide(DimensionId dimensionId) {
return BoundingBoxTypeHelper.shouldRender(BoundingBoxType.Beacon);
}
@Override
- public Iterable<BoundingBoxBeacon> get(int dimensionId) {
+ public Iterable<BoundingBoxBeacon> get(DimensionId dimensionId) {
return TileEntitiesHelper.map(BeaconTileEntity.class, beacon -> {
int levels = beacon.getLevels();
Coords coords = new Coords(beacon.getPos());
import com.irtimaled.bbor.common.BoundingBoxType;
import com.irtimaled.bbor.common.MathHelper;
import com.irtimaled.bbor.common.models.Coords;
+import com.irtimaled.bbor.common.models.DimensionId;
import java.util.HashMap;
import java.util.Map;
private static Map<Coords, BoundingBoxBiomeBorder> lastBorders = new HashMap<>();
@Override
- public boolean canProvide(int dimensionId) {
+ public boolean canProvide(DimensionId dimensionId) {
return BoundingBoxTypeHelper.shouldRender(BoundingBoxType.BiomeBorder);
}
@Override
- public Iterable<BoundingBoxBiomeBorder> get(int dimensionId) {
+ public Iterable<BoundingBoxBiomeBorder> get(DimensionId dimensionId) {
Coords playerCoords = Player.getCoords();
Integer renderDistance = ConfigManager.biomeBordersRenderDistance.get();
Boolean renderAllTransitions = !ConfigManager.renderOnlyCurrentBiome.get();
import com.irtimaled.bbor.common.BoundingBoxCache;
import com.irtimaled.bbor.common.MathHelper;
import com.irtimaled.bbor.common.models.AbstractBoundingBox;
+import com.irtimaled.bbor.common.models.DimensionId;
import java.util.HashSet;
import java.util.Map;
}
@Override
- public Iterable<AbstractBoundingBox> get(int dimensionId) {
+ public Iterable<AbstractBoundingBox> get(DimensionId dimensionId) {
Boolean outerBoxesOnly = ConfigManager.outerBoxesOnly.get();
Set<AbstractBoundingBox> boundingBoxes = new HashSet<>();
import com.irtimaled.bbor.common.BoundingBoxType;
import com.irtimaled.bbor.common.ReflectionHelper;
import com.irtimaled.bbor.common.models.Coords;
+import com.irtimaled.bbor.common.models.DimensionId;
import net.minecraft.tileentity.ConduitTileEntity;
import net.minecraft.util.math.BlockPos;
ReflectionHelper.getPrivateFieldGetter(ConduitTileEntity.class, List.class, BlockPos.class);
@Override
- public boolean canProvide(int dimensionId) {
+ public boolean canProvide(DimensionId dimensionId) {
return BoundingBoxTypeHelper.shouldRender(BoundingBoxType.Conduit);
}
@Override
- public Iterable<BoundingBoxConduit> get(int dimensionId) {
+ public Iterable<BoundingBoxConduit> get(DimensionId dimensionId) {
return TileEntitiesHelper.map(ConduitTileEntity.class, conduit -> {
List<BlockPos> blocks = blocksFetcher.apply(conduit);
if (blocks == null) return null;
import com.irtimaled.bbor.client.models.BoundingBoxBeacon;
import com.irtimaled.bbor.common.BoundingBoxType;
import com.irtimaled.bbor.common.models.Coords;
+import com.irtimaled.bbor.common.models.DimensionId;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
public class CustomBeaconProvider implements IBoundingBoxProvider<BoundingBoxBeacon> {
- private static final Map<Integer, Map<Coords, BoundingBoxBeacon>> dimensionsCache = new HashMap<>();
+ private static final Map<DimensionId, Map<Coords, BoundingBoxBeacon>> dimensionsCache = new HashMap<>();
- private static Map<Coords, BoundingBoxBeacon> getCache(int dimensionId) {
+ private static Map<Coords, BoundingBoxBeacon> getCache(DimensionId dimensionId) {
return dimensionsCache.computeIfAbsent(dimensionId, i -> new ConcurrentHashMap<>());
}
public static void add(Coords coords, int level) {
- int dimensionId = Player.getDimensionId();
+ DimensionId dimensionId = Player.getDimensionId();
BoundingBoxBeacon beacon = BoundingBoxBeacon.from(coords, level, BoundingBoxType.Custom);
getCache(dimensionId).put(coords, beacon);
}
public static boolean remove(Coords coords) {
- int dimensionId = Player.getDimensionId();
+ DimensionId dimensionId = Player.getDimensionId();
return getCache(dimensionId).remove(coords) != null;
}
}
@Override
- public Iterable<BoundingBoxBeacon> get(int dimensionId) {
+ public Iterable<BoundingBoxBeacon> get(DimensionId dimensionId) {
return getCache(dimensionId).values();
}
}
import com.irtimaled.bbor.common.BoundingBoxType;
import com.irtimaled.bbor.common.models.BoundingBoxCuboid;
import com.irtimaled.bbor.common.models.Coords;
+import com.irtimaled.bbor.common.models.DimensionId;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
public class CustomBoxProvider implements IBoundingBoxProvider<BoundingBoxCuboid> {
- private static final Map<Integer, Map<Integer, BoundingBoxCuboid>> dimensionCache = new HashMap<>();
+ private static final Map<DimensionId, Map<Integer, BoundingBoxCuboid>> dimensionCache = new HashMap<>();
private static int getHashKey(Coords minCoords, Coords maxCoords) {
return (31 + minCoords.hashCode()) * 31 + maxCoords.hashCode();
}
- private static Map<Integer, BoundingBoxCuboid> getCache(int dimensionId) {
+ private static Map<Integer, BoundingBoxCuboid> getCache(DimensionId dimensionId) {
return dimensionCache.computeIfAbsent(dimensionId, i -> new ConcurrentHashMap<>());
}
public static void add(Coords minCoords, Coords maxCoords) {
- int dimensionId = Player.getDimensionId();
+ DimensionId dimensionId = Player.getDimensionId();
int cacheKey = getHashKey(minCoords, maxCoords);
BoundingBoxCuboid cuboid = BoundingBoxCuboid.from(minCoords, maxCoords, BoundingBoxType.Custom);
getCache(dimensionId).put(cacheKey, cuboid);
}
public static boolean remove(Coords minCoords, Coords maxCoords) {
- int dimensionId = Player.getDimensionId();
+ DimensionId dimensionId = Player.getDimensionId();
int cacheKey = getHashKey(minCoords, maxCoords);
return getCache(dimensionId).remove(cacheKey) != null;
}
}
@Override
- public Iterable<BoundingBoxCuboid> get(int dimensionId) {
+ public Iterable<BoundingBoxCuboid> get(DimensionId dimensionId) {
return getCache(dimensionId).values();
}
}
import com.irtimaled.bbor.client.models.BoundingBoxLine;
import com.irtimaled.bbor.client.models.Point;
import com.irtimaled.bbor.common.BoundingBoxType;
+import com.irtimaled.bbor.common.models.DimensionId;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
public class CustomLineProvider implements IBoundingBoxProvider<BoundingBoxLine> {
- private static final Map<Integer, Map<Integer, BoundingBoxLine>> dimensionCache = new HashMap<>();
+ private static final Map<DimensionId, Map<Integer, BoundingBoxLine>> dimensionCache = new HashMap<>();
private static int getHashKey(Point minPoint, Point maxPoint) {
return (31 + minPoint.hashCode()) * 31 + maxPoint.hashCode();
}
- private static Map<Integer, BoundingBoxLine> getCache(int dimensionId) {
+ private static Map<Integer, BoundingBoxLine> getCache(DimensionId dimensionId) {
return dimensionCache.computeIfAbsent(dimensionId, i -> new ConcurrentHashMap<>());
}
public static void add(Point minPoint, Point maxPoint, Double width) {
- int dimensionId = Player.getDimensionId();
+ DimensionId dimensionId = Player.getDimensionId();
int cacheKey = getHashKey(minPoint, maxPoint);
BoundingBoxLine line = BoundingBoxLine.from(minPoint, maxPoint, width, BoundingBoxType.Custom);
getCache(dimensionId).put(cacheKey, line);
}
public static boolean remove(Point min, Point max) {
- int dimensionId = Player.getDimensionId();
+ DimensionId dimensionId = Player.getDimensionId();
int cacheKey = getHashKey(min, max);
return getCache(dimensionId).remove(cacheKey) != null;
}
}
@Override
- public Iterable<BoundingBoxLine> get(int dimensionId) {
+ public Iterable<BoundingBoxLine> get(DimensionId dimensionId) {
return getCache(dimensionId).values();
}
}
import com.irtimaled.bbor.client.models.BoundingBoxSphere;
import com.irtimaled.bbor.client.models.Point;
import com.irtimaled.bbor.common.BoundingBoxType;
+import com.irtimaled.bbor.common.models.DimensionId;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
public class CustomSphereProvider implements IBoundingBoxProvider<BoundingBoxSphere> {
- private static final Map<Integer, Map<Integer, BoundingBoxSphere>> dimensionCache = new HashMap<>();
+ private static final Map<DimensionId, Map<Integer, BoundingBoxSphere>> dimensionCache = new HashMap<>();
- private static Map<Integer, BoundingBoxSphere> getCache(int dimensionId) {
+ private static Map<Integer, BoundingBoxSphere> getCache(DimensionId dimensionId) {
return dimensionCache.computeIfAbsent(dimensionId, i -> new ConcurrentHashMap<>());
}
public static void add(Point center, double radius) {
- int dimensionId = Player.getDimensionId();
+ DimensionId dimensionId = Player.getDimensionId();
int cacheKey = center.hashCode();
BoundingBoxSphere sphere = new BoundingBoxSphere(center, radius, BoundingBoxType.Custom);
getCache(dimensionId).put(cacheKey, sphere);
}
public static boolean remove(Point center) {
- int dimensionId = Player.getDimensionId();
+ DimensionId dimensionId = Player.getDimensionId();
int cacheKey = center.hashCode();
return getCache(dimensionId).remove(cacheKey) != null;
}
}
@Override
- public Iterable<BoundingBoxSphere> get(int dimensionId) {
+ public Iterable<BoundingBoxSphere> get(DimensionId dimensionId) {
return getCache(dimensionId).values();
}
}
package com.irtimaled.bbor.client.providers;
import com.irtimaled.bbor.common.models.AbstractBoundingBox;
+import com.irtimaled.bbor.common.models.DimensionId;
public interface IBoundingBoxProvider<T extends AbstractBoundingBox> {
- Iterable<T> get(int dimensionId);
+ Iterable<T> get(DimensionId dimensionId);
- default boolean canProvide(int dimensionId) {
+ default boolean canProvide(DimensionId dimensionId) {
return true;
}
}
import com.irtimaled.bbor.client.models.BoundingBoxMobSpawner;
import com.irtimaled.bbor.common.BoundingBoxType;
import com.irtimaled.bbor.common.models.Coords;
+import com.irtimaled.bbor.common.models.DimensionId;
import net.minecraft.tileentity.MobSpawnerTileEntity;
public class MobSpawnerProvider implements IBoundingBoxProvider<BoundingBoxMobSpawner> {
@Override
- public boolean canProvide(int dimensionId) {
+ public boolean canProvide(DimensionId dimensionId) {
return BoundingBoxTypeHelper.shouldRender(BoundingBoxType.MobSpawner);
}
@Override
- public Iterable<BoundingBoxMobSpawner> get(int dimensionId) {
+ public Iterable<BoundingBoxMobSpawner> get(DimensionId dimensionId) {
return TileEntitiesHelper.map(MobSpawnerTileEntity.class, spawner -> {
Coords coords = new Coords(spawner.getPos());
return BoundingBoxMobSpawner.from(coords);
import com.irtimaled.bbor.client.interop.ClientInterop;
import com.irtimaled.bbor.client.models.BoundingBoxSlimeChunk;
import com.irtimaled.bbor.common.BoundingBoxType;
-import com.irtimaled.bbor.common.Dimensions;
import com.irtimaled.bbor.common.MathHelper;
import com.irtimaled.bbor.common.models.Coords;
+import com.irtimaled.bbor.common.models.DimensionId;
import java.util.HashSet;
import java.util.Random;
}
@Override
- public boolean canProvide(int dimensionId) {
- return dimensionId == Dimensions.OVERWORLD && seed != null && BoundingBoxTypeHelper.shouldRender(BoundingBoxType.SlimeChunks);
+ public boolean canProvide(DimensionId dimensionId) {
+ return dimensionId == DimensionId.OVERWORLD && seed != null && BoundingBoxTypeHelper.shouldRender(BoundingBoxType.SlimeChunks);
}
@Override
- public Iterable<BoundingBoxSlimeChunk> get(int dimensionId) {
+ public Iterable<BoundingBoxSlimeChunk> get(DimensionId dimensionId) {
Set<BoundingBoxSlimeChunk> slimeChunks = new HashSet<>();
int renderDistanceChunks = ClientInterop.getRenderDistanceChunks();
int playerChunkX = MathHelper.floor(Player.getX() / CHUNK_SIZE);
import com.irtimaled.bbor.client.models.BoundingBoxSpawnableBlocks;
import com.irtimaled.bbor.common.BoundingBoxType;
import com.irtimaled.bbor.common.MathHelper;
+import com.irtimaled.bbor.common.models.DimensionId;
import net.minecraft.client.Minecraft;
import java.util.HashSet;
}
@Override
- public boolean canProvide(int dimensionId) {
+ public boolean canProvide(DimensionId dimensionId) {
return BoundingBoxTypeHelper.shouldRender(BoundingBoxType.SpawnableBlocks) &&
!isWithinActiveSpawningSphere();
}
@Override
- public Iterable<BoundingBoxSpawnableBlocks> get(int dimensionId) {
+ public Iterable<BoundingBoxSpawnableBlocks> get(DimensionId dimensionId) {
long gameTime = minecraft.world.getGameTime();
if (lastBoundingBox == null || (!((Long) gameTime).equals(lastGameTime) && gameTime % 2L == 0L)) {
lastGameTime = gameTime;
import com.irtimaled.bbor.client.models.Point;
import com.irtimaled.bbor.common.BoundingBoxType;
import com.irtimaled.bbor.common.MathHelper;
+import com.irtimaled.bbor.common.models.DimensionId;
import net.minecraft.client.Minecraft;
import java.util.HashSet;
private static Set<BoundingBoxSpawningSphere> lastBoundingBox = null;
private static BoundingBoxSpawningSphere spawningSphere;
- private static Integer dimensionId;
+ private static DimensionId dimensionId;
public static void setSphere(Point point) {
if (spawningSphere != null && spawningSphere.getPoint().equals(point)) return;
return hasSpawningSphereInDimension(Player.getDimensionId()) && spawningSphere.isWithinSphere(Player.getPoint());
}
- public static boolean hasSpawningSphereInDimension(int dimensionId) {
+ public static boolean hasSpawningSphereInDimension(DimensionId dimensionId) {
return spawningSphere != null && SpawningSphereProvider.dimensionId == dimensionId;
}
}
@Override
- public boolean canProvide(int dimensionId) {
+ public boolean canProvide(DimensionId dimensionId) {
return hasSpawningSphereInDimension(dimensionId) && BoundingBoxTypeHelper.shouldRender(BoundingBoxType.AFKSphere);
}
@Override
- public Iterable<BoundingBoxSpawningSphere> get(int dimensionId) {
+ public Iterable<BoundingBoxSpawningSphere> get(DimensionId dimensionId) {
long gameTime = minecraft.world.getGameTime();
if (lastBoundingBox == null || (!((Long) gameTime).equals(lastGameTime) && gameTime % 2L == 0L)) {
lastGameTime = gameTime;
import com.irtimaled.bbor.client.config.BoundingBoxTypeHelper;
import com.irtimaled.bbor.client.models.BoundingBoxWorldSpawn;
import com.irtimaled.bbor.common.BoundingBoxType;
-import com.irtimaled.bbor.common.Dimensions;
import com.irtimaled.bbor.common.models.Coords;
+import com.irtimaled.bbor.common.models.DimensionId;
import java.util.HashSet;
import java.util.Set;
}
@Override
- public boolean canProvide(int dimensionId) {
- return dimensionId == Dimensions.OVERWORLD;
+ public boolean canProvide(DimensionId dimensionId) {
+ return dimensionId == DimensionId.OVERWORLD;
}
@Override
- public Iterable<BoundingBoxWorldSpawn> get(int dimensionId) {
+ public Iterable<BoundingBoxWorldSpawn> get(DimensionId dimensionId) {
Set<BoundingBoxWorldSpawn> boundingBoxes = new HashSet<>();
if (BoundingBoxTypeHelper.shouldRender(BoundingBoxType.WorldSpawn)) {
if (worldSpawn != null) boundingBoxes.add(worldSpawn);
import com.irtimaled.bbor.common.messages.InitializeClient;
import com.irtimaled.bbor.common.messages.PayloadBuilder;
import com.irtimaled.bbor.common.models.AbstractBoundingBox;
+import com.irtimaled.bbor.common.models.DimensionId;
import com.irtimaled.bbor.common.models.ServerPlayer;
import java.util.HashMap;
public class CommonProxy {
private final Map<Integer, ServerPlayer> players = new ConcurrentHashMap<>();
private final Map<Integer, Set<AbstractBoundingBox>> playerBoundingBoxesCache = new HashMap<>();
- private final Map<Integer, StructureProcessor> structureProcessors = new HashMap<>();
- private final Map<Integer, BoundingBoxCache> dimensionCache = new ConcurrentHashMap<>();
+ private final Map<DimensionId, StructureProcessor> structureProcessors = new HashMap<>();
+ private final Map<DimensionId, BoundingBoxCache> dimensionCache = new ConcurrentHashMap<>();
private Long seed = null;
private Integer spawnX = null;
private Integer spawnZ = null;
}
private void worldLoaded(WorldLoaded event) {
- int dimensionId = event.getDimensionId();
+ DimensionId dimensionId = event.getDimensionId();
long seed = event.getSeed();
- if (dimensionId == Dimensions.OVERWORLD) {
+ if (dimensionId == DimensionId.OVERWORLD) {
setSeed(seed);
setWorldSpawn(event.getSpawnX(), event.getSpawnZ());
}
}
private void structuresLoaded(StructuresLoaded event) {
- int dimensionId = event.getDimensionId();
+ DimensionId dimensionId = event.getDimensionId();
StructureProcessor structureProcessor = getStructureProcessor(dimensionId);
structureProcessor.process(event.getStructures());
}
- private StructureProcessor getStructureProcessor(int dimensionId) {
+ private StructureProcessor getStructureProcessor(DimensionId dimensionId) {
StructureProcessor structureProcessor = structureProcessors.get(dimensionId);
if (structureProcessor == null) {
structureProcessor = new StructureProcessor(getOrCreateCache(dimensionId));
}
private void sendToPlayer(int playerId, ServerPlayer player) {
- for (Map.Entry<Integer, BoundingBoxCache> entry : dimensionCache.entrySet()) {
- int dimensionId = entry.getKey();
+ for (Map.Entry<DimensionId, BoundingBoxCache> entry : dimensionCache.entrySet()) {
+ DimensionId dimensionId = entry.getKey();
BoundingBoxCache boundingBoxCache = entry.getValue();
if (boundingBoxCache == null) return;
}
}
- protected BoundingBoxCache getCache(int dimensionId) {
+ protected BoundingBoxCache getCache(DimensionId dimensionId) {
return dimensionCache.get(dimensionId);
}
- protected BoundingBoxCache getOrCreateCache(int dimensionId) {
+ protected BoundingBoxCache getOrCreateCache(DimensionId dimensionId) {
return dimensionCache.computeIfAbsent(dimensionId, dt -> new BoundingBoxCache());
}
+++ /dev/null
-package com.irtimaled.bbor.common;
-
-public class Dimensions {
- public static final int OVERWORLD = 0;
-}
package com.irtimaled.bbor.common.events;
+import com.irtimaled.bbor.common.models.DimensionId;
import net.minecraft.world.gen.feature.structure.StructureStart;
import java.util.Map;
public class StructuresLoaded {
private final Map<String, StructureStart> structures;
- private final int dimensionId;
+ private final DimensionId dimensionId;
- public StructuresLoaded(Map<String, StructureStart> structures, int dimensionId) {
+ public StructuresLoaded(Map<String, StructureStart> structures, DimensionId dimensionId) {
this.structures = structures;
this.dimensionId = dimensionId;
}
return structures;
}
- public int getDimensionId() {
+ public DimensionId getDimensionId() {
return dimensionId;
}
}
package com.irtimaled.bbor.common.events;
+import com.irtimaled.bbor.common.models.DimensionId;
import net.minecraft.world.ServerWorld;
import net.minecraft.world.storage.WorldInfo;
public class WorldLoaded {
- private final int dimensionId;
+ private final DimensionId dimensionId;
private final long seed;
private final int spawnX;
private final int spawnZ;
public WorldLoaded(ServerWorld world) {
WorldInfo info = world.getWorldInfo();
- this.dimensionId = world.getDimension().getType().getId();
+ this.dimensionId = DimensionId.from(world.getDimension().getType());
this.seed = info.getSeed();
this.spawnX = info.getSpawnX();
this.spawnZ = info.getSpawnZ();
}
- public int getDimensionId() {
+ public DimensionId getDimensionId() {
return dimensionId;
}
import com.irtimaled.bbor.common.EventBus;
import com.irtimaled.bbor.common.events.*;
+import com.irtimaled.bbor.common.models.DimensionId;
import com.irtimaled.bbor.common.models.ServerPlayer;
import net.minecraft.entity.player.ServerPlayerEntity;
import net.minecraft.network.NetworkManager;
public class CommonInterop {
public static void chunkLoaded(Chunk chunk) {
- int dimensionId = chunk.getWorld().getDimension().getType().getId();
+ DimensionId dimensionId = DimensionId.from(chunk.getWorld().getDimension().getType());
Map<String, StructureStart> structures = chunk.getStructureStarts();
if (structures.size() > 0) EventBus.publish(new StructuresLoaded(structures, dimensionId));
}
import com.irtimaled.bbor.client.events.AddBoundingBoxReceived;
import com.irtimaled.bbor.common.models.AbstractBoundingBox;
+import com.irtimaled.bbor.common.models.DimensionId;
import java.util.HashSet;
import java.util.Set;
public class AddBoundingBox {
- public static final String NAME = "bbor:add_bounding_box";
+ public static final String NAME = "bbor:add_bounding_box_v2";
- public static PayloadBuilder getPayload(int dimensionId, AbstractBoundingBox key, Set<AbstractBoundingBox> boundingBoxes) {
+ public static PayloadBuilder getPayload(DimensionId dimensionId, AbstractBoundingBox key, Set<AbstractBoundingBox> boundingBoxes) {
if (!BoundingBoxSerializer.canSerialize(key)) return null;
PayloadBuilder builder = PayloadBuilder.clientBound(NAME)
- .writeVarInt(dimensionId);
+ .writeDimensionId(dimensionId);
BoundingBoxSerializer.serialize(key, builder);
if (boundingBoxes != null && boundingBoxes.size() > 1) {
for (AbstractBoundingBox boundingBox : boundingBoxes) {
}
public static AddBoundingBoxReceived getEvent(PayloadReader reader) {
- int dimensionId = reader.readVarInt();
+ DimensionId dimensionId = reader.readDimensionId();
AbstractBoundingBox key = BoundingBoxDeserializer.deserialize(reader);
if (key == null) return null;
package com.irtimaled.bbor.common.messages;
import com.irtimaled.bbor.common.models.Coords;
+import com.irtimaled.bbor.common.models.DimensionId;
import io.netty.buffer.Unpooled;
import net.minecraft.network.IPacket;
import net.minecraft.network.PacketBuffer;
.writeVarInt(coords.getY())
.writeVarInt(coords.getZ());
}
+
+ public PayloadBuilder writeDimensionId(DimensionId dimensionId) {
+ buffer.writeResourceLocation(dimensionId.getValue());
+ packet = null;
+ return this;
+ }
}
package com.irtimaled.bbor.common.messages;
import com.irtimaled.bbor.common.models.Coords;
+import com.irtimaled.bbor.common.models.DimensionId;
import net.minecraft.network.PacketBuffer;
+import net.minecraft.util.ResourceLocation;
public class PayloadReader {
private final PacketBuffer buffer;
int z = readVarInt();
return new Coords(x, y, z);
}
+
+ DimensionId readDimensionId() {
+ return DimensionId.from(buffer.readResourceLocation());
+ }
}
--- /dev/null
+package com.irtimaled.bbor.common.models;
+
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.world.dimension.DimensionType;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class DimensionId {
+ private static final Map<ResourceLocation, DimensionId> dimensionIdMap = new HashMap<>();
+
+ public static DimensionId from(DimensionType dimensionType) {
+ return from(DimensionType.getKey(dimensionType));
+ }
+
+ public static DimensionId from(ResourceLocation value) {
+ return dimensionIdMap.computeIfAbsent(value, DimensionId::new);
+ }
+
+ public static DimensionId OVERWORLD = DimensionId.from(DimensionType.OVERWORLD);
+
+ private final ResourceLocation value;
+
+ public DimensionId(ResourceLocation value) {
+ this.value = value;
+ }
+
+ public ResourceLocation getValue() {
+ return value;
+ }
+
+ public DimensionType getDimensionType() {
+ return DimensionType.byName(value);
+ }
+
+ @Override
+ public String toString() {
+ return value.toString();
+ }
+}
import java.util.function.Consumer;
public class ServerPlayer {
- private final int dimensionId;
+ private final DimensionId dimensionId;
private final Consumer<IPacket<?>> packetConsumer;
public ServerPlayer(ServerPlayerEntity player) {
- this.dimensionId = player.dimension.getId();
+ this.dimensionId = DimensionId.from(player.dimension);
this.packetConsumer = player.connection::sendPacket;
}
- public int getDimensionId() {
+ public DimensionId getDimensionId() {
return dimensionId;
}