package com.irtimaled.bbor.client;
import com.irtimaled.bbor.common.BoundingBoxCache;
+import com.irtimaled.bbor.common.BoundingBoxType;
import com.irtimaled.bbor.common.models.*;
import com.irtimaled.bbor.config.ConfigManager;
import net.minecraft.client.Minecraft;
ChunkPos chunk = new ChunkPos(chunkX, chunkZ);
BlockPos minBlockPos = new BlockPos(chunk.getXStart(), 1, chunk.getZStart());
BlockPos maxBlockPos = new BlockPos(chunk.getXEnd(), 38, chunk.getZEnd());
- slimeChunks.add(BoundingBoxSlimeChunk.from(minBlockPos, maxBlockPos, Colors.DARK_GREEN));
+ slimeChunks.add(BoundingBoxSlimeChunk.from(minBlockPos, maxBlockPos));
}
}
return slimeChunks;
}
private BoundingBox getSpawnChunksBoundingBox(int spawnX, int spawnZ) {
- return dimensionCache.getOrSetSpawnChunks(() -> buildSpawnChunksBoundingBox(spawnX, spawnZ, 12));
+ return dimensionCache.getOrSetSpawnChunks(() -> buildSpawnChunksBoundingBox(spawnX, spawnZ, 12, BoundingBoxType.SpawnChunks));
}
private BoundingBox getLazySpawnChunksBoundingBox(int spawnX, int spawnZ) {
- return dimensionCache.getOrSetLazySpawnChunks(() -> buildSpawnChunksBoundingBox(spawnX, spawnZ, 16));
+ return dimensionCache.getOrSetLazySpawnChunks(() -> buildSpawnChunksBoundingBox(spawnX, spawnZ, 16, BoundingBoxType.LazySpawnChunks));
}
- private BoundingBox buildSpawnChunksBoundingBox(int spawnX, int spawnZ, int size) {
+ private BoundingBox 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;
midZ += (double) CHUNK_SIZE;
}
BlockPos maxBlockPos = new BlockPos(midX + midOffset, 0, midZ + midOffset);
- return BoundingBoxWorldSpawn.from(minBlockPos, maxBlockPos, Color.RED);
+ return BoundingBoxWorldSpawn.from(minBlockPos, maxBlockPos, type);
}
private BoundingBox getWorldSpawnBoundingBox(int spawnX, int spawnZ) {
BlockPos minBlockPos = new BlockPos(spawnX - 10, 0, spawnZ - 10);
BlockPos maxBlockPos = new BlockPos(spawnX + 10, 0, spawnZ + 10);
- return BoundingBoxWorldSpawn.from(minBlockPos, maxBlockPos, Color.RED);
+ return BoundingBoxWorldSpawn.from(minBlockPos, maxBlockPos, BoundingBoxType.WorldSpawn);
}
}
import com.irtimaled.bbor.Logger;
import com.irtimaled.bbor.common.BoundingBoxCache;
+import com.irtimaled.bbor.common.BoundingBoxType;
import com.irtimaled.bbor.common.DimensionCache;
-import com.irtimaled.bbor.common.StructureType;
import com.irtimaled.bbor.common.models.BoundingBox;
import com.irtimaled.bbor.common.models.BoundingBoxStructure;
import com.irtimaled.bbor.common.models.BoundingBoxVillage;
import net.minecraft.util.math.BlockPos;
import net.minecraft.world.dimension.DimensionType;
-import java.awt.*;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
private static BoundingBoxCache loadOverworldStructures(File localStructuresFolder) {
BoundingBoxCache cache = new BoundingBoxCache();
- if (ConfigManager.drawDesertTemples.getBoolean()) {
- loadStructure(localStructuresFolder, cache, "Temple.dat", StructureType.DesertTemple.getColor(), "TeDP");
- }
- if (ConfigManager.drawJungleTemples.getBoolean()) {
- loadStructure(localStructuresFolder, cache, "Temple.dat", StructureType.JungleTemple.getColor(), "TeJP");
- }
- if (ConfigManager.drawWitchHuts.getBoolean()) {
- loadStructure(localStructuresFolder, cache, "Temple.dat", StructureType.WitchHut.getColor(), "TeSH");
- }
- if (ConfigManager.drawOceanMonuments.getBoolean()) {
- loadStructure(localStructuresFolder, cache, "Monument.dat", StructureType.OceanMonument.getColor(), "*");
- }
- if (ConfigManager.drawStrongholds.getBoolean()) {
- loadStructure(localStructuresFolder, cache, "Stronghold.dat", StructureType.Stronghold.getColor(), "*");
- }
- if (ConfigManager.drawMansions.getBoolean()) {
- loadStructure(localStructuresFolder, cache, "Mansion.dat", StructureType.Mansion.getColor(), "*");
- }
- if (ConfigManager.drawMineShafts.getBoolean()) {
- loadStructure(localStructuresFolder, cache, "Mineshaft.dat", StructureType.MineShaft.getColor(), "*");
- }
- if (ConfigManager.drawVillages.getBoolean()) {
- loadVillages(localStructuresFolder, cache, "Villages.dat");
- }
+ loadStructure(localStructuresFolder, cache, "Temple.dat", "TeDP", BoundingBoxType.DesertTemple);
+ loadStructure(localStructuresFolder, cache, "Temple.dat", "TeJP", BoundingBoxType.JungleTemple);
+ loadStructure(localStructuresFolder, cache, "Temple.dat", "TeSH", BoundingBoxType.WitchHut);
+ loadStructure(localStructuresFolder, cache, "Monument.dat", "*", BoundingBoxType.OceanMonument);
+ loadStructure(localStructuresFolder, cache, "Stronghold.dat", "*", BoundingBoxType.Stronghold);
+ loadStructure(localStructuresFolder, cache, "Mansion.dat", "*", BoundingBoxType.Mansion);
+ loadStructure(localStructuresFolder, cache, "Mineshaft.dat", "*", BoundingBoxType.MineShaft);
+ loadVillages(localStructuresFolder, cache, "Villages.dat");
return cache;
}
private static BoundingBoxCache loadNetherStructures(File localStructuresFolder) {
BoundingBoxCache cache = new BoundingBoxCache();
- if (ConfigManager.drawNetherFortresses.getBoolean())
- loadStructure(localStructuresFolder, cache, "Fortress.dat", StructureType.NetherFortress.getColor(), "*");
- if (ConfigManager.drawVillages.getBoolean()) {
- loadVillages(localStructuresFolder, cache, "villages_nether.dat");
- }
+ loadStructure(localStructuresFolder, cache, "Fortress.dat", "*", BoundingBoxType.NetherFortress);
+ loadVillages(localStructuresFolder, cache, "villages_nether.dat");
return cache;
}
private static BoundingBoxCache loadEndStructures(File localStructuresFolder) {
BoundingBoxCache cache = new BoundingBoxCache();
- if (ConfigManager.drawVillages.getBoolean()) {
- loadVillages(localStructuresFolder, cache, "Villages_end.dat");
- }
- if (ConfigManager.drawEndCities.getBoolean()) {
- loadStructure(localStructuresFolder, cache, "EndCity.dat", StructureType.EndCity.getColor(), "*");
- }
+ loadVillages(localStructuresFolder, cache, "Villages_end.dat");
+ loadStructure(localStructuresFolder, cache, "EndCity.dat", "*", BoundingBoxType.EndCity);
return cache;
}
- private static void loadStructure(File localStructuresFolder, BoundingBoxCache cache, String fileName, Color color, String id) {
+ private static void loadStructure(File localStructuresFolder, BoundingBoxCache cache, String fileName, String id, BoundingBoxType type) {
+ if(!type.shouldRender()) return;
+
File file = new File(localStructuresFolder, fileName);
NBTTagCompound nbt = loadNbtFile(file);
if (nbt == null)
int loadedStructureCount = 0;
for (Object key : features.getKeySet()) {
NBTTagCompound feature = features.getCompoundTag((String) key);
- BoundingBox structure = BoundingBoxStructure.from(feature.getIntArray("BB"), color);
+ BoundingBox structure = BoundingBoxStructure.from(feature.getIntArray("BB"), type);
Set<BoundingBox> boundingBoxes = new HashSet<>();
NBTTagCompound[] children = getChildCompoundTags(feature, "Children");
for (NBTTagCompound child : children) {
if (id.equals(child.getString("id")) || id.equals("*"))
- boundingBoxes.add(BoundingBoxStructure.from(child.getIntArray("BB"), color));
+ boundingBoxes.add(BoundingBoxStructure.from(child.getIntArray("BB"), type));
}
if (boundingBoxes.size() > 0)
++loadedStructureCount;
}
private static void loadVillages(File localStructuresFolder, BoundingBoxCache cache, String fileName) {
+ if(!BoundingBoxType.Village.shouldRender()) return;
+
File file = new File(localStructuresFolder, fileName);
NBTTagCompound nbt = loadNbtFile(file);
if (nbt == null)
--- /dev/null
+package com.irtimaled.bbor.common;
+
+import com.irtimaled.bbor.common.models.Colors;
+import com.irtimaled.bbor.config.ConfigManager;
+import com.irtimaled.bbor.config.Setting;
+
+import java.awt.*;
+import java.util.HashMap;
+import java.util.Map;
+
+public class BoundingBoxType {
+ private final static Map<Integer, BoundingBoxType> structureTypeMap = new HashMap<>();
+
+ public final static BoundingBoxType JungleTemple = register(Colors.DARK_GREEN, "Jungle_Pyramid", ConfigManager.drawJungleTemples);
+ public final static BoundingBoxType DesertTemple = register(Color.ORANGE, "Desert_Pyramid", ConfigManager.drawDesertTemples);
+ public final static BoundingBoxType WitchHut = register(Color.BLUE, "Swamp_Hut", ConfigManager.drawWitchHuts);
+ public final static BoundingBoxType OceanMonument = register(Color.CYAN, "Monument", ConfigManager.drawOceanMonuments);
+ public final static BoundingBoxType Shipwreck = register(Color.CYAN, "Shipwreck", ConfigManager.drawShipwrecks);
+ public final static BoundingBoxType OceanRuin = register(Color.CYAN, "Ocean_Ruin", ConfigManager.drawOceanRuins);
+ public final static BoundingBoxType BuriedTreasure = register(Color.CYAN, "Buried_Treasure", ConfigManager.drawBuriedTreasure);
+ public final static BoundingBoxType Stronghold = register(Color.YELLOW, "Stronghold", ConfigManager.drawStrongholds);
+ public final static BoundingBoxType MineShaft = register(Color.LIGHT_GRAY, "Mineshaft", ConfigManager.drawMineShafts);
+ public final static BoundingBoxType NetherFortress = register(Color.RED, "Fortress", ConfigManager.drawNetherFortresses);
+ public final static BoundingBoxType EndCity = register(Color.MAGENTA, "EndCity", ConfigManager.drawEndCities);
+ public final static BoundingBoxType Mansion = register(Colors.BROWN, "Mansion", ConfigManager.drawMansions);
+ public final static BoundingBoxType Igloo = register(Color.WHITE, "Igloo", ConfigManager.drawIgloos);
+ public final static BoundingBoxType PillagerOutpost = register(Color.GRAY, "Pillager_Outpost", ConfigManager.drawPillagerOutposts);
+ public final static BoundingBoxType WorldSpawn = register(Color.RED, "World_Spawn", ConfigManager.drawWorldSpawn);
+ public final static BoundingBoxType SpawnChunks = register(Color.RED, "Spawn_Chunks", ConfigManager.drawWorldSpawn);
+ public final static BoundingBoxType LazySpawnChunks = register(Color.RED, "Lazy_Chunks", ConfigManager.drawLazySpawnChunks);
+ public final static BoundingBoxType MobSpawner = register(Color.GREEN, "Mob_Spawner", ConfigManager.drawMobSpawners);
+ public final static BoundingBoxType SlimeChunks = register(Colors.DARK_GREEN, "Slime_Chunks", ConfigManager.drawSlimeChunks);
+ public final static BoundingBoxType Village = register(null, "Village", ConfigManager.drawVillages);
+
+ private static BoundingBoxType register(Color color, String name, Setting shouldRenderSetting) {
+ return structureTypeMap.computeIfAbsent(name.hashCode(), k -> new BoundingBoxType(color, name, shouldRenderSetting));
+ }
+
+ public static BoundingBoxType getByNameHash(Integer nameHash) {
+ return structureTypeMap.get(nameHash);
+ }
+
+ private final Color color;
+ private final String name;
+ private final Setting shouldRenderSetting;
+
+ private BoundingBoxType(Color color, String name, Setting shouldRenderSetting) {
+ this.color = color;
+ this.name = name;
+ this.shouldRenderSetting = shouldRenderSetting;
+ }
+
+ public Color getColor() {
+ return color;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public Boolean shouldRender() {
+ return shouldRenderSetting.getBoolean();
+ }
+}
Logger.info("create world dimension: %s, %s (seed: %d)", dimensionType, world.getClass().toString(), world.getSeed());
DimensionProcessor boundingBoxCache = new DimensionProcessor(dimensionType);
dimensionCache.put(dimensionType, boundingBoxCache);
- if (ConfigManager.drawVillages.getBoolean()) {
+ if (BoundingBoxType.Village.shouldRender()) {
villageProcessors.add(new VillageProcessor(world, dimensionType, boundingBoxCache));
}
}
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.config.ConfigManager;
-import com.irtimaled.bbor.config.Setting;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.tileentity.TileEntityMobSpawner;
import net.minecraft.util.math.MutableBoundingBox;
import net.minecraft.world.gen.feature.structure.StructurePiece;
import net.minecraft.world.gen.feature.structure.StructureStart;
-import java.awt.*;
import java.util.Collection;
import java.util.HashSet;
import java.util.Map;
super.close();
}
- private void addStructures(Setting drawStructure, StructureType structureType, Map<String, StructureStart> structureMap) {
- if (!drawStructure.getBoolean()) return;
+ private void addStructures(BoundingBoxType type, Map<String, StructureStart> structureMap) {
+ if (!type.shouldRender()) return;
- StructureStart structureStart = structureMap.get(structureType.getName());
+ StructureStart structureStart = structureMap.get(type.getName());
if (structureStart == null) return;
- Color color = structureType.getColor();
MutableBoundingBox bb = structureStart.getBoundingBox();
- if (bb == null)
- return;
+ if (bb == null) return;
- BoundingBox boundingBox = BoundingBoxStructure.from(bb, color);
+ BoundingBox boundingBox = BoundingBoxStructure.from(bb, type);
if (isCached(boundingBox)) return;
Set<BoundingBox> structureBoundingBoxes = new HashSet<>();
for (StructurePiece structureComponent : structureStart.getComponents()) {
- structureBoundingBoxes.add(BoundingBoxStructure.from(structureComponent.getBoundingBox(), color));
+ structureBoundingBoxes.add(BoundingBoxStructure.from(structureComponent.getBoundingBox(), type));
}
addBoundingBoxes(boundingBox, structureBoundingBoxes);
Logger.info("[%s] new dimensionCache entries: %d", dimensionType, structureBoundingBoxes.size());
}
- public synchronized void processChunk(Chunk chunk) {
+ private void addMobSpawners(Chunk chunk) {
+ Collection<TileEntity> tileEntities = chunk.getTileEntityMap().values();
+ for (TileEntity tileEntity : tileEntities) {
+ if (tileEntity instanceof TileEntityMobSpawner) {
+ addBoundingBox(BoundingBoxMobSpawner.from(tileEntity.getPos()));
+ }
+ }
+ }
+
+ synchronized void processChunk(Chunk chunk) {
if (closed) return;
Map<String, StructureStart> structureMap = chunk.getStructureStarts();
if (structureMap.size() > 0) {
- addStructures(ConfigManager.drawDesertTemples, StructureType.DesertTemple, structureMap);
- addStructures(ConfigManager.drawJungleTemples, StructureType.JungleTemple, structureMap);
- addStructures(ConfigManager.drawWitchHuts, StructureType.WitchHut, structureMap);
- addStructures(ConfigManager.drawOceanMonuments, StructureType.OceanMonument, structureMap);
- addStructures(ConfigManager.drawStrongholds, StructureType.Stronghold, structureMap);
- addStructures(ConfigManager.drawMansions, StructureType.Mansion, structureMap);
- addStructures(ConfigManager.drawMineShafts, StructureType.MineShaft, structureMap);
- addStructures(ConfigManager.drawShipwrecks, StructureType.Shipwreck, structureMap);
- addStructures(ConfigManager.drawOceanRuins, StructureType.OceanRuin, structureMap);
- addStructures(ConfigManager.drawBuriedTreasure, StructureType.BuriedTreasure, structureMap);
- addStructures(ConfigManager.drawIgloos, StructureType.Igloo, structureMap);
- addStructures(ConfigManager.drawNetherFortresses, StructureType.NetherFortress, structureMap);
- addStructures(ConfigManager.drawEndCities, StructureType.EndCity, structureMap);
- addStructures(ConfigManager.drawPillagerOutposts, StructureType.PillagerOutpost, structureMap);
+ addStructures(BoundingBoxType.DesertTemple, structureMap);
+ addStructures(BoundingBoxType.JungleTemple, structureMap);
+ addStructures(BoundingBoxType.WitchHut, structureMap);
+ addStructures(BoundingBoxType.OceanMonument, structureMap);
+ addStructures(BoundingBoxType.Stronghold, structureMap);
+ addStructures(BoundingBoxType.Mansion, structureMap);
+ addStructures(BoundingBoxType.MineShaft, structureMap);
+ addStructures(BoundingBoxType.Shipwreck, structureMap);
+ addStructures(BoundingBoxType.OceanRuin, structureMap);
+ addStructures(BoundingBoxType.BuriedTreasure, structureMap);
+ addStructures(BoundingBoxType.Igloo, structureMap);
+ addStructures(BoundingBoxType.NetherFortress, structureMap);
+ addStructures(BoundingBoxType.EndCity, structureMap);
+ addStructures(BoundingBoxType.PillagerOutpost, structureMap);
}
- if (ConfigManager.drawMobSpawners.getBoolean()) {
- Collection<TileEntity> tileEntities = chunk.getTileEntityMap().values();
- for (TileEntity tileEntity : tileEntities) {
- if (tileEntity instanceof TileEntityMobSpawner) {
- addBoundingBox(BoundingBoxMobSpawner.from(tileEntity.getPos()));
- }
- }
+ if (BoundingBoxType.MobSpawner.shouldRender()) {
+ addMobSpawners(chunk);
}
}
}
+++ /dev/null
-package com.irtimaled.bbor.common;
-
-import com.irtimaled.bbor.common.models.Colors;
-
-import java.awt.*;
-
-public class StructureType {
- public final static StructureType JungleTemple = new StructureType(Colors.DARK_GREEN, "Jungle_Pyramid");
- public final static StructureType DesertTemple = new StructureType(Color.ORANGE, "Desert_Pyramid");
- public final static StructureType WitchHut = new StructureType(Color.BLUE, "Swamp_Hut");
- public final static StructureType OceanMonument = new StructureType(Color.CYAN, "Monument");
- public final static StructureType Shipwreck = new StructureType(Color.CYAN, "Shipwreck");
- public final static StructureType OceanRuin = new StructureType(Color.CYAN, "Ocean_Ruin");
- public final static StructureType BuriedTreasure = new StructureType(Color.CYAN, "Buried_Treasure");
- public final static StructureType Stronghold = new StructureType(Color.YELLOW, "Stronghold");
- public final static StructureType MineShaft = new StructureType(Color.LIGHT_GRAY, "Mineshaft");
- public final static StructureType NetherFortress = new StructureType(Color.RED, "Fortress");
- public final static StructureType EndCity = new StructureType(Color.MAGENTA, "EndCity");
- public final static StructureType Mansion = new StructureType(new Color(139, 69, 19), "Mansion");
- public final static StructureType Igloo = new StructureType(Color.WHITE, "Igloo");
- public final static StructureType PillagerOutpost = new StructureType(Color.GRAY, "Pillager_Outpost");
-
- private final Color color;
- private String name;
-
- private StructureType(Color color, String name) {
- this.color = color;
- this.name = name;
- }
-
- public Color getColor() {
- return color;
- }
-
- public String getName() {
- return name;
- }
-}
package com.irtimaled.bbor.common.messages;
+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 java.util.HashSet;
import java.util.Set;
-public class BoundingBoxDeserializer {
+class BoundingBoxDeserializer {
static BoundingBox deserialize(PacketBuffer buf) {
char type = buf.readChar();
switch (type) {
}
private static BoundingBox deserializeStructure(PacketBuffer buf) {
+ BoundingBoxType type = BoundingBoxType.getByNameHash(buf.readInt());
+ if(type == null) return null;
BlockPos minBlockPos = deserializeBlockPos(buf);
BlockPos maxBlockPos = deserializeBlockPos(buf);
- Color color = new Color(buf.readVarInt());
- return BoundingBoxStructure.from(minBlockPos, maxBlockPos, color);
+ return BoundingBoxStructure.from(minBlockPos, maxBlockPos, type);
}
private static BoundingBox deserializeVillage(PacketBuffer buf) {
import java.awt.*;
-public class BoundingBoxSerializer {
+class BoundingBoxSerializer {
static void serialize(BoundingBox boundingBox, PacketBuffer buf) {
if (boundingBox instanceof BoundingBoxVillage) {
serializeVillage((BoundingBoxVillage) boundingBox, buf);
private static void serializeStructure(BoundingBoxStructure boundingBox, PacketBuffer buf) {
buf.writeChar('S');
+ buf.writeInt(boundingBox.getTypeName().hashCode());
serializeCuboid(boundingBox, buf);
- serializeColor(boundingBox.getColor(), buf);
}
private static void serializeMobSpawner(BoundingBoxMobSpawner boundingBox, PacketBuffer buf) {
package com.irtimaled.bbor.common.models;
+import com.irtimaled.bbor.common.BoundingBoxType;
import net.minecraft.util.math.AxisAlignedBB;
import net.minecraft.util.math.BlockPos;
import java.awt.*;
public abstract class BoundingBox {
- private final Color color;
private final BlockPos minBlockPos;
private final BlockPos maxBlockPos;
+ private final BoundingBoxType type;
- protected BoundingBox(BlockPos minBlockPos, BlockPos maxBlockPos, Color color) {
+ protected BoundingBox(BlockPos minBlockPos, BlockPos maxBlockPos, BoundingBoxType type) {
this.minBlockPos = minBlockPos;
this.maxBlockPos = maxBlockPos;
- this.color = color;
+ this.type = type;
}
@Override
}
public Color getColor() {
- return color;
+ return type.getColor();
+ }
+
+ public Boolean shouldRender() { return type.shouldRender(); }
+
+ public String getTypeName() {
+ return type.getName();
}
}
package com.irtimaled.bbor.common.models;
-import net.minecraft.tileentity.TileEntityMobSpawner;
+import com.irtimaled.bbor.common.BoundingBoxType;
import net.minecraft.util.math.BlockPos;
-import java.awt.*;
-
public class BoundingBoxMobSpawner extends BoundingBox {
private final BlockPos center;
private final Integer radius;
- private BoundingBoxMobSpawner(BlockPos center, Integer radius, Color color, BlockPos minBlockPos, BlockPos maxBlockPos) {
- super(minBlockPos, maxBlockPos, color);
+ private BoundingBoxMobSpawner(BlockPos center, Integer radius, BlockPos minBlockPos, BlockPos maxBlockPos) {
+ super(minBlockPos, maxBlockPos, BoundingBoxType.MobSpawner);
this.center = center;
this.radius = radius;
}
BlockPos maxBlockPos = new BlockPos(center.getX() + 5,
center.getY() + 2,
center.getZ() + 5);
- return new BoundingBoxMobSpawner(center, 16, Color.GREEN, minBlockPos, maxBlockPos);
+ return new BoundingBoxMobSpawner(center, 16, minBlockPos, maxBlockPos);
}
@Override
package com.irtimaled.bbor.common.models;
+import com.irtimaled.bbor.common.BoundingBoxType;
import net.minecraft.util.math.BlockPos;
-import java.awt.*;
-
public class BoundingBoxSlimeChunk extends BoundingBox {
- private BoundingBoxSlimeChunk(BlockPos minBlockPos, BlockPos maxBlockPos, Color color) {
- super(minBlockPos, maxBlockPos, color);
+ private BoundingBoxSlimeChunk(BlockPos minBlockPos, BlockPos maxBlockPos) {
+ super(minBlockPos, maxBlockPos, BoundingBoxType.SlimeChunks);
}
- public static BoundingBoxSlimeChunk from(BlockPos minBlockPos, BlockPos maxBlockPos, Color color) {
- return new BoundingBoxSlimeChunk(minBlockPos, maxBlockPos, color);
+ public static BoundingBoxSlimeChunk from(BlockPos minBlockPos, BlockPos maxBlockPos) {
+ return new BoundingBoxSlimeChunk(minBlockPos, maxBlockPos);
}
}
package com.irtimaled.bbor.common.models;
+import com.irtimaled.bbor.common.BoundingBoxType;
import net.minecraft.util.math.BlockPos;
import net.minecraft.util.math.MutableBoundingBox;
-import java.awt.*;
-
public class BoundingBoxStructure extends BoundingBox {
- private BoundingBoxStructure(BlockPos minBlockPos, BlockPos maxBlockPos, Color color) {
- super(minBlockPos, maxBlockPos, color);
+ private BoundingBoxStructure(BlockPos minBlockPos, BlockPos maxBlockPos, BoundingBoxType type) {
+ super(minBlockPos, maxBlockPos, type);
}
- public static BoundingBoxStructure from(MutableBoundingBox bb, Color color) {
+ public static BoundingBoxStructure from(MutableBoundingBox bb, BoundingBoxType type) {
BlockPos minBlockPos = new BlockPos(bb.minX, bb.minY, bb.minZ);
BlockPos maxBlockPos = new BlockPos(bb.maxX, bb.maxY, bb.maxZ);
- return new BoundingBoxStructure(minBlockPos, maxBlockPos, color);
+ return new BoundingBoxStructure(minBlockPos, maxBlockPos, type);
}
- public static BoundingBoxStructure from(int[] bb, Color color) {
+ public static BoundingBoxStructure from(int[] bb, BoundingBoxType type) {
BlockPos minBlockPos = new BlockPos(bb[0], bb[1], bb[2]);
BlockPos maxBlockPos = new BlockPos(bb[3], bb[4], bb[5]);
- return new BoundingBoxStructure(minBlockPos, maxBlockPos, color);
+ return new BoundingBoxStructure(minBlockPos, maxBlockPos, type);
}
- public static BoundingBoxStructure from(BlockPos minBlockPos, BlockPos maxBlockPos, Color color) {
- return new BoundingBoxStructure(minBlockPos, maxBlockPos, color);
+ public static BoundingBoxStructure from(BlockPos minBlockPos, BlockPos maxBlockPos, BoundingBoxType type) {
+ return new BoundingBoxStructure(minBlockPos, maxBlockPos, type);
}
}
package com.irtimaled.bbor.common.models;
+import com.irtimaled.bbor.common.BoundingBoxType;
import com.irtimaled.bbor.common.VillageColorCache;
import net.minecraft.util.math.BlockPos;
import net.minecraft.village.Village;
private final BlockPos center;
private final Integer radius;
private final boolean spawnsIronGolems;
+ private final Color color;
private Set<BlockPos> doors;
private Double centerOffsetX;
private Double centerOffsetZ;
private int villageHash;
private BoundingBoxVillage(BlockPos center, Integer radius, Color color, boolean spawnsIronGolems, Set<BlockPos> doors, BlockPos minBlockPos, BlockPos maxBlockPos) {
- super(minBlockPos, maxBlockPos, color);
+ super(minBlockPos, maxBlockPos, BoundingBoxType.Village);
this.center = center;
this.radius = radius;
+ this.color = color;
this.spawnsIronGolems = spawnsIronGolems;
this.doors = doors;
this.villageHash = computeHash(center, radius, spawnsIronGolems, doors);
return center;
}
+ public Color getColor() { return color; }
+
public Double getCenterOffsetX() {
return centerOffsetX;
}
package com.irtimaled.bbor.common.models;
+import com.irtimaled.bbor.common.BoundingBoxType;
import net.minecraft.util.math.BlockPos;
-import java.awt.*;
-
public class BoundingBoxWorldSpawn extends BoundingBox {
- private BoundingBoxWorldSpawn(BlockPos minBlockPos, BlockPos maxBlockPos, Color color) {
- super(minBlockPos, maxBlockPos, color);
+ private BoundingBoxWorldSpawn(BlockPos minBlockPos, BlockPos maxBlockPos, BoundingBoxType type) {
+ super(minBlockPos, maxBlockPos, type);
}
- public static BoundingBoxWorldSpawn from(BlockPos minBlockPos, BlockPos maxBlockPos, Color color) {
- return new BoundingBoxWorldSpawn(minBlockPos, maxBlockPos, color);
+ public static BoundingBoxWorldSpawn from(BlockPos minBlockPos, BlockPos maxBlockPos, BoundingBoxType type) {
+ return new BoundingBoxWorldSpawn(minBlockPos, maxBlockPos, type);
}
}
public class Colors {
public final static Color DARK_ORANGE = new Color(255, 127, 0);
public final static Color DARK_GREEN = new Color(0, 96, 0);
+ public final static Color BROWN = new Color(139, 69, 19);
}
projects / BoundingBoxOutlineReloaded.git / commitdiff