mirror of
https://github.com/GTNewHorizons/NotEnoughItems.git
synced 2026-11-21 20:52:11 +00:00
421 lines
17 KiB
Java
421 lines
17 KiB
Java
package codechicken.nei.moboverlay;
|
|
|
|
import net.minecraft.block.Block;
|
|
import net.minecraft.entity.Entity;
|
|
import net.minecraft.entity.EnumCreatureType;
|
|
import net.minecraft.entity.passive.EntityPig;
|
|
import net.minecraft.entity.player.EntityPlayer;
|
|
import net.minecraft.util.AxisAlignedBB;
|
|
import net.minecraft.world.EnumSkyBlock;
|
|
import net.minecraft.world.IWorldAccess;
|
|
import net.minecraft.world.SpawnerAnimals;
|
|
import net.minecraft.world.World;
|
|
import net.minecraft.world.biome.BiomeGenBase;
|
|
import net.minecraft.world.chunk.Chunk;
|
|
|
|
import codechicken.lib.math.MathHelper;
|
|
|
|
/**
|
|
* Spawn modes, and the tops of flat blocks such as carpets, in a box around the player. The spawn modes are from
|
|
* {@link Column#getSpawnMode}: 0 for no spawns, 1 for night only and 2 for any time. The box moves with the player once
|
|
* the player is a few blocks from the box's centre, and {@link #update} scans only the blocks that enter the box.
|
|
* {@link #update} rescans the column of a block or light change on the next tick. On each tick, {@link #update} also
|
|
* rescans a slice of the columns, for changes with no block update, such as a boat that moves into the box.
|
|
*/
|
|
public final class MobOverlayScan {
|
|
|
|
public static final byte NIGHT_ONLY = 1;
|
|
public static final int MIN_RADIUS = 8;
|
|
public static final int MAX_RADIUS = 64;
|
|
public static final int DEFAULT_RADIUS = 32;
|
|
public static final int MIN_VERTICAL_RADIUS = 4;
|
|
public static final int MAX_VERTICAL_RADIUS = 64;
|
|
public static final int DEFAULT_VERTICAL_RADIUS = 16;
|
|
private static final int RECENTRE_DISTANCE = 4;
|
|
private static final int VERTICAL_RECENTRE_DISTANCE = 2;
|
|
private static final int RESCAN_TICKS = 40;
|
|
private static final int SPAWN_MODE_MASK = 3;
|
|
private static final int COVER_TOP_SHIFT = 2;
|
|
private static final int COVER_TOP_STEPS = 32;
|
|
|
|
private final IWorldAccess changeListener = new ChangeListener();
|
|
private final Column column = new Column();
|
|
private int radius;
|
|
private int verticalRadius;
|
|
private int span;
|
|
private int height;
|
|
// a ring buffer over the box, indexed by `findCell()`. A cell has the spawn mode in the bits of `SPAWN_MODE_MASK`,
|
|
// and `Column.readCoverTop()` shifted left by `COVER_TOP_SHIFT`
|
|
private byte[] modes = new byte[0];
|
|
// indexed by `findColumn(x, z)`
|
|
private boolean[] dirty = new boolean[0];
|
|
private boolean hasDirtyColumns;
|
|
private int minX;
|
|
private int minY;
|
|
private int minZ;
|
|
// the slice rescan of `update()` continues from this column, numbered `(x - minX) * span + (z - minZ)`
|
|
private int nextRescanColumn;
|
|
private int modesVersion;
|
|
private boolean hasModes;
|
|
private long scannedTick;
|
|
// world of `modes`, with `changeListener` added
|
|
private World scannedWorld;
|
|
|
|
public void clear() {
|
|
if (scannedWorld == null && span == 0) return;
|
|
|
|
if (scannedWorld != null) scannedWorld.removeWorldAccess(changeListener);
|
|
radius = 0;
|
|
verticalRadius = 0;
|
|
span = 0;
|
|
height = 0;
|
|
modes = new byte[0];
|
|
dirty = new boolean[0];
|
|
hasModes = false;
|
|
scannedWorld = null;
|
|
// `Chunk.worldObj` references the world
|
|
column.chunk = null;
|
|
}
|
|
|
|
/**
|
|
* Scan every column in this call after {@link #clear}, a change of either radius, a world change, or a move of
|
|
* {@link #getSpan} blocks or more across or {@link #getHeight} blocks or more up or down. {@code newRadius} is
|
|
* clamped between {@link #MIN_RADIUS} and {@link #MAX_RADIUS}, and {@code newVerticalRadius} between
|
|
* {@link #MIN_VERTICAL_RADIUS} and {@link #MAX_VERTICAL_RADIUS}.
|
|
*/
|
|
public void update(Entity entity, int newRadius, int newVerticalRadius) {
|
|
final World world = entity.worldObj;
|
|
final int clampedRadius = (int) MathHelper.clip(newRadius, MIN_RADIUS, MAX_RADIUS);
|
|
final int clampedVerticalRadius = (int) MathHelper
|
|
.clip(newVerticalRadius, MIN_VERTICAL_RADIUS, MAX_VERTICAL_RADIUS);
|
|
if (radius != clampedRadius || verticalRadius != clampedVerticalRadius) {
|
|
resize(clampedRadius, clampedVerticalRadius);
|
|
}
|
|
final int centreX = MathHelper.floor_double(entity.posX);
|
|
final int centreY = (int) MathHelper.clip(entity.posY, verticalRadius, world.getHeight() - verticalRadius);
|
|
final int centreZ = MathHelper.floor_double(entity.posZ);
|
|
final boolean isNearBox = Math.abs(centreX - radius - minX) < span && Math.abs(centreZ - radius - minZ) < span
|
|
&& Math.abs(centreY - verticalRadius - minY) < height;
|
|
if (!(hasModes && world == scannedWorld && isNearBox)) {
|
|
if (world != scannedWorld) watchWorld(world);
|
|
scanFullBox(centreX, centreY, centreZ);
|
|
return;
|
|
}
|
|
|
|
final long worldTicks = world.getTotalWorldTime();
|
|
if (worldTicks == scannedTick) return;
|
|
|
|
scannedTick = worldTicks;
|
|
boolean isChanged = moveBox(centreX, centreY, centreZ);
|
|
if (hasDirtyColumns) isChanged |= rescanDirtyColumns();
|
|
isChanged |= rescanSlice();
|
|
if (isChanged) modesVersion++;
|
|
}
|
|
|
|
/** The version changes when a spawn mode or the top of a flat block changes, or the box moves. */
|
|
public int getModesVersion() {
|
|
return modesVersion;
|
|
}
|
|
|
|
public int getSpan() {
|
|
return span;
|
|
}
|
|
|
|
public int getHeight() {
|
|
return height;
|
|
}
|
|
|
|
public int getMinX() {
|
|
return minX;
|
|
}
|
|
|
|
public int getMinY() {
|
|
return minY;
|
|
}
|
|
|
|
public int getMinZ() {
|
|
return minZ;
|
|
}
|
|
|
|
/** {@code i} and {@code j} are from 0 to {@link #getSpan}, and {@code k} is from 0 to {@link #getHeight}. */
|
|
public byte readSpawnMode(int i, int k, int j) {
|
|
return (byte) (modes[findCell(minX + i, minY + k, minZ + j)] & SPAWN_MODE_MASK);
|
|
}
|
|
|
|
/**
|
|
* Height of the overlay above the bottom of the block, so that a flat block such as a carpet does not cover the
|
|
* overlay. The indices are those of {@link #readSpawnMode}.
|
|
*/
|
|
public double readOverlayYOffset(int i, int k, int j) {
|
|
final double OVERLAY_GAP = 0.02;
|
|
final int coverTopSteps = modes[findCell(minX + i, minY + k, minZ + j)] >> COVER_TOP_SHIFT;
|
|
return (double) coverTopSteps / COVER_TOP_STEPS + OVERLAY_GAP;
|
|
}
|
|
|
|
private void resize(int newRadius, int newVerticalRadius) {
|
|
radius = newRadius;
|
|
verticalRadius = newVerticalRadius;
|
|
span = 2 * newRadius + 1;
|
|
height = 2 * newVerticalRadius + 1;
|
|
modes = new byte[span * span * height];
|
|
dirty = new boolean[span * span];
|
|
hasModes = false;
|
|
nextRescanColumn = 0;
|
|
}
|
|
|
|
private void scanFullBox(int centreX, int centreY, int centreZ) {
|
|
minX = centreX - radius;
|
|
minY = centreY - verticalRadius;
|
|
minZ = centreZ - radius;
|
|
for (int x = minX; x < minX + span; x++) {
|
|
for (int z = minZ; z < minZ + span; z++) {
|
|
scanColumn(x, z);
|
|
}
|
|
}
|
|
hasModes = true;
|
|
modesVersion++;
|
|
scannedTick = scannedWorld.getTotalWorldTime();
|
|
}
|
|
|
|
private void watchWorld(World world) {
|
|
if (scannedWorld != null) scannedWorld.removeWorldAccess(changeListener);
|
|
world.addWorldAccess(changeListener);
|
|
scannedWorld = world;
|
|
}
|
|
|
|
/** @return whether the box moved */
|
|
private boolean moveBox(int centreX, int centreY, int centreZ) {
|
|
boolean isMoved = false;
|
|
final int offsetX = centreX - radius - minX;
|
|
if (Math.abs(offsetX) > RECENTRE_DISTANCE) {
|
|
final int enteringX = offsetX > 0 ? minX + span : minX + offsetX;
|
|
minX += offsetX;
|
|
for (int x = enteringX; x < enteringX + Math.abs(offsetX); x++) {
|
|
for (int z = minZ; z < minZ + span; z++) {
|
|
scanColumn(x, z);
|
|
}
|
|
}
|
|
isMoved = true;
|
|
}
|
|
|
|
final int offsetZ = centreZ - radius - minZ;
|
|
if (Math.abs(offsetZ) > RECENTRE_DISTANCE) {
|
|
final int enteringZ = offsetZ > 0 ? minZ + span : minZ + offsetZ;
|
|
minZ += offsetZ;
|
|
for (int x = minX; x < minX + span; x++) {
|
|
for (int z = enteringZ; z < enteringZ + Math.abs(offsetZ); z++) {
|
|
scanColumn(x, z);
|
|
}
|
|
}
|
|
isMoved = true;
|
|
}
|
|
|
|
final int offsetY = centreY - verticalRadius - minY;
|
|
if (Math.abs(offsetY) > VERTICAL_RECENTRE_DISTANCE) {
|
|
final int enteringY = offsetY > 0 ? minY + height : minY + offsetY;
|
|
minY += offsetY;
|
|
for (int x = minX; x < minX + span; x++) {
|
|
for (int z = minZ; z < minZ + span; z++) {
|
|
column.moveTo(x, z);
|
|
column.scan(enteringY, enteringY + Math.abs(offsetY));
|
|
}
|
|
}
|
|
isMoved = true;
|
|
}
|
|
return isMoved;
|
|
}
|
|
|
|
private boolean rescanDirtyColumns() {
|
|
hasDirtyColumns = false;
|
|
boolean isChanged = false;
|
|
for (int x = minX; x < minX + span; x++) {
|
|
for (int z = minZ; z < minZ + span; z++) {
|
|
if (dirty[findColumn(x, z)]) isChanged |= scanColumn(x, z);
|
|
}
|
|
}
|
|
return isChanged;
|
|
}
|
|
|
|
private boolean rescanSlice() {
|
|
final int columnCount = span * span;
|
|
final int sliceEnd = Math.min(columnCount, nextRescanColumn + (columnCount + RESCAN_TICKS - 1) / RESCAN_TICKS);
|
|
boolean isChanged = false;
|
|
for (; nextRescanColumn < sliceEnd; nextRescanColumn++) {
|
|
final int x = minX + nextRescanColumn / span;
|
|
final int z = minZ + nextRescanColumn % span;
|
|
isChanged |= scanColumn(x, z);
|
|
}
|
|
if (nextRescanColumn >= columnCount) nextRescanColumn = 0;
|
|
return isChanged;
|
|
}
|
|
|
|
/** @return whether a spawn mode or the top of a flat block changed */
|
|
private boolean scanColumn(int x, int z) {
|
|
column.moveTo(x, z);
|
|
dirty[findColumn(x, z)] = false;
|
|
return column.scan(minY, minY + height);
|
|
}
|
|
|
|
private int findColumn(int x, int z) {
|
|
return Math.floorMod(x, span) * span + Math.floorMod(z, span);
|
|
}
|
|
|
|
private int findCell(int x, int y, int z) {
|
|
return findColumn(x, z) * height + Math.floorMod(y, height);
|
|
}
|
|
|
|
/**
|
|
* {@link #moveTo} reads a column's chunk, biome and highest non-air block in the box, and {@link #scan} reads the
|
|
* column's blocks.
|
|
*/
|
|
private final class Column {
|
|
|
|
private final Entity dummyEntity = new EntityPig(null);
|
|
private final AxisAlignedBB spawnBox = AxisAlignedBB.getBoundingBox(0, 0, 0, 0, 0, 0);
|
|
private int x;
|
|
private int z;
|
|
private Chunk chunk;
|
|
private int topY;
|
|
private boolean canBiomeSpawn;
|
|
|
|
private void moveTo(int newX, int newZ) {
|
|
x = newX;
|
|
z = newZ;
|
|
final BiomeGenBase biome = scannedWorld.getBiomeGenForCoords(x, z);
|
|
canBiomeSpawn = !biome.getSpawnableList(EnumCreatureType.monster).isEmpty()
|
|
&& biome.getSpawningChance() > 0;
|
|
chunk = scannedWorld.getChunkFromBlockCoords(x, z);
|
|
// `getHeightValue()` is the height above the highest block with a light opacity above 0. A block with a
|
|
// light opacity of 0 can be higher: Tinkers' Construct slime grass, a hopper or a snow layer. A mob can
|
|
// spawn on top of slime grass, a hopper or a full snow block. Search the blocks for the highest non-air
|
|
// block
|
|
final int SECTION_HEIGHT = 16;
|
|
int y = Math.min(minY + height - 1, chunk.getTopFilledSegment() + SECTION_HEIGHT - 1);
|
|
while (y >= minY && chunk.getBlock(x & 15, y, z & 15).isAir(chunk.worldObj, x, y, z)) y--;
|
|
topY = y + 1;
|
|
}
|
|
|
|
/** @return whether a spawn mode or the top of a flat block changed */
|
|
private boolean scan(int fromY, int toY) {
|
|
boolean isChanged = false;
|
|
for (int y = fromY; y < toY; y++) {
|
|
final int spawnMode = canBiomeSpawn && y <= topY ? getSpawnMode(y) : 0;
|
|
final byte cellValue = (byte) (spawnMode == 0 ? 0 : spawnMode | (readCoverTop(y) << COVER_TOP_SHIFT));
|
|
final int cell = findCell(x, y, z);
|
|
isChanged |= modes[cell] != cellValue;
|
|
modes[cell] = cellValue;
|
|
}
|
|
return isChanged;
|
|
}
|
|
|
|
/** The spawn mode of the block at height {@code y} in this column. */
|
|
private byte getSpawnMode(int y) {
|
|
if (y >= chunk.worldObj.getHeight()) {
|
|
return 0;
|
|
}
|
|
|
|
if (chunk.getSavedLightValue(EnumSkyBlock.Block, x & 15, y, z & 15) >= 8 || !SpawnerAnimals
|
|
.canCreatureTypeSpawnAtLocation(EnumCreatureType.monster, chunk.worldObj, x, y, z)) {
|
|
return 0;
|
|
}
|
|
|
|
// the size of a zombie, a creeper and a skeleton that is not a wither skeleton. A taller or wider monster,
|
|
// such as an enderman or a spider, needs more room
|
|
final double MOB_WIDTH = 0.6;
|
|
final double MOB_HEIGHT = 1.8;
|
|
spawnBox.minX = x + 0.5 - MOB_WIDTH / 2;
|
|
spawnBox.maxX = x + 0.5 + MOB_WIDTH / 2;
|
|
spawnBox.minY = y;
|
|
spawnBox.maxY = y + MOB_HEIGHT;
|
|
spawnBox.minZ = z + 0.5 - MOB_WIDTH / 2;
|
|
spawnBox.maxZ = z + 0.5 + MOB_WIDTH / 2;
|
|
if (!chunk.worldObj.getCollidingBoundingBoxes(dummyEntity, spawnBox).isEmpty()
|
|
|| chunk.worldObj.isAnyLiquid(spawnBox)) {
|
|
return 0;
|
|
}
|
|
|
|
return (byte) (chunk.getSavedLightValue(EnumSkyBlock.Sky, x & 15, y, z & 15) >= 8 ? 1 : 2);
|
|
}
|
|
|
|
/**
|
|
* The top of the block at height {@code y}, in fractions of a block with {@link MobOverlayScan#COVER_TOP_STEPS}
|
|
* as the denominator, or 0 for a tall block.
|
|
*/
|
|
private int readCoverTop(int y) {
|
|
final double MAX_COVER_TOP = 0.25;
|
|
final Block block = chunk.getBlock(x & 15, y, z & 15);
|
|
block.setBlockBoundsBasedOnState(chunk.worldObj, x, y, z);
|
|
final double top = block.getBlockBoundsMaxY();
|
|
// a mark on the bounds of a plant or a sloped rail would float above most of the block. Keep the mark at
|
|
// the floor for a tall block
|
|
return top > MAX_COVER_TOP ? 0 : (int) Math.ceil(top * COVER_TOP_STEPS);
|
|
}
|
|
}
|
|
|
|
/** Marks the columns of the block and light changes in {@link #scannedWorld}. */
|
|
private final class ChangeListener implements IWorldAccess {
|
|
|
|
@Override
|
|
public void markBlockForUpdate(int x, int y, int z) {
|
|
markChanged(x, y, z);
|
|
}
|
|
|
|
@Override
|
|
public void markBlockForRenderUpdate(int x, int y, int z) {
|
|
markChanged(x, y, z);
|
|
}
|
|
|
|
@Override
|
|
public void markBlockRangeForRenderUpdate(int fromX, int fromY, int fromZ, int toX, int toY, int toZ) {
|
|
for (int x = Math.max(fromX, minX); x <= Math.min(toX, minX + span - 1); x++) {
|
|
for (int z = Math.max(fromZ, minZ); z <= Math.min(toZ, minZ + span - 1); z++) {
|
|
markColumn(x, z);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void playSound(String soundName, double x, double y, double z, float volume, float pitch) {}
|
|
|
|
@Override
|
|
public void playSoundToNearExcept(EntityPlayer player, String soundName, double x, double y, double z,
|
|
float volume, float pitch) {}
|
|
|
|
@Override
|
|
public void spawnParticle(String particleName, double x, double y, double z, double velocityX, double velocityY,
|
|
double velocityZ) {}
|
|
|
|
@Override
|
|
public void onEntityCreate(Entity entity) {}
|
|
|
|
@Override
|
|
public void onEntityDestroy(Entity entity) {}
|
|
|
|
@Override
|
|
public void playRecord(String recordName, int x, int y, int z) {}
|
|
|
|
@Override
|
|
public void broadcastSound(int soundId, int x, int y, int z, int data) {}
|
|
|
|
@Override
|
|
public void playAuxSFX(EntityPlayer player, int sfxType, int x, int y, int z, int data) {}
|
|
|
|
@Override
|
|
public void destroyBlockPartially(int breakerId, int x, int y, int z, int progress) {}
|
|
|
|
@Override
|
|
public void onStaticEntitiesChanged() {}
|
|
|
|
private void markChanged(int x, int y, int z) {
|
|
// spawn modes depend on the block below and the block above
|
|
final boolean isInBox = x >= minX && x < minX + span && z >= minZ && z < minZ + span;
|
|
if (isInBox && y >= minY - 1 && y <= minY + height) markColumn(x, z);
|
|
}
|
|
|
|
private void markColumn(int x, int z) {
|
|
dirty[findColumn(x, z)] = true;
|
|
hasDirtyColumns = true;
|
|
}
|
|
}
|
|
}
|