import cn.nukkit.level.format.FullChunk; //导入依赖的package包/类
@Override
public void setChunk(int chunkX, int chunkZ, FullChunk chunk) {
    if (!(chunk instanceof Chunk)) {
        throw new ChunkException("Invalid Chunk class");
    }
    chunk.setProvider(this);
    int regionX = chunkX >> 5;
    int regionZ = chunkZ >> 5;
    this.loadRegion(regionX, regionZ);
    chunk.setX(chunkX);
    chunk.setZ(chunkZ);
    long index = Level.chunkHash(chunkX, chunkZ);
    if (this.chunks.containsKey(index) && !this.chunks.get(index).equals(chunk)) {
        this.unloadChunk(chunkX, chunkZ, false);
    }
    this.chunks.put(index, (Chunk) chunk);
}
 

import cn.nukkit.level.format.FullChunk; //导入依赖的package包/类
protected void generateChunk(int chunkX, int chunkZ, FullChunk generatingChunkBuffer) {
    if (this.random.nextInt(300) >= this.ravineRarity)
        return;
    double d1 = (chunkX * 16) + this.random.nextInt(16);
    double d2 = numberInRange(random, this.ravineMinAltitude, this.ravineMaxAltitude);
    double d3 = (chunkZ * 16) + this.random.nextInt(16);

    int i = 1;

    for (int j = 0; j < i; j++) {
        float f1 = this.random.nextFloat() * 3.141593F * 2.0F;
        float f2 = (this.random.nextFloat() - 0.5F) * 2.0F / 8.0F;
        float f3 = (this.random.nextFloat() * 2.0F + this.random.nextFloat()) * 2.0F;

        int size = numberInRange(random, this.ravineMinLength, this.ravineMaxLength);

        createRavine(this.random.nextLong(), generatingChunkBuffer, d1, d2, d3, f3, f1, f2, size, this.ravineDepth);
    }
}
 

import cn.nukkit.level.format.FullChunk; //导入依赖的package包/类
public BlockEntityChest(FullChunk chunk, CompoundTag nbt) {
    super(chunk, nbt);
    this.inventory = new ChestInventory(this);

    if (!this.namedTag.contains("Items") || !(this.namedTag.get("Items") instanceof ListTag)) {
        this.namedTag.putList(new ListTag<CompoundTag>("Items"));
    }

    /* for (int i = 0; i < this.getSize(); i++) {
        this.inventory.setItem(i, this.getItem(i));
    } */
    
    ListTag<CompoundTag> list = (ListTag<CompoundTag>) this.namedTag.getList("Items");
    for (CompoundTag compound : list.getAll()) {
        Item item = NBTIO.getItemHelper(compound);
        this.inventory.slots.put(compound.getByte("Slot"), item);
    }
}
 

import cn.nukkit.level.format.FullChunk; //导入依赖的package包/类
public BlockEntity(FullChunk chunk, CompoundTag nbt) {
    if (chunk == null || chunk.getProvider() == null) {
        throw new ChunkException("Invalid garbage Chunk given to Block Entity");
    }

    this.timing = Timings.getBlockEntityTiming(this);
    this.server = chunk.getProvider().getLevel().getServer();
    this.chunk = chunk;
    this.setLevel(chunk.getProvider().getLevel());
    this.namedTag = nbt;
    this.name = "";
    this.lastUpdate = System.currentTimeMillis();
    this.id = BlockEntity.count++;
    this.x = this.namedTag.getInt("x");
    this.y = this.namedTag.getInt("y");
    this.z = this.namedTag.getInt("z");
    this.movable = this.namedTag.getBoolean("isMovable");

    this.chunk.addBlockEntity(this);
    this.getLevel().addBlockEntity(this);
}
 

import cn.nukkit.level.format.FullChunk; //导入依赖的package包/类
public BlockEntityHopper(FullChunk chunk, CompoundTag nbt) {
    super(chunk, nbt);

    if (this.namedTag.contains("TransferCooldown")) {
        this.transferCooldown = this.namedTag.getInt("TransferCooldown");
    }

    this.inventory = new HopperInventory(this);

    if (!this.namedTag.contains("Items") || !(this.namedTag.get("Items") instanceof ListTag)) {
        this.namedTag.putList(new ListTag<CompoundTag>("Items"));
    }

    for (int i = 0; i < this.getSize(); i++) {
        this.inventory.setItem(i, this.getItem(i));
    }

    this.pickupArea = new AxisAlignedBB(this.x, this.y, this.z, this.x + 1, this.y + 2, this.z + 1);

    this.scheduleUpdate();
}
 

import cn.nukkit.level.format.FullChunk; //导入依赖的package包/类
private void generateChunk(FullChunk chunk) {
    chunk.setGenerated();
    int c = Biome.getBiome(biome).getColor();
    int R = c >> 16;
    int G = (c >> 8) & 0xff;
    int B = c & 0xff;

    for (int Z = 0; Z < 16; ++Z) {
        for (int X = 0; X < 16; ++X) {
            chunk.setBiomeId(X, Z, biome);
            chunk.setBiomeColor(X, Z, R, G, B);
            for (int y = 0; y < 256; ++y) {
                int k = this.structure[y][0];
                int l = this.structure[y][1];
                chunk.setBlock(X, y, Z, this.structure[y][0], this.structure[y][1]);
            }
        }
    }
}
 

import cn.nukkit.level.format.FullChunk; //导入依赖的package包/类
public BlockEntity(FullChunk chunk, CompoundTag nbt) {
    if (chunk == null || chunk.getProvider() == null) {
        throw new ChunkException("Invalid garbage Chunk given to Block Entity");
    }

    this.timing = Timings.getBlockEntityTiming(this);
    this.server = chunk.getProvider().getLevel().getServer();
    this.chunk = chunk;
    this.setLevel(chunk.getProvider().getLevel());
    this.namedTag = nbt;
    this.name = "";
    this.lastUpdate = System.currentTimeMillis();
    this.id = BlockEntity.count++;
    this.x = this.namedTag.getInt("x");
    this.y = this.namedTag.getInt("y");
    this.z = this.namedTag.getInt("z");

    this.chunk.addBlockEntity(this);
    this.getLevel().addBlockEntity(this);
}
 

import cn.nukkit.level.format.FullChunk; //导入依赖的package包/类
public BlockEntityBrewingStand(FullChunk chunk, CompoundTag nbt) {
    super(chunk, nbt);
    inventory = new BrewingInventory(this);

    if (!namedTag.contains("Items") || !(namedTag.get("Items") instanceof ListTag)) {
        namedTag.putList(new ListTag<CompoundTag>("Items"));
    }

    for (int i = 0; i < getSize(); i++) {
        inventory.setItem(i, this.getItem(i));
    }

    if (!namedTag.contains("CookTime") || namedTag.getShort("CookTime") > MAX_BREW_TIME) {
        this.brewTime = MAX_BREW_TIME;
    } else {
        this.brewTime = namedTag.getShort("CookTime");
    }

    if (brewTime < MAX_BREW_TIME) {
        this.scheduleUpdate();
    }
}
 

import cn.nukkit.level.format.FullChunk; //导入依赖的package包/类
@Override
public void setChunk(int chunkX, int chunkZ, FullChunk chunk) {
    if (!(chunk instanceof Chunk)) {
        throw new ChunkException("Invalid Chunk class");
    }
    chunk.setProvider(this);

    chunk.setX(chunkX);
    chunk.setZ(chunkZ);
    long index = Level.chunkHash(chunkX, chunkZ);

    if (this.chunks.containsKey(index) && !this.chunks.get(index).equals(chunk)) {
        this.unloadChunk(chunkX, chunkZ, false);
    }

    this.chunks.put(index, (Chunk) chunk);
}
 

import cn.nukkit.level.format.FullChunk; //导入依赖的package包/类
public Entity(FullChunk chunk, CompoundTag nbt) {
    if (this instanceof Player) {
        return;
    }

    this.init(chunk, nbt);
}
 

import cn.nukkit.level.format.FullChunk; //导入依赖的package包/类
public void saveChunks() {
    for (FullChunk chunk : new ArrayList<>(this.chunks.values())) {
        if (chunk.hasChanged()) {
            try {
                this.provider.setChunk(chunk.getX(), chunk.getZ(), chunk);
                this.provider.saveChunk(chunk.getX(), chunk.getZ());

                chunk.setChanged(false);
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
    }
}
 

import cn.nukkit.level.format.FullChunk; //导入依赖的package包/类
public ChunkConverter to(Class<? extends FullChunk> toClass) {
    if (toClass != Chunk.class) {
        throw new IllegalArgumentException("To type can be only Anvil");
    }
    this.toClass = toClass;
    return this;
}
 

import cn.nukkit.level.format.FullChunk; //导入依赖的package包/类
public BlockEntityFurnace(FullChunk chunk, CompoundTag nbt) {
    super(chunk, nbt);
    this.inventory = new FurnaceInventory(this);

    if (!this.namedTag.contains("Items") || !(this.namedTag.get("Items") instanceof ListTag)) {
        this.namedTag.putList(new ListTag<CompoundTag>("Items"));
    }

    for (int i = 0; i < this.getSize(); i++) {
        this.inventory.setItem(i, this.getItem(i));
    }

    if (!this.namedTag.contains("BurnTime") || this.namedTag.getShort("BurnTime") < 0) {
        burnTime = 0;
    } else {
        burnTime = this.namedTag.getShort("BurnTime");
    }

    if (!this.namedTag.contains("CookTime") || this.namedTag.getShort("CookTime") < 0 || (this.namedTag.getShort("BurnTime") == 0 && this.namedTag.getShort("CookTime") > 0)) {
        cookTime = 0;
    } else {
        cookTime = this.namedTag.getShort("CookTime");
    }

    if (!this.namedTag.contains("MaxTime")) {
        maxTime = burnTime;
        burnDuration = 0;
    } else {
        maxTime = this.namedTag.getShort("MaxTime");
    }

    if (this.namedTag.contains("BurnTicks")) {
        burnDuration = this.namedTag.getShort("BurnTicks");
        this.namedTag.remove("BurnTicks");
    }

    if (burnTime > 0) {
        this.scheduleUpdate();
    }
}
 

import cn.nukkit.level.format.FullChunk; //导入依赖的package包/类
@Override
public void setChunk(int chunkX, int chunkZ, FullChunk chunk) {
    if (!(chunk instanceof Chunk)) {
        throw new ChunkException("Invalid Chunk class");
    }
    chunk.setProvider(this);
    int regionX = chunkX >> 5;
    int regionZ = chunkZ >> 5;
    this.loadRegion(regionX, regionZ);

    chunk.setX(chunkX);
    chunk.setZ(chunkZ);
    long index = Level.chunkHash(chunkX, chunkZ);
    this.chunks.put(index, (Chunk) chunk);
}
 

import cn.nukkit.level.format.FullChunk; //导入依赖的package包/类
@Override
public void saveChunk(int x, int z, FullChunk chunk) {
    if (!(chunk instanceof Chunk)) {
        throw new ChunkException("Invalid Chunk class");
    }
    this.writeChunk((Chunk) chunk);
}
 

import cn.nukkit.level.format.FullChunk; //导入依赖的package包/类
@Override
public void generateChunk(int chunkX, int chunkZ) {
    if (!this.init) {
        init = true;
        if (this.options.containsKey("preset") && !"".equals(this.options.get("preset"))) {
            this.parsePreset((String) this.options.get("preset"), chunkX, chunkZ);
        } else {
            this.parsePreset(this.preset, chunkX, chunkZ);
        }
    }
    FullChunk chunk = this.level.getChunk(chunkX, chunkZ);
    this.generateChunk(chunk);
}
 

import cn.nukkit.level.format.FullChunk; //导入依赖的package包/类
public BlockEntityCauldron(FullChunk chunk, CompoundTag nbt) {
    super(chunk, nbt);

    if (!namedTag.contains("PotionId")) {
        namedTag.putShort("PotionId", 0xffff);
    }

    if (!namedTag.contains("SplashPotion")) {
        namedTag.putByte("SplashPotion", 0);
    }
}
 

import cn.nukkit.level.format.FullChunk; //导入依赖的package包/类
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);
        // TODO: decrease light level by time of day
        if (level < 15) {
            level = Math.max(chunk.getBlockLight((int) pos.x & 0x0f, (int) pos.y & 0xff, (int) pos.z & 0x0f),
                    level);
            // todo: check this
        }
    }

    return level;
}
 

import cn.nukkit.level.format.FullChunk; //导入依赖的package包/类
public BlockEntityItemFrame(FullChunk chunk, CompoundTag nbt) {
    super(chunk, nbt);
    if (!nbt.contains("Item")) {
        nbt.putCompound("Item", NBTIO.putItemHelper(new ItemBlock(new BlockAir())));
    }
    if (!nbt.contains("ItemRotation")) {
        nbt.putByte("ItemRotation", 0);
    }
    if (!nbt.contains("ItemDropChance")) {
        nbt.putFloat("ItemDropChance", 1.0f);
    }

    this.level.updateComparatorOutputLevel(this);
}
 

import cn.nukkit.level.format.FullChunk; //导入依赖的package包/类
public void doChunkGarbageCollection() {
    this.timings.doChunkGC.startTiming();
    // remove all invaild block entities.
    List<BlockEntity> toClose = new ArrayList<>();
    for (BlockEntity anBlockEntity : blockEntities.values()) {
        if (anBlockEntity == null)
            continue;
        if (anBlockEntity.isBlockEntityValid())
            continue;
        toClose.add(anBlockEntity);
    }
    for (BlockEntity be : toClose.toArray(new BlockEntity[toClose.size()])) {
        be.close();
    }

    for (Long index : this.chunks.keySet()) {

        if (!this.unloadQueue.containsKey(index)) {
            int X = getHashX(index);
            int Z = getHashZ(index);
            if (!this.isSpawnChunk(X, Z)) {
                this.unloadChunkRequest(X, Z, true);
            }
        }
    }

    for (FullChunk chunk : new ArrayList<>(this.provider.getLoadedChunks().values())) {
        if (!this.chunks.containsKey(Level.chunkHash(chunk.getX(), chunk.getZ()))) {
            this.provider.unloadChunk(chunk.getX(), chunk.getZ(), false);
        }
    }

    this.provider.doGarbageCollection();
    this.timings.doChunkGC.stopTiming();
}