public class ClientRenderer {
private static final int CHUNK_SIZE = 16;
- private static final Map<Class<? extends BoundingBox>, Renderer> boundingBoxRendererMap = new HashMap<>();
+ private static final Map<Class<? extends AbstractBoundingBox>, AbstractRenderer> boundingBoxRendererMap = new HashMap<>();
private final GetCache getCache;
private long seed;
- private Set<BoundingBox> spawnChunkBoundingBoxes = new HashSet<>();
+ private Set<AbstractBoundingBox> spawnChunkBoundingBoxes = new HashSet<>();
ClientRenderer(GetCache getCache) {
this.getCache = getCache;
boundingBoxRendererMap.put(BoundingBoxMobSpawner.class, new MobSpawnerRenderer());
}
- private boolean isWithinRenderDistance(BoundingBox boundingBox) {
+ private boolean isWithinRenderDistance(AbstractBoundingBox boundingBox) {
Coords minCoords = boundingBox.getMinCoords();
Coords maxCoords = boundingBox.getMaxCoords();
int renderDistanceBlocks = getRenderDistanceChunks() * CHUNK_SIZE;
}
public void render(int dimensionId, Boolean outerBoxesOnly) {
- Map<BoundingBox, Set<BoundingBox>> boundingBoxes = getBoundingBoxes(dimensionId);
+ Map<AbstractBoundingBox, Set<AbstractBoundingBox>> boundingBoxes = getBoundingBoxes(dimensionId);
GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
GL11.glLineWidth(2.0f);
if (ConfigManager.alwaysVisible.get()) {
GL11.glClear(GL11.GL_DEPTH_BUFFER_BIT);
}
- for (Map.Entry<BoundingBox, Set<BoundingBox>> entry : boundingBoxes.entrySet()) {
- BoundingBox key = entry.getKey();
+ for (Map.Entry<AbstractBoundingBox, Set<AbstractBoundingBox>> entry : boundingBoxes.entrySet()) {
+ AbstractBoundingBox key = entry.getKey();
if (!key.shouldRender()) continue;
- Renderer renderer = boundingBoxRendererMap.get(key.getClass());
+ AbstractRenderer renderer = boundingBoxRendererMap.get(key.getClass());
if (renderer == null) continue;
if (!outerBoxesOnly) {
- Set<BoundingBox> children = entry.getValue();
+ Set<AbstractBoundingBox> children = entry.getValue();
if (children != null) {
children.forEach(renderer::render);
continue;
GL11.glEnable(GL11.GL_TEXTURE_2D);
}
- private Map<BoundingBox, Set<BoundingBox>> getBoundingBoxes(int dimensionId) {
- Map<BoundingBox, Set<BoundingBox>> boundingBoxes = new HashMap<>();
+ private Map<AbstractBoundingBox, Set<AbstractBoundingBox>> getBoundingBoxes(int dimensionId) {
+ Map<AbstractBoundingBox, Set<AbstractBoundingBox>> boundingBoxes = new HashMap<>();
if (dimensionId == Dimensions.OVERWORLD) {
if (BoundingBoxType.SlimeChunks.shouldRender()) {
addSlimeChunks(boundingBoxes);
}
- for (BoundingBox boundingBox : spawnChunkBoundingBoxes) {
+ for (AbstractBoundingBox boundingBox : spawnChunkBoundingBoxes) {
if (boundingBox.shouldRender() && isWithinRenderDistance(boundingBox)) {
boundingBoxes.put(boundingBox, null);
}
BoundingBoxCache cache = getCache.apply(dimensionId);
if (cache != null) {
- for (Map.Entry<BoundingBox, Set<BoundingBox>> entry : cache.getBoundingBoxes().entrySet()) {
- BoundingBox key = entry.getKey();
+ for (Map.Entry<AbstractBoundingBox, Set<AbstractBoundingBox>> entry : cache.getBoundingBoxes().entrySet()) {
+ AbstractBoundingBox key = entry.getKey();
if (key.shouldRender() && isWithinRenderDistance(key)) {
boundingBoxes.put(key, entry.getValue());
}
return boundingBoxes;
}
- private void addSlimeChunks(Map<BoundingBox, Set<BoundingBox>> boundingBoxes) {
+ private void addSlimeChunks(Map<AbstractBoundingBox, Set<AbstractBoundingBox>> boundingBoxes) {
int renderDistanceChunks = getRenderDistanceChunks();
int playerChunkX = MathHelper.floor(PlayerCoords.getX() / 16.0D);
int playerChunkZ = MathHelper.floor(PlayerCoords.getZ() / 16.0D);
spawnChunkBoundingBoxes = getSpawnChunkBoundingBoxes(spawnX, spawnZ);
}
- private Set<BoundingBox> getSpawnChunkBoundingBoxes(int spawnX, int spawnZ) {
- Set<BoundingBox> boundingBoxes = new HashSet<>();
+ private Set<AbstractBoundingBox> getSpawnChunkBoundingBoxes(int spawnX, int spawnZ) {
+ Set<AbstractBoundingBox> boundingBoxes = new HashSet<>();
boundingBoxes.add(getWorldSpawnBoundingBox(spawnX, spawnZ));
boundingBoxes.add(buildSpawnChunksBoundingBox(spawnX, spawnZ, 12, BoundingBoxType.SpawnChunks));
boundingBoxes.add(buildSpawnChunksBoundingBox(spawnX, spawnZ, 16, BoundingBoxType.LazySpawnChunks));
return boundingBoxes;
}
- private BoundingBox getWorldSpawnBoundingBox(int spawnX, int spawnZ) {
+ private AbstractBoundingBox getWorldSpawnBoundingBox(int spawnX, int spawnZ) {
Coords minCoords = new Coords(spawnX - 10, 0, spawnZ - 10);
Coords maxCoords = new Coords(spawnX + 10, 0, spawnZ + 10);
return BoundingBoxWorldSpawn.from(minCoords, maxCoords, BoundingBoxType.WorldSpawn);
}
- private BoundingBox buildSpawnChunksBoundingBox(int spawnX, int spawnZ, int size, BoundingBoxType type) {
+ private AbstractBoundingBox buildSpawnChunksBoundingBox(int spawnX, int spawnZ, int size, BoundingBoxType type) {
double midOffset = CHUNK_SIZE * (size / 2.0);
double midX = Math.round((float) (spawnX / (double) CHUNK_SIZE)) * (double) CHUNK_SIZE;
double midZ = Math.round((float) (spawnZ / (double) CHUNK_SIZE)) * (double) CHUNK_SIZE;
import com.irtimaled.bbor.common.BoundingBoxCache;
import com.irtimaled.bbor.common.BoundingBoxType;
import com.irtimaled.bbor.common.Dimensions;
-import com.irtimaled.bbor.common.models.BoundingBox;
+import com.irtimaled.bbor.common.models.AbstractBoundingBox;
import com.irtimaled.bbor.common.models.BoundingBoxStructure;
import com.irtimaled.bbor.common.models.BoundingBoxVillage;
import com.irtimaled.bbor.common.models.Coords;
int loadedStructureCount = 0;
for (Object key : features.getKeySet()) {
NBTTagCompound feature = features.getCompoundTag((String) key);
- BoundingBox structure = buildStructure(feature, type);
- Set<BoundingBox> boundingBoxes = new HashSet<>();
+ AbstractBoundingBox structure = buildStructure(feature, type);
+ Set<AbstractBoundingBox> boundingBoxes = new HashSet<>();
NBTTagCompound[] children = getChildCompoundTags(feature, "Children");
for (NBTTagCompound child : children) {
if (id.equals(child.getString("id")) || id.equals("*"))
int radius = village.getInteger("Radius");
int population = village.getInteger("PopSize");
Set<Coords> doors = getDoors(village);
- BoundingBox boundingBox = BoundingBoxVillage.from(center, radius, village.hashCode(), population, doors);
+ AbstractBoundingBox boundingBox = BoundingBoxVillage.from(center, radius, village.hashCode(), population, doors);
cache.addBoundingBox(boundingBox);
}
package com.irtimaled.bbor.client.events;
-import com.irtimaled.bbor.common.models.BoundingBox;
+import com.irtimaled.bbor.common.models.AbstractBoundingBox;
import java.util.Set;
public class AddBoundingBoxReceived {
private final int dimensionId;
- private final BoundingBox key;
- private final Set<BoundingBox> boundingBoxes;
+ private final AbstractBoundingBox key;
+ private final Set<AbstractBoundingBox> boundingBoxes;
- public AddBoundingBoxReceived(int dimensionId, BoundingBox key, Set<BoundingBox> boundingBoxes) {
+ public AddBoundingBoxReceived(int dimensionId, AbstractBoundingBox key, Set<AbstractBoundingBox> boundingBoxes) {
this.dimensionId = dimensionId;
this.key = key;
this.boundingBoxes = boundingBoxes;
return dimensionId;
}
- public BoundingBox getKey() {
+ public AbstractBoundingBox getKey() {
return key;
}
- public Set<BoundingBox> getBoundingBoxes() {
+ public Set<AbstractBoundingBox> getBoundingBoxes() {
return boundingBoxes;
}
}
package com.irtimaled.bbor.client.events;
-import com.irtimaled.bbor.common.models.BoundingBox;
+import com.irtimaled.bbor.common.models.AbstractBoundingBox;
public class RemoveBoundingBoxReceived {
private final int dimensionId;
- private final BoundingBox key;
+ private final AbstractBoundingBox key;
- public RemoveBoundingBoxReceived(int dimensionId, BoundingBox key) {
+ public RemoveBoundingBoxReceived(int dimensionId, AbstractBoundingBox key) {
this.dimensionId = dimensionId;
this.key = key;
}
return dimensionId;
}
- public BoundingBox getKey() {
+ public AbstractBoundingBox getKey() {
return key;
}
}
--- /dev/null
+package com.irtimaled.bbor.client.renderers;
+
+import com.irtimaled.bbor.common.models.AbstractBoundingBox;
+import com.irtimaled.bbor.config.ConfigManager;
+import net.minecraft.client.renderer.BufferBuilder;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
+import org.lwjgl.opengl.GL11;
+
+import java.awt.*;
+
+public abstract class AbstractRenderer<T extends AbstractBoundingBox> {
+ public abstract void render(T boundingBox);
+
+ void renderBoundingBox(T boundingBox) {
+ OffsetBox bb = new OffsetBox(boundingBox.getMinCoords(), boundingBox.getMaxCoords());
+ renderCuboid(bb, boundingBox.getColor(), fill());
+ }
+
+ boolean fill() {
+ return ConfigManager.fill.get();
+ }
+
+ void renderLine(OffsetPoint point1, OffsetPoint point2, Color color) {
+ int colorR = color.getRed();
+ int colorG = color.getGreen();
+ int colorB = color.getBlue();
+
+ Tessellator tessellator = Tessellator.getInstance();
+ BufferBuilder worldRenderer = tessellator.getBuffer();
+ worldRenderer.begin(GL11.GL_LINES, worldRenderer.getVertexFormat());
+ worldRenderer.pos(point1.getX(), point1.getY(), point1.getZ()).color(colorR, colorG, colorB, 255).endVertex();
+ worldRenderer.pos(point2.getX(), point2.getY(), point2.getZ()).color(colorR, colorG, colorB, 255).endVertex();
+ tessellator.draw();
+ }
+
+ void renderCuboid(OffsetBox bb, Color color, boolean fill) {
+ bb = bb.nudge();
+ if (fill) {
+ renderFilledCuboid(bb, color);
+ }
+ renderUnfilledCuboid(bb, color);
+ }
+
+ private void renderFilledCuboid(OffsetBox bb, Color color) {
+ GL11.glPolygonMode(GL11.GL_FRONT_AND_BACK, GL11.GL_FILL);
+ GL11.glEnable(GL11.GL_BLEND);
+ renderCuboid(bb, 30, color);
+ GL11.glDisable(GL11.GL_BLEND);
+ GL11.glEnable(GL11.GL_POLYGON_OFFSET_LINE);
+ GL11.glPolygonOffset(-1.f, -1.f);
+ }
+
+ private void renderUnfilledCuboid(OffsetBox bb, Color color) {
+ GL11.glPolygonMode(GL11.GL_FRONT_AND_BACK, GL11.GL_LINE);
+ renderCuboid(bb, 255, color);
+ }
+
+ private void renderCuboid(OffsetBox bb, int alphaChannel, Color color) {
+ int colorR = color.getRed();
+ int colorG = color.getGreen();
+ int colorB = color.getBlue();
+
+ OffsetPoint min = bb.getMin();
+ OffsetPoint max = bb.getMax();
+
+ Tessellator tessellator = Tessellator.getInstance();
+ BufferBuilder worldRenderer = tessellator.getBuffer();
+
+ worldRenderer.begin(GL11.GL_QUADS, DefaultVertexFormats.POSITION_COLOR);
+ worldRenderer.pos(min.getX(), min.getY(), min.getZ())
+ .color(colorR, colorG, colorB, alphaChannel)
+ .endVertex();
+ worldRenderer.pos(max.getX(), min.getY(), min.getZ())
+ .color(colorR, colorG, colorB, alphaChannel)
+ .endVertex();
+ worldRenderer.pos(max.getX(), min.getY(), max.getZ())
+ .color(colorR, colorG, colorB, alphaChannel)
+ .endVertex();
+ worldRenderer.pos(min.getX(), min.getY(), max.getZ())
+ .color(colorR, colorG, colorB, alphaChannel)
+ .endVertex();
+
+ if (min.getY() != max.getY()) {
+ worldRenderer.pos(min.getX(), max.getY(), min.getZ())
+ .color(colorR, colorG, colorB, alphaChannel)
+ .endVertex();
+ worldRenderer.pos(max.getX(), max.getY(), min.getZ())
+ .color(colorR, colorG, colorB, alphaChannel)
+ .endVertex();
+ worldRenderer.pos(max.getX(), max.getY(), max.getZ())
+ .color(colorR, colorG, colorB, alphaChannel)
+ .endVertex();
+ worldRenderer.pos(min.getX(), max.getY(), max.getZ())
+ .color(colorR, colorG, colorB, alphaChannel)
+ .endVertex();
+
+ worldRenderer.pos(min.getX(), min.getY(), max.getZ())
+ .color(colorR, colorG, colorB, alphaChannel)
+ .endVertex();
+ worldRenderer.pos(min.getX(), max.getY(), max.getZ())
+ .color(colorR, colorG, colorB, alphaChannel)
+ .endVertex();
+ worldRenderer.pos(max.getX(), max.getY(), max.getZ())
+ .color(colorR, colorG, colorB, alphaChannel)
+ .endVertex();
+ worldRenderer.pos(max.getX(), min.getY(), max.getZ())
+ .color(colorR, colorG, colorB, alphaChannel)
+ .endVertex();
+
+ worldRenderer.pos(min.getX(), min.getY(), min.getZ())
+ .color(colorR, colorG, colorB, alphaChannel)
+ .endVertex();
+ worldRenderer.pos(min.getX(), max.getY(), min.getZ())
+ .color(colorR, colorG, colorB, alphaChannel)
+ .endVertex();
+ worldRenderer.pos(max.getX(), max.getY(), min.getZ())
+ .color(colorR, colorG, colorB, alphaChannel)
+ .endVertex();
+ worldRenderer.pos(max.getX(), min.getY(), min.getZ())
+ .color(colorR, colorG, colorB, alphaChannel)
+ .endVertex();
+
+ worldRenderer.pos(min.getX(), min.getY(), min.getZ())
+ .color(colorR, colorG, colorB, alphaChannel)
+ .endVertex();
+ worldRenderer.pos(min.getX(), min.getY(), max.getZ())
+ .color(colorR, colorG, colorB, alphaChannel)
+ .endVertex();
+ worldRenderer.pos(min.getX(), max.getY(), max.getZ())
+ .color(colorR, colorG, colorB, alphaChannel)
+ .endVertex();
+ worldRenderer.pos(min.getX(), max.getY(), min.getZ())
+ .color(colorR, colorG, colorB, alphaChannel)
+ .endVertex();
+
+ worldRenderer.pos(max.getX(), min.getY(), min.getZ())
+ .color(colorR, colorG, colorB, alphaChannel)
+ .endVertex();
+ worldRenderer.pos(max.getX(), min.getY(), max.getZ())
+ .color(colorR, colorG, colorB, alphaChannel)
+ .endVertex();
+ worldRenderer.pos(max.getX(), max.getY(), max.getZ())
+ .color(colorR, colorG, colorB, alphaChannel)
+ .endVertex();
+ worldRenderer.pos(max.getX(), max.getY(), min.getZ())
+ .color(colorR, colorG, colorB, alphaChannel)
+ .endVertex();
+ }
+ tessellator.draw();
+ }
+}
import java.awt.*;
-public class MobSpawnerRenderer extends Renderer<BoundingBoxMobSpawner> {
+public class MobSpawnerRenderer extends AbstractRenderer<BoundingBoxMobSpawner> {
@Override
public void render(BoundingBoxMobSpawner boundingBox) {
Coords coords = boundingBox.getCoords();
+++ /dev/null
-package com.irtimaled.bbor.client.renderers;
-
-import com.irtimaled.bbor.common.models.BoundingBox;
-import com.irtimaled.bbor.config.ConfigManager;
-import net.minecraft.client.renderer.BufferBuilder;
-import net.minecraft.client.renderer.Tessellator;
-import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
-import org.lwjgl.opengl.GL11;
-
-import java.awt.*;
-
-public abstract class Renderer<T extends BoundingBox> {
- public abstract void render(T boundingBox);
-
- void renderBoundingBox(T boundingBox) {
- OffsetBox bb = new OffsetBox(boundingBox.getMinCoords(), boundingBox.getMaxCoords());
- renderCuboid(bb, boundingBox.getColor(), fill());
- }
-
- boolean fill() {
- return ConfigManager.fill.get();
- }
-
- void renderLine(OffsetPoint point1, OffsetPoint point2, Color color) {
- int colorR = color.getRed();
- int colorG = color.getGreen();
- int colorB = color.getBlue();
-
- Tessellator tessellator = Tessellator.getInstance();
- BufferBuilder worldRenderer = tessellator.getBuffer();
- worldRenderer.begin(GL11.GL_LINES, worldRenderer.getVertexFormat());
- worldRenderer.pos(point1.getX(), point1.getY(), point1.getZ()).color(colorR, colorG, colorB, 255).endVertex();
- worldRenderer.pos(point2.getX(), point2.getY(), point2.getZ()).color(colorR, colorG, colorB, 255).endVertex();
- tessellator.draw();
- }
-
- void renderCuboid(OffsetBox bb, Color color, boolean fill) {
- bb = bb.nudge();
- if (fill) {
- renderFilledCuboid(bb, color);
- }
- renderUnfilledCuboid(bb, color);
- }
-
- private void renderFilledCuboid(OffsetBox bb, Color color) {
- GL11.glPolygonMode(GL11.GL_FRONT_AND_BACK, GL11.GL_FILL);
- GL11.glEnable(GL11.GL_BLEND);
- renderCuboid(bb, 30, color);
- GL11.glDisable(GL11.GL_BLEND);
- GL11.glEnable(GL11.GL_POLYGON_OFFSET_LINE);
- GL11.glPolygonOffset(-1.f, -1.f);
- }
-
- private void renderUnfilledCuboid(OffsetBox bb, Color color) {
- GL11.glPolygonMode(GL11.GL_FRONT_AND_BACK, GL11.GL_LINE);
- renderCuboid(bb, 255, color);
- }
-
- private void renderCuboid(OffsetBox bb, int alphaChannel, Color color) {
- int colorR = color.getRed();
- int colorG = color.getGreen();
- int colorB = color.getBlue();
-
- OffsetPoint min = bb.getMin();
- OffsetPoint max = bb.getMax();
-
- Tessellator tessellator = Tessellator.getInstance();
- BufferBuilder worldRenderer = tessellator.getBuffer();
-
- worldRenderer.begin(GL11.GL_QUADS, DefaultVertexFormats.POSITION_COLOR);
- worldRenderer.pos(min.getX(), min.getY(), min.getZ())
- .color(colorR, colorG, colorB, alphaChannel)
- .endVertex();
- worldRenderer.pos(max.getX(), min.getY(), min.getZ())
- .color(colorR, colorG, colorB, alphaChannel)
- .endVertex();
- worldRenderer.pos(max.getX(), min.getY(), max.getZ())
- .color(colorR, colorG, colorB, alphaChannel)
- .endVertex();
- worldRenderer.pos(min.getX(), min.getY(), max.getZ())
- .color(colorR, colorG, colorB, alphaChannel)
- .endVertex();
-
- if (min.getY() != max.getY()) {
- worldRenderer.pos(min.getX(), max.getY(), min.getZ())
- .color(colorR, colorG, colorB, alphaChannel)
- .endVertex();
- worldRenderer.pos(max.getX(), max.getY(), min.getZ())
- .color(colorR, colorG, colorB, alphaChannel)
- .endVertex();
- worldRenderer.pos(max.getX(), max.getY(), max.getZ())
- .color(colorR, colorG, colorB, alphaChannel)
- .endVertex();
- worldRenderer.pos(min.getX(), max.getY(), max.getZ())
- .color(colorR, colorG, colorB, alphaChannel)
- .endVertex();
-
- worldRenderer.pos(min.getX(), min.getY(), max.getZ())
- .color(colorR, colorG, colorB, alphaChannel)
- .endVertex();
- worldRenderer.pos(min.getX(), max.getY(), max.getZ())
- .color(colorR, colorG, colorB, alphaChannel)
- .endVertex();
- worldRenderer.pos(max.getX(), max.getY(), max.getZ())
- .color(colorR, colorG, colorB, alphaChannel)
- .endVertex();
- worldRenderer.pos(max.getX(), min.getY(), max.getZ())
- .color(colorR, colorG, colorB, alphaChannel)
- .endVertex();
-
- worldRenderer.pos(min.getX(), min.getY(), min.getZ())
- .color(colorR, colorG, colorB, alphaChannel)
- .endVertex();
- worldRenderer.pos(min.getX(), max.getY(), min.getZ())
- .color(colorR, colorG, colorB, alphaChannel)
- .endVertex();
- worldRenderer.pos(max.getX(), max.getY(), min.getZ())
- .color(colorR, colorG, colorB, alphaChannel)
- .endVertex();
- worldRenderer.pos(max.getX(), min.getY(), min.getZ())
- .color(colorR, colorG, colorB, alphaChannel)
- .endVertex();
-
- worldRenderer.pos(min.getX(), min.getY(), min.getZ())
- .color(colorR, colorG, colorB, alphaChannel)
- .endVertex();
- worldRenderer.pos(min.getX(), min.getY(), max.getZ())
- .color(colorR, colorG, colorB, alphaChannel)
- .endVertex();
- worldRenderer.pos(min.getX(), max.getY(), max.getZ())
- .color(colorR, colorG, colorB, alphaChannel)
- .endVertex();
- worldRenderer.pos(min.getX(), max.getY(), min.getZ())
- .color(colorR, colorG, colorB, alphaChannel)
- .endVertex();
-
- worldRenderer.pos(max.getX(), min.getY(), min.getZ())
- .color(colorR, colorG, colorB, alphaChannel)
- .endVertex();
- worldRenderer.pos(max.getX(), min.getY(), max.getZ())
- .color(colorR, colorG, colorB, alphaChannel)
- .endVertex();
- worldRenderer.pos(max.getX(), max.getY(), max.getZ())
- .color(colorR, colorG, colorB, alphaChannel)
- .endVertex();
- worldRenderer.pos(max.getX(), max.getY(), min.getZ())
- .color(colorR, colorG, colorB, alphaChannel)
- .endVertex();
- }
- tessellator.draw();
- }
-}
import java.awt.*;
-public class SlimeChunkRenderer extends Renderer<BoundingBoxSlimeChunk> {
+public class SlimeChunkRenderer extends AbstractRenderer<BoundingBoxSlimeChunk> {
@Override
public void render(BoundingBoxSlimeChunk boundingBox) {
OffsetBox bb = new OffsetBox(boundingBox.getMinCoords(), boundingBox.getMaxCoords());
import com.irtimaled.bbor.common.models.BoundingBoxStructure;
-public class StructureRenderer extends Renderer<BoundingBoxStructure> {
+public class StructureRenderer extends AbstractRenderer<BoundingBoxStructure> {
@Override
public void render(BoundingBoxStructure boundingBox) {
renderBoundingBox(boundingBox);
import java.util.HashSet;
import java.util.Set;
-public class VillageRenderer extends Renderer<BoundingBoxVillage> {
+public class VillageRenderer extends AbstractRenderer<BoundingBoxVillage> {
@Override
public void render(BoundingBoxVillage boundingBox) {
if (ConfigManager.renderVillageAsSphere.get()) {
import java.awt.*;
-public class WorldSpawnRenderer extends Renderer<BoundingBoxWorldSpawn> {
+public class WorldSpawnRenderer extends AbstractRenderer<BoundingBoxWorldSpawn> {
@Override
public void render(BoundingBoxWorldSpawn boundingBox) {
Color color = boundingBox.getColor();
package com.irtimaled.bbor.common;
-import com.irtimaled.bbor.common.models.BoundingBox;
+import com.irtimaled.bbor.common.models.AbstractBoundingBox;
import java.util.HashSet;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
public class BoundingBoxCache {
- private Map<BoundingBox, Set<BoundingBox>> cache = new ConcurrentHashMap<>();
+ private Map<AbstractBoundingBox, Set<AbstractBoundingBox>> cache = new ConcurrentHashMap<>();
- public Map<BoundingBox, Set<BoundingBox>> getBoundingBoxes() {
+ public Map<AbstractBoundingBox, Set<AbstractBoundingBox>> getBoundingBoxes() {
return cache;
}
cache.clear();
}
- public boolean isCached(BoundingBox key) {
+ public boolean isCached(AbstractBoundingBox key) {
return cache.containsKey(key);
}
- public void addBoundingBoxes(BoundingBox key, Set<BoundingBox> boundingBoxes) {
+ public void addBoundingBoxes(AbstractBoundingBox key, Set<AbstractBoundingBox> boundingBoxes) {
cache.put(key, boundingBoxes);
}
- public void addBoundingBox(BoundingBox key) {
+ public void addBoundingBox(AbstractBoundingBox key) {
if(isCached(key)) return;
- Set<BoundingBox> boundingBoxes = new HashSet<>();
+ Set<AbstractBoundingBox> boundingBoxes = new HashSet<>();
boundingBoxes.add(key);
addBoundingBoxes(key, boundingBoxes);
}
- void removeBoundingBox(BoundingBox key) {
+ void removeBoundingBox(AbstractBoundingBox key) {
cache.remove(key);
}
}
package com.irtimaled.bbor.common;
import com.irtimaled.bbor.Logger;
-import com.irtimaled.bbor.common.chunkProcessors.ChunkProcessor;
+import com.irtimaled.bbor.common.chunkProcessors.AbstractChunkProcessor;
import com.irtimaled.bbor.common.chunkProcessors.EndChunkProcessor;
import com.irtimaled.bbor.common.chunkProcessors.NetherChunkProcessor;
import com.irtimaled.bbor.common.chunkProcessors.OverworldChunkProcessor;
public class CommonProxy {
private Set<ServerPlayer> players = new HashSet<>();
- private Map<ServerPlayer, Set<BoundingBox>> playerBoundingBoxesCache = new HashMap<>();
+ private Map<ServerPlayer, Set<AbstractBoundingBox>> playerBoundingBoxesCache = new HashMap<>();
private Map<Integer, VillageProcessor> villageProcessors = new HashMap<>();
- private Map<Integer, ChunkProcessor> chunkProcessors = new HashMap<>();
+ private Map<Integer, AbstractChunkProcessor> chunkProcessors = new HashMap<>();
private WorldData worldData = null;
private final Map<Integer, BoundingBoxCache> dimensionCache = new ConcurrentHashMap<>();
private void worldLoaded(WorldServer world) {
int dimensionId = world.dimension.getType().getId();
BoundingBoxCache boundingBoxCache = getOrCreateCache(dimensionId);
- ChunkProcessor chunkProcessor = null;
+ AbstractChunkProcessor chunkProcessor = null;
if (dimensionId == Dimensions.OVERWORLD) {
setWorldData(world.getSeed(), world.getWorldInfo().getSpawnX(), world.getWorldInfo().getSpawnZ());
chunkProcessor = new OverworldChunkProcessor(boundingBoxCache);
private void chunkLoaded(Chunk chunk) {
int dimensionId = chunk.getWorld().dimension.getType().getId();
- ChunkProcessor chunkProcessor = chunkProcessors.get(dimensionId);
+ AbstractChunkProcessor chunkProcessor = chunkProcessors.get(dimensionId);
if (chunkProcessor != null) {
chunkProcessor.process(chunk);
}
playerBoundingBoxesCache.remove(player);
}
- private void sendRemoveBoundingBox(int dimensionId, BoundingBox boundingBox) {
+ private void sendRemoveBoundingBox(int dimensionId, AbstractBoundingBox boundingBox) {
PayloadBuilder payload = RemoveBoundingBox.getPayload(dimensionId, boundingBox);
if (payload == null) return;
private void sendToPlayer(ServerPlayer player, BoundingBoxCache boundingBoxCache) {
if (boundingBoxCache == null) return;
- Map<BoundingBox, Set<BoundingBox>> cacheSubset = getBoundingBoxMap(player, boundingBoxCache.getBoundingBoxes());
+ Map<AbstractBoundingBox, Set<AbstractBoundingBox>> cacheSubset = getBoundingBoxMap(player, boundingBoxCache.getBoundingBoxes());
- for (BoundingBox key : cacheSubset.keySet()) {
- Set<BoundingBox> boundingBoxes = cacheSubset.get(key);
+ for (AbstractBoundingBox key : cacheSubset.keySet()) {
+ Set<AbstractBoundingBox> boundingBoxes = cacheSubset.get(key);
PayloadBuilder payload = AddBoundingBox.getPayload(player.getDimensionId(), key, boundingBoxes);
if (payload != null)
player.sendPacket(payload);
}
}
- private Map<BoundingBox, Set<BoundingBox>> getBoundingBoxMap(ServerPlayer player, Map<BoundingBox, Set<BoundingBox>> boundingBoxMap) {
- Map<BoundingBox, Set<BoundingBox>> cacheSubset = new HashMap<>();
- for (BoundingBox key : boundingBoxMap.keySet()) {
+ private Map<AbstractBoundingBox, Set<AbstractBoundingBox>> getBoundingBoxMap(ServerPlayer player, Map<AbstractBoundingBox, Set<AbstractBoundingBox>> boundingBoxMap) {
+ Map<AbstractBoundingBox, Set<AbstractBoundingBox>> cacheSubset = new HashMap<>();
+ for (AbstractBoundingBox key : boundingBoxMap.keySet()) {
if (!playerBoundingBoxesCache.containsKey(player) || !playerBoundingBoxesCache.get(player).contains(key)) {
cacheSubset.put(key, boundingBoxMap.get(key));
}
return cacheSubset;
}
- protected void addBoundingBox(int dimensionId, BoundingBox key, Set<BoundingBox> boundingBoxes) {
+ protected void addBoundingBox(int dimensionId, AbstractBoundingBox key, Set<AbstractBoundingBox> boundingBoxes) {
BoundingBoxCache cache = getCache(dimensionId);
if (cache == null) return;
cache.addBoundingBoxes(key, boundingBoxes);
}
- protected void removeBoundingBox(int dimensionId, BoundingBox key) {
+ protected void removeBoundingBox(int dimensionId, AbstractBoundingBox key) {
BoundingBoxCache cache = getCache(dimensionId);
if (cache == null) return;
}
private void mobSpawnerBroken(int dimensionId, Coords pos) {
- BoundingBox boundingBox = BoundingBoxMobSpawner.from(pos);
+ AbstractBoundingBox boundingBox = BoundingBoxMobSpawner.from(pos);
removeBoundingBox(dimensionId, boundingBox);
sendRemoveBoundingBox(dimensionId, boundingBox);
}
--- /dev/null
+package com.irtimaled.bbor.common.chunkProcessors;
+
+import com.irtimaled.bbor.common.BoundingBoxCache;
+import com.irtimaled.bbor.common.BoundingBoxType;
+import com.irtimaled.bbor.common.models.AbstractBoundingBox;
+import com.irtimaled.bbor.common.models.BoundingBoxMobSpawner;
+import com.irtimaled.bbor.common.models.BoundingBoxStructure;
+import com.irtimaled.bbor.common.models.Coords;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.tileentity.TileEntityMobSpawner;
+import net.minecraft.util.math.MutableBoundingBox;
+import net.minecraft.world.chunk.Chunk;
+import net.minecraft.world.gen.feature.structure.StructurePiece;
+import net.minecraft.world.gen.feature.structure.StructureStart;
+
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+public abstract class AbstractChunkProcessor {
+ Set<BoundingBoxType> supportedStructures = new HashSet<>();
+
+ AbstractChunkProcessor(BoundingBoxCache boundingBoxCache) {
+ this.boundingBoxCache = boundingBoxCache;
+ }
+
+ private final BoundingBoxCache boundingBoxCache;
+
+ private void addStructures(BoundingBoxType type, Map<String, StructureStart> structureMap) {
+ StructureStart structureStart = structureMap.get(type.getName());
+ if (structureStart == null) return;
+
+ MutableBoundingBox bb = structureStart.getBoundingBox();
+ if (bb == null) return;
+
+ AbstractBoundingBox boundingBox = buildStructure(bb, type);
+ if (boundingBoxCache.isCached(boundingBox)) return;
+
+ Set<AbstractBoundingBox> structureBoundingBoxes = new HashSet<>();
+ for (StructurePiece structureComponent : structureStart.getComponents()) {
+ structureBoundingBoxes.add(buildStructure(structureComponent.getBoundingBox(), type));
+ }
+ boundingBoxCache.addBoundingBoxes(boundingBox, structureBoundingBoxes);
+ }
+
+ private AbstractBoundingBox buildStructure(MutableBoundingBox bb, BoundingBoxType type) {
+ Coords min = new Coords(bb.minX, bb.minY, bb.minZ);
+ Coords max = new Coords(bb.maxX, bb.maxY, bb.maxZ);
+ return BoundingBoxStructure.from(min, max, type);
+ }
+
+ private void addMobSpawners(Chunk chunk) {
+ Collection<TileEntity> tileEntities = chunk.getTileEntityMap().values();
+ for (TileEntity tileEntity : tileEntities) {
+ if (tileEntity instanceof TileEntityMobSpawner) {
+ Coords coords = new Coords(tileEntity.getPos());
+ boundingBoxCache.addBoundingBox(BoundingBoxMobSpawner.from(coords));
+ }
+ }
+ }
+
+ public void process(Chunk chunk) {
+ Map<String, StructureStart> structureMap = chunk.getStructureStarts();
+ if (structureMap.size() > 0) {
+ supportedStructures.forEach(type -> addStructures(type, structureMap));
+ }
+ addMobSpawners(chunk);
+ }
+}
+++ /dev/null
-package com.irtimaled.bbor.common.chunkProcessors;
-
-import com.irtimaled.bbor.common.BoundingBoxCache;
-import com.irtimaled.bbor.common.BoundingBoxType;
-import com.irtimaled.bbor.common.models.BoundingBox;
-import com.irtimaled.bbor.common.models.BoundingBoxMobSpawner;
-import com.irtimaled.bbor.common.models.BoundingBoxStructure;
-import com.irtimaled.bbor.common.models.Coords;
-import net.minecraft.tileentity.TileEntity;
-import net.minecraft.tileentity.TileEntityMobSpawner;
-import net.minecraft.util.math.MutableBoundingBox;
-import net.minecraft.world.chunk.Chunk;
-import net.minecraft.world.gen.feature.structure.StructurePiece;
-import net.minecraft.world.gen.feature.structure.StructureStart;
-
-import java.util.Collection;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
-
-public class ChunkProcessor {
- Set<BoundingBoxType> supportedStructures = new HashSet<>();
-
- ChunkProcessor(BoundingBoxCache boundingBoxCache) {
- this.boundingBoxCache = boundingBoxCache;
- }
-
- private final BoundingBoxCache boundingBoxCache;
-
- private void addStructures(BoundingBoxType type, Map<String, StructureStart> structureMap) {
- StructureStart structureStart = structureMap.get(type.getName());
- if (structureStart == null) return;
-
- MutableBoundingBox bb = structureStart.getBoundingBox();
- if (bb == null) return;
-
- BoundingBox boundingBox = buildStructure(bb, type);
- if (boundingBoxCache.isCached(boundingBox)) return;
-
- Set<BoundingBox> structureBoundingBoxes = new HashSet<>();
- for (StructurePiece structureComponent : structureStart.getComponents()) {
- structureBoundingBoxes.add(buildStructure(structureComponent.getBoundingBox(), type));
- }
- boundingBoxCache.addBoundingBoxes(boundingBox, structureBoundingBoxes);
- }
-
- private BoundingBox buildStructure(MutableBoundingBox bb, BoundingBoxType type) {
- Coords min = new Coords(bb.minX, bb.minY, bb.minZ);
- Coords max = new Coords(bb.maxX, bb.maxY, bb.maxZ);
- return BoundingBoxStructure.from(min, max, type);
- }
-
- private void addMobSpawners(Chunk chunk) {
- Collection<TileEntity> tileEntities = chunk.getTileEntityMap().values();
- for (TileEntity tileEntity : tileEntities) {
- if (tileEntity instanceof TileEntityMobSpawner) {
- Coords coords = new Coords(tileEntity.getPos());
- boundingBoxCache.addBoundingBox(BoundingBoxMobSpawner.from(coords));
- }
- }
- }
-
- public void process(Chunk chunk) {
- Map<String, StructureStart> structureMap = chunk.getStructureStarts();
- if (structureMap.size() > 0) {
- supportedStructures.forEach(type -> addStructures(type, structureMap));
- }
- addMobSpawners(chunk);
- }
-}
import com.irtimaled.bbor.common.BoundingBoxCache;
import com.irtimaled.bbor.common.BoundingBoxType;
-public class EndChunkProcessor extends ChunkProcessor {
+public class EndChunkProcessor extends AbstractChunkProcessor {
public EndChunkProcessor(BoundingBoxCache boundingBoxCache) {
super(boundingBoxCache);
supportedStructures.add(BoundingBoxType.EndCity);
import com.irtimaled.bbor.common.BoundingBoxCache;
import com.irtimaled.bbor.common.BoundingBoxType;
-public class NetherChunkProcessor extends ChunkProcessor {
+public class NetherChunkProcessor extends AbstractChunkProcessor {
public NetherChunkProcessor(BoundingBoxCache boundingBoxCache) {
super(boundingBoxCache);
supportedStructures.add(BoundingBoxType.NetherFortress);
import com.irtimaled.bbor.common.BoundingBoxCache;
import com.irtimaled.bbor.common.BoundingBoxType;
-public class OverworldChunkProcessor extends ChunkProcessor {
+public class OverworldChunkProcessor extends AbstractChunkProcessor {
public OverworldChunkProcessor(BoundingBoxCache boundingBoxCache) {
super(boundingBoxCache);
supportedStructures.add(BoundingBoxType.DesertTemple);
package com.irtimaled.bbor.common.messages;
import com.irtimaled.bbor.client.events.AddBoundingBoxReceived;
-import com.irtimaled.bbor.common.models.BoundingBox;
+import com.irtimaled.bbor.common.models.AbstractBoundingBox;
import java.util.HashSet;
import java.util.Set;
public class AddBoundingBox {
public static final String NAME = "bbor:add_bounding_box";
- public static PayloadBuilder getPayload(int dimensionId, BoundingBox key, Set<BoundingBox> boundingBoxes) {
+ public static PayloadBuilder getPayload(int dimensionId, AbstractBoundingBox key, Set<AbstractBoundingBox> boundingBoxes) {
if (!BoundingBoxSerializer.canSerialize(key)) return null;
PayloadBuilder builder = PayloadBuilder.clientBound(NAME)
.writeVarInt(dimensionId);
BoundingBoxSerializer.serialize(key, builder);
if (boundingBoxes != null && boundingBoxes.size() > 1) {
- for (BoundingBox boundingBox : boundingBoxes) {
+ for (AbstractBoundingBox boundingBox : boundingBoxes) {
BoundingBoxSerializer.serialize(boundingBox, builder);
}
}
public static AddBoundingBoxReceived getEvent(PayloadReader reader) {
int dimensionId = reader.readVarInt();
- BoundingBox key = BoundingBoxDeserializer.deserialize(reader);
+ AbstractBoundingBox key = BoundingBoxDeserializer.deserialize(reader);
if (key == null) return null;
- Set<BoundingBox> boundingBoxes = new HashSet<>();
+ Set<AbstractBoundingBox> boundingBoxes = new HashSet<>();
while (reader.isReadable()) {
- BoundingBox boundingBox = BoundingBoxDeserializer.deserialize(reader);
+ AbstractBoundingBox boundingBox = BoundingBoxDeserializer.deserialize(reader);
boundingBoxes.add(boundingBox);
}
if (boundingBoxes.size() == 0)
import java.util.Set;
class BoundingBoxDeserializer {
- static BoundingBox deserialize(PayloadReader reader) {
+ static AbstractBoundingBox deserialize(PayloadReader reader) {
if (!reader.isReadable(2)) return null;
char type = reader.readChar();
return null;
}
- private static BoundingBox deserializeStructure(PayloadReader reader) {
+ private static AbstractBoundingBox deserializeStructure(PayloadReader reader) {
BoundingBoxType type = BoundingBoxType.getByNameHash(reader.readInt());
if (type == null) return null;
Coords minCoords = reader.readCoords();
return BoundingBoxStructure.from(minCoords, maxCoords, type);
}
- private static BoundingBox deserializeVillage(PayloadReader reader) {
+ private static AbstractBoundingBox deserializeVillage(PayloadReader reader) {
Coords center = reader.readCoords();
int radius = reader.readVarInt();
boolean spawnsIronGolems = reader.readBoolean();
return BoundingBoxVillage.from(center, radius, color, spawnsIronGolems, doors);
}
- private static BoundingBox deserializeMobSpawner(PayloadReader reader) {
+ private static AbstractBoundingBox deserializeMobSpawner(PayloadReader reader) {
return BoundingBoxMobSpawner.from(reader.readCoords());
}
}
import java.util.function.BiConsumer;
class BoundingBoxSerializer {
- private static final Map<Class, BiConsumer<BoundingBox, PayloadBuilder>> serializers = new HashMap<>();
+ private static final Map<Class, BiConsumer<AbstractBoundingBox, PayloadBuilder>> serializers = new HashMap<>();
static {
serializers.put(BoundingBoxVillage.class, (bb, pb) -> serializeVillage((BoundingBoxVillage) bb, pb));
serializers.put(BoundingBoxMobSpawner.class, (bb, pb) -> serializeMobSpawner((BoundingBoxMobSpawner) bb, pb));
}
- static boolean canSerialize(BoundingBox key) {
+ static boolean canSerialize(AbstractBoundingBox key) {
return serializers.containsKey(key.getClass());
}
- static void serialize(BoundingBox boundingBox, PayloadBuilder builder) {
- BiConsumer<BoundingBox, PayloadBuilder> serializer = serializers.get(boundingBox.getClass());
+ static void serialize(AbstractBoundingBox boundingBox, PayloadBuilder builder) {
+ BiConsumer<AbstractBoundingBox, PayloadBuilder> serializer = serializers.get(boundingBox.getClass());
if (serializer == null) return;
serializer.accept(boundingBox, builder);
package com.irtimaled.bbor.common.messages;
import com.irtimaled.bbor.client.events.RemoveBoundingBoxReceived;
-import com.irtimaled.bbor.common.models.BoundingBox;
+import com.irtimaled.bbor.common.models.AbstractBoundingBox;
public class RemoveBoundingBox {
public static final String NAME = "bbor:remove_bounding_box";
- public static PayloadBuilder getPayload(int dimensionId, BoundingBox key) {
+ public static PayloadBuilder getPayload(int dimensionId, AbstractBoundingBox key) {
if (!BoundingBoxSerializer.canSerialize(key)) return null;
PayloadBuilder builder = PayloadBuilder.clientBound(NAME)
public static RemoveBoundingBoxReceived getEvent(PayloadReader reader) {
int dimensionId = reader.readVarInt();
- BoundingBox key = BoundingBoxDeserializer.deserialize(reader);
+ AbstractBoundingBox key = BoundingBoxDeserializer.deserialize(reader);
if (key == null) return null;
return new RemoveBoundingBoxReceived(dimensionId, key);
--- /dev/null
+package com.irtimaled.bbor.common.models;
+
+import com.irtimaled.bbor.common.BoundingBoxType;
+
+import java.awt.*;
+
+public abstract class AbstractBoundingBox {
+ private final Coords minCoords;
+ private final Coords maxCoords;
+ private final BoundingBoxType type;
+
+ protected AbstractBoundingBox(Coords minCoords, Coords maxCoords, BoundingBoxType type) {
+ this.minCoords = minCoords;
+ this.maxCoords = maxCoords;
+ this.type = type;
+ }
+
+ @Override
+ public int hashCode() {
+ final int prime = 31;
+ int result = 1;
+ result = prime * result + minCoords.hashCode();
+ result = prime * result + maxCoords.hashCode();
+ return result;
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj)
+ return true;
+ if (obj == null)
+ return false;
+ if (getClass() != obj.getClass())
+ return false;
+ AbstractBoundingBox other = (AbstractBoundingBox) obj;
+ return minCoords.equals(other.minCoords) && maxCoords.equals(other.maxCoords);
+ }
+
+ @Override
+ public String toString() {
+ return "(" + minCoords.toString() + "; " + maxCoords.toString() + ")";
+ }
+
+ public Coords getMinCoords() {
+ return minCoords;
+ }
+
+ public Coords getMaxCoords() {
+ return maxCoords;
+ }
+
+ public Color getColor() {
+ return type.getColor();
+ }
+
+ public Boolean shouldRender() {
+ return type.shouldRender();
+ }
+
+ public String getTypeName() {
+ return type.getName();
+ }
+}
+++ /dev/null
-package com.irtimaled.bbor.common.models;
-
-import com.irtimaled.bbor.common.BoundingBoxType;
-
-import java.awt.*;
-
-public abstract class BoundingBox {
- private final Coords minCoords;
- private final Coords maxCoords;
- private final BoundingBoxType type;
-
- protected BoundingBox(Coords minCoords, Coords maxCoords, BoundingBoxType type) {
- this.minCoords = minCoords;
- this.maxCoords = maxCoords;
- this.type = type;
- }
-
- @Override
- public int hashCode() {
- final int prime = 31;
- int result = 1;
- result = prime * result + minCoords.hashCode();
- result = prime * result + maxCoords.hashCode();
- return result;
- }
-
- @Override
- public boolean equals(Object obj) {
- if (this == obj)
- return true;
- if (obj == null)
- return false;
- if (getClass() != obj.getClass())
- return false;
- BoundingBox other = (BoundingBox) obj;
- return minCoords.equals(other.minCoords) && maxCoords.equals(other.maxCoords);
- }
-
- @Override
- public String toString() {
- return "(" + minCoords.toString() + "; " + maxCoords.toString() + ")";
- }
-
- public Coords getMinCoords() {
- return minCoords;
- }
-
- public Coords getMaxCoords() {
- return maxCoords;
- }
-
- public Color getColor() {
- return type.getColor();
- }
-
- public Boolean shouldRender() {
- return type.shouldRender();
- }
-
- public String getTypeName() {
- return type.getName();
- }
-}
import com.irtimaled.bbor.common.BoundingBoxType;
-public class BoundingBoxMobSpawner extends BoundingBox {
+public class BoundingBoxMobSpawner extends AbstractBoundingBox {
private final Coords coords;
private BoundingBoxMobSpawner(Coords coords, Coords minCoords, Coords maxCoords) {
import com.irtimaled.bbor.common.BoundingBoxType;
-public class BoundingBoxSlimeChunk extends BoundingBox {
+public class BoundingBoxSlimeChunk extends AbstractBoundingBox {
private BoundingBoxSlimeChunk(Coords minCoords, Coords maxCoords) {
super(minCoords, maxCoords, BoundingBoxType.SlimeChunks);
}
import com.irtimaled.bbor.common.BoundingBoxType;
-public class BoundingBoxStructure extends BoundingBox {
+public class BoundingBoxStructure extends AbstractBoundingBox {
private BoundingBoxStructure(Coords minCoords, Coords maxCoords, BoundingBoxType type) {
super(minCoords, maxCoords, type);
}
import java.awt.*;
import java.util.Set;
-public class BoundingBoxVillage extends BoundingBox {
+public class BoundingBoxVillage extends AbstractBoundingBox {
private final Coords center;
private final Integer radius;
private final boolean spawnsIronGolems;
import com.irtimaled.bbor.common.BoundingBoxType;
-public class BoundingBoxWorldSpawn extends BoundingBox {
+public class BoundingBoxWorldSpawn extends AbstractBoundingBox {
private BoundingBoxWorldSpawn(Coords minCoords, Coords maxCoords, BoundingBoxType type) {
super(minCoords, maxCoords, type);
}
--- /dev/null
+package com.irtimaled.bbor.config;
+
+public abstract class AbstractSetting {
+ String comment;
+ String category;
+ String name;
+
+ private final char type;
+
+ public AbstractSetting(char type) {
+ this.type = type;
+ }
+
+ char getType() {
+ return type;
+ }
+
+ abstract Object getValue();
+}
package com.irtimaled.bbor.config;
-public class Setting<T> extends SettingBase {
+public class Setting<T> extends AbstractSetting {
private T value;
public Setting(char type, T value) {
+++ /dev/null
-package com.irtimaled.bbor.config;
-
-public abstract class SettingBase {
- String comment;
- String category;
- String name;
-
- private final char type;
-
- public SettingBase(char type) {
- this.type = type;
- }
-
- char getType() {
- return type;
- }
-
- abstract Object getValue();
-}
projects / BoundingBoxOutlineReloaded.git / commitdiff