cn.nukkit.level.Level Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of powernukkit Show documentation
Show all versions of powernukkit Show documentation
A Minecraft Bedrock Edition server software implementation made in Java from scratch which supports all new features.
package cn.nukkit.level;
import cn.nukkit.Player;
import cn.nukkit.Server;
import cn.nukkit.api.DeprecationDetails;
import cn.nukkit.api.PowerNukkitDifference;
import cn.nukkit.api.PowerNukkitOnly;
import cn.nukkit.api.Since;
import cn.nukkit.block.*;
import cn.nukkit.blockentity.BlockEntity;
import cn.nukkit.blockstate.BlockState;
import cn.nukkit.blockstate.exception.InvalidBlockStateException;
import cn.nukkit.entity.Entity;
import cn.nukkit.entity.item.EntityItem;
import cn.nukkit.entity.item.EntityXPOrb;
import cn.nukkit.entity.projectile.EntityArrow;
import cn.nukkit.entity.weather.EntityLightning;
import cn.nukkit.event.block.BlockBreakEvent;
import cn.nukkit.event.block.BlockPlaceEvent;
import cn.nukkit.event.block.BlockUpdateEvent;
import cn.nukkit.event.level.*;
import cn.nukkit.event.player.PlayerInteractEvent;
import cn.nukkit.event.player.PlayerInteractEvent.Action;
import cn.nukkit.event.weather.LightningStrikeEvent;
import cn.nukkit.item.Item;
import cn.nukkit.item.ItemBlock;
import cn.nukkit.item.ItemBucket;
import cn.nukkit.item.enchantment.Enchantment;
import cn.nukkit.level.biome.Biome;
import cn.nukkit.level.format.Chunk;
import cn.nukkit.level.format.ChunkSection;
import cn.nukkit.level.format.FullChunk;
import cn.nukkit.level.format.LevelProvider;
import cn.nukkit.level.format.generic.BaseFullChunk;
import cn.nukkit.level.format.generic.BaseLevelProvider;
import cn.nukkit.level.format.generic.EmptyChunkSection;
import cn.nukkit.level.generator.Generator;
import cn.nukkit.level.generator.PopChunkManager;
import cn.nukkit.level.generator.task.GenerationTask;
import cn.nukkit.level.generator.task.LightPopulationTask;
import cn.nukkit.level.generator.task.PopulationTask;
import cn.nukkit.level.particle.DestroyBlockParticle;
import cn.nukkit.level.particle.Particle;
import cn.nukkit.math.*;
import cn.nukkit.math.BlockFace.Plane;
import cn.nukkit.metadata.BlockMetadataStore;
import cn.nukkit.metadata.MetadataValue;
import cn.nukkit.metadata.Metadatable;
import cn.nukkit.nbt.NBTIO;
import cn.nukkit.nbt.tag.*;
import cn.nukkit.network.protocol.*;
import cn.nukkit.plugin.Plugin;
import cn.nukkit.scheduler.AsyncTask;
import cn.nukkit.scheduler.BlockUpdateScheduler;
import cn.nukkit.timings.LevelTimings;
import cn.nukkit.utils.*;
import co.aikar.timings.Timings;
import co.aikar.timings.TimingsHistory;
import com.google.common.base.Preconditions;
import it.unimi.dsi.fastutil.ints.Int2IntMap;
import it.unimi.dsi.fastutil.ints.Int2IntOpenHashMap;
import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
import it.unimi.dsi.fastutil.longs.*;
import it.unimi.dsi.fastutil.objects.ObjectIterator;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.extern.log4j.Log4j2;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import java.io.File;
import java.lang.ref.SoftReference;
import java.util.*;
import java.util.concurrent.*;
import java.util.function.*;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import static cn.nukkit.utils.Utils.dynamic;
/**
* @author MagicDroidX (Nukkit Project)
*/
@Log4j2
public class Level implements ChunkManager, Metadatable {
@PowerNukkitOnly
@Since("1.4.0.0-PN")
public static final Level[] EMPTY_ARRAY = new Level[0];
private static int levelIdCounter = 1;
private static int chunkLoaderCounter = 1;
@SuppressWarnings({"java:S1444", "java:S3008"})
public static int COMPRESSION_LEVEL = 8;
public static final int BLOCK_UPDATE_NORMAL = 1;
public static final int BLOCK_UPDATE_RANDOM = 2;
public static final int BLOCK_UPDATE_SCHEDULED = 3;
public static final int BLOCK_UPDATE_WEAK = 4;
public static final int BLOCK_UPDATE_TOUCH = 5;
public static final int BLOCK_UPDATE_REDSTONE = 6;
public static final int BLOCK_UPDATE_TICK = 7;
@PowerNukkitOnly
@Since("1.4.0.0-PN")
public static final int BLOCK_UPDATE_MOVED = dynamic(1_000_000);
public static final int TIME_DAY = 0;
public static final int TIME_NOON = 6000;
public static final int TIME_SUNSET = 12000;
public static final int TIME_NIGHT = 14000;
public static final int TIME_MIDNIGHT = 18000;
public static final int TIME_SUNRISE = 23000;
public static final int TIME_FULL = 24000;
public static final int DIMENSION_OVERWORLD = 0;
public static final int DIMENSION_NETHER = 1;
public static final int DIMENSION_THE_END = 2;
// Lower values use less memory
public static final int MAX_BLOCK_CACHE = 512;
// The blocks that can randomly tick
private static final boolean[] randomTickBlocks = new boolean[Block.MAX_BLOCK_ID];
static {
randomTickBlocks[BlockID.GRASS] = true;
randomTickBlocks[BlockID.FARMLAND] = true;
randomTickBlocks[BlockID.MYCELIUM] = true;
randomTickBlocks[BlockID.SAPLING] = true;
randomTickBlocks[BlockID.LEAVES] = true;
randomTickBlocks[BlockID.LEAVES2] = true;
randomTickBlocks[BlockID.SNOW_LAYER] = true;
randomTickBlocks[BlockID.ICE] = true;
randomTickBlocks[BlockID.LAVA] = true;
randomTickBlocks[BlockID.STILL_LAVA] = true;
randomTickBlocks[BlockID.CACTUS] = true;
randomTickBlocks[BlockID.BEETROOT_BLOCK] = true;
randomTickBlocks[BlockID.CARROT_BLOCK] = true;
randomTickBlocks[BlockID.POTATO_BLOCK] = true;
randomTickBlocks[BlockID.MELON_STEM] = true;
randomTickBlocks[BlockID.PUMPKIN_STEM] = true;
randomTickBlocks[BlockID.WHEAT_BLOCK] = true;
randomTickBlocks[BlockID.SUGARCANE_BLOCK] = true;
randomTickBlocks[BlockID.RED_MUSHROOM] = true;
randomTickBlocks[BlockID.BROWN_MUSHROOM] = true;
randomTickBlocks[BlockID.NETHER_WART_BLOCK] = true;
randomTickBlocks[BlockID.FIRE] = true;
randomTickBlocks[BlockID.GLOWING_REDSTONE_ORE] = true;
randomTickBlocks[BlockID.COCOA_BLOCK] = true;
randomTickBlocks[BlockID.VINE] = true;
randomTickBlocks[BlockID.CORAL_FAN] = true;
randomTickBlocks[BlockID.CORAL_FAN_DEAD] = true;
randomTickBlocks[BlockID.BLOCK_KELP] = true;
randomTickBlocks[BlockID.SWEET_BERRY_BUSH] = true;
randomTickBlocks[BlockID.TURTLE_EGG] = true;
randomTickBlocks[BlockID.BAMBOO] = true;
randomTickBlocks[BlockID.BAMBOO_SAPLING] = true;
randomTickBlocks[BlockID.CRIMSON_NYLIUM] = true;
randomTickBlocks[BlockID.WARPED_NYLIUM] = true;
randomTickBlocks[BlockID.TWISTING_VINES] = true;
}
@PowerNukkitOnly
@Since("1.4.0.0-PN")
public static boolean canRandomTick(int blockId) {
return blockId < randomTickBlocks.length && randomTickBlocks[blockId];
}
@PowerNukkitOnly
@Since("1.4.0.0-PN")
public static void setCanRandomTick(int blockId, boolean newValue) {
randomTickBlocks[blockId] = newValue;
}
private final Long2ObjectOpenHashMap blockEntities = new Long2ObjectOpenHashMap<>();
private final Long2ObjectOpenHashMap players = new Long2ObjectOpenHashMap<>();
private final Long2ObjectOpenHashMap entities = new Long2ObjectOpenHashMap<>();
public final Long2ObjectOpenHashMap updateEntities = new Long2ObjectOpenHashMap<>();
private final ConcurrentLinkedQueue updateBlockEntities = new ConcurrentLinkedQueue<>();
private boolean cacheChunks = false;
private final Server server;
private final int levelId;
private LevelProvider provider;
private final Int2ObjectOpenHashMap loaders = new Int2ObjectOpenHashMap<>();
private final Int2IntMap loaderCounter = new Int2IntOpenHashMap();
private final Long2ObjectOpenHashMap> chunkLoaders = new Long2ObjectOpenHashMap<>();
private final Long2ObjectOpenHashMap> playerLoaders = new Long2ObjectOpenHashMap<>();
private final Long2ObjectOpenHashMap> chunkPackets = new Long2ObjectOpenHashMap<>();
private final Long2LongMap unloadQueue = Long2LongMaps.synchronize(new Long2LongOpenHashMap());
private float time;
public boolean stopTime;
public float skyLightSubtracted;
private String folderName;
private Vector3 mutableBlock;
// Avoid OOM, gc'd references result in whole chunk being sent (possibly higher cpu)
private final Long2ObjectOpenHashMap>> changedBlocks = new Long2ObjectOpenHashMap<>();
// Storing the vector is redundant
private final Object changeBlocksPresent = new Object();
// Storing extra blocks past 512 is redundant
private final Map changeBlocksFullMap = new HashMap() {
@Override
public int size() {
return Character.MAX_VALUE;
}
};
private final BlockUpdateScheduler updateQueue;
private final Queue normalUpdateQueue = new ConcurrentLinkedDeque<>();
// private final TreeSet updateQueue = new TreeSet<>();
// private final List nextTickUpdates = Lists.newArrayList();
//private final Map updateQueueIndex = new HashMap<>();
private final ConcurrentMap> chunkSendQueue = new ConcurrentHashMap<>();
private final LongSet chunkSendTasks = new LongOpenHashSet();
private final Long2ObjectOpenHashMap chunkPopulationQueue = new Long2ObjectOpenHashMap<>();
private final Long2ObjectOpenHashMap chunkPopulationLock = new Long2ObjectOpenHashMap<>();
private final Long2ObjectOpenHashMap chunkGenerationQueue = new Long2ObjectOpenHashMap<>();
private int chunkGenerationQueueSize = 8;
private int chunkPopulationQueueSize = 2;
private boolean autoSave;
private BlockMetadataStore blockMetadata;
private boolean useSections;
private Position temporalPosition;
private Vector3 temporalVector;
public int sleepTicks = 0;
private int chunkTickRadius;
private final Long2IntMap chunkTickList = new Long2IntOpenHashMap();
private int chunksPerTicks;
private boolean clearChunksOnTick;
private int updateLCG = ThreadLocalRandom.current().nextInt();
private static final int LCG_CONSTANT = 1013904223;
public LevelTimings timings;
private int tickRate;
public int tickRateTime = 0;
public int tickRateCounter = 0;
private Class generatorClass;
private IterableThreadLocal generators = new IterableThreadLocal() {
@Override
public Generator init() {
try {
Generator generator = generatorClass.getConstructor(Map.class).newInstance(requireProvider().getGeneratorOptions());
NukkitRandom rand = new NukkitRandom(getSeed());
ChunkManager manager;
if (Server.getInstance().isPrimaryThread()) {
generator.init(Level.this, rand);
}
generator.init(new PopChunkManager(getSeed()), rand);
return generator;
} catch (Throwable e) {
e.printStackTrace();
return null;
}
}
};
private boolean raining = false;
private int rainTime = 0;
private boolean thundering = false;
private int thunderTime = 0;
private long levelCurrentTick = 0;
private int dimension;
public GameRules gameRules;
public Level(Server server, String name, String path, Class provider) {
this(server, name, path,
()-> {
try {
return (boolean) provider.getMethod("usesChunkSection").invoke(null);
} catch (ReflectiveOperationException e) {
throw new LevelException("usesChunkSection of "+provider+" failed", e);
}
},
(level, levelPath) -> {
try {
return provider.getConstructor(Level.class, String.class).newInstance(level, levelPath);
} catch (ReflectiveOperationException e) {
throw new LevelException("Constructor of "+provider+" failed", e);
}
}
);
}
@PowerNukkitOnly("Makes easier to create tests")
@Since("1.4.0.0-PN")
Level(Server server, String name, File path, boolean usesChunkSection, LevelProvider provider) {
this(server, name, path.getAbsolutePath()+"/", ()-> usesChunkSection, (lvl, p)-> provider);
}
@PowerNukkitOnly("Makes easier to create tests")
@Since("1.4.0.0-PN")
Level(Server server, String name, String path, BooleanSupplier usesChunkSection, BiFunction provider) {
this.levelId = levelIdCounter++;
this.blockMetadata = new BlockMetadataStore(this);
this.server = server;
this.autoSave = server.getAutoSave();
this.provider = provider.apply(this, path);
LevelProvider levelProvider = requireProvider();
this.timings = new LevelTimings(this);
levelProvider.updateLevelName(name);
log.info(this.server.getLanguage().translateString("nukkit.level.preparing",
TextFormat.GREEN + levelProvider.getName() + TextFormat.WHITE));
this.generatorClass = Generator.getGenerator(levelProvider.getGenerator());
this.useSections = usesChunkSection.getAsBoolean();
this.folderName = name;
this.time = levelProvider.getTime();
this.raining = levelProvider.isRaining();
this.rainTime = this.requireProvider().getRainTime();
if (this.rainTime <= 0) {
setRainTime(ThreadLocalRandom.current().nextInt(168000) + 12000);
}
this.thundering = levelProvider.isThundering();
this.thunderTime = levelProvider.getThunderTime();
if (this.thunderTime <= 0) {
setThunderTime(ThreadLocalRandom.current().nextInt(168000) + 12000);
}
this.levelCurrentTick = levelProvider.getCurrentTick();
this.updateQueue = new BlockUpdateScheduler(this, levelCurrentTick);
this.chunkTickRadius = Math.min(this.server.getViewDistance(),
Math.max(1, this.server.getConfig("chunk-ticking.tick-radius", 4)));
this.chunksPerTicks = this.server.getConfig("chunk-ticking.per-tick", 40);
this.chunkGenerationQueueSize = this.server.getConfig("chunk-generation.queue-size", 8);
this.chunkPopulationQueueSize = this.server.getConfig("chunk-generation.population-queue-size", 2);
this.chunkTickList.clear();
this.clearChunksOnTick = this.server.getConfig("chunk-ticking.clear-tick-list", true);
this.cacheChunks = this.server.getConfig("chunk-sending.cache-chunks", false);
this.temporalPosition = new Position(0, 0, 0, this);
this.temporalVector = new Vector3(0, 0, 0);
this.tickRate = 1;
this.skyLightSubtracted = this.calculateSkylightSubtracted(1);
}
public static long chunkHash(int x, int z) {
return (((long) x) << 32) | (z & 0xffffffffL);
}
public static long blockHash(int x, int y, int z) {
if (y < 0 || y >= 256) {
throw new IllegalArgumentException("Y coordinate y is out of range!");
}
return (((long) x & (long) 0xFFFFFFF) << 36) | (((long) y & (long) 0xFF) << 28) | ((long) z & (long) 0xFFFFFFF);
}
public static char localBlockHash(double x, double y, double z) {
byte hi = (byte) (((int) x & 15) + (((int) z & 15) << 4));
byte lo = (byte) y;
return (char) (((hi & 0xFF) << 8) | (lo & 0xFF));
}
public static Vector3 getBlockXYZ(long chunkHash, char blockHash) {
int hi = (byte) (blockHash >>> 8);
int lo = (byte) blockHash;
int y = lo & 0xFF;
int x = (hi & 0xF) + (getHashX(chunkHash) << 4);
int z = ((hi >> 4) & 0xF) + (getHashZ(chunkHash) << 4);
return new Vector3(x, y, z);
}
public static int chunkBlockHash(int x, int y, int z) {
return (x << 12) | (z << 8) | y;
}
public static int getHashX(long hash) {
return (int) (hash >> 32);
}
public static int getHashZ(long hash) {
return (int) hash;
}
public static Vector3 getBlockXYZ(BlockVector3 hash) {
return new Vector3(hash.x, hash.y, hash.z);
}
public static Chunk.Entry getChunkXZ(long hash) {
return new Chunk.Entry(getHashX(hash), getHashZ(hash));
}
public static int generateChunkLoaderId(ChunkLoader loader) {
if (loader.getLoaderId() == 0) {
return chunkLoaderCounter++;
} else {
throw new IllegalStateException("ChunkLoader has a loader id already assigned: " + loader.getLoaderId());
}
}
public int getTickRate() {
return tickRate;
}
public int getTickRateTime() {
return tickRateTime;
}
public void setTickRate(int tickRate) {
this.tickRate = tickRate;
}
public void initLevel() {
Generator generator = generators.get();
this.dimension = generator.getDimension();
this.gameRules = this.requireProvider().getGamerules();
log.info("Preparing start region for level \"{}\"", this.getFolderName());
Position spawn = this.getSpawnLocation();
this.populateChunk(spawn.getChunkX(), spawn.getChunkZ(), true);
}
public Generator getGenerator() {
return generators.get();
}
public BlockMetadataStore getBlockMetadata() {
return this.blockMetadata;
}
public Server getServer() {
return server;
}
public final LevelProvider getProvider() {
return provider;
}
/**
* Returns the level provider if it exists. Tries to close and unregister the level and then throw an exception if it doesn't.
* @throws LevelException If the level is already closed
*/
@PowerNukkitOnly
@Since("1.4.0.0-PN")
@Nonnull
public final LevelProvider requireProvider() {
LevelProvider levelProvider = getProvider();
if (levelProvider == null) {
LevelException levelException = new LevelException("The level \"" + getFolderName() + "\" is already closed (have no providers)");
try {
close();
} catch (Exception e) {
levelException.addSuppressed(e);
}
throw levelException;
}
return levelProvider;
}
public final int getId() {
return this.levelId;
}
public void close() {
LevelProvider levelProvider = this.provider;
if (levelProvider != null) {
if (this.getAutoSave()) {
this.save(true);
}
levelProvider.close();
}
this.provider = null;
this.blockMetadata = null;
this.temporalPosition = null;
this.server.getLevels().remove(this.levelId);
this.generators.clean();
}
public void addSound(Vector3 pos, Sound sound) {
this.addSound(pos, sound, 1, 1, (Player[]) null);
}
public void addSound(Vector3 pos, Sound sound, float volume, float pitch) {
this.addSound(pos, sound, volume, pitch, (Player[]) null);
}
public void addSound(Vector3 pos, Sound sound, float volume, float pitch, Collection players) {
this.addSound(pos, sound, volume, pitch, players.toArray(Player.EMPTY_ARRAY));
}
public void addSound(Vector3 pos, Sound sound, float volume, float pitch, Player... players) {
Preconditions.checkArgument(volume >= 0 && volume <= 1, "Sound volume must be between 0 and 1");
Preconditions.checkArgument(pitch >= 0, "Sound pitch must be higher than 0");
PlaySoundPacket packet = new PlaySoundPacket();
packet.name = sound.getSound();
packet.volume = volume;
packet.pitch = pitch;
packet.x = pos.getFloorX();
packet.y = pos.getFloorY();
packet.z = pos.getFloorZ();
if (players == null || players.length == 0) {
addChunkPacket(pos.getFloorX() >> 4, pos.getFloorZ() >> 4, packet);
} else {
Server.broadcastPacket(players, packet);
}
}
public void addLevelEvent(int type, int data) {
addLevelEvent(type, data, null);
}
public void addLevelEvent(int type, int data, Vector3 pos) {
if (pos == null) {
addLevelEvent(type, data, 0, 0, 0);
} else {
addLevelEvent(type, data, (float) pos.x, (float) pos.y, (float) pos.z);
}
}
public void addLevelEvent(int type, int data, float x, float y, float z) {
LevelEventPacket packet = new LevelEventPacket();
packet.evid = type;
packet.x = x;
packet.y = y;
packet.z = z;
packet.data = data;
this.addChunkPacket(NukkitMath.floorFloat(x) >> 4, NukkitMath.floorFloat(z) >> 4, packet);
}
public void addLevelEvent(Vector3 pos, int event) {
this.addLevelEvent(pos, event, 0);
}
@Since("1.4.0.0-PN")
public void addLevelEvent(Vector3 pos, int event, int data) {
LevelEventPacket pk = new LevelEventPacket();
pk.evid = event;
pk.x = (float) pos.x;
pk.y = (float) pos.y;
pk.z = (float) pos.z;
pk.data = data;
addChunkPacket(pos.getFloorX() >> 4, pos.getFloorZ() >> 4, pk);
}
@PowerNukkitDifference(info = "Default sound method changed to addSound", since = "1.4.0.0-PN")
@Deprecated
@DeprecationDetails(reason = "Old method, use addSound(pos, Sound.).", since = "1.4.0.0-PN")
public void addLevelSoundEvent(Vector3 pos, int type, int data, int entityType) {
addLevelSoundEvent(pos, type, data, entityType, false, false);
}
@PowerNukkitDifference(info = "Default sound method changed to addSound", since = "1.4.0.0-PN")
@Deprecated
@DeprecationDetails(reason = "Old method, use addSound(pos, Sound.).", since = "1.4.0.0-PN")
public void addLevelSoundEvent(Vector3 pos, int type, int data, int entityType, boolean isBaby, boolean isGlobal) {
String identifier = AddEntityPacket.LEGACY_IDS.getOrDefault(entityType, ":");
addLevelSoundEvent(pos, type, data, identifier, isBaby, isGlobal);
}
@PowerNukkitDifference(info = "Default sound method changed to addSound", since = "1.4.0.0-PN")
@Deprecated
@DeprecationDetails(reason = "Old method, use addSound(pos, Sound.).", since = "1.4.0.0-PN")
public void addLevelSoundEvent(Vector3 pos, int type) {
this.addLevelSoundEvent(pos, type, -1);
}
/**
* Broadcasts sound to players
*
* @param pos position where sound should be played
* @param type ID of the sound from {@link cn.nukkit.network.protocol.LevelSoundEventPacket}
* @param data generic data that can affect sound
*/
@PowerNukkitDifference(info = "Default sound method changed to addSound", since = "1.4.0.0-PN")
@Deprecated
@DeprecationDetails(reason = "Old method, use addSound(pos, Sound.).", since = "1.4.0.0-PN")
public void addLevelSoundEvent(Vector3 pos, int type, int data) {
this.addLevelSoundEvent(pos, type, data, ":", false, false);
}
@PowerNukkitDifference(info = "Default sound method changed to addSound", since = "1.4.0.0-PN")
@Deprecated
@DeprecationDetails(reason = "Old method, use addSound(pos, Sound.).", since = "1.4.0.0-PN")
public void addLevelSoundEvent(Vector3 pos, int type, int data, String identifier, boolean isBaby, boolean isGlobal) {
LevelSoundEventPacket pk = new LevelSoundEventPacket();
pk.sound = type;
pk.extraData = data;
pk.entityIdentifier = identifier;
pk.x = (float) pos.x;
pk.y = (float) pos.y;
pk.z = (float) pos.z;
pk.isGlobal = isGlobal;
pk.isBabyMob = isBaby;
this.addChunkPacket(pos.getFloorX() >> 4, pos.getFloorZ() >> 4, pk);
}
public void addParticle(Particle particle) {
this.addParticle(particle, (Player[]) null);
}
public void addParticle(Particle particle, Player player) {
this.addParticle(particle, new Player[]{player});
}
public void addParticle(Particle particle, Player[] players) {
DataPacket[] packets = particle.encode();
if (players == null) {
if (packets != null) {
for (DataPacket packet : packets) {
this.addChunkPacket((int) particle.x >> 4, (int) particle.z >> 4, packet);
}
}
} else {
if (packets != null) {
if (packets.length == 1) {
Server.broadcastPacket(players, packets[0]);
} else {
this.server.batchPackets(players, packets, false);
}
}
}
}
public void addParticle(Particle particle, Collection players) {
this.addParticle(particle, players.toArray(Player.EMPTY_ARRAY));
}
public void addParticleEffect(Vector3 pos, ParticleEffect particleEffect) {
this.addParticleEffect(pos, particleEffect, -1, this.dimension, (Player[]) null);
}
public void addParticleEffect(Vector3 pos, ParticleEffect particleEffect, long uniqueEntityId) {
this.addParticleEffect(pos, particleEffect, uniqueEntityId, this.dimension, (Player[]) null);
}
public void addParticleEffect(Vector3 pos, ParticleEffect particleEffect, long uniqueEntityId, int dimensionId) {
this.addParticleEffect(pos, particleEffect, uniqueEntityId, dimensionId, (Player[]) null);
}
public void addParticleEffect(Vector3 pos, ParticleEffect particleEffect, long uniqueEntityId, int dimensionId, Collection players) {
this.addParticleEffect(pos, particleEffect, uniqueEntityId, dimensionId, players.toArray(Player.EMPTY_ARRAY));
}
public void addParticleEffect(Vector3 pos, ParticleEffect particleEffect, long uniqueEntityId, int dimensionId, Player... players) {
this.addParticleEffect(pos.asVector3f(), particleEffect.getIdentifier(), uniqueEntityId, dimensionId, players);
}
public void addParticleEffect(Vector3f pos, String identifier, long uniqueEntityId, int dimensionId, Player... players) {
SpawnParticleEffectPacket pk = new SpawnParticleEffectPacket();
pk.identifier = identifier;
pk.uniqueEntityId = uniqueEntityId;
pk.dimensionId = dimensionId;
pk.position = pos;
if (players == null || players.length == 0) {
addChunkPacket(pos.getFloorX() >> 4, pos.getFloorZ() >> 4, pk);
} else {
Server.broadcastPacket(players, pk);
}
}
public boolean getAutoSave() {
return this.autoSave;
}
public void setAutoSave(boolean autoSave) {
this.autoSave = autoSave;
}
public boolean unload() {
return this.unload(false);
}
public boolean unload(boolean force) {
LevelUnloadEvent ev = new LevelUnloadEvent(this);
if (this == this.server.getDefaultLevel() && !force) {
ev.setCancelled();
}
this.server.getPluginManager().callEvent(ev);
if (!force && ev.isCancelled()) {
return false;
}
log.info(this.server.getLanguage().translateString("nukkit.level.unloading",
TextFormat.GREEN + this.getName() + TextFormat.WHITE));
Level defaultLevel = this.server.getDefaultLevel();
for (Player player : new ArrayList<>(this.getPlayers().values())) {
if (this == defaultLevel || defaultLevel == null) {
player.close(player.getLeaveMessage(), "Forced default level unload");
} else {
player.teleport(this.server.getDefaultLevel().getSafeSpawn());
}
}
if (this == defaultLevel) {
this.server.setDefaultLevel(null);
}
this.close();
return true;
}
public Map getChunkPlayers(int chunkX, int chunkZ) {
long index = Level.chunkHash(chunkX, chunkZ);
if (this.playerLoaders.containsKey(index)) {
return new HashMap<>(this.playerLoaders.get(index));
} else {
return new HashMap<>();
}
}
public ChunkLoader[] getChunkLoaders(int chunkX, int chunkZ) {
long index = Level.chunkHash(chunkX, chunkZ);
if (this.chunkLoaders.containsKey(index)) {
return this.chunkLoaders.get(index).values().toArray(ChunkLoader.EMPTY_ARRAY);
} else {
return ChunkLoader.EMPTY_ARRAY;
}
}
public void addChunkPacket(int chunkX, int chunkZ, DataPacket packet) {
long index = Level.chunkHash(chunkX, chunkZ);
synchronized (chunkPackets) {
Deque packets = chunkPackets.computeIfAbsent(index, i -> new ArrayDeque<>());
packets.add(packet);
}
}
public void registerChunkLoader(ChunkLoader loader, int chunkX, int chunkZ) {
this.registerChunkLoader(loader, chunkX, chunkZ, true);
}
public void registerChunkLoader(ChunkLoader loader, int chunkX, int chunkZ, boolean autoLoad) {
int hash = loader.getLoaderId();
long index = Level.chunkHash(chunkX, chunkZ);
if (!this.chunkLoaders.containsKey(index)) {
this.chunkLoaders.put(index, new HashMap<>());
this.playerLoaders.put(index, new HashMap<>());
} else if (this.chunkLoaders.get(index).containsKey(hash)) {
return;
}
this.chunkLoaders.get(index).put(hash, loader);
if (loader instanceof Player) {
this.playerLoaders.get(index).put(hash, (Player) loader);
}
if (!this.loaders.containsKey(hash)) {
this.loaderCounter.put(hash, 1);
this.loaders.put(hash, loader);
} else {
this.loaderCounter.put(hash, this.loaderCounter.get(hash) + 1);
}
this.cancelUnloadChunkRequest(hash);
if (autoLoad) {
this.loadChunk(chunkX, chunkZ);
}
}
public void unregisterChunkLoader(ChunkLoader loader, int chunkX, int chunkZ) {
int hash = loader.getLoaderId();
long index = Level.chunkHash(chunkX, chunkZ);
Map chunkLoadersIndex = this.chunkLoaders.get(index);
if (chunkLoadersIndex != null) {
ChunkLoader oldLoader = chunkLoadersIndex.remove(hash);
if (oldLoader != null) {
if (chunkLoadersIndex.isEmpty()) {
this.chunkLoaders.remove(index);
this.playerLoaders.remove(index);
this.unloadChunkRequest(chunkX, chunkZ, true);
} else {
Map playerLoadersIndex = this.playerLoaders.get(index);
playerLoadersIndex.remove(hash);
}
int count = this.loaderCounter.get(hash);
if (--count == 0) {
this.loaderCounter.remove(hash);
this.loaders.remove(hash);
} else {
this.loaderCounter.put(hash, count);
}
}
}
}
public void checkTime() {
if (!this.stopTime && this.gameRules.getBoolean(GameRule.DO_DAYLIGHT_CYCLE)) {
this.time += tickRate;
}
}
public void sendTime(Player... players) {
SetTimePacket pk = new SetTimePacket();
pk.time = (int) this.time;
Server.broadcastPacket(players, pk);
}
public void sendTime() {
sendTime(this.players.values().toArray(Player.EMPTY_ARRAY));
}
public GameRules getGameRules() {
return gameRules;
}
public void doTick(int currentTick) {
this.timings.doTick.startTiming();
requireProvider();
updateBlockLight(lightQueue);
this.checkTime();
if (currentTick % 1200 == 0) { // Send time to client every 60 seconds to make sure it stay in sync
this.sendTime();
}
// Tick Weather
if (this.dimension != DIMENSION_NETHER && this.dimension != DIMENSION_THE_END && gameRules.getBoolean(GameRule.DO_WEATHER_CYCLE)) {
this.rainTime--;
if (this.rainTime <= 0) {
if (!this.setRaining(!this.raining)) {
if (this.raining) {
setRainTime(ThreadLocalRandom.current().nextInt(12000) + 12000);
} else {
setRainTime(ThreadLocalRandom.current().nextInt(168000) + 12000);
}
}
}
this.thunderTime--;
if (this.thunderTime <= 0) {
if (!this.setThundering(!this.thundering)) {
if (this.thundering) {
setThunderTime(ThreadLocalRandom.current().nextInt(12000) + 3600);
} else {
setThunderTime(ThreadLocalRandom.current().nextInt(168000) + 12000);
}
}
}
if (this.isThundering()) {
Map chunks = getChunks();
if (chunks instanceof Long2ObjectOpenHashMap) {
Long2ObjectOpenHashMap fastChunks = (Long2ObjectOpenHashMap) chunks;
ObjectIterator> iter = fastChunks.long2ObjectEntrySet().fastIterator();
while (iter.hasNext()) {
Long2ObjectMap.Entry entry = iter.next();
performThunder(entry.getLongKey(), entry.getValue());
}
} else {
for (Map.Entry entry : getChunks().entrySet()) {
performThunder(entry.getKey(), entry.getValue());
}
}
}
}
this.skyLightSubtracted = this.calculateSkylightSubtracted(1);
this.levelCurrentTick++;
this.unloadChunks();
this.timings.doTickPending.startTiming();
int polled = 0;
this.updateQueue.tick(this.getCurrentTick());
this.timings.doTickPending.stopTiming();
while (!this.normalUpdateQueue.isEmpty()) {
QueuedUpdate queuedUpdate = this.normalUpdateQueue.poll();
Block block = getBlock(queuedUpdate.block, queuedUpdate.block.layer);
BlockUpdateEvent event = new BlockUpdateEvent(block);
this.server.getPluginManager().callEvent(event);
if (!event.isCancelled()) {
block.onUpdate(BLOCK_UPDATE_NORMAL);
if (queuedUpdate.neighbor != null) {
block.onNeighborChange(queuedUpdate.neighbor.getOpposite());
}
}
}
TimingsHistory.entityTicks += this.updateEntities.size();
this.timings.entityTick.startTiming();
if (!this.updateEntities.isEmpty()) {
for (long id : new ArrayList<>(this.updateEntities.keySet())) {
Entity entity = this.updateEntities.get(id);
if (entity == null) {
this.updateEntities.remove(id);
continue;
}
if (entity.closed || !entity.onUpdate(currentTick)) {
this.updateEntities.remove(id);
}
}
}
this.timings.entityTick.stopTiming();
TimingsHistory.tileEntityTicks += this.updateBlockEntities.size();
this.timings.blockEntityTick.startTiming();
this.updateBlockEntities.removeIf(blockEntity -> !blockEntity.isValid() || !blockEntity.onUpdate());
this.timings.blockEntityTick.stopTiming();
this.timings.tickChunks.startTiming();
this.tickChunks();
this.timings.tickChunks.stopTiming();
synchronized (changedBlocks) {
if (!this.changedBlocks.isEmpty()) {
if (!this.players.isEmpty()) {
ObjectIterator>>> iter = changedBlocks.long2ObjectEntrySet().fastIterator();
while (iter.hasNext()) {
Long2ObjectMap.Entry>> entry = iter.next();
long index = entry.getLongKey();
Map blocks = entry.getValue().get();
int chunkX = Level.getHashX(index);
int chunkZ = Level.getHashZ(index);
if (blocks == null || blocks.size() > MAX_BLOCK_CACHE) {
FullChunk chunk = this.getChunk(chunkX, chunkZ);
for (Player p : this.getChunkPlayers(chunkX, chunkZ).values()) {
p.onChunkChanged(chunk);
}
} else {
Collection toSend = this.getChunkPlayers(chunkX, chunkZ).values();
Player[] playerArray = toSend.toArray(Player.EMPTY_ARRAY);
Vector3[] blocksArray = new Vector3[blocks.size()];
int i = 0;
for (char blockHash : blocks.keySet()) {
Vector3 hash = getBlockXYZ(index, blockHash);
blocksArray[i++] = hash;
}
this.sendBlocks(playerArray, blocksArray, UpdateBlockPacket.FLAG_ALL);
}
}
}
this.changedBlocks.clear();
}
}
this.processChunkRequest();
if (this.sleepTicks > 0 && --this.sleepTicks <= 0) {
this.checkSleep();
}
synchronized (chunkPackets) {
for (long index : this.chunkPackets.keySet()) {
int chunkX = Level.getHashX(index);
int chunkZ = Level.getHashZ(index);
Player[] chunkPlayers = this.getChunkPlayers(chunkX, chunkZ).values().toArray(Player.EMPTY_ARRAY);
if (chunkPlayers.length > 0) {
for (DataPacket pk : this.chunkPackets.get(index)) {
Server.broadcastPacket(chunkPlayers, pk);
}
}
}
this.chunkPackets.clear();
}
if (gameRules.isStale()) {
GameRulesChangedPacket packet = new GameRulesChangedPacket();
packet.gameRules = gameRules;
Server.broadcastPacket(players.values().toArray(Player.EMPTY_ARRAY), packet);
gameRules.refresh();
}
this.timings.doTick.stopTiming();
}
private void performThunder(long index, FullChunk chunk) {
if (areNeighboringChunksLoaded(index)) return;
if (ThreadLocalRandom.current().nextInt(10000) == 0) {
int LCG = this.getUpdateLCG() >> 2;
int chunkX = chunk.getX() * 16;
int chunkZ = chunk.getZ() * 16;
Vector3 vector = this.adjustPosToNearbyEntity(new Vector3(chunkX + (LCG & 0xf), 0, chunkZ + (LCG >> 8 & 0xf)));
Biome biome = Biome.getBiome(this.getBiomeId(vector.getFloorX(), vector.getFloorZ()));
if (!biome.canRain()) {
return;
}
int bId = this.getBlockIdAt(vector.getFloorX(), vector.getFloorY(), vector.getFloorZ());
if (bId != Block.TALL_GRASS && bId != Block.WATER)
vector.y += 1;
CompoundTag nbt = new CompoundTag()
.putList(new ListTag("Pos").add(new DoubleTag("", vector.x))
.add(new DoubleTag("", vector.y)).add(new DoubleTag("", vector.z)))
.putList(new ListTag("Motion").add(new DoubleTag("", 0))
.add(new DoubleTag("", 0)).add(new DoubleTag("", 0)))
.putList(new ListTag("Rotation").add(new FloatTag("", 0))
.add(new FloatTag("", 0)));
EntityLightning bolt = new EntityLightning(chunk, nbt);
LightningStrikeEvent ev = new LightningStrikeEvent(this, bolt);
getServer().getPluginManager().callEvent(ev);
if (!ev.isCancelled()) {
bolt.spawnToAll();
} else {
bolt.setEffect(false);
}
this.addLevelSoundEvent(vector, LevelSoundEventPacket.SOUND_THUNDER, -1, EntityLightning.NETWORK_ID);
this.addLevelSoundEvent(vector, LevelSoundEventPacket.SOUND_EXPLODE, -1, EntityLightning.NETWORK_ID);
}
}
public Vector3 adjustPosToNearbyEntity(Vector3 pos) {
pos.y = this.getHighestBlockAt(pos.getFloorX(), pos.getFloorZ());
AxisAlignedBB axisalignedbb = new SimpleAxisAlignedBB(pos.x, pos.y, pos.z, pos.getX(), 255, pos.getZ()).expand(3, 3, 3);
List list = new ArrayList<>();
for (Entity entity : this.getCollidingEntities(axisalignedbb)) {
if (entity.isAlive() && canBlockSeeSky(entity)) {
list.add(entity);
}
}
if (!list.isEmpty()) {
return list.get(ThreadLocalRandom.current().nextInt(list.size())).getPosition();
} else {
if (pos.getY() == -1) {
pos = pos.up(2);
}
return pos;
}
}
public void checkSleep() {
if (this.players.isEmpty()) {
return;
}
boolean resetTime = true;
for (Player p : this.getPlayers().values()) {
if (!p.isSleeping()) {
resetTime = false;
break;
}
}
if (resetTime) {
int time = this.getTime() % Level.TIME_FULL;
if (time >= Level.TIME_NIGHT && time < Level.TIME_SUNRISE) {
this.setTime(this.getTime() + Level.TIME_FULL - time);
for (Player p : this.getPlayers().values()) {
p.stopSleep();
}
}
}
}
public void sendBlockExtraData(int x, int y, int z, int id, int data) {
this.sendBlockExtraData(x, y, z, id, data, this.getChunkPlayers(x >> 4, z >> 4).values());
}
public void sendBlockExtraData(int x, int y, int z, int id, int data, Collection players) {
sendBlockExtraData(x, y, z, id, data, players.toArray(Player.EMPTY_ARRAY));
}
public void sendBlockExtraData(int x, int y, int z, int id, int data, Player[] players) {
LevelEventPacket pk = new LevelEventPacket();
pk.evid = LevelEventPacket.EVENT_SET_DATA;
pk.x = x + 0.5f;
pk.y = y + 0.5f;
pk.z = z + 0.5f;
pk.data = (data << 8) | id;
Server.broadcastPacket(players, pk);
}
public void sendBlocks(Player[] target, Vector3[] blocks) {
this.sendBlocks(target, blocks, UpdateBlockPacket.FLAG_NONE, 0);
this.sendBlocks(target, blocks, UpdateBlockPacket.FLAG_NONE, 1);
}
public void sendBlocks(Player[] target, Vector3[] blocks, int flags) {
this.sendBlocks(target, blocks, flags, 0);
this.sendBlocks(target, blocks, flags, 1);
}
public void sendBlocks(Player[] target, Vector3[] blocks, int flags, boolean optimizeRebuilds) {
this.sendBlocks(target, blocks, flags, 0, optimizeRebuilds);
this.sendBlocks(target, blocks, flags, 1, optimizeRebuilds);
}
public void sendBlocks(Player[] target, Vector3[] blocks, int flags, int dataLayer) {
this.sendBlocks(target, blocks, flags, dataLayer, false);
}
public void sendBlocks(Player[] target, Vector3[] blocks, int flags, int dataLayer, boolean optimizeRebuilds) {
int size = 0;
for (Vector3 block : blocks) {
if (block != null) size++;
}
int packetIndex = 0;
UpdateBlockPacket[] packets = new UpdateBlockPacket[size];
LongSet chunks = null;
if (optimizeRebuilds) {
chunks = new LongOpenHashSet();
}
for (Vector3 b : blocks) {
if (b == null) {
continue;
}
boolean first = !optimizeRebuilds;
if (optimizeRebuilds) {
long index = Level.chunkHash((int) b.x >> 4, (int) b.z >> 4);
if (!chunks.contains(index)) {
chunks.add(index);
first = true;
}
}
UpdateBlockPacket updateBlockPacket = new UpdateBlockPacket();
updateBlockPacket.x = (int) b.x;
updateBlockPacket.y = (int) b.y;
updateBlockPacket.z = (int) b.z;
updateBlockPacket.flags = first ? flags : UpdateBlockPacket.FLAG_NONE;
updateBlockPacket.dataLayer = dataLayer;
int runtimeId;
if (b instanceof Block) {
runtimeId = ((Block) b).getRuntimeId();
} else {
runtimeId = getBlockRuntimeId((int) b.x, (int) b.y, (int) b.z, dataLayer);
}
try {
updateBlockPacket.blockRuntimeId = runtimeId;
} catch (NoSuchElementException e) {
throw new IllegalStateException("Unable to create BlockUpdatePacket at (" +
b.x + ", " + b.y + ", " + b.z + ") in " + getName(), e);
}
packets[packetIndex++] = updateBlockPacket;
}
this.server.batchPackets(target, packets);
}
private void tickChunks() {
if (this.chunksPerTicks <= 0 || this.loaders.isEmpty()) {
this.chunkTickList.clear();
return;
}
int chunksPerLoader = Math.min(200, Math.max(1, (int) (((double) (this.chunksPerTicks - this.loaders.size()) / this.loaders.size() + 0.5))));
int randRange = 3 + chunksPerLoader / 30;
randRange = Math.min(randRange, this.chunkTickRadius);
ThreadLocalRandom random = ThreadLocalRandom.current();
if (!this.loaders.isEmpty()) {
for (ChunkLoader loader : this.loaders.values()) {
int chunkX = (int) loader.getX() >> 4;
int chunkZ = (int) loader.getZ() >> 4;
long index = Level.chunkHash(chunkX, chunkZ);
int existingLoaders = Math.max(0, this.chunkTickList.getOrDefault(index, 0));
this.chunkTickList.put(index, existingLoaders + 1);
for (int chunk = 0; chunk < chunksPerLoader; ++chunk) {
int dx = random.nextInt(2 * randRange) - randRange;
int dz = random.nextInt(2 * randRange) - randRange;
long hash = Level.chunkHash(dx + chunkX, dz + chunkZ);
if (!this.chunkTickList.containsKey(hash) && requireProvider().isChunkLoaded(hash)) {
this.chunkTickList.put(hash, -1);
}
}
}
}
boolean blockTest = false;
if (!chunkTickList.isEmpty()) {
ObjectIterator iter = chunkTickList.long2IntEntrySet().iterator();
while (iter.hasNext()) {
Long2IntMap.Entry entry = iter.next();
long index = entry.getLongKey();
if (!areNeighboringChunksLoaded(index)) {
iter.remove();
continue;
}
int loaders = entry.getIntValue();
int chunkX = getHashX(index);
int chunkZ = getHashZ(index);
FullChunk chunk;
if ((chunk = this.getChunk(chunkX, chunkZ, false)) == null) {
iter.remove();
continue;
} else if (loaders <= 0) {
iter.remove();
}
for (Entity entity : chunk.getEntities().values()) {
entity.scheduleUpdate();
}
int tickSpeed = gameRules.getInteger(GameRule.RANDOM_TICK_SPEED);
if (tickSpeed > 0) {
if (this.useSections) {
for (ChunkSection section : ((Chunk) chunk).getSections()) {
if (!(section instanceof EmptyChunkSection)) {
int Y = section.getY();
for (int i = 0; i < tickSpeed; ++i) {
int lcg = this.getUpdateLCG();
int x = lcg & 0x0f;
int y = lcg >>> 8 & 0x0f;
int z = lcg >>> 16 & 0x0f;
BlockState state = section.getBlockState(x, y, z);
if (randomTickBlocks[state.getBlockId()]) {
Block block = state.getBlockRepairing(this, chunkX * 16 + x, (Y << 4) + y, chunkZ * 16 + z);
block.onUpdate(BLOCK_UPDATE_RANDOM);
}
}
}
}
} else {
for (int Y = 0; Y < 8 && (Y < 3 || blockTest); ++Y) {
blockTest = false;
for (int i = 0; i < tickSpeed; ++i) {
int lcg = this.getUpdateLCG();
int x = lcg & 0x0f;
int y = lcg >>> 8 & 0x0f;
int z = lcg >>> 16 & 0x0f;
BlockState state = chunk.getBlockState(x, y + (Y << 4), z);
blockTest = blockTest || !state.equals(BlockState.AIR);
if (Level.randomTickBlocks[state.getBlockId()]) {
Block block = state.getBlockRepairing(this, x, y + (Y << 4), z);
block.onUpdate(BLOCK_UPDATE_RANDOM);
}
}
}
}
}
}
}
if (this.clearChunksOnTick) {
this.chunkTickList.clear();
}
}
public boolean save() {
return this.save(false);
}
public boolean save(boolean force) {
if (!this.getAutoSave() && !force) {
return false;
}
this.server.getPluginManager().callEvent(new LevelSaveEvent(this));
LevelProvider levelProvider = this.requireProvider();
levelProvider.setTime((int) this.time);
levelProvider.setRaining(this.raining);
levelProvider.setRainTime(this.rainTime);
levelProvider.setThundering(this.thundering);
levelProvider.setThunderTime(this.thunderTime);
levelProvider.setCurrentTick(this.levelCurrentTick);
levelProvider.setGameRules(this.gameRules);
this.saveChunks();
if (levelProvider instanceof BaseLevelProvider) {
levelProvider.saveLevelData();
}
return true;
}
public void saveChunks() {
requireProvider().saveChunks();
}
@Deprecated @DeprecationDetails(reason = "Was moved to RedstoneComponent", since = "1.4.0.0-PN",
replaceWith = "RedstoneComponent#updateAroundRedstone", by = "PowerNukkit")
public void updateAroundRedstone(Vector3 pos, BlockFace face) {
Location loc = new Location(pos.x, pos.y, pos.z, this);
RedstoneComponent.updateAroundRedstone(loc, face);
}
public void updateComparatorOutputLevel(Vector3 v) {
updateComparatorOutputLevelSelective(v, true);
}
@PowerNukkitOnly
@Since("1.4.0.0-PN")
public void updateComparatorOutputLevelSelective(Vector3 v, boolean observer) {
for (BlockFace face : Plane.HORIZONTAL) {
temporalVector.setComponentsAdding(v, face);
if (this.isChunkLoaded((int) temporalVector.x >> 4, (int) temporalVector.z >> 4)) {
Block block1 = this.getBlock(temporalVector);
if (block1.getId() == BlockID.OBSERVER) {
if (observer) {
block1.onNeighborChange(face.getOpposite());
}
} else if (BlockRedstoneDiode.isDiode(block1)) {
block1.onUpdate(BLOCK_UPDATE_REDSTONE);
} else if (block1.isNormalBlock()) {
block1 = this.getBlock(temporalVector.setComponentsAdding(temporalVector, face));
if (BlockRedstoneDiode.isDiode(block1)) {
block1.onUpdate(BLOCK_UPDATE_REDSTONE);
}
}
}
}
if (!observer) {
return;
}
for (BlockFace face : Plane.VERTICAL) {
Block block1 = this.getBlock(temporalVector.setComponentsAdding(v, face));
if (block1.getId() == BlockID.OBSERVER) {
block1.onNeighborChange(face.getOpposite());
}
}
}
public void updateAround(Vector3 pos) {
Block block = getBlock(pos);
for (BlockFace face : BlockFace.values()) {
final Block side = block.getSideAtLayer(0, face);
normalUpdateQueue.add(new QueuedUpdate(side, face));
normalUpdateQueue.add(new QueuedUpdate(side.getLevelBlockAtLayer(1), face));
}
}
public void updateAround(int x, int y, int z) {
updateAround(new Vector3(x, y, z));
}
public void scheduleUpdate(Block pos, int delay) {
this.scheduleUpdate(pos, pos, delay, 0, true);
}
public void scheduleUpdate(Block block, Vector3 pos, int delay) {
this.scheduleUpdate(block, pos, delay, 0, true);
}
public void scheduleUpdate(Block block, Vector3 pos, int delay, int priority) {
this.scheduleUpdate(block, pos, delay, priority, true);
}
public void scheduleUpdate(Block block, Vector3 pos, int delay, int priority, boolean checkArea) {
if (block.getId() == 0 || (checkArea && !this.isChunkLoaded(block.getFloorX() >> 4, block.getFloorZ() >> 4))) {
return;
}
BlockUpdateEntry entry = new BlockUpdateEntry(pos.floor(), block, ((long) delay) + getCurrentTick(), priority);
if (!this.updateQueue.contains(entry)) {
this.updateQueue.add(entry);
}
}
public boolean cancelSheduledUpdate(Vector3 pos, Block block) {
return this.updateQueue.remove(new BlockUpdateEntry(pos, block));
}
public boolean isUpdateScheduled(Vector3 pos, Block block) {
return this.updateQueue.contains(new BlockUpdateEntry(pos, block));
}
public boolean isBlockTickPending(Vector3 pos, Block block) {
return this.updateQueue.isBlockTickPending(pos, block);
}
public Set getPendingBlockUpdates(FullChunk chunk) {
int minX = (chunk.getX() << 4) - 2;
int maxX = minX + 16 + 2;
int minZ = (chunk.getZ() << 4) - 2;
int maxZ = minZ + 16 + 2;
return this.getPendingBlockUpdates(new SimpleAxisAlignedBB(minX, 0, minZ, maxX, 256, maxZ));
}
public Set getPendingBlockUpdates(AxisAlignedBB boundingBox) {
return updateQueue.getPendingBlockUpdates(boundingBox);
}
@PowerNukkitOnly
@Since("1.4.0.0-PN")
public List scanBlocks(@Nonnull AxisAlignedBB bb, @Nonnull BiPredicate condition) {
BlockVector3 min = new BlockVector3(NukkitMath.floorDouble(bb.getMinX()), NukkitMath.floorDouble(bb.getMinY()), NukkitMath.floorDouble(bb.getMinZ()));
BlockVector3 max = new BlockVector3(NukkitMath.floorDouble(bb.getMaxX()), NukkitMath.floorDouble(bb.getMaxY()), NukkitMath.floorDouble(bb.getMaxZ()));
ChunkVector2 minChunk = min.getChunkVector();
ChunkVector2 maxChunk = max.getChunkVector();
return IntStream.rangeClosed(minChunk.getX(), maxChunk.getX())
.mapToObj(x-> IntStream.rangeClosed(minChunk.getZ(), maxChunk.getZ()).mapToObj(z-> new ChunkVector2(x, z)))
.flatMap(Function.identity()).parallel()
.map(this::getChunk).filter(Objects::nonNull)
.flatMap(chunk-> chunk.scanBlocks(min, max, condition))
.collect(Collectors.toList());
}
public Block[] getCollisionBlocks(AxisAlignedBB bb) {
return this.getCollisionBlocks(bb, false);
}
public Block[] getCollisionBlocks(AxisAlignedBB bb, boolean targetFirst) {
return getCollisionBlocks(bb, targetFirst, false);
}
public Block[] getCollisionBlocks(AxisAlignedBB bb, boolean targetFirst, boolean ignoreCollidesCheck) {
return getCollisionBlocks(bb, targetFirst, ignoreCollidesCheck, block -> block.getId() != 0);
}
public Block[] getCollisionBlocks(AxisAlignedBB bb, boolean targetFirst, boolean ignoreCollidesCheck, Predicate condition) {
int minX = NukkitMath.floorDouble(bb.getMinX());
int minY = NukkitMath.floorDouble(bb.getMinY());
int minZ = NukkitMath.floorDouble(bb.getMinZ());
int maxX = NukkitMath.ceilDouble(bb.getMaxX());
int maxY = NukkitMath.ceilDouble(bb.getMaxY());
int maxZ = NukkitMath.ceilDouble(bb.getMaxZ());
List collides = new ArrayList<>();
if (targetFirst) {
for (int z = minZ; z <= maxZ; ++z) {
for (int x = minX; x <= maxX; ++x) {
for (int y = minY; y <= maxY; ++y) {
Block block = this.getBlock(this.temporalVector.setComponents(x, y, z), false);
if (block != null && condition.test(block) && (ignoreCollidesCheck || block.collidesWithBB(bb))) {
return new Block[]{block};
}
}
}
}
} else {
for (int z = minZ; z <= maxZ; ++z) {
for (int x = minX; x <= maxX; ++x) {
for (int y = minY; y <= maxY; ++y) {
Block block = this.getBlock(this.temporalVector.setComponents(x, y, z), false);
if (block != null && condition.test(block) && (ignoreCollidesCheck || block.collidesWithBB(bb))) {
collides.add(block);
}
}
}
}
}
return collides.toArray(Block.EMPTY_ARRAY);
}
public boolean isFullBlock(Vector3 pos) {
AxisAlignedBB bb;
if (pos instanceof Block) {
if (((Block) pos).isSolid()) {
return true;
}
bb = ((Block) pos).getBoundingBox();
} else {
bb = this.getBlock(pos).getBoundingBox();
}
return bb != null && bb.getAverageEdgeLength() >= 1;
}
public AxisAlignedBB[] getCollisionCubes(Entity entity, AxisAlignedBB bb) {
return this.getCollisionCubes(entity, bb, true);
}
public AxisAlignedBB[] getCollisionCubes(Entity entity, AxisAlignedBB bb, boolean entities) {
return getCollisionCubes(entity, bb, entities, false);
}
public AxisAlignedBB[] getCollisionCubes(Entity entity, AxisAlignedBB bb, boolean entities, boolean solidEntities) {
int minX = NukkitMath.floorDouble(bb.getMinX());
int minY = NukkitMath.floorDouble(bb.getMinY());
int minZ = NukkitMath.floorDouble(bb.getMinZ());
int maxX = NukkitMath.ceilDouble(bb.getMaxX());
int maxY = NukkitMath.ceilDouble(bb.getMaxY());
int maxZ = NukkitMath.ceilDouble(bb.getMaxZ());
List collides = new ArrayList<>();
for (int z = minZ; z <= maxZ; ++z) {
for (int x = minX; x <= maxX; ++x) {
for (int y = minY; y <= maxY; ++y) {
Block block = this.getBlock(this.temporalVector.setComponents(x, y, z), false);
if (!block.canPassThrough() && block.collidesWithBB(bb)) {
collides.add(block.getBoundingBox());
}
}
}
}
if (entities || solidEntities) {
for (Entity ent : this.getCollidingEntities(bb.grow(0.25f, 0.25f, 0.25f), entity)) {
if (solidEntities && !ent.canPassThrough()) {
collides.add(ent.boundingBox.clone());
}
}
}
return collides.toArray(AxisAlignedBB.EMPTY_ARRAY);
}
@PowerNukkitDifference(since = "1.4.0.0-PN", info = "Rounds the AABB to have precision 4 before checking for collision, fix PowerNukkit#506")
public boolean hasCollision(Entity entity, AxisAlignedBB bb, boolean entities) {
int minX = NukkitMath.floorDouble(NukkitMath.round(bb.getMinX(), 4));
int minY = NukkitMath.floorDouble(NukkitMath.round(bb.getMinY(), 4));
int minZ = NukkitMath.floorDouble(NukkitMath.round(bb.getMinZ(), 4));
int maxX = NukkitMath.ceilDouble(NukkitMath.round(bb.getMaxX(), 4) - 0.00001);
int maxY = NukkitMath.ceilDouble(NukkitMath.round(bb.getMaxY(), 4) - 0.00001);
int maxZ = NukkitMath.ceilDouble(NukkitMath.round(bb.getMaxZ(), 4) - 0.00001);
for (int z = minZ; z <= maxZ; ++z) {
for (int x = minX; x <= maxX; ++x) {
for (int y = minY; y <= maxY; ++y) {
Block block = this.getBlock(this.temporalVector.setComponents(x, y, z));
if (!block.canPassThrough() && block.collidesWithBB(bb)) {
return true;
}
}
}
}
if (entities) {
return this.getCollidingEntities(bb.grow(0.25f, 0.25f, 0.25f), entity).length > 0;
}
return false;
}
public int getFullLight(Vector3 pos) {
FullChunk chunk = this.getChunk((int) pos.x >> 4, (int) pos.z >> 4, false);
int level = 0;
if (chunk != null) {
level = chunk.getBlockSkyLight((int) pos.x & 0x0f, (int) pos.y & 0xff, (int) pos.z & 0x0f);
level -= this.skyLightSubtracted;
if (level < 15) {
level = Math.max(chunk.getBlockLight((int) pos.x & 0x0f, (int) pos.y & 0xff, (int) pos.z & 0x0f),
level);
}
}
return level;
}
public int calculateSkylightSubtracted(float tickDiff) {
float angle = this.getCelestialAngle(tickDiff);
float light = 1.0F - (MathHelper.cos(angle * ((float) Math.PI * 2F)) * 2.0F + 0.5F);
light = MathHelper.clamp(light, 0.0F, 1.0F);
light = 1.0F - light;
light = (float)((double)light * (1.0D - (double)(this.getRainStrength(tickDiff) * 5.0F) / 16.0D));
light = (float)((double)light * (1.0D - (double)(this.getThunderStrength(tickDiff) * 5.0F) / 16.0D));
light = 1.0F - light;
return (int)(light * 11.0F);
}
public float getRainStrength(float tickDiff) {
return isRaining() ? 1 : 0; // TODO: real implementation
}
public float getThunderStrength(float tickDiff) {
return isThundering() ? 1 : 0; // TODO: real implementation
}
public float getCelestialAngle(float tickDiff) {
return calculateCelestialAngle(getTime(), tickDiff);
}
public float calculateCelestialAngle(int time, float tickDiff) {
int i = (int)(time % 24000L);
float angle = ((float)i + tickDiff) / 24000.0F - 0.25F;
if (angle < 0.0F) {
++angle;
}
if (angle > 1.0F) {
--angle;
}
float f1 = 1.0F - (float)((Math.cos((double) angle * Math.PI) + 1.0D) / 2.0D);
angle = angle + (f1 - angle) / 3.0F;
return angle;
}
public int getMoonPhase(long worldTime) {
return (int) (worldTime / 24000 % 8 + 8) % 8;
}
@Deprecated
@DeprecationDetails(reason = "The meta is limited to 32 bits", since = "1.3.0.0-PN")
public int getFullBlock(int x, int y, int z) {
return getFullBlock(x, y, z, 0);
}
@Deprecated
@DeprecationDetails(reason ="The meta is limited to 32 bits", since = "1.3.0.0-PN")
public int getFullBlock(int x, int y, int z, int layer) {
return this.getChunk(x >> 4, z >> 4, false).getFullBlock(x & 0x0f, y & 0xff, z & 0x0f, layer);
}
@PowerNukkitOnly
@Since("1.3.0.0-PN")
public int getBlockRuntimeId(int x, int y, int z) {
return getBlockRuntimeId(x, y, z, 0);
}
@PowerNukkitOnly
@Since("1.3.0.0-PN")
public int getBlockRuntimeId(int x, int y, int z, int layer) {
return this.getChunk(x >> 4, z >> 4, false).getBlockRuntimeId(x & 0x0f, y & 0xff, z & 0x0f, layer);
}
public synchronized Block getBlock(Vector3 pos) {
return getBlock(pos, 0);
}
public synchronized Block getBlock(Vector3 pos, int layer) {
return this.getBlock(pos.getFloorX(), pos.getFloorY(), pos.getFloorZ(), layer);
}
public synchronized Block getBlock(Vector3 pos, boolean load) {
return getBlock(pos, 0, load);
}
public synchronized Block getBlock(Vector3 pos, int layer, boolean load) {
return this.getBlock(pos.getFloorX(), pos.getFloorY(), pos.getFloorZ(), layer, load);
}
public synchronized Block getBlock(int x, int y, int z) {
return getBlock(x, y, z, 0);
}
public synchronized Block getBlock(int x, int y, int z, int layer) {
return getBlock(x, y, z, layer, true);
}
public synchronized Block getBlock(int x, int y, int z, boolean load) {
return getBlock(x, y, z, 0, load);
}
@PowerNukkitDifference(since = "1.4.0.0-PN", info = "Will automatically repair broken block states")
public synchronized Block getBlock(int x, int y, int z, int layer, boolean load) {
BlockState fullState;
if (y >= 0 && y < 256) {
int cx = x >> 4;
int cz = z >> 4;
BaseFullChunk chunk;
if (load) {
chunk = getChunk(cx, cz);
} else {
chunk = getChunkIfLoaded(cx, cz);
}
if (chunk != null) {
fullState = chunk.getBlockState(x & 0xF, y, z & 0xF, layer);
} else {
fullState = BlockState.AIR;
}
} else {
fullState = BlockState.AIR;
}
OptionalBoolean valid = fullState.getCachedValidation();
if (valid == OptionalBoolean.TRUE) {
return fullState.getBlock(this, x, y, z, layer);
}
if (valid == OptionalBoolean.EMPTY) {
try {
return fullState.getBlock(this, x, y, z, layer);
} catch (InvalidBlockStateException ignored) {
}
}
Block block = fullState.getBlockRepairing(this, x, y, z, layer);
setBlock(x, y, z, layer, block, false, false); // Update set to false to fix PowerNukkit#650
return block;
}
public void updateAllLight(Vector3 pos) {
this.updateBlockSkyLight((int) pos.x, (int) pos.y, (int) pos.z);
this.addLightUpdate((int) pos.x, (int) pos.y, (int) pos.z);
}
public void updateBlockSkyLight(int x, int y, int z) {
BaseFullChunk chunk = getChunkIfLoaded(x >> 4, z >> 4);
if (chunk == null) return;
int oldHeightMap = chunk.getHeightMap(x & 0xf, z & 0xf);
int sourceId = getBlockIdAt(x, y, z);
int yPlusOne = y + 1;
int newHeightMap;
if (yPlusOne == oldHeightMap) { // Block changed directly beneath the heightmap. Check if a block was removed or changed to a different light-filter
newHeightMap = chunk.recalculateHeightMapColumn(x & 0x0f, z & 0x0f);
} else if (yPlusOne > oldHeightMap) { // Block changed above the heightmap
if (Block.lightFilter[sourceId] > 1 || Block.diffusesSkyLight[sourceId]) {
chunk.setHeightMap(x & 0xf, y & 0xf, yPlusOne);
newHeightMap = yPlusOne;
} else { // Block changed which has no effect on direct sky light, for example placing or removing glass.
return;
}
} else { // Block changed below heightmap
newHeightMap = oldHeightMap;
}
if (newHeightMap > oldHeightMap) { // Heightmap increase, block placed, remove sky light
for (int i = y; i >= oldHeightMap; --i) {
setBlockSkyLightAt(x, i, z, 0);
}
} else if (newHeightMap < oldHeightMap) { // Heightmap decrease, block changed or removed, add sky light
for (int i = y; i >= newHeightMap; --i) {
setBlockSkyLightAt(x, i, z, 15);
}
} else { // No heightmap change, block changed "underground"
setBlockSkyLightAt(x, y, z, Math.max(0, getHighestAdjacentBlockSkyLight(x, y, z) - Block.lightFilter[sourceId]));
}
}
/**
* Returns the highest block skylight level available in the positions adjacent to the specified block coordinates.
*/
public int getHighestAdjacentBlockSkyLight(int x, int y, int z) {
int[] lightLevels = new int[] {
getBlockSkyLightAt(x + 1, y, z),
getBlockSkyLightAt(x - 1, y, z),
getBlockSkyLightAt(x, y + 1, z),
getBlockSkyLightAt(x, y - 1, z),
getBlockSkyLightAt(x, y, z + 1),
getBlockSkyLightAt(x, y, z - 1),
};
int maxValue = lightLevels[0];
for(int i = 1; i < lightLevels.length; i++) {
if (lightLevels[i] > maxValue) {
maxValue = lightLevels[i];
}
}
return maxValue;
}
public void updateBlockLight(Map> map) {
int size = map.size();
if (size == 0) {
return;
}
Queue lightPropagationQueue = new ConcurrentLinkedQueue<>();
Queue lightRemovalQueue = new ConcurrentLinkedQueue<>();
Long2ObjectOpenHashMap