public static void toggleActive() {
active = !active;
if (active)
- PlayerData.setActiveY();
+ PlayerCoords.setActiveY();
}
private static void toggleOuterBoxesOnly() {
private void render(float partialTicks) {
EntityPlayer entityPlayer = Minecraft.getInstance().player;
- PlayerData.setPlayerPosition(partialTicks, entityPlayer);
+ PlayerCoords.setPlayerPosition(partialTicks, entityPlayer);
if (active) {
renderer.render(DimensionType.getById(entityPlayer.dimension), ConfigManager.outerBoxesOnly.get());
import com.irtimaled.bbor.common.models.*;
import com.irtimaled.bbor.config.ConfigManager;
import net.minecraft.client.Minecraft;
-import net.minecraft.util.math.BlockPos;
import net.minecraft.util.math.ChunkPos;
import net.minecraft.util.math.MathHelper;
import net.minecraft.world.dimension.DimensionType;
boundingBoxRendererMap.put(BoundingBoxMobSpawner.class, new MobSpawnerRenderer());
}
- private boolean isWithinRenderDistance(BlockPos minBlockPos, BlockPos maxBlockPos) {
+ private boolean isWithinRenderDistance(Coords minCoords, Coords maxCoords) {
int renderDistanceBlocks = Minecraft.getInstance().gameSettings.renderDistanceChunks * CHUNK_SIZE;
- int minX = MathHelper.floor(PlayerData.getX() - renderDistanceBlocks);
- int maxX = MathHelper.floor(PlayerData.getX() + renderDistanceBlocks);
- int minZ = MathHelper.floor(PlayerData.getZ() - renderDistanceBlocks);
- int maxZ = MathHelper.floor(PlayerData.getZ() + renderDistanceBlocks);
-
- return maxBlockPos.getX() >= minX &&
- maxBlockPos.getZ() >= minZ &&
- minBlockPos.getX() <= maxX &&
- minBlockPos.getZ() <= maxZ;
+ int minX = MathHelper.floor(PlayerCoords.getX() - renderDistanceBlocks);
+ int maxX = MathHelper.floor(PlayerCoords.getX() + renderDistanceBlocks);
+ int minZ = MathHelper.floor(PlayerCoords.getZ() - renderDistanceBlocks);
+ int maxZ = MathHelper.floor(PlayerCoords.getZ() + renderDistanceBlocks);
+
+ return maxCoords.getX() >= minX &&
+ maxCoords.getZ() >= minZ &&
+ minCoords.getX() <= maxX &&
+ minCoords.getZ() <= maxZ;
}
private boolean isWithinRenderDistance(BoundingBox boundingBox) {
- return isWithinRenderDistance(boundingBox.getMinBlockPos(), boundingBox.getMaxBlockPos());
+ return isWithinRenderDistance(boundingBox.getMinCoords(), boundingBox.getMaxCoords());
}
public void render(DimensionType dimensionType, Boolean outerBoxesOnly) {
private void addSlimeChunks(Map<BoundingBox, Set<BoundingBox>> boundingBoxes) {
Minecraft minecraft = Minecraft.getInstance();
int renderDistanceChunks = minecraft.gameSettings.renderDistanceChunks;
- int playerChunkX = MathHelper.floor(PlayerData.getX() / 16.0D);
- int playerChunkZ = MathHelper.floor(PlayerData.getZ() / 16.0D);
+ int playerChunkX = MathHelper.floor(PlayerCoords.getX() / 16.0D);
+ int playerChunkZ = MathHelper.floor(PlayerCoords.getZ() / 16.0D);
for (int chunkX = playerChunkX - renderDistanceChunks; chunkX <= playerChunkX + renderDistanceChunks; ++chunkX) {
for (int chunkZ = playerChunkZ - renderDistanceChunks; chunkZ <= playerChunkZ + renderDistanceChunks; ++chunkZ) {
if (isSlimeChunk(chunkX, chunkZ)) {
ChunkPos chunk = new ChunkPos(chunkX, chunkZ);
- BlockPos minBlockPos = new BlockPos(chunk.getXStart(), 1, chunk.getZStart());
- BlockPos maxBlockPos = new BlockPos(chunk.getXEnd(), 38, chunk.getZEnd());
- boundingBoxes.put(BoundingBoxSlimeChunk.from(minBlockPos, maxBlockPos), null);
+ Coords minCoords = new Coords(chunk.getXStart(), 1, chunk.getZStart());
+ Coords maxCoords = new Coords(chunk.getXEnd(), 38, chunk.getZEnd());
+ boundingBoxes.put(BoundingBoxSlimeChunk.from(minCoords, maxCoords), null);
}
}
}
}
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);
+ Coords minCoords = new Coords(spawnX - 10, 0, spawnZ - 10);
+ Coords maxCoords = new Coords(spawnX + 10, 0, spawnZ + 10);
- return BoundingBoxWorldSpawn.from(minBlockPos, maxBlockPos, BoundingBoxType.WorldSpawn);
+ return BoundingBoxWorldSpawn.from(minCoords, maxCoords, BoundingBoxType.WorldSpawn);
}
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;
- BlockPos minBlockPos = new BlockPos(midX - midOffset, 0, midZ - midOffset);
+ Coords minCoords = new Coords(midX - midOffset, 0, midZ - midOffset);
if (spawnX / (double) CHUNK_SIZE % 0.5D == 0.0D && spawnZ / (double) CHUNK_SIZE % 0.5D == 0.0D) {
midX += (double) CHUNK_SIZE;
midZ += (double) CHUNK_SIZE;
}
- BlockPos maxBlockPos = new BlockPos(midX + midOffset, 0, midZ + midOffset);
- return BoundingBoxWorldSpawn.from(minBlockPos, maxBlockPos, type);
+ Coords maxCoords = new Coords(midX + midOffset, 0, midZ + midOffset);
+ return BoundingBoxWorldSpawn.from(minCoords, maxCoords, type);
}
}
import com.irtimaled.bbor.common.models.BoundingBox;
import com.irtimaled.bbor.common.models.BoundingBoxStructure;
import com.irtimaled.bbor.common.models.BoundingBoxVillage;
+import com.irtimaled.bbor.common.models.Coords;
import com.irtimaled.bbor.config.ConfigManager;
import net.minecraft.nbt.CompressedStreamTools;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.nbt.NBTTagList;
-import net.minecraft.util.math.BlockPos;
import net.minecraft.world.dimension.DimensionType;
import java.io.File;
int loadedStructureCount = 0;
for (Object key : features.getKeySet()) {
NBTTagCompound feature = features.getCompoundTag((String) key);
- BoundingBox structure = BoundingBoxStructure.from(feature.getIntArray("BB"), type);
+ BoundingBox structure = buildStructure(feature, 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"), type));
+ boundingBoxes.add(buildStructure(child, type));
}
if (boundingBoxes.size() > 0)
++loadedStructureCount;
Logger.info("Loaded %s (%d structures with type %s)", fileName, loadedStructureCount, id);
}
+ private static BoundingBoxStructure buildStructure(NBTTagCompound feature, BoundingBoxType type) {
+ int[] bb = feature.getIntArray("BB");
+ Coords minCoords = new Coords(bb[0], bb[1], bb[2]);
+ Coords maxCoords = new Coords(bb[3], bb[4], bb[5]);
+ return BoundingBoxStructure.from(minCoords, maxCoords, type);
+ }
+
private static void loadVillages(File localStructuresFolder, BoundingBoxCache cache, String fileName) {
File file = new File(localStructuresFolder, fileName);
NBTTagCompound nbt = loadNbtFile(file);
NBTTagCompound[] villages = getChildCompoundTags(nbt.getCompoundTag("data"), "Villages");
for (NBTTagCompound village : villages) {
- BlockPos center = new BlockPos(village.getInteger("CX"), village.getInteger("CY"), village.getInteger("CZ"));
+ Coords center = new Coords(village.getInteger("CX"), village.getInteger("CY"), village.getInteger("CZ"));
int radius = village.getInteger("Radius");
int population = village.getInteger("PopSize");
- Set<BlockPos> doors = getDoors(village);
+ Set<Coords> doors = getDoors(village);
BoundingBox boundingBox = BoundingBoxVillage.from(center, radius, village.hashCode(), population, doors);
cache.addBoundingBox(boundingBox);
}
Logger.info("Loaded %s (%d villages)", fileName, villages.length);
}
- private static Set<BlockPos> getDoors(NBTTagCompound village) {
- Set<BlockPos> doors = new HashSet<>();
+ private static Set<Coords> getDoors(NBTTagCompound village) {
+ Set<Coords> doors = new HashSet<>();
for (NBTTagCompound door : getChildCompoundTags(village, "Doors")) {
- doors.add(new BlockPos(door.getInteger("X"), door.getInteger("Y"), door.getInteger("Z")));
+ doors.add(new Coords(door.getInteger("X"), door.getInteger("Y"), door.getInteger("Z")));
}
return doors;
}
--- /dev/null
+package com.irtimaled.bbor.client;
+
+import net.minecraft.entity.player.EntityPlayer;
+
+public class PlayerCoords {
+ private static double x;
+ private static double y;
+ private static double z;
+ private static double activeY;
+
+ static void setPlayerPosition(double partialTicks, EntityPlayer entityPlayer) {
+ x = entityPlayer.lastTickPosX + (entityPlayer.posX - entityPlayer.lastTickPosX) * partialTicks;
+ y = entityPlayer.lastTickPosY + (entityPlayer.posY - entityPlayer.lastTickPosY) * partialTicks;
+ z = entityPlayer.lastTickPosZ + (entityPlayer.posZ - entityPlayer.lastTickPosZ) * partialTicks;
+ }
+
+ static void setActiveY() {
+ activeY = y;
+ }
+
+ public static double getX() {
+ return x;
+ }
+
+ public static double getY() {
+ return y;
+ }
+
+ public static double getZ() {
+ return z;
+ }
+
+ public static double getMaxY(double configMaxY) {
+ if (configMaxY == -1) {
+ return activeY;
+ }
+ if (configMaxY == 0) {
+ return y;
+ }
+ return configMaxY;
+ }
+}
+++ /dev/null
-package com.irtimaled.bbor.client;
-
-import net.minecraft.entity.player.EntityPlayer;
-
-public class PlayerData {
- private static double x;
- private static double y;
- private static double z;
- private static double activeY;
-
- static void setPlayerPosition(double partialTicks, EntityPlayer entityPlayer) {
- x = entityPlayer.lastTickPosX + (entityPlayer.posX - entityPlayer.lastTickPosX) * partialTicks;
- y = entityPlayer.lastTickPosY + (entityPlayer.posY - entityPlayer.lastTickPosY) * partialTicks;
- z = entityPlayer.lastTickPosZ + (entityPlayer.posZ - entityPlayer.lastTickPosZ) * partialTicks;
- }
-
- static void setActiveY() {
- activeY = y;
- }
-
- public static double getX() {
- return x;
- }
-
- public static double getY() {
- return y;
- }
-
- public static double getZ() {
- return z;
- }
-
- public static double getMaxY(double configMaxY) {
- if (configMaxY == -1) {
- return activeY;
- }
- if (configMaxY == 0) {
- return y;
- }
- return configMaxY;
- }
-}
package com.irtimaled.bbor.client.renderers;
-import com.irtimaled.bbor.client.PlayerData;
+import com.irtimaled.bbor.client.PlayerCoords;
import com.irtimaled.bbor.common.models.BoundingBoxMobSpawner;
import com.irtimaled.bbor.common.models.Colors;
+import com.irtimaled.bbor.common.models.Coords;
import com.irtimaled.bbor.config.ConfigManager;
-import net.minecraft.util.math.AxisAlignedBB;
-import net.minecraft.util.math.BlockPos;
import java.awt.*;
public class MobSpawnerRenderer extends Renderer<BoundingBoxMobSpawner> {
@Override
public void render(BoundingBoxMobSpawner boundingBox) {
- BlockPos center = boundingBox.getCenter();
+ Coords coords = boundingBox.getCoords();
Color color = boundingBox.getColor();
- OffsetPoint centerPoint = new OffsetPoint(center)
- .add(0.5, 0.5, 0.5);
- double radius = boundingBox.getRadius();
if (ConfigManager.renderMobSpawnerSpawnArea.get()) {
renderBoundingBox(boundingBox);
} else {
- renderCuboid(new AxisAlignedBB(center, center).expand(1, 1, 1), color, fill());
+ renderCuboid(getAxisAlignedBB(coords, coords, true), color, fill());
}
if (!ConfigManager.renderMobSpawnerActivationLines.get()) return;
- OffsetPoint playerPos = new OffsetPoint(PlayerData.getX(), PlayerData.getY(), PlayerData.getZ());
+ renderActivationLines(coords);
+ }
+
+ private void renderActivationLines(Coords coords) {
+ OffsetPoint centerPoint = new OffsetPoint(coords).add(0.5, 0.5, 0.5);
+ OffsetPoint playerPos = new OffsetPoint(PlayerCoords.getX(), PlayerCoords.getY(), PlayerCoords.getZ());
double distance = centerPoint.getDistance(playerPos);
- if (distance <= (radius * 1.25)) {
- if (distance > radius) {
- color = Colors.DARK_ORANGE;
- }
- if (distance > radius * 1.125) {
- color = Color.RED;
- }
-
- renderLine(centerPoint, playerPos.add(0, 0.1, 0), color);
- }
+ if (distance > 20.0) return;
+
+ Color color = distance <= 18.0 ? distance <= 16.0 ? Color.GREEN : Colors.DARK_ORANGE : Color.RED;
+ renderLine(centerPoint, playerPos.add(0, 0.1, 0), color);
+
}
}
package com.irtimaled.bbor.client.renderers;
-import com.irtimaled.bbor.client.PlayerData;
-import net.minecraft.util.math.BlockPos;
+import com.irtimaled.bbor.client.PlayerCoords;
+import com.irtimaled.bbor.common.models.Coords;
public class OffsetPoint {
private final double x;
this.z = z;
}
- OffsetPoint(BlockPos blockPos) {
- this.x = blockPos.getX();
- this.y = blockPos.getY();
- this.z = blockPos.getZ();
+ OffsetPoint(Coords coords) {
+ this.x = coords.getX();
+ this.y = coords.getY();
+ this.z = coords.getZ();
}
double getX() {
- return x - PlayerData.getX();
+ return x - PlayerCoords.getX();
}
double getY() {
- return y - PlayerData.getY();
+ return y - PlayerCoords.getY();
}
double getZ() {
- return z - PlayerData.getZ();
+ return z - PlayerCoords.getZ();
}
public OffsetPoint add(double x, double y, double z) {
}
public double getDistanceFromPlayer() {
- double dx = this.x - PlayerData.getX();
- double dy = this.y - PlayerData.getY();
- double dz = this.z - PlayerData.getZ();
+ double dx = this.x - PlayerCoords.getX();
+ double dy = this.y - PlayerCoords.getY();
+ double dz = this.z - PlayerCoords.getZ();
return Math.sqrt(dx * dx + dy * dy + dz * dz);
}
}
package com.irtimaled.bbor.client.renderers;
-import com.irtimaled.bbor.client.PlayerData;
+import com.irtimaled.bbor.client.PlayerCoords;
import com.irtimaled.bbor.common.models.BoundingBox;
+import com.irtimaled.bbor.common.models.Coords;
import com.irtimaled.bbor.config.ConfigManager;
import net.minecraft.client.renderer.BufferBuilder;
import net.minecraft.client.renderer.Tessellator;
public abstract void render(T boundingBox);
void renderBoundingBox(T boundingBox) {
- renderCuboid(boundingBox.toAxisAlignedBB(), boundingBox.getColor(), fill());
+ renderCuboid(getAxisAlignedBB(boundingBox), boundingBox.getColor(), fill());
+ }
+
+ AxisAlignedBB getAxisAlignedBB(T boundingBox) {
+ return getAxisAlignedBB(boundingBox, true);
+ }
+
+ AxisAlignedBB getAxisAlignedBB(T boundingBox, boolean extendMaxByOne) {
+ Coords min = boundingBox.getMinCoords();
+ Coords max = boundingBox.getMaxCoords();
+ return getAxisAlignedBB(min, max, extendMaxByOne);
+ }
+
+ AxisAlignedBB getAxisAlignedBB(Coords min, Coords max, boolean extendMaxByOne) {
+ AxisAlignedBB bb = new AxisAlignedBB(min.getX(), min.getY(), min.getZ(), max.getX(), max.getY(), max.getZ());
+ if (extendMaxByOne)
+ return bb.expand(1, 1, 1);
+ return bb;
}
boolean fill() {
}
return axisAlignedBB
.grow(growXZ, growY, growXZ)
- .offset(-PlayerData.getX(), -PlayerData.getY(), -PlayerData.getZ());
+ .offset(-PlayerCoords.getX(), -PlayerCoords.getY(), -PlayerCoords.getZ());
}
private void renderFilledCuboid(AxisAlignedBB aaBB, Color color) {
package com.irtimaled.bbor.client.renderers;
-import com.irtimaled.bbor.client.PlayerData;
+import com.irtimaled.bbor.client.PlayerCoords;
import com.irtimaled.bbor.common.models.BoundingBoxSlimeChunk;
import com.irtimaled.bbor.config.ConfigManager;
import net.minecraft.util.math.AxisAlignedBB;
public class SlimeChunkRenderer extends Renderer<BoundingBoxSlimeChunk> {
@Override
public void render(BoundingBoxSlimeChunk boundingBox) {
- AxisAlignedBB aaBB = boundingBox.toAxisAlignedBB();
+ AxisAlignedBB aaBB = getAxisAlignedBB(boundingBox);
Color color = boundingBox.getColor();
renderCuboid(aaBB, color, fill());
- double maxY = PlayerData.getMaxY(ConfigManager.slimeChunkMaxY.get());
+ double maxY = PlayerCoords.getMaxY(ConfigManager.slimeChunkMaxY.get());
if (maxY > 39) {
renderRectangle(aaBB, 39, maxY, color, fill());
}
package com.irtimaled.bbor.client.renderers;
import com.irtimaled.bbor.common.models.BoundingBoxVillage;
+import com.irtimaled.bbor.common.models.Coords;
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 net.minecraft.util.math.AxisAlignedBB;
-import net.minecraft.util.math.BlockPos;
import org.lwjgl.opengl.GL11;
import java.awt.*;
}
private void renderIronGolemSpawnArea(BoundingBoxVillage boundingBox) {
- BlockPos center = boundingBox.getCenter();
- AxisAlignedBB abb = new AxisAlignedBB(new BlockPos(center.getX() - 8,
- center.getY() - 3,
- center.getZ() - 8),
- new BlockPos(center.getX() + 8,
- center.getY() + 3,
- center.getZ() + 8))
+ Coords center = boundingBox.getCenter();
+ AxisAlignedBB abb = getAxisAlignedBB(center, center, false)
+ .grow(8, 3, 8)
.offset(boundingBox.getCenterOffsetX(), 0.0, boundingBox.getCenterOffsetZ());
renderCuboid(abb, boundingBox.getColor(), false);
int colorB = color.getBlue();
worldRenderer.begin(GL11.GL_LINES, worldRenderer.getVertexFormat());
- for (BlockPos door : boundingBox.getDoors()) {
+ for (Coords door : boundingBox.getDoors()) {
OffsetPoint point = new OffsetPoint(door).add(0.5, 0, 0.5);
worldRenderer.pos(point.getX(), point.getY(), point.getZ()).color(colorR, colorG, colorB, 255).endVertex();
package com.irtimaled.bbor.client.renderers;
-import com.irtimaled.bbor.client.PlayerData;
+import com.irtimaled.bbor.client.PlayerCoords;
import com.irtimaled.bbor.common.models.BoundingBoxWorldSpawn;
import com.irtimaled.bbor.config.ConfigManager;
import net.minecraft.util.math.AxisAlignedBB;
public class WorldSpawnRenderer extends Renderer<BoundingBoxWorldSpawn> {
@Override
public void render(BoundingBoxWorldSpawn boundingBox) {
- AxisAlignedBB aaBB = boundingBox.toAxisAlignedBB(false);
+ AxisAlignedBB aaBB = getAxisAlignedBB(boundingBox, false);
Color color = boundingBox.getColor();
- double y = PlayerData.getMaxY(ConfigManager.worldSpawnMaxY.get()) + 0.001F;
+ double y = PlayerCoords.getMaxY(ConfigManager.worldSpawnMaxY.get()) + 0.001F;
renderRectangle(aaBB, y, y, color, false);
}
}
import com.irtimaled.bbor.common.messages.RemoveBoundingBox;
import com.irtimaled.bbor.common.models.BoundingBox;
import com.irtimaled.bbor.common.models.BoundingBoxMobSpawner;
+import com.irtimaled.bbor.common.models.Coords;
import com.irtimaled.bbor.common.models.WorldData;
import io.netty.channel.local.LocalAddress;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.network.play.server.SPacketCustomPayload;
-import net.minecraft.util.math.BlockPos;
import net.minecraft.world.World;
import net.minecraft.world.WorldServer;
import net.minecraft.world.chunk.Chunk;
cache.removeBoundingBox(key);
}
- private void mobSpawnerBroken(DimensionType dimensionType, BlockPos pos) {
+ private void mobSpawnerBroken(DimensionType dimensionType, Coords pos) {
BoundingBox boundingBox = BoundingBoxMobSpawner.from(pos);
removeBoundingBox(dimensionType, boundingBox);
sendRemoveBoundingBox(dimensionType, boundingBox);
--- /dev/null
+package com.irtimaled.bbor.common;
+
+public class MathHelper {
+ public static int floor(double value) {
+ int intValue = (int) value;
+ return value > intValue ? intValue : intValue - 1;
+ }
+}
--- /dev/null
+package com.irtimaled.bbor.common;
+
+import com.irtimaled.bbor.common.models.Coords;
+
+import java.util.Set;
+
+public class VillageHelper {
+ public static boolean shouldSpawnIronGolems(int population, int doorCount) {
+ return population >= 10 && doorCount >= 21;
+ }
+
+ public static int computeHash(Coords center, Integer radius, boolean spawnsIronGolems, Set<Coords> doors) {
+ int result = (center.hashCode() * 31) + radius;
+ for (Coords door : doors) {
+ result = (31 * result) + door.hashCode();
+ }
+ if (spawnsIronGolems) {
+ result = 31 * result;
+ }
+ return result;
+ }
+}
import com.irtimaled.bbor.common.events.VillageRemoved;
import com.irtimaled.bbor.common.models.BoundingBoxVillage;
+import com.irtimaled.bbor.common.models.Coords;
import net.minecraft.village.Village;
import net.minecraft.village.VillageCollection;
+import net.minecraft.village.VillageDoorInfo;
import net.minecraft.world.dimension.DimensionType;
-import java.util.HashMap;
-import java.util.Map;
+import java.util.*;
class VillageProcessor {
- private final DimensionType dimensionType;
private final BoundingBoxCache boundingBoxCache;
private Map<Integer, BoundingBoxVillage> villageCache = new HashMap<>();
+ private DimensionType dimensionId;
- VillageProcessor(DimensionType dimensionType, BoundingBoxCache boundingBoxCache) {
-
- this.dimensionType = dimensionType;
+ VillageProcessor(DimensionType dimensionId, BoundingBoxCache boundingBoxCache) {
+ this.dimensionId = dimensionId;
this.boundingBoxCache = boundingBoxCache;
}
for (Village village : villageCollection.getVillageList()) {
int villageId = village.hashCode();
BoundingBoxVillage newVillage = oldVillages.get(villageId);
- if (newVillage != null && newVillage.matches(village)) {
+ if (areEquivalent(village, newVillage)) {
oldVillages.remove(villageId);
} else {
- newVillage = BoundingBoxVillage.from(village);
+ newVillage = buildBoundingBox(village);
boundingBoxCache.addBoundingBox(newVillage);
}
newVillages.put(villageId, newVillage);
}
for (BoundingBoxVillage village : oldVillages.values()) {
boundingBoxCache.removeBoundingBox(village);
- EventBus.publish(new VillageRemoved(dimensionType, village));
+ EventBus.publish(new VillageRemoved(dimensionId, village));
}
villageCache = newVillages;
}
+ private static Set<Coords> getDoorsFromVillage(Village village) {
+ Set<Coords> doors = new HashSet<>();
+ List<VillageDoorInfo> doorInfoList = village.getVillageDoorInfoList();
+ for (VillageDoorInfo doorInfo : doorInfoList) {
+ doors.add(new Coords(doorInfo.getDoorBlockPos()));
+ }
+ return doors;
+ }
+
+ private boolean areEquivalent(Village village, BoundingBoxVillage newVillage) {
+ if (newVillage == null) return false;
+ Coords center = new Coords(village.getCenter());
+ int radius = village.getVillageRadius();
+ boolean spawnsIronGolems = VillageHelper.shouldSpawnIronGolems(village.getNumVillagers(), village.getNumVillageDoors());
+ Set<Coords> doors = getDoorsFromVillage(village);
+ int villageHash = VillageHelper.computeHash(center, radius, spawnsIronGolems, doors);
+ return newVillage.getVillageHash() == villageHash;
+ }
+
+ private BoundingBoxVillage buildBoundingBox(Village village) {
+ Coords center = new Coords(village.getCenter());
+ int radius = village.getVillageRadius();
+ Set<Coords> doors = getDoorsFromVillage(village);
+ return BoundingBoxVillage.from(center, radius, village.hashCode(), village.getNumVillagers(), doors);
+ }
+
void clear() {
villageCache.clear();
}
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 java.util.Set;
public class ChunkProcessor {
- protected Set<BoundingBoxType> supportedStructures = new HashSet<>();
+ Set<BoundingBoxType> supportedStructures = new HashSet<>();
ChunkProcessor(BoundingBoxCache boundingBoxCache) {
this.boundingBoxCache = boundingBoxCache;
}
- protected final BoundingBoxCache boundingBoxCache;
+ private final BoundingBoxCache boundingBoxCache;
private void addStructures(BoundingBoxType type, Map<String, StructureStart> structureMap) {
StructureStart structureStart = structureMap.get(type.getName());
MutableBoundingBox bb = structureStart.getBoundingBox();
if (bb == null) return;
- BoundingBox boundingBox = BoundingBoxStructure.from(bb, type);
+ BoundingBox boundingBox = buildStructure(bb, type);
if (boundingBoxCache.isCached(boundingBox)) return;
Set<BoundingBox> structureBoundingBoxes = new HashSet<>();
for (StructurePiece structureComponent : structureStart.getComponents()) {
- structureBoundingBoxes.add(BoundingBoxStructure.from(structureComponent.getBoundingBox(), type));
+ 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) {
- boundingBoxCache.addBoundingBox(BoundingBoxMobSpawner.from(tileEntity.getPos()));
+ Coords coords = new Coords(tileEntity.getPos());
+ boundingBoxCache.addBoundingBox(BoundingBoxMobSpawner.from(coords));
}
}
}
package com.irtimaled.bbor.common.events;
-import net.minecraft.util.math.BlockPos;
+import com.irtimaled.bbor.common.models.Coords;
import net.minecraft.world.dimension.DimensionType;
public class MobSpawnerBroken {
private final DimensionType dimensionType;
- private final BlockPos pos;
+ private final Coords pos;
- public MobSpawnerBroken(DimensionType dimensionType, BlockPos pos) {
+ public MobSpawnerBroken(DimensionType dimensionType, Coords pos) {
this.dimensionType = dimensionType;
this.pos = pos;
}
return dimensionType;
}
- public BlockPos getPos() {
+ public Coords getPos() {
return pos;
}
}
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 com.irtimaled.bbor.common.models.BoundingBoxVillage;
+import com.irtimaled.bbor.common.models.*;
import net.minecraft.network.PacketBuffer;
-import net.minecraft.util.math.BlockPos;
import java.awt.*;
import java.util.HashSet;
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);
- return BoundingBoxStructure.from(minBlockPos, maxBlockPos, type);
+ Coords minCoords = deserializeCoords(buf);
+ Coords maxCoords = deserializeCoords(buf);
+ return BoundingBoxStructure.from(minCoords, maxCoords, type);
}
private static BoundingBox deserializeVillage(PacketBuffer buf) {
- BlockPos center = deserializeBlockPos(buf);
+ Coords center = deserializeCoords(buf);
int radius = buf.readVarInt();
boolean spawnsIronGolems = buf.readBoolean();
Color color = new Color(buf.readVarInt());
- Set<BlockPos> doors = new HashSet<>();
+ Set<Coords> doors = new HashSet<>();
while (buf.isReadable()) {
- BlockPos door = deserializeBlockPos(buf);
+ Coords door = deserializeCoords(buf);
doors.add(door);
}
return BoundingBoxVillage.from(center, radius, color, spawnsIronGolems, doors);
}
private static BoundingBox deserializeMobSpawner(PacketBuffer buf) {
- BlockPos center = deserializeBlockPos(buf);
+ Coords center = deserializeCoords(buf);
return BoundingBoxMobSpawner.from(center);
}
- private static BlockPos deserializeBlockPos(PacketBuffer buf) {
+ private static Coords deserializeCoords(PacketBuffer buf) {
int x = buf.readVarInt();
int y = buf.readVarInt();
int z = buf.readVarInt();
- return new BlockPos(x, y, z);
+ return new Coords(x, y, z);
}
}
package com.irtimaled.bbor.common.messages;
-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.BoundingBoxVillage;
+import com.irtimaled.bbor.common.models.*;
import net.minecraft.network.PacketBuffer;
-import net.minecraft.util.math.BlockPos;
import java.awt.*;
import java.util.HashMap;
private static void serializeVillage(BoundingBoxVillage boundingBox, PacketBuffer buf) {
buf.writeChar('V');
- serializeBlockPos(boundingBox.getCenter(), buf);
+ serializeCoords(boundingBox.getCenter(), buf);
buf.writeVarInt(boundingBox.getRadius());
buf.writeBoolean(boundingBox.getSpawnsIronGolems());
serializeColor(boundingBox.getColor(), buf);
- for (BlockPos door : boundingBox.getDoors()) {
- serializeBlockPos(door, buf);
+ for (Coords door : boundingBox.getDoors()) {
+ serializeCoords(door, buf);
}
}
private static void serializeMobSpawner(BoundingBoxMobSpawner boundingBox, PacketBuffer buf) {
buf.writeChar('M');
- serializeBlockPos(boundingBox.getCenter(), buf);
+ serializeCoords(boundingBox.getCoords(), buf);
}
private static void serializeColor(Color color, PacketBuffer buf) {
}
private static void serializeCuboid(BoundingBox boundingBox, PacketBuffer buf) {
- serializeBlockPos(boundingBox.getMinBlockPos(), buf);
- serializeBlockPos(boundingBox.getMaxBlockPos(), buf);
+ serializeCoords(boundingBox.getMinCoords(), buf);
+ serializeCoords(boundingBox.getMaxCoords(), buf);
}
- private static void serializeBlockPos(BlockPos blockPos, PacketBuffer buf) {
- buf.writeVarInt(blockPos.getX());
- buf.writeVarInt(blockPos.getY());
- buf.writeVarInt(blockPos.getZ());
+ private static void serializeCoords(Coords coords, PacketBuffer buf) {
+ buf.writeVarInt(coords.getX());
+ buf.writeVarInt(coords.getY());
+ buf.writeVarInt(coords.getZ());
}
}
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 BlockPos minBlockPos;
- private final BlockPos maxBlockPos;
+ private final Coords minCoords;
+ private final Coords maxCoords;
private final BoundingBoxType type;
- protected BoundingBox(BlockPos minBlockPos, BlockPos maxBlockPos, BoundingBoxType type) {
- this.minBlockPos = minBlockPos;
- this.maxBlockPos = maxBlockPos;
+ protected BoundingBox(Coords minCoords, Coords maxCoords, BoundingBoxType type) {
+ this.minCoords = minCoords;
+ this.maxCoords = maxCoords;
this.type = type;
}
public int hashCode() {
final int prime = 31;
int result = 1;
- result = prime * result + minBlockPos.hashCode();
- result = prime * result + maxBlockPos.hashCode();
+ result = prime * result + minCoords.hashCode();
+ result = prime * result + maxCoords.hashCode();
return result;
}
if (getClass() != obj.getClass())
return false;
BoundingBox other = (BoundingBox) obj;
- return minBlockPos.equals(other.minBlockPos) && maxBlockPos.equals(other.maxBlockPos);
+ return minCoords.equals(other.minCoords) && maxCoords.equals(other.maxCoords);
}
@Override
public String toString() {
- return "(" + minBlockPos.toString() + "; " + maxBlockPos.toString() + ")";
+ return "(" + minCoords.toString() + "; " + maxCoords.toString() + ")";
}
- public AxisAlignedBB toAxisAlignedBB() {
- return toAxisAlignedBB(true);
+ public Coords getMinCoords() {
+ return minCoords;
}
- public AxisAlignedBB toAxisAlignedBB(boolean extendMaxByOne) {
- AxisAlignedBB axisAlignedBB = new AxisAlignedBB(minBlockPos, maxBlockPos);
- if (extendMaxByOne)
- return axisAlignedBB.expand(1, 1, 1);
- return axisAlignedBB;
- }
-
- public BlockPos getMinBlockPos() {
- return minBlockPos;
- }
-
- public BlockPos getMaxBlockPos() {
- return maxBlockPos;
+ public Coords getMaxCoords() {
+ return maxCoords;
}
public Color getColor() {
return type.getColor();
}
- public Boolean shouldRender() { return type.shouldRender(); }
+ public Boolean shouldRender() {
+ return type.shouldRender();
+ }
public String getTypeName() {
return type.getName();
package com.irtimaled.bbor.common.models;
import com.irtimaled.bbor.common.BoundingBoxType;
-import net.minecraft.util.math.BlockPos;
public class BoundingBoxMobSpawner extends BoundingBox {
- private final BlockPos center;
- private final Integer radius;
+ private final Coords coords;
- private BoundingBoxMobSpawner(BlockPos center, Integer radius, BlockPos minBlockPos, BlockPos maxBlockPos) {
- super(minBlockPos, maxBlockPos, BoundingBoxType.MobSpawner);
- this.center = center;
- this.radius = radius;
+ private BoundingBoxMobSpawner(Coords coords, Coords minCoords, Coords maxCoords) {
+ super(minCoords, maxCoords, BoundingBoxType.MobSpawner);
+ this.coords = coords;
}
- public static BoundingBoxMobSpawner from(BlockPos center) {
- BlockPos minBlockPos = new BlockPos(center.getX() - 5,
- center.getY() - 1,
- center.getZ() - 5);
- BlockPos maxBlockPos = new BlockPos(center.getX() + 5,
- center.getY() + 2,
- center.getZ() + 5);
- return new BoundingBoxMobSpawner(center, 16, minBlockPos, maxBlockPos);
+ public static BoundingBoxMobSpawner from(Coords coords) {
+ Coords minCoords = new Coords(coords.getX() - 5,
+ coords.getY() - 1,
+ coords.getZ() - 5);
+ Coords maxCoords = new Coords(coords.getX() + 5,
+ coords.getY() + 2,
+ coords.getZ() + 5);
+ return new BoundingBoxMobSpawner(coords, minCoords, maxCoords);
}
@Override
public String toString() {
- return "(" + center.toString() + "; " + radius.toString() + ")";
+ return "(" + coords.toString() + ")";
}
- public Integer getRadius() {
- return radius;
- }
-
- public BlockPos getCenter() {
- return center;
+ public Coords getCoords() {
+ return coords;
}
}
package com.irtimaled.bbor.common.models;
import com.irtimaled.bbor.common.BoundingBoxType;
-import net.minecraft.util.math.BlockPos;
public class BoundingBoxSlimeChunk extends BoundingBox {
- private BoundingBoxSlimeChunk(BlockPos minBlockPos, BlockPos maxBlockPos) {
- super(minBlockPos, maxBlockPos, BoundingBoxType.SlimeChunks);
+ private BoundingBoxSlimeChunk(Coords minCoords, Coords maxCoords) {
+ super(minCoords, maxCoords, BoundingBoxType.SlimeChunks);
}
- public static BoundingBoxSlimeChunk from(BlockPos minBlockPos, BlockPos maxBlockPos) {
- return new BoundingBoxSlimeChunk(minBlockPos, maxBlockPos);
+ public static BoundingBoxSlimeChunk from(Coords minCoords, Coords maxCoords) {
+ return new BoundingBoxSlimeChunk(minCoords, maxCoords);
}
}
package com.irtimaled.bbor.common.models;
import com.irtimaled.bbor.common.BoundingBoxType;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.util.math.MutableBoundingBox;
public class BoundingBoxStructure extends BoundingBox {
- private BoundingBoxStructure(BlockPos minBlockPos, BlockPos maxBlockPos, BoundingBoxType type) {
- super(minBlockPos, maxBlockPos, type);
+ private BoundingBoxStructure(Coords minCoords, Coords maxCoords, BoundingBoxType type) {
+ super(minCoords, maxCoords, type);
}
- 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, type);
- }
-
- 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, type);
- }
-
- public static BoundingBoxStructure from(BlockPos minBlockPos, BlockPos maxBlockPos, BoundingBoxType type) {
- return new BoundingBoxStructure(minBlockPos, maxBlockPos, type);
+ public static BoundingBoxStructure from(Coords minCoords, Coords maxCoords, BoundingBoxType type) {
+ return new BoundingBoxStructure(minCoords, maxCoords, type);
}
}
import com.irtimaled.bbor.common.BoundingBoxType;
import com.irtimaled.bbor.common.VillageColorCache;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.village.Village;
-import net.minecraft.village.VillageDoorInfo;
+import com.irtimaled.bbor.common.VillageHelper;
import java.awt.*;
-import java.util.HashSet;
-import java.util.List;
import java.util.Set;
public class BoundingBoxVillage extends BoundingBox {
- private final BlockPos center;
+ private final Coords center;
private final Integer radius;
private final boolean spawnsIronGolems;
private final Color color;
- private Set<BlockPos> doors;
+ private Set<Coords> 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, BoundingBoxType.Village);
+ private BoundingBoxVillage(Coords center, Integer radius, Color color, boolean spawnsIronGolems, Set<Coords> doors, Coords minCoords, Coords maxCoords) {
+ super(minCoords, maxCoords, BoundingBoxType.Village);
this.center = center;
this.radius = radius;
this.color = color;
this.spawnsIronGolems = spawnsIronGolems;
this.doors = doors;
- this.villageHash = computeHash(center, radius, spawnsIronGolems, doors);
+ this.villageHash = VillageHelper.computeHash(center, radius, spawnsIronGolems, doors);
calculateCenterOffsets(doors);
}
- public static BoundingBoxVillage from(BlockPos center, Integer radius, Color color, boolean spawnsIronGolems, Set<BlockPos> doors) {
- BlockPos minBlockPos = new BlockPos(center.getX() - radius,
+ public static BoundingBoxVillage from(Coords center, Integer radius, Color color, boolean spawnsIronGolems, Set<Coords> doors) {
+ Coords minCoords = new Coords(center.getX() - radius,
center.getY() - 4,
center.getZ() - radius);
- BlockPos maxBlockPos = new BlockPos(center.getX() + radius,
+ Coords maxCoords = new Coords(center.getX() + radius,
center.getY() + 4,
center.getZ() + radius);
- return new BoundingBoxVillage(center, radius, color, spawnsIronGolems, doors, minBlockPos, maxBlockPos);
+ return new BoundingBoxVillage(center, radius, color, spawnsIronGolems, doors, minCoords, maxCoords);
}
- public static BoundingBoxVillage from(BlockPos center, Integer radius, int villageId, int population, Set<BlockPos> doors) {
- boolean spawnsIronGolems = shouldSpawnIronGolems(population, doors.size());
+ public static BoundingBoxVillage from(Coords center, Integer radius, int villageId, int population, Set<Coords> doors) {
+ boolean spawnsIronGolems = VillageHelper.shouldSpawnIronGolems(population, doors.size());
Color color = VillageColorCache.getColor(villageId);
return from(center, radius, color, spawnsIronGolems, doors);
}
- private static boolean shouldSpawnIronGolems(int population, int doorCount) {
- return population >= 10 && doorCount >= 21;
- }
-
- public static BoundingBoxVillage from(Village village) {
- BlockPos center = village.getCenter();
- int radius = village.getVillageRadius();
- Set<BlockPos> doors = getDoorsFromVillage(village);
- return from(center, radius, village.hashCode(), village.getNumVillagers(), doors);
- }
-
- private static Set<BlockPos> getDoorsFromVillage(Village village) {
- Set<BlockPos> doors = new HashSet<>();
- List<VillageDoorInfo> doorInfoList = village.getVillageDoorInfoList();
- for (VillageDoorInfo doorInfo : doorInfoList) {
- doors.add(doorInfo.getDoorBlockPos());
- }
- return doors;
- }
-
- private void calculateCenterOffsets(Set<BlockPos> doors) {
+ private void calculateCenterOffsets(Set<Coords> doors) {
boolean processedFirstDoor = false;
int minX = 0;
int maxX = 0;
int minZ = 0;
int maxZ = 0;
- for (BlockPos door : doors) {
+ for (Coords door : doors) {
if (!processedFirstDoor ||
(minX > door.getX()))
minX = door.getX();
return radius;
}
- public BlockPos getCenter() {
+ public Coords getCenter() {
return center;
}
- public Color getColor() { return color; }
+ public Color getColor() {
+ return color;
+ }
public Double getCenterOffsetX() {
return centerOffsetX;
return centerOffsetZ;
}
- private static int computeHash(BlockPos center, Integer radius, boolean spawnsIronGolems, Set<BlockPos> doors) {
- int result = (center.hashCode() * 31) + radius;
- for (BlockPos door : doors) {
- result = (31 * result) + door.hashCode();
- }
- if (spawnsIronGolems) {
- result = 31 * result;
- }
- return result;
- }
-
- public boolean matches(Village village) {
- return this.villageHash == computeHash(village.getCenter(),
- village.getVillageRadius(),
- shouldSpawnIronGolems(village.getNumVillagers(), village.getNumVillageDoors()),
- getDoorsFromVillage(village));
- }
-
@Override
public int hashCode() {
return (super.hashCode() * 31) + villageHash;
return spawnsIronGolems;
}
- public Set<BlockPos> getDoors() {
+ public Set<Coords> getDoors() {
return doors;
}
+
+ public int getVillageHash() {
+ return villageHash;
+ }
}
package com.irtimaled.bbor.common.models;
import com.irtimaled.bbor.common.BoundingBoxType;
-import net.minecraft.util.math.BlockPos;
public class BoundingBoxWorldSpawn extends BoundingBox {
- private BoundingBoxWorldSpawn(BlockPos minBlockPos, BlockPos maxBlockPos, BoundingBoxType type) {
- super(minBlockPos, maxBlockPos, type);
+ private BoundingBoxWorldSpawn(Coords minCoords, Coords maxCoords, BoundingBoxType type) {
+ super(minCoords, maxCoords, type);
}
- public static BoundingBoxWorldSpawn from(BlockPos minBlockPos, BlockPos maxBlockPos, BoundingBoxType type) {
- return new BoundingBoxWorldSpawn(minBlockPos, maxBlockPos, type);
+ public static BoundingBoxWorldSpawn from(Coords minCoords, Coords maxCoords, BoundingBoxType type) {
+ return new BoundingBoxWorldSpawn(minCoords, maxCoords, type);
}
}
--- /dev/null
+package com.irtimaled.bbor.common.models;
+
+import com.irtimaled.bbor.common.MathHelper;
+import net.minecraft.util.math.BlockPos;
+
+public class Coords {
+ private final int x;
+ private final int y;
+ private final int z;
+
+ public Coords(int x, int y, int z) {
+ this.x = x;
+ this.y = y;
+ this.z = z;
+ }
+
+ public Coords(double x, double y, double z) {
+ this.x = MathHelper.floor(x);
+ this.y = MathHelper.floor(y);
+ this.z = MathHelper.floor(z);
+ }
+
+ public Coords(BlockPos blockPos) {
+ this(blockPos.getX(), blockPos.getY(), blockPos.getZ());
+ }
+
+ public int getX() {
+ return x;
+ }
+
+ public int getY() {
+ return y;
+ }
+
+ public int getZ() {
+ return z;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (this == other) {
+ return true;
+ }
+
+ if (!(other instanceof Coords)) {
+ return false;
+ }
+
+ Coords coords = (Coords)other;
+ return this.getX() == coords.getX() &&
+ this.getY() == coords.getY() &&
+ this.getZ() == coords.getZ();
+ }
+
+ @Override
+ public int hashCode() {
+ return (this.getY() + this.getZ() * 31) * 31 + this.getX();
+ }
+}
+
import com.irtimaled.bbor.common.EventBus;
import com.irtimaled.bbor.common.events.MobSpawnerBroken;
+import com.irtimaled.bbor.common.models.Coords;
import net.minecraft.block.Block;
import net.minecraft.block.BlockMobSpawner;
import net.minecraft.server.management.PlayerInteractionManager;
private void tryHarvestBlock(BlockPos pos, CallbackInfoReturnable<Boolean> cir) {
Block block = this.world.getBlockState(pos).getBlock();
if (block instanceof BlockMobSpawner) {
- EventBus.publish(new MobSpawnerBroken(this.world.dimension.getType(), pos));
+ EventBus.publish(new MobSpawnerBroken(this.world.dimension.getType(), new Coords(pos)));
}
}
}
projects / BoundingBoxOutlineReloaded.git / commitdiff