Plexus/Plex-FAWE
1
0
Fork 0
mirror of https://github.com/plexusorg/Plex-FAWE.git synced 2025-06-12 04:23:54 +00:00
Code Issues Packages Projects Releases Wiki Activity

Some optimizations for 1.13

Browse Source
This commit is contained in:
Jesse Boyd
2019-04-13 16:44:23 +10:00
parent 99c4c2f35d
commit f9f6aead0f
21 changed files with 1395 additions and 1308 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
worldedit-bukkit/src/main/java/com/boydti/fawe/bukkit/FaweBukkit.java
View File

@ -31,6 +31,7 @@ import com.boydti.fawe.bukkit.v0.BukkitQueue_0;
import com.boydti.fawe.bukkit.v0.BukkitQueue_All;
import com.boydti.fawe.bukkit.v0.ChunkListener_8;
import com.boydti.fawe.bukkit.v0.ChunkListener_9;
import com.boydti.fawe.bukkit.v1_13.BukkitQueue_1_13;
import com.boydti.fawe.config.BBC;
import com.boydti.fawe.config.Settings;
import com.boydti.fawe.object.FaweCommand;
@ -588,16 +589,6 @@ public class FaweBukkit implements IFawe, Listener {
try {
BukkitQueue_0.checkVersion(v.name());
this.version = tmp = v;
if (tmp == Version.v1_13_R1) {
try {
Fawe.debug("Running 1.13 registry dumper!");
// TODO FIXME
// NMSRegistryDumper dumper = new NMSRegistryDumper(MainUtil.getFile(plugin.getDataFolder(), "extrablocks.json"));
// dumper.run();
} catch (Throwable e) {
e.printStackTrace();
}
}
break;
} catch (IllegalStateException e) {}
}
@ -606,20 +597,14 @@ public class FaweBukkit implements IFawe, Listener {
}
public enum Version {
// v1_7_R4,
// v1_8_R3,
// v1_9_R2,
// v1_10_R1,
// v1_11_R1,
// v1_12_R2,
v1_13_R1,
v1_13_R2,
NONE,
}
private FaweQueue getQueue(World world) {
switch (getVersion()) {
case v1_13_R1:
// return new BukkitQueue_1_13(world);
case v1_13_R2:
return new BukkitQueue_1_13(world);
default:
case NONE:
return new BukkitQueue_All(world);
@ -628,8 +613,8 @@ public class FaweBukkit implements IFawe, Listener {
private FaweQueue getQueue(String world) {
switch (getVersion()) {
case v1_13_R1:
// return new BukkitQueue_1_13(world);
case v1_13_R2:
return new BukkitQueue_1_13(world);
default:
case NONE:
return new BukkitQueue_All(world);

18
worldedit-bukkit/src/main/java/com/boydti/fawe/bukkit/adapter/v1_13_1/Spigot_v1_13_R2.java
View File

@ -88,7 +88,7 @@ public final class Spigot_v1_13_R2 extends CachedBukkitAdapter implements Bukkit
nbtCreateTagMethod.setAccessible(true);
}
private int[] idbToStateOrdinal;
public int[] idbToStateOrdinal;
private boolean init() {
if (idbToStateOrdinal != null) return false;
@ -502,13 +502,21 @@ public final class Spigot_v1_13_R2 extends CachedBukkitAdapter implements Bukkit
@Override
public BlockState adapt(BlockData blockData) {
CraftBlockData cbd = ((CraftBlockData) blockData);
IBlockData ibd = cbd.getState();
return adapt(ibd);
}
public BlockState adapt(IBlockData ibd) {
return BlockTypes.states[adaptToInt(ibd)];
}
public int adaptToInt(IBlockData ibd) {
try {
CraftBlockData cbd = ((CraftBlockData) blockData);
IBlockData ibd = cbd.getState();
int id = Block.REGISTRY_ID.getId(ibd);
return BlockTypes.states[idbToStateOrdinal[id]];
return idbToStateOrdinal[id];
} catch (NullPointerException e) {
if (init()) return adapt(blockData);
if (init()) return adaptToInt(ibd);
throw e;
}
}

153
worldedit-bukkit/src/main/java/com/boydti/fawe/bukkit/v0/BukkitChunk_All.java
View File

@ -1,7 +1,6 @@
package com.boydti.fawe.bukkit.v0;
import com.boydti.fawe.Fawe;
import com.boydti.fawe.FaweCache;
import com.boydti.fawe.config.Settings;
import com.boydti.fawe.example.IntFaweChunk;
import com.boydti.fawe.object.FaweChunk;
@ -16,16 +15,9 @@ import com.sk89q.jnbt.Tag;
import com.sk89q.worldedit.bukkit.BukkitAdapter;
import com.sk89q.worldedit.bukkit.adapter.BukkitImplAdapter;
import com.sk89q.worldedit.entity.BaseEntity;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import com.sk89q.worldedit.entity.Player;
import com.sk89q.worldedit.world.biome.BiomeType;
import com.sk89q.worldedit.world.block.BaseBlock;
import com.sk89q.worldedit.world.block.BlockStateHolder;
import com.sk89q.worldedit.world.block.BlockType;
import com.sk89q.worldedit.world.block.BlockTypes;
import com.sk89q.worldedit.world.entity.EntityTypes;
@ -39,8 +31,17 @@ import org.bukkit.block.Block;
import org.bukkit.block.BlockState;
import org.bukkit.entity.Entity;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
public class BukkitChunk_All extends IntFaweChunk<Chunk, BukkitQueue_All> {
private int layer = -1;
private int index;
private boolean place = true;
/**
* A FaweSections object represents a chunk and the blocks that you wish to change in it.
*
@ -52,18 +53,22 @@ public class BukkitChunk_All extends IntFaweChunk<Chunk, BukkitQueue_All> {
super(parent, x, z);
}
public BukkitChunk_All(FaweQueue parent, int x, int z, int[][] ids, short[] count, short[] air, byte[] heightMap) {
super(parent, x, z, ids, count, air, heightMap);
public BukkitChunk_All(FaweQueue parent, int x, int z, int[][] ids, short[] count, short[] air) {
super(parent, x, z, ids, count, air);
}
private static boolean canTick(BlockType type) {
return type.getMaterial().isTicksRandomly();
}
@Override
public IntFaweChunk copy(boolean shallow) {
BukkitChunk_All copy;
if (shallow) {
copy = new BukkitChunk_All(getParent(), getX(), getZ(), ids, count, air, heightMap);
copy = new BukkitChunk_All(getParent(), getX(), getZ(), ids, count, air);
copy.biomes = biomes;
} else {
copy = new BukkitChunk_All(getParent(), getX(), getZ(), (int[][]) MainUtil.copyNd(ids), count.clone(), air.clone(), heightMap.clone());
copy = new BukkitChunk_All(getParent(), getX(), getZ(), (int[][]) MainUtil.copyNd(ids), count.clone(), air.clone());
copy.biomes = biomes != null ? biomes.clone() : null;
}
copy.chunk = chunk;
@ -75,21 +80,12 @@ public class BukkitChunk_All extends IntFaweChunk<Chunk, BukkitQueue_All> {
return Bukkit.getWorld(getParent().getWorldName()).getChunkAt(getX(), getZ());
}
private int layer = -1;
private int index;
private boolean place = true;
@Override
public void start() {
getChunk().load(true);
}
private static boolean canTick(BlockType type) {
return type.getMaterial().isTicksRandomly();
}
/**
*
* @return
*/
@Override
@ -214,9 +210,9 @@ public class BukkitChunk_All extends IntFaweChunk<Chunk, BukkitQueue_All> {
if (newArray == null) {
continue;
}
final byte[] cacheX = FaweCache.CACHE_X[layer];
final short[] cacheY = FaweCache.CACHE_Y[layer];
final byte[] cacheZ = FaweCache.CACHE_Z[layer];
// final byte[] cacheX = FaweCache.CACHE_X[layer];
// final short[] cacheY = FaweCache.CACHE_Y[layer];
// final byte[] cacheZ = FaweCache.CACHE_Z[layer];
boolean checkTime = !((getAir(layer) == 4096 || (getCount(layer) == 4096 && getAir(layer) == 0) || (getCount(layer) == getAir(layer))));
Location mutableLoc = new Location(world, 0, 0, 0);
@ -270,85 +266,86 @@ public class BukkitChunk_All extends IntFaweChunk<Chunk, BukkitQueue_All> {
}
}
} else {
int yStart = layer << 4;
for (; index < 4096; index++) {
int j = place ? index : 4095 - index;
int combined = newArray[j];
if (combined == 0) continue;
BlockType type = BlockTypes.getFromStateId(combined);
if (type == BlockTypes.__RESERVED__) continue;
if (type.getMaterial().isAir()) {
if (!place) {
int x = cacheX[j];
int z = cacheZ[j];
int y = cacheY[j];
mutableLoc.setX(bx + x);
mutableLoc.setY(y);
mutableLoc.setZ(bz + z);
setBlock(adapter, chunk, mutableLoc, combined, update);
}
continue;
} else {
boolean light = type.getMaterial().getLightValue() > 0;
if (light) {
if (place) {
continue;
}
light = light && getParent().getSettings().LIGHTING.MODE != 0;
if (light) {
parent.enableLighting(disableResult);
}
} else if (!place) {
int x = j & 15;
int y = yStart + (j >> 8);
int z = (j >> 4) & 15;
mutableLoc.setX(bx + x);
mutableLoc.setY(y);
mutableLoc.setZ(bz + z);
setBlock(adapter, chunk, mutableLoc, combined, update);
}
continue;
} else {
boolean light = type.getMaterial().getLightValue() > 0;
if (light) {
if (place) {
continue;
}
int x = cacheX[j];
int z = cacheZ[j];
int y = cacheY[j];
if (type.getMaterial().hasContainer() && adapter != null) {
CompoundTag tile = getTile(x, y, z);
if (tile != null) {
synchronized (BukkitChunk_All.this) {
BaseBlock state = BaseBlock.getFromInternalId(combined, tile);
adapter.setBlock(chunk, bx + x, y, bz + z, state, update);
}
continue;
}
light = light && getParent().getSettings().LIGHTING.MODE != 0;
if (light) {
parent.enableLighting(disableResult);
}
if (type.getMaterial().isTicksRandomly()) {
} else if (!place) {
continue;
}
int x = j & 15;
int y = yStart + (j >> 8);
int z = (j >> 4) & 15;
if (type.getMaterial().hasContainer() && adapter != null) {
CompoundTag tile = getTile(x, y, z);
if (tile != null) {
synchronized (BukkitChunk_All.this) {
mutableLoc.setX(bx + x);
mutableLoc.setY(y);
mutableLoc.setZ(bz + z);
setBlock(adapter, chunk, mutableLoc, combined, update);
BaseBlock state = BaseBlock.getFromInternalId(combined, tile);
adapter.setBlock(chunk, bx + x, y, bz + z, state, update);
}
} else {
continue;
}
}
if (type.getMaterial().isTicksRandomly()) {
synchronized (BukkitChunk_All.this) {
mutableLoc.setX(bx + x);
mutableLoc.setY(y);
mutableLoc.setZ(bz + z);
setBlock(adapter, chunk, mutableLoc, combined, update);
}
if (light) {
parent.disableLighting(disableResult);
}
} else {
mutableLoc.setX(bx + x);
mutableLoc.setY(y);
mutableLoc.setZ(bz + z);
setBlock(adapter, chunk, mutableLoc, combined, update);
}
if (System.currentTimeMillis() - start > recommended) {
index++;
break mainloop;
if (light) {
parent.disableLighting(disableResult);
}
}
index = 0;
if (System.currentTimeMillis() - start > recommended) {
index++;
break mainloop;
}
}
} catch (final Throwable e) {
MainUtil.handleError(e);
index = 0;
}
} while (System.currentTimeMillis() - start < recommended);
if (more || place) {
this.addToQueue();
} catch (final Throwable e) {
MainUtil.handleError(e);
}
parent.resetLighting(disableResult);
return this;
} while (System.currentTimeMillis() - start < recommended);
if (more || place) {
this.addToQueue();
}
parent.resetLighting(disableResult);
return this;
}
public void setBlock(BukkitImplAdapter adapter, Chunk chunk, Location location, int combinedId, boolean update) {
com.sk89q.worldedit.world.block.BaseBlock base = com.sk89q.worldedit.world.block.BlockState.getFromInternalId(combinedId).toBaseBlock();
com.sk89q.worldedit.world.block.BaseBlock base = com.sk89q.worldedit.world.block.BlockState.getFromInternalId(combinedId).toBaseBlock();
if (adapter != null) {
adapter.setBlock(chunk, (int) location.getX(), (int) location.getY(), (int) location.getZ(), base, update);
} else {

5
worldedit-bukkit/src/main/java/com/boydti/fawe/bukkit/v0/BukkitQueue_All.java
View File

@ -206,11 +206,6 @@ public class BukkitQueue_All extends BukkitQueue_0<ChunkSnapshot, ChunkSnapshot,
return true;
}
@Override
public void setHeightMap(FaweChunk chunk, byte[] heightMap) {
// Not supported
}
@Override
public void setSkyLight(ChunkSnapshot chunk, int x, int y, int z, int value) {
// Not supported

590
worldedit-bukkit/src/main/java/com/boydti/fawe/bukkit/v1_13/BukkitChunk_1_13.java Normal file
View File

@ -0,0 +1,590 @@
package com.boydti.fawe.bukkit.v1_13;
import com.bekvon.bukkit.residence.commands.current;
import com.bekvon.bukkit.residence.commands.set;
import com.boydti.fawe.Fawe;
import com.boydti.fawe.FaweCache;
import com.boydti.fawe.bukkit.adapter.v1_13_1.BlockMaterial_1_13;
import com.boydti.fawe.bukkit.adapter.v1_13_1.Spigot_v1_13_R2;
import com.boydti.fawe.bukkit.v0.BukkitQueue_0;
import com.boydti.fawe.config.Settings;
import com.boydti.fawe.example.IntFaweChunk;
import com.boydti.fawe.object.FaweChunk;
import com.boydti.fawe.object.FaweQueue;
import com.boydti.fawe.util.MainUtil;
import com.boydti.fawe.util.MathMan;
import com.boydti.fawe.util.ReflectionUtils;
import com.sk89q.jnbt.CompoundTag;
import com.sk89q.jnbt.ListTag;
import com.sk89q.jnbt.LongTag;
import com.sk89q.jnbt.StringTag;
import com.sk89q.jnbt.Tag;
import com.sk89q.worldedit.bukkit.BukkitAdapter;
import com.sk89q.worldedit.bukkit.adapter.BukkitImplAdapter;
import com.sk89q.worldedit.internal.Constants;
import com.sk89q.worldedit.world.biome.BiomeType;
import com.sk89q.worldedit.world.block.BlockID;
import com.sk89q.worldedit.world.block.BlockState;
import com.sk89q.worldedit.world.block.BlockType;
import com.sk89q.worldedit.world.block.BlockTypes;
import net.minecraft.server.v1_13_R2.BiomeBase;
import net.minecraft.server.v1_13_R2.Block;
import net.minecraft.server.v1_13_R2.BlockPosition;
import net.minecraft.server.v1_13_R2.Blocks;
import net.minecraft.server.v1_13_R2.ChunkSection;
import net.minecraft.server.v1_13_R2.DataBits;
import net.minecraft.server.v1_13_R2.DataPalette;
import net.minecraft.server.v1_13_R2.DataPaletteBlock;
import net.minecraft.server.v1_13_R2.DataPaletteGlobal;
import net.minecraft.server.v1_13_R2.DataPaletteHash;
import net.minecraft.server.v1_13_R2.DataPaletteLinear;
import net.minecraft.server.v1_13_R2.Entity;
import net.minecraft.server.v1_13_R2.EntityPlayer;
import net.minecraft.server.v1_13_R2.EntityTypes;
import net.minecraft.server.v1_13_R2.GameProfileSerializer;
import net.minecraft.server.v1_13_R2.IBlockData;
import net.minecraft.server.v1_13_R2.MinecraftKey;
import net.minecraft.server.v1_13_R2.NBTTagCompound;
import net.minecraft.server.v1_13_R2.NBTTagInt;
import net.minecraft.server.v1_13_R2.NibbleArray;
import net.minecraft.server.v1_13_R2.RegistryID;
import net.minecraft.server.v1_13_R2.TileEntity;
import org.bukkit.Chunk;
import org.bukkit.World;
import org.bukkit.block.Biome;
import org.bukkit.block.data.BlockData;
import org.bukkit.craftbukkit.v1_13_R2.CraftChunk;
import org.bukkit.craftbukkit.v1_13_R2.block.CraftBlock;
import org.bukkit.event.entity.CreatureSpawnEvent;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import static com.boydti.fawe.bukkit.v1_13.BukkitQueue_1_13.*;
public class BukkitChunk_1_13 extends IntFaweChunk<Chunk, BukkitQueue_1_13> {
public ChunkSection[] sectionPalettes;
private static final IBlockData AIR = ((BlockMaterial_1_13) BlockTypes.AIR.getMaterial()).getState();
/**
* A FaweSections object represents a chunk and the blocks that you wish to change in it.
*
* @param parent
* @param x
* @param z
*/
public BukkitChunk_1_13(FaweQueue parent, int x, int z) {
super(parent, x, z);
}
public BukkitChunk_1_13(FaweQueue parent, int x, int z, int[][] ids, short[] count, short[] air) {
super(parent, x, z, ids, count, air);
}
public void storeBiomes(BiomeBase[] biomes) {
if (biomes != null) {
if (this.biomes == null) {
this.biomes = new BiomeType[256];
}
for (int i = 0; i < 256; i++) {
this.biomes[i] = BukkitAdapter.adapt(CraftBlock.biomeBaseToBiome(biomes[i]));
}
}
}
public boolean storeTile(TileEntity tile, BlockPosition pos) {
CompoundTag nativeTag = getParent().getTag(tile);
setTile(pos.getX() & 15, pos.getY(), pos.getZ() & 15, nativeTag);
return true;
}
public boolean storeEntity(Entity ent) throws InvocationTargetException, IllegalAccessException {
if (ent instanceof EntityPlayer || BukkitQueue_0.getAdapter() == null) {
return false;
}
EntityTypes<?> type = ent.P();
MinecraftKey id = EntityTypes.getName(type);
if (id != null) {
NBTTagCompound tag = new NBTTagCompound();
ent.save(tag); // readEntityIntoTag
CompoundTag nativeTag = (CompoundTag) BukkitQueue_0.toNative(tag);
Map<String, Tag> map = ReflectionUtils.getMap(nativeTag.getValue());
map.put("Id", new StringTag(id.toString()));
setEntity(nativeTag);
return true;
} else {
return false;
}
}
public boolean storeSection(ChunkSection section, int layer) throws IllegalAccessException {
if (sectionPalettes == null) {
// TODO FIXME don't copy light
sectionPalettes = new ChunkSection[16];
}
sectionPalettes[layer] = section;
return true;
}
public ChunkSection copy(ChunkSection current) throws IllegalAccessException, InvocationTargetException, NoSuchFieldException {
int y = current.getYPosition();
ChunkSection newSection = new ChunkSection(y, current.getSkyLightArray() != null);
// Copy light
NibbleArray skyLight = current.getSkyLightArray();
NibbleArray blockLight = current.getEmittedLightArray();
NibbleArray newBlockLight = newSection.getEmittedLightArray();
NibbleArray newSkyLight = newSection.getSkyLightArray();
byte[] newBlockBytes = newBlockLight.asBytes();
byte[] blockLightBytes = blockLight.asBytes();
for (int i = 0; i < 2048; i++) newBlockBytes[i] = blockLightBytes[i];
if (skyLight != null) {
byte[] newSkyBytes = newSkyLight.asBytes();
byte[] skyLightBytes = skyLight.asBytes();
for (int i = 0; i < 2048; i++) newSkyBytes[i] = skyLightBytes[i];
}
// Copy counters
Object nonEmptyBlockCount = BukkitQueue_1_13.fieldNonEmptyBlockCount.get(current);
BukkitQueue_1_13.fieldNonEmptyBlockCount.set(newSection, nonEmptyBlockCount);
Object tickingBlockCount = BukkitQueue_1_13.fieldTickingBlockCount.get(current);
BukkitQueue_1_13.fieldTickingBlockCount.set(newSection, tickingBlockCount);
Object liquidCount = BukkitQueue_1_13.fieldLiquidCount.get(current);
BukkitQueue_1_13.fieldLiquidCount.set(newSection, liquidCount);
// Copy blocks
DataPaletteBlock<IBlockData> blocks = current.getBlocks();
DataPaletteBlock<IBlockData> blocksCopy = copy(blocks);
BukkitQueue_1_13.fieldSection.set(newSection, blocksCopy);
return newSection;
}
public DataPaletteBlock<IBlockData> copy(DataPaletteBlock current) throws IllegalAccessException, InvocationTargetException, NoSuchFieldException {
// Clone palette
DataPalette currentPalette = (DataPalette) BukkitQueue_1_13.fieldPalette.get(current);
DataPaletteBlock<IBlockData> paletteBlock = newDataPaletteBlock();
int size = BukkitQueue_1_13.fieldSize.getInt(current);
DataPalette<IBlockData> newPalette = currentPalette;
if (currentPalette instanceof DataPaletteHash) {
// TODO optimize resize
newPalette = new DataPaletteHash<>(Block.REGISTRY_ID, size, paletteBlock, GameProfileSerializer::d, GameProfileSerializer::a);
RegistryID<IBlockData> currReg = (RegistryID<IBlockData>) BukkitQueue_1_13.fieldHashBlocks.get(currentPalette);
RegistryID<IBlockData> newReg = (RegistryID<IBlockData>) BukkitQueue_1_13.fieldHashBlocks.get(newPalette);
int arrLen = 1 << size;
System.arraycopy(fieldRegistryb.get(currReg), 0, fieldRegistryb.get(newReg), 0, arrLen);
System.arraycopy(fieldRegistryc.get(currReg), 0, fieldRegistryc.get(newReg), 0, arrLen);
System.arraycopy(fieldRegistryd.get(currReg), 0, fieldRegistryd.get(newReg), 0, arrLen);
fieldRegistrye.set(newReg, fieldRegistrye.get(currReg));
fieldRegistryf.set(newReg, fieldRegistryf.get(currReg));
} else if (currentPalette instanceof DataPaletteLinear) {
// TODO optimize resize
newPalette = new DataPaletteLinear<>(Block.REGISTRY_ID, size, paletteBlock, GameProfileSerializer::d);
Object[] currArray = ((Object[]) BukkitQueue_1_13.fieldLinearBlocks.get(currentPalette));
Object[] newArray = ((Object[]) BukkitQueue_1_13.fieldLinearBlocks.get(newPalette));
BukkitQueue_1_13.fieldLinearIndex.set(newPalette, BukkitQueue_1_13.fieldLinearIndex.get(currentPalette));
for (int i = 0; i < newArray.length; i++) newArray[i] = currArray[i];
}
BukkitQueue_1_13.fieldPalette.set(paletteBlock, newPalette);
// Clone size
BukkitQueue_1_13.fieldSize.set(paletteBlock, size);
// Clone palette
DataBits currentBits = (DataBits) BukkitQueue_1_13.fieldBits.get(current);
DataBits newBits = new DataBits(currentBits.c(), currentBits.b(), currentBits.a().clone());
BukkitQueue_1_13.fieldBits.set(paletteBlock, newBits);
// TODO copy only if different
Object defaultBlock = BukkitQueue_1_13.fieldDefaultBlock.get(current);
if (defaultBlock != AIR) {
ReflectionUtils.setFailsafeFieldValue(BukkitQueue_1_13.fieldDefaultBlock, paletteBlock, BukkitQueue_1_13.fieldDefaultBlock.get(current));
}
return paletteBlock;
}
@Override
public IntFaweChunk<Chunk, BukkitQueue_1_13> copy(boolean shallow) {
BukkitChunk_1_13 copy;
if (shallow) {
copy = new BukkitChunk_1_13(getParent(), getX(), getZ(), ids, count, air);
copy.biomes = biomes;
copy.chunk = chunk;
} else {
copy = new BukkitChunk_1_13(getParent(), getX(), getZ(), (int[][]) MainUtil.copyNd(ids), count.clone(), air.clone());
copy.biomes = biomes != null ? biomes.clone() : null;
copy.chunk = chunk;
}
if (sectionPalettes != null) {
copy.sectionPalettes = new ChunkSection[16];
try {
for (int i = 0; i < sectionPalettes.length; i++) {
ChunkSection current = sectionPalettes[i];
if (current == null) {
continue;
}
sectionPalettes[i] = copy(current);
}
} catch (Throwable e) {
MainUtil.handleError(e);
}
}
return copy;
}
private DataPaletteBlock<IBlockData> newDataPaletteBlock() {
return new DataPaletteBlock<>(ChunkSection.GLOBAL_PALETTE, Block.REGISTRY_ID, GameProfileSerializer::d, GameProfileSerializer::a, Blocks.AIR.getBlockData());
}
@Override
public Chunk getNewChunk() {
return ((BukkitQueue_1_13) getParent()).getWorld().getChunkAt(getX(), getZ());
}
public void optimize() {
if (sectionPalettes != null) {
return;
}
int[][] arrays = getCombinedIdArrays();
for (int layer = 0; layer < 16; layer++) {
if (getCount(layer) > 0) {
if (sectionPalettes == null) {
sectionPalettes = new ChunkSection[16];
}
int[] array = arrays[layer];
sectionPalettes[layer] = BukkitQueue_1_13.newChunkSection(layer, getParent().hasSky(), array);
}
}
}
@Override
public void start() {
getChunk().load(true);
}
private void removeEntity(Entity entity) {
entity.b(false);
entity.die();
entity.valid = false;
}
@Override
public FaweChunk call() {
Spigot_v1_13_R2 adapter = (Spigot_v1_13_R2) BukkitQueue_0.getAdapter();
try {
BukkitChunk_1_13_Copy copy = getParent().getChangeTask() != null ? new BukkitChunk_1_13_Copy(getParent(), getX(), getZ()) : null;
final Chunk chunk = this.getChunk();
final World world = chunk.getWorld();
Settings settings = getParent().getSettings();
int bx = this.getX() << 4;
int bz = this.getZ() << 4;
final boolean flag = world.getEnvironment() == World.Environment.NORMAL;
net.minecraft.server.v1_13_R2.Chunk nmsChunk = ((CraftChunk) chunk).getHandle();
nmsChunk.f(true); // Set Modified
nmsChunk.mustSave = true;
net.minecraft.server.v1_13_R2.World nmsWorld = nmsChunk.world;
ChunkSection[] sections = nmsChunk.getSections();
List<Entity>[] entities = nmsChunk.getEntitySlices();
Map<BlockPosition, TileEntity> tiles = nmsChunk.getTileEntities();
// Remove entities
HashSet<UUID> entsToRemove = this.getEntityRemoves();
if (!entsToRemove.isEmpty()) {
for (int i = 0; i < entities.length; i++) {
Collection<Entity> ents = entities[i];
if (!ents.isEmpty()) {
Iterator<Entity> iter = ents.iterator();
while (iter.hasNext()) {
Entity entity = iter.next();
if (entsToRemove.contains(entity.getUniqueID())) {
if (copy != null) {
copy.storeEntity(entity);
}
iter.remove();
synchronized (BukkitQueue_0.class) {
removeEntity(entity);
}
}
}
}
}
}
for (int i = 0; i < entities.length; i++) {
int count = this.getCount(i);
if (count == 0 || settings.EXPERIMENTAL.KEEP_ENTITIES_IN_BLOCKS) {
continue;
} else if (count >= 4096) {
Collection<Entity> ents = entities[i];
if (!ents.isEmpty()) {
synchronized (BukkitQueue_0.class) {
Iterator<Entity> iter = ents.iterator();
while (iter.hasNext()) {
Entity entity = iter.next();
if (entity instanceof EntityPlayer) {
continue;
}
iter.remove();
if (copy != null) {
copy.storeEntity(entity);
}
removeEntity(entity);
}
}
}
} else {
Collection<Entity> ents = entities[i];
if (!ents.isEmpty()) {
int layerYStart = i << 4;
int layerYEnd = layerYStart + 15;
int[] array = this.getIdArray(i);
if (array == null) continue;
Iterator<Entity> iter = ents.iterator();
while (iter.hasNext()) {
Entity entity = iter.next();
if (entity instanceof EntityPlayer) {
continue;
}
int y = MathMan.roundInt(entity.locY);
if (y > layerYEnd || y < layerYStart) continue;
int x = (MathMan.roundInt(entity.locX) & 15);
int z = (MathMan.roundInt(entity.locZ) & 15);
int index = (((y & 0xF) << 8) | (z << 4) | x);
if (array[index] != 0) {
if (copy != null) {
copy.storeEntity(entity);
}
iter.remove();
synchronized (BukkitQueue_0.class) {
removeEntity(entity);
}
}
}
}
}
}
// Set entities
Set<CompoundTag> entitiesToSpawn = this.getEntities();
if (!entitiesToSpawn.isEmpty()) {
synchronized (BukkitQueue_0.class) {
for (CompoundTag nativeTag : entitiesToSpawn) {
Map<String, Tag> entityTagMap = ReflectionUtils.getMap(nativeTag.getValue());
StringTag idTag = (StringTag) entityTagMap.get("Id");
ListTag posTag = (ListTag) entityTagMap.get("Pos");
ListTag rotTag = (ListTag) entityTagMap.get("Rotation");
if (idTag == null || posTag == null || rotTag == null) {
Fawe.debug("Unknown entity tag: " + nativeTag);
continue;
}
double x = posTag.getDouble(0);
double y = posTag.getDouble(1);
double z = posTag.getDouble(2);
float yaw = rotTag.getFloat(0);
float pitch = rotTag.getFloat(1);
String id = idTag.getValue();
Entity entity = EntityTypes.a(nmsWorld, new MinecraftKey(id));
if (entity != null) {
UUID uuid = entity.getUniqueID();
entityTagMap.put("UUIDMost", new LongTag(uuid.getMostSignificantBits()));
entityTagMap.put("UUIDLeast", new LongTag(uuid.getLeastSignificantBits()));
if (nativeTag != null) {
NBTTagCompound tag = (NBTTagCompound) BukkitQueue_1_13.fromNative(nativeTag);
for (String name : Constants.NO_COPY_ENTITY_NBT_FIELDS) {
tag.remove(name);
}
entity.f(tag);
}
entity.setLocation(x, y, z, yaw, pitch);
synchronized (BukkitQueue_0.class) {
nmsWorld.addEntity(entity, CreatureSpawnEvent.SpawnReason.CUSTOM);
}
}
}
}
}
// Set blocks
for (int j = 0; j < sections.length; j++) {
int count = this.getCount(j);
if (count == 0) {
continue;
}
int countAir = this.getAir(j);
final int[] array = this.getIdArray(j);
if (array == null) {
continue;
}
ChunkSection section = sections[j];
if (copy != null) {
if (section != null) {
copy.storeSection(copy(section), j);
}
}
if (section == null) {
if (count == countAir) {
continue;
}
if (this.sectionPalettes != null && this.sectionPalettes[j] != null) {
section = sections[j] = this.sectionPalettes[j];
getParent().setCount(0, count - this.getAir(j), section);
continue;
} else {
sections[j] = getParent().newChunkSection(j << 4, flag, array);
continue;
}
} else if (count >= 4096) {
if (countAir >= 4096) {
sections[j] = null;
continue;
}
if (this.sectionPalettes != null && this.sectionPalettes[j] != null) {
section = sections[j] = this.sectionPalettes[j];
getParent().setCount(0, count - this.getAir(j), section);
continue;
} else {
sections[j] = getParent().newChunkSection(j << 4, flag, array);
continue;
}
}
int by = j << 4;
DataPaletteBlock<IBlockData> nibble = section.getBlocks();
int nonEmptyBlockCount = 0;
IBlockData existing;
for (int y = 0, i = 0; y < 16; y++) {
for (int z = 0; z < 16; z++) {
for (int x= 0; x < 16; x++, i++) {
int combinedId = array[i];
switch (combinedId) {
case 0:
continue;
case BlockID.AIR:
case BlockID.CAVE_AIR:
case BlockID.VOID_AIR:
existing = nibble.a(x, y, z);
if (!existing.isAir()) {
if (existing.e() > 0) {
getParent().getRelighter().addLightUpdate(bx + x, by + y, bz + z);
}
nonEmptyBlockCount--;
nibble.setBlock(x, y, z, AIR);
}
continue;
default:
existing = nibble.a(x, y, z);
if (!existing.isAir()) {
if (existing.e() > 0) {
getParent().getRelighter().addLightUpdate(bx + x, by + y, bz + z);
}
} else {
nonEmptyBlockCount++;
}
BlockState state = BlockState.getFromInternalId(combinedId);
IBlockData ibd = ((BlockMaterial_1_13) state.getMaterial()).getState();
nibble.setBlock(x, y, z, ibd);
}
}
}
}
getParent().setCount(0, getParent().getNonEmptyBlockCount(section) + nonEmptyBlockCount, section);
}
// Trim tiles
HashMap<BlockPosition, TileEntity> toRemove = null;
if (!tiles.isEmpty()) {
Iterator<Map.Entry<BlockPosition, TileEntity>> iterator = tiles.entrySet().iterator();
while (iterator.hasNext()) {
Map.Entry<BlockPosition, TileEntity> tile = iterator.next();
BlockPosition pos = tile.getKey();
int lx = pos.getX() & 15;
int ly = pos.getY();
int lz = pos.getZ() & 15;
int layer = ly >> 4;
int[] array = this.getIdArray(layer);
if (array == null) {
continue;
}
int index = (((ly & 0xF) << 8) | (lz << 4) | lx);
if (array[index] != 0) {
if (toRemove == null) {
toRemove = new HashMap<>();
}
if (copy != null) {
copy.storeTile(tile.getValue(), tile.getKey());
}
toRemove.put(tile.getKey(), tile.getValue());
}
}
if (toRemove != null) {
synchronized (BukkitQueue_0.class) {
for (Map.Entry<BlockPosition, TileEntity> entry : toRemove.entrySet()) {
BlockPosition bp = entry.getKey();
TileEntity tile = entry.getValue();
nmsWorld.n(bp);
tiles.remove(bp);
tile.z();
tile.invalidateBlockCache();
}
}
}
}
// Set biomes
if (this.biomes != null) {
BiomeBase[] currentBiomes = nmsChunk.getBiomeIndex();
if (copy != null) {
copy.storeBiomes(currentBiomes);
}
for (int i = 0 ; i < this.biomes.length; i++) {
BiomeType biome = this.biomes[i];
if (biome != null) {
Biome craftBiome = adapter.adapt(biome);
currentBiomes[i] = CraftBlock.biomeToBiomeBase(craftBiome);
}
}
}
// Set tiles
Map<Short, CompoundTag> tilesToSpawn = this.getTiles();
if (!tilesToSpawn.isEmpty()) {
for (Map.Entry<Short, CompoundTag> entry : tilesToSpawn.entrySet()) {
CompoundTag nativeTag = entry.getValue();
short blockHash = entry.getKey();
int x = (blockHash >> 12 & 0xF) + bx;
int y = (blockHash & 0xFF);
int z = (blockHash >> 8 & 0xF) + bz;
BlockPosition pos = new BlockPosition(x, y, z); // Set pos
synchronized (BukkitQueue_0.class) {
TileEntity tileEntity = nmsWorld.getTileEntity(pos);
if (tileEntity != null) {
NBTTagCompound tag = (NBTTagCompound) BukkitQueue_1_13.fromNative(nativeTag);
tag.set("x", new NBTTagInt(x));
tag.set("y", new NBTTagInt(y));
tag.set("z", new NBTTagInt(z));
tileEntity.load(tag);
}
}
}
}
// Change task
if (copy != null) {
getParent().getChangeTask().run(copy, this);
}
} catch (Throwable e) {
MainUtil.handleError(e);
}
return this;
}
}

89
worldedit-bukkit/src/main/java/com/boydti/fawe/bukkit/v1_13/BukkitChunk_1_13_Copy.java Normal file
View File

@ -0,0 +1,89 @@
package com.boydti.fawe.bukkit.v1_13;
import com.boydti.fawe.bukkit.adapter.v1_13_1.Spigot_v1_13_R2;
import com.boydti.fawe.jnbt.anvil.BitArray4096;
import com.boydti.fawe.object.FaweQueue;
import com.sk89q.jnbt.CompoundTag;
import com.sk89q.worldedit.world.biome.BiomeType;
import com.sk89q.worldedit.world.block.BlockStateHolder;
import com.sk89q.worldedit.world.block.BlockTypes;
import net.minecraft.server.v1_13_R2.ChunkSection;
import net.minecraft.server.v1_13_R2.DataBits;
import net.minecraft.server.v1_13_R2.DataPalette;
import net.minecraft.server.v1_13_R2.DataPaletteBlock;
import net.minecraft.server.v1_13_R2.IBlockData;
import static com.boydti.fawe.bukkit.v0.BukkitQueue_0.getAdapter;
public class BukkitChunk_1_13_Copy extends BukkitChunk_1_13 {
public BukkitChunk_1_13_Copy(FaweQueue parent, int x, int z) {
super(parent, x, z);
}
@Override
public int[][] getCombinedIdArrays() {
for (int i = 0; i < ids.length; i++) {
getIdArray(i);
}
return super.getCombinedIdArrays();
}
@Override
public int[] getIdArray(int layer) {
ChunkSection section = this.sectionPalettes[layer];
int[] idsArray = this.ids[layer];
if (section != null && idsArray == null) {
idsArray = new int[4096];
if (!section.a()) {
try {
DataPaletteBlock<IBlockData> blocks = section.getBlocks();
DataBits bits = (DataBits) BukkitQueue_1_13.fieldBits.get(blocks);
DataPalette<IBlockData> palette = (DataPalette<IBlockData>) BukkitQueue_1_13.fieldPalette.get(blocks);
long[] raw = bits.a();
int bitsPerEntry = bits.c();
new BitArray4096(raw, bitsPerEntry).toRaw(idsArray);
IBlockData defaultBlock = (IBlockData) BukkitQueue_1_13.fieldDefaultBlock.get(blocks);
// TODO optimize away palette.a
for (int i = 0; i < 4096; i++) {
IBlockData ibd = palette.a(idsArray[i]);
if (ibd == null) {
ibd = defaultBlock;
}
int ordinal = ((Spigot_v1_13_R2) getAdapter()).adaptToInt(ibd);
idsArray[i] = BlockTypes.states[ordinal].getInternalId();
}
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
}
return idsArray;
}
@Override
public void setTile(int x, int y, int z, CompoundTag tile) {
throw new UnsupportedOperationException("Read only");
}
@Override
public <B extends BlockStateHolder<B>> void setBlock(int x, int y, int z, B block) {
throw new UnsupportedOperationException("Read only");
}
@Override
public void setBiome(BiomeType biome) {
throw new UnsupportedOperationException("Read only");
}
@Override
public void setBiome(int x, int z, BiomeType biome) {
throw new UnsupportedOperationException("Read only");
}
@Override
public void setBlock(int x, int y, int z, int combinedId) {
throw new UnsupportedOperationException("Read only");
}
}

918
worldedit-bukkit/src/main/java/com/boydti/fawe/bukkit/v1_13/BukkitQueue_1_13.java Normal file
View File

@ -0,0 +1,918 @@
package com.boydti.fawe.bukkit.v1_13;
import com.boydti.fawe.Fawe;
import com.boydti.fawe.FaweCache;
import com.boydti.fawe.bukkit.BukkitPlayer;
import com.boydti.fawe.bukkit.adapter.v1_13_1.BlockMaterial_1_13;
import com.boydti.fawe.bukkit.adapter.v1_13_1.Spigot_v1_13_R2;
import com.boydti.fawe.bukkit.v0.BukkitQueue_0;
import com.boydti.fawe.example.IntFaweChunk;
import com.boydti.fawe.jnbt.anvil.BitArray4096;
import com.boydti.fawe.object.FaweChunk;
import com.boydti.fawe.object.FawePlayer;
import com.boydti.fawe.object.RegionWrapper;
import com.boydti.fawe.object.brush.visualization.VisualChunk;
import com.boydti.fawe.object.visitor.FaweChunkVisitor;
import com.boydti.fawe.util.MainUtil;
import com.boydti.fawe.util.MathMan;
import com.boydti.fawe.util.ReflectionUtils;
import com.sk89q.jnbt.CompoundTag;
import com.sk89q.worldedit.world.biome.BiomeType;
import com.sk89q.worldedit.world.block.BlockID;
import com.sk89q.worldedit.world.block.BlockState;
import com.sk89q.worldedit.world.block.BlockTypes;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufAllocator;
import net.minecraft.server.v1_13_R2.BiomeBase;
import net.minecraft.server.v1_13_R2.Block;
import net.minecraft.server.v1_13_R2.BlockPosition;
import net.minecraft.server.v1_13_R2.ChunkProviderGenerate;
import net.minecraft.server.v1_13_R2.ChunkProviderServer;
import net.minecraft.server.v1_13_R2.ChunkSection;
import net.minecraft.server.v1_13_R2.DataBits;
import net.minecraft.server.v1_13_R2.DataPalette;
import net.minecraft.server.v1_13_R2.DataPaletteBlock;
import net.minecraft.server.v1_13_R2.DataPaletteHash;
import net.minecraft.server.v1_13_R2.DataPaletteLinear;
import net.minecraft.server.v1_13_R2.Entity;
import net.minecraft.server.v1_13_R2.EntityPlayer;
import net.minecraft.server.v1_13_R2.EnumSkyBlock;
import net.minecraft.server.v1_13_R2.GameProfileSerializer;
import net.minecraft.server.v1_13_R2.IBlockData;
import net.minecraft.server.v1_13_R2.NBTTagCompound;
import net.minecraft.server.v1_13_R2.Packet;
import net.minecraft.server.v1_13_R2.PacketDataSerializer;
import net.minecraft.server.v1_13_R2.PacketPlayOutMapChunk;
import net.minecraft.server.v1_13_R2.PacketPlayOutMultiBlockChange;
import net.minecraft.server.v1_13_R2.PlayerChunk;
import net.minecraft.server.v1_13_R2.PlayerChunkMap;
import net.minecraft.server.v1_13_R2.RegistryID;
import net.minecraft.server.v1_13_R2.TileEntity;
import net.minecraft.server.v1_13_R2.WorldChunkManager;
import net.minecraft.server.v1_13_R2.WorldData;
import net.minecraft.server.v1_13_R2.WorldServer;
import org.bukkit.Chunk;
import org.bukkit.World;
import org.bukkit.craftbukkit.v1_13_R2.CraftChunk;
import org.bukkit.craftbukkit.v1_13_R2.CraftWorld;
import org.bukkit.craftbukkit.v1_13_R2.block.CraftBlock;
import org.bukkit.craftbukkit.v1_13_R2.entity.CraftPlayer;
import java.io.IOException;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.Collection;
import java.util.Map;
import java.util.concurrent.atomic.LongAdder;
public class BukkitQueue_1_13 extends BukkitQueue_0<net.minecraft.server.v1_13_R2.Chunk, ChunkSection[], ChunkSection> {
protected final static Field fieldBits;
protected final static Field fieldPalette;
protected final static Field fieldSize;
protected final static Field fieldHashBlocks;
protected final static Field fieldLinearBlocks;
protected final static Field fieldHashIndex;
protected final static Field fieldRegistryb;
protected final static Field fieldRegistryc;
protected final static Field fieldRegistryd;
protected final static Field fieldRegistrye;
protected final static Field fieldRegistryf;
protected final static Field fieldLinearIndex;
protected final static Field fieldDefaultBlock;
protected final static Field fieldTickingBlockCount;
protected final static Field fieldNonEmptyBlockCount;
protected final static Field fieldSection;
protected final static Field fieldLiquidCount;
protected final static Field fieldEmittedLight;
protected final static Field fieldSkyLight;
// protected final static Field fieldBiomes;
protected final static Field fieldChunkGenerator;
protected final static Field fieldSeed;
// protected final static Field fieldBiomeCache;
// protected final static Field fieldBiomes2;
protected final static Field fieldGenLayer1;
protected final static Field fieldGenLayer2;
protected final static Field fieldSave;
// protected final static MutableGenLayer genLayer;
protected final static ChunkSection emptySection;
// protected static final Method methodResize;
static {
try {
emptySection = new ChunkSection(0, true);
Arrays.fill(emptySection.getSkyLightArray().asBytes(), (byte) 255);
fieldSection = ChunkSection.class.getDeclaredField("blockIds");
fieldLiquidCount = ChunkSection.class.getDeclaredField("e");
fieldEmittedLight = ChunkSection.class.getDeclaredField("emittedLight");
fieldSkyLight = ChunkSection.class.getDeclaredField("skyLight");
fieldTickingBlockCount = ChunkSection.class.getDeclaredField("tickingBlockCount");
fieldNonEmptyBlockCount = ChunkSection.class.getDeclaredField("nonEmptyBlockCount");
fieldSection.setAccessible(true);
fieldTickingBlockCount.setAccessible(true);
fieldNonEmptyBlockCount.setAccessible(true);
fieldLiquidCount.setAccessible(true);
fieldEmittedLight.setAccessible(true);
fieldSkyLight.setAccessible(true);
// fieldBiomes = ChunkProviderGenerate.class.getDeclaredField("D"); // *
// fieldBiomes.setAccessible(true);
fieldChunkGenerator = ChunkProviderServer.class.getDeclaredField("chunkGenerator");
fieldChunkGenerator.setAccessible(true);
fieldSeed = WorldData.class.getDeclaredField("e");
fieldSeed.setAccessible(true);
// fieldBiomeCache = WorldChunkManager.class.getDeclaredField("d"); // *
// fieldBiomeCache.setAccessible(true);
// fieldBiomes2 = WorldChunkManager.class.getDeclaredField("e"); // *
// fieldBiomes2.setAccessible(true);
fieldGenLayer1 = WorldChunkManager.class.getDeclaredField("b") ;
fieldGenLayer2 = WorldChunkManager.class.getDeclaredField("c") ;
fieldGenLayer1.setAccessible(true);
fieldGenLayer2.setAccessible(true);
fieldSave = ReflectionUtils.setAccessible(net.minecraft.server.v1_13_R2.Chunk.class.getDeclaredField("s")); //*
fieldHashBlocks = DataPaletteHash.class.getDeclaredField("b");
fieldHashBlocks.setAccessible(true);
fieldLinearBlocks = DataPaletteLinear.class.getDeclaredField("b");
fieldLinearBlocks.setAccessible(true);
fieldHashIndex = DataPaletteHash.class.getDeclaredField("f");
fieldHashIndex.setAccessible(true);
fieldRegistryb = RegistryID.class.getDeclaredField("b");
fieldRegistryc = RegistryID.class.getDeclaredField("c");
fieldRegistryd = RegistryID.class.getDeclaredField("d");
fieldRegistrye = RegistryID.class.getDeclaredField("e");
fieldRegistryf = RegistryID.class.getDeclaredField("f");
fieldRegistryb.setAccessible(true);
fieldRegistryc.setAccessible(true);
fieldRegistryd.setAccessible(true);
fieldRegistrye.setAccessible(true);
fieldRegistryf.setAccessible(true);
fieldLinearIndex = DataPaletteLinear.class.getDeclaredField("f");
fieldLinearIndex.setAccessible(true);
fieldDefaultBlock = DataPaletteBlock.class.getDeclaredField("g");
fieldDefaultBlock.setAccessible(true);
fieldSize = DataPaletteBlock.class.getDeclaredField("i");
fieldSize.setAccessible(true);
fieldBits = DataPaletteBlock.class.getDeclaredField("a");
fieldBits.setAccessible(true);
fieldPalette = DataPaletteBlock.class.getDeclaredField("h");
fieldPalette.setAccessible(true);
// methodResize = DataPaletteBlock.class.getDeclaredMethod("b", int.class);
// methodResize.setAccessible(true);
Fawe.debug("Using adapter: " + getAdapter());
Fawe.debug("=========================================");
} catch (Throwable e) {
throw new RuntimeException(e);
}
}
public BukkitQueue_1_13(final com.sk89q.worldedit.world.World world) {
super(world);
getImpWorld();
}
public BukkitQueue_1_13(final String world) {
super(world);
getImpWorld();
}
private boolean save(net.minecraft.server.v1_13_R2.Chunk chunk, ChunkProviderServer cps) {
cps.saveChunk(chunk, false);
chunk.a(false);
return true;
}
@Override
public ChunkSection[] getSections(net.minecraft.server.v1_13_R2.Chunk chunk) {
return chunk.getSections();
}
@Override
public net.minecraft.server.v1_13_R2.Chunk loadChunk(World world, int x, int z, boolean generate) {
ChunkProviderServer provider = ((CraftWorld) world).getHandle().getChunkProvider();
if (generate) {
return provider.getChunkAt(x, z, true, true);
} else {
return provider.getChunkAt(x, z, true, false);
}
}
@Override
public ChunkSection[] getCachedSections(World world, int cx, int cz) {
net.minecraft.server.v1_13_R2.Chunk chunk = ((CraftWorld) world).getHandle().getChunkProvider().getChunkAt(cx, cz, false, false);
if (chunk != null) {
return chunk.getSections();
}
return null;
}
@Override
public net.minecraft.server.v1_13_R2.Chunk getCachedChunk(World world, int cx, int cz) {
return ((CraftWorld) world).getHandle().getChunkProvider().getChunkAt(cx, cz, false, false);
}
@Override
public ChunkSection getCachedSection(ChunkSection[] chunkSections, int cy) {
return chunkSections[cy];
}
@Override
public void saveChunk(net.minecraft.server.v1_13_R2.Chunk chunk) {
chunk.f(true); // Set Modified
chunk.mustSave = true;
}
@Override
public boolean regenerateChunk(World world, int x, int z, BiomeType biome, Long seed) {
// if (biome != null) {
// try {
// if (seed == null) {
// seed = world.getSeed();
// }
// nmsWorld.worldData.getSeed();
// boolean result;
// ChunkProviderGenerate generator = new ChunkProviderGenerate(nmsWorld, seed, false, "");
// Biome bukkitBiome = getAdapter().getBiome(biome.getId());
// BiomeBase base = BiomeBase.getBiome(biome.getId());
// fieldBiomes.set(generator, new BiomeBase[]{base});
// boolean cold = base.getTemperature() <= 1;
// net.minecraft.server.v1_13_R2.ChunkGenerator existingGenerator = nmsWorld.getChunkProvider().chunkGenerator;
// long existingSeed = world.getSeed();
// {
// if (genLayer == null) genLayer = new MutableGenLayer(seed);
// genLayer.set(biome.getId());
// Object existingGenLayer1 = fieldGenLayer1.get(nmsWorld.getWorldChunkManager());
// Object existingGenLayer2 = fieldGenLayer2.get(nmsWorld.getWorldChunkManager());
// fieldGenLayer1.set(nmsWorld.getWorldChunkManager(), genLayer);
// fieldGenLayer2.set(nmsWorld.getWorldChunkManager(), genLayer);
//
// fieldSeed.set(nmsWorld.worldData, seed);
//
// ReflectionUtils.setFailsafeFieldValue(fieldBiomeCache, this.nmsWorld.getWorldChunkManager(), new BiomeCache(this.nmsWorld.getWorldChunkManager()));
//
// ReflectionUtils.setFailsafeFieldValue(fieldChunkGenerator, this.nmsWorld.getChunkProvider(), generator);
//
// keepLoaded.remove(MathMan.pairInt(x, z));
// result = getWorld().regenerateChunk(x, z);
// net.minecraft.server.v1_13_R2.Chunk nmsChunk = getCachedChunk(world, x, z);
// if (nmsChunk != null) {
// nmsChunk.f(true); // Set Modified
// nmsChunk.mustSave = true;
// }
//
// ReflectionUtils.setFailsafeFieldValue(fieldChunkGenerator, this.nmsWorld.getChunkProvider(), existingGenerator);
//
// fieldSeed.set(nmsWorld.worldData, existingSeed);
//
// fieldGenLayer1.set(nmsWorld.getWorldChunkManager(), existingGenLayer1);
// fieldGenLayer2.set(nmsWorld.getWorldChunkManager(), existingGenLayer2);
// }
// return result;
// } catch (Throwable e) {
// e.printStackTrace();
// }
// }
return super.regenerateChunk(world, x, z, biome, seed);
}
@Override
public boolean setMCA(final int mcaX, final int mcaZ, final RegionWrapper allowed, final Runnable whileLocked, final boolean saveChunks, final boolean load) {
throw new UnsupportedOperationException("Anvil not implemented yet");
// TaskManager.IMP.sync(new RunnableVal<Boolean>() {
// @Override
// public void run(Boolean value) {
// long start = System.currentTimeMillis();
// long last = start;
// synchronized (RegionFileCache.class) {
// World world = getWorld();
// if (world.getKeepSpawnInMemory()) world.setKeepSpawnInMemory(false);
// ChunkProviderServer provider = nmsWorld.getChunkProvider();
//
// boolean mustSave = false;
// boolean[][] chunksUnloaded = null;
// { // Unload chunks
// Iterator<net.minecraft.server.v1_13_R2.Chunk> iter = provider.a().iterator();
// while (iter.hasNext()) {
// net.minecraft.server.v1_13_R2.Chunk chunk = iter.next();
// if (chunk.locX >> 5 == mcaX && chunk.locZ >> 5 == mcaZ) {
// boolean isIn = allowed.isInChunk(chunk.locX, chunk.locZ);
// if (isIn) {
// if (!load) {
// mustSave |= saveChunks && save(chunk, provider);
// continue;
// }
// iter.remove();
// boolean save = saveChunks && chunk.a(false);
// mustSave |= save;
// provider.unloadChunk(chunk, save);
// if (chunksUnloaded == null) {
// chunksUnloaded = new boolean[32][];
// }
// int relX = chunk.locX & 31;
// boolean[] arr = chunksUnloaded[relX];
// if (arr == null) {
// arr = chunksUnloaded[relX] = new boolean[32];
// }
// arr[chunk.locZ & 31] = true;
// }
// }
// }
// }
// if (mustSave) {
// provider.c(); // TODO only the necessary chunks
// }
//
// File unloadedRegion = null;
// if (load && !RegionFileCache.a.isEmpty()) {
// Map<File, RegionFile> map = RegionFileCache.a;
// Iterator<Map.Entry<File, RegionFile>> iter = map.entrySet().iterator();
// String requiredPath = world.getName() + File.separator + "region";
// while (iter.hasNext()) {
// Map.Entry<File, RegionFile> entry = iter.next();
// File file = entry.getKey();
// int[] regPos = MainUtil.regionNameToCoords(file.getPath());
// if (regPos[0] == mcaX && regPos[1] == mcaZ && file.getPath().contains(requiredPath)) {
// if (file.exists()) {
// unloadedRegion = file;
// RegionFile regionFile = entry.getValue();
// iter.remove();
// try {
// regionFile.c();
// } catch (IOException e) {
// e.printStackTrace();
// }
// }
// break;
// }
// }
// }
//
// long now = System.currentTimeMillis();
// if (whileLocked != null) whileLocked.run();
// if (!load) return;
//
// { // Load the region again
// if (unloadedRegion != null && chunksUnloaded != null && unloadedRegion.exists()) {
// final boolean[][] finalChunksUnloaded = chunksUnloaded;
// TaskManager.IMP.async(() -> {
// int bx = mcaX << 5;
// int bz = mcaZ << 5;
// for (int x = 0; x < finalChunksUnloaded.length; x++) {
// boolean[] arr = finalChunksUnloaded[x];
// if (arr != null) {
// for (int z = 0; z < arr.length; z++) {
// if (arr[z]) {
// int cx = bx + x;
// int cz = bz + z;
// SetQueue.IMP.addTask(new Runnable() {
// @Override
// public void run() {
// net.minecraft.server.v1_13_R2.Chunk chunk = provider.getChunkAt(cx, cz, null, false);
// if (chunk != null) {
// PlayerChunk pc = getPlayerChunk(nmsWorld, cx, cz);
// if (pc != null) {
// sendChunk(pc, chunk, 0);
// }
// }
// }
// });
// }
// }
// }
// }
// });
// }
// }
// }
// }
// });
// return true;
}
@Override
public boolean next(int amount, long time) {
return super.next(amount, time);
}
@Override
public void setSkyLight(ChunkSection section, int x, int y, int z, int value) {
section.getSkyLightArray().a(x & 15, y & 15, z & 15, value);
}
@Override
public void setBlockLight(ChunkSection section, int x, int y, int z, int value) {
section.getEmittedLightArray().a(x & 15, y & 15, z & 15, value);
}
// @Override
// public World createWorld(final WorldCreator creator) {
// final String name = creator.name();
// ChunkGenerator generator = creator.generator();
// final CraftServer server = (CraftServer) Bukkit.getServer();
// final MinecraftServer console = server.getServer();
// final File folder = new File(server.getWorldContainer(), name);
// final World world = server.getWorld(name);
// final WorldType type = WorldType.getType(creator.type().getName());
// final boolean generateStructures = creator.generateStructures();
// if (world != null) {
// return world;
// }
// if (folder.exists() && !folder.isDirectory()) {
// throw new IllegalArgumentException("File exists with the name '" + name + "' and isn't a folder");
// }
// TaskManager.IMP.sync(new RunnableVal<Object>() {
// @Override
// public void run(Object value) {
// try {
// Field field = CraftServer.class.getDeclaredField("worlds");
// field.setAccessible(true);
// Map<Object, Object> existing = (Map<Object, Object>) field.get(server);
// if (!existing.getClass().getName().contains("SynchronizedMap")) {
// field.set(server, Collections.synchronizedMap(existing));
// }
// } catch (Throwable e) {
// e.printStackTrace();
// }
// }
// });
// if (generator == null) {
// generator = server.getGenerator(name);
// }
// int dimension = 10 + console.worlds.size();
// boolean used = false;
// do {
// for (final WorldServer ws : console.worlds) {
// used = (ws.dimension == dimension);
// if (used) {
// ++dimension;
// break;
// }
// }
// } while (used);
// final boolean hardcore = false;
// final IDataManager sdm = new ServerNBTManager(server.getWorldContainer(), name, true, server.getHandle().getServer().dataConverterManager);
// WorldData worlddata = sdm.getWorldData();
// final WorldSettings worldSettings;
// if (worlddata == null) {
// worldSettings = new WorldSettings(creator.seed(), EnumGamemode.getById(server.getDefaultGameMode().getValue()), generateStructures, hardcore, type);
// worldSettings.setGeneratorSettings(creator.generatorSettings());
// worlddata = new WorldData(worldSettings, name);
// } else {
// worldSettings = null;
// }
// worlddata.checkName(name);
// final WorldServer internal = (WorldServer)new WorldServer(console, sdm, worlddata, dimension, console.methodProfiler, creator.environment(), generator).b();
// startSet(true); // Temporarily allow async chunk load since the world isn't added yet
// if (worldSettings != null) {
// internal.a(worldSettings);
// }
// endSet(true);
// internal.scoreboard = server.getScoreboardManager().getMainScoreboard().getHandle();
// internal.tracker = new EntityTracker(internal);
// internal.addIWorldAccess(new WorldManager(console, internal));
// internal.worldData.setDifficulty(EnumDifficulty.EASY);
// internal.setSpawnFlags(true, true);
// if (generator != null) {
// internal.getWorld().getPopulators().addAll(generator.getDefaultPopulators(internal.getWorld()));
// }
// // Add the world
// return TaskManager.IMP.sync(new RunnableVal<World>() {
// @Override
// public void run(World value) {
// console.worlds.add(internal);
// server.getPluginManager().callEvent(new WorldInitEvent(internal.getWorld()));
// server.getPluginManager().callEvent(new WorldLoadEvent(internal.getWorld()));
// this.value = internal.getWorld();
// }
// });
// }
@Override
public int getCombinedId4Data(ChunkSection lastSection, int x, int y, int z) {
DataPaletteBlock<IBlockData> dataPalette = lastSection.getBlocks();
IBlockData ibd = dataPalette.a(x & 15, y & 15, z & 15);
return ((Spigot_v1_13_R2) getAdapter()).adaptToInt(ibd);
}
@Override
public BiomeType getBiome(net.minecraft.server.v1_13_R2.Chunk chunk, int x, int z) {
BiomeBase base = chunk.getBiomeIndex()[((z & 15) << 4) + (x & 15)];
return getAdapter().adapt(CraftBlock.biomeBaseToBiome(base));
}
@Override
public int getOpacity(ChunkSection section, int x, int y, int z) {
DataPaletteBlock<IBlockData> dataPalette = section.getBlocks();
IBlockData ibd = dataPalette.a(x & 15, y & 15, z & 15);
pos.a(x, y, z);
return ibd.b(nmsWorld, pos);
}
@Override
public int getBrightness(ChunkSection section, int x, int y, int z) {
DataPaletteBlock<IBlockData> dataPalette = section.getBlocks();
IBlockData ibd = dataPalette.a(x & 15, y & 15, z & 15);
return ibd.e();
}
@Override
public int getOpacityBrightnessPair(ChunkSection section, int x, int y, int z) {
DataPaletteBlock<IBlockData> dataPalette = section.getBlocks();
IBlockData ibd = dataPalette.a(x & 15, y & 15, z & 15);
pos.a(x, y, z);
int opacity = ibd.b(nmsWorld, pos);
int brightness = ibd.e();
return MathMan.pair16(brightness, opacity);
}
@Override
public void sendChunk(int x, int z, int bitMask) {
net.minecraft.server.v1_13_R2.Chunk chunk = getCachedChunk(getWorld(), x, z);
if (chunk != null) {
sendChunk(getPlayerChunk((WorldServer) chunk.getWorld(), chunk.locX, chunk.locZ), chunk, bitMask);
}
}
@Override
public void sendChunkUpdatePLIB(FaweChunk chunk, FawePlayer... players) {
// PlayerChunkMap playerManager = ((CraftWorld) getWorld()).getHandle().getPlayerChunkMap();
// ProtocolManager manager = ProtocolLibrary.getProtocolManager();
// WirePacket packet = null;
// try {
// for (int i = 0; i < players.length; i++) {
// CraftPlayer bukkitPlayer = ((CraftPlayer) ((BukkitPlayer) players[i]).parent);
// EntityPlayer player = bukkitPlayer.getHandle();
//
// if (playerManager.a(player, chunk.getX(), chunk.getZ())) {
// if (packet == null) {
// byte[] data;
// byte[] buffer = new byte[8192];
// if (chunk instanceof LazyFaweChunk) {
// chunk = (FaweChunk) chunk.getChunk();
// }
// if (chunk instanceof MCAChunk) {
// data = new MCAChunkPacket((MCAChunk) chunk, true, true, hasSky()).apply(buffer);
// } else {
// data = new FaweChunkPacket(chunk, true, true, hasSky()).apply(buffer);
// }
// packet = new WirePacket(PacketType.Play.Server.MAP_CHUNK, data);
// }
// manager.sendWirePacket(bukkitPlayer, packet);
// }
// }
// } catch (InvocationTargetException e) {
// throw new RuntimeException(e);
// }
super.sendChunkUpdatePLIB(chunk, players); // TODO remove
}
@Override
public void sendBlockUpdate(FaweChunk chunk, FawePlayer... players) {
try {
PlayerChunkMap playerManager = ((CraftWorld) getWorld()).getHandle().getPlayerChunkMap();
boolean watching = false;
boolean[] watchingArr = new boolean[players.length];
for (int i = 0; i < players.length; i++) {
EntityPlayer player = ((CraftPlayer) ((BukkitPlayer) players[i]).parent).getHandle();
if (playerManager.a(player, chunk.getX(), chunk.getZ())) {
watchingArr[i] = true;
watching = true;
}
}
if (!watching) return;
final LongAdder size = new LongAdder();
if (chunk instanceof VisualChunk) {
size.add(((VisualChunk) chunk).size());
} else if (chunk instanceof IntFaweChunk) {
size.add(((IntFaweChunk) chunk).getTotalCount());
} else {
chunk.forEachQueuedBlock(new FaweChunkVisitor() {
@Override
public void run(int localX, int y, int localZ, int combined) {
size.add(1);
}
});
}
if (size.intValue() == 0) return;
PacketPlayOutMultiBlockChange packet = new PacketPlayOutMultiBlockChange();
ByteBuf byteBuf = ByteBufAllocator.DEFAULT.buffer();
final PacketDataSerializer buffer = new PacketDataSerializer(byteBuf);
buffer.writeInt(chunk.getX());
buffer.writeInt(chunk.getZ());
buffer.d(size.intValue());
chunk.forEachQueuedBlock(new FaweChunkVisitor() {
@Override
public void run(int localX, int y, int localZ, int combined) {
short index = (short) (localX << 12 | localZ << 8 | y);
if (combined < 16) combined = 0;
buffer.writeShort(index);
buffer.d(combined);
}
});
packet.a(buffer);
for (int i = 0; i < players.length; i++) {
if (watchingArr[i]) ((CraftPlayer) ((BukkitPlayer) players[i]).parent).getHandle().playerConnection.sendPacket(packet);
}
} catch (IOException e) {
e.printStackTrace();
}
}
@Override
public void refreshChunk(FaweChunk fc) {
sendChunk(fc.getX(), fc.getZ(), fc.getBitMask());
}
public void sendPacket(int cx, int cz, Packet packet) {
PlayerChunk chunk = getPlayerChunk(nmsWorld, cx, cz);
if (chunk != null) {
for (EntityPlayer player : chunk.players) {
player.playerConnection.sendPacket(packet);
}
}
}
private PlayerChunk getPlayerChunk(WorldServer w, int cx, int cz) {
PlayerChunkMap chunkMap = w.getPlayerChunkMap();
PlayerChunk playerChunk = chunkMap.getChunk(cx, cz);
if (playerChunk == null) {
return null;
}
if (playerChunk.players.isEmpty()) {
return null;
}
return playerChunk;
}
public boolean sendChunk(PlayerChunk playerChunk, net.minecraft.server.v1_13_R2.Chunk nmsChunk, int mask) {
if (playerChunk == null) {
return false;
}
if (mask == 0) {
PacketPlayOutMapChunk packet = new PacketPlayOutMapChunk(nmsChunk, 65535);
for (EntityPlayer player : playerChunk.players) {
player.playerConnection.sendPacket(packet);
}
return true;
}
// Send chunks
boolean empty = false;
ChunkSection[] sections = nmsChunk.getSections();
for (int i = 0; i < sections.length; i++) {
if (sections[i] == null) {
sections[i] = emptySection;
empty = true;
}
}
if (mask == 0 || mask == 65535 && hasEntities(nmsChunk)) {
PacketPlayOutMapChunk packet = new PacketPlayOutMapChunk(nmsChunk, 65280);
for (EntityPlayer player : playerChunk.players) {
player.playerConnection.sendPacket(packet);
}
mask = 255;
}
PacketPlayOutMapChunk packet = new PacketPlayOutMapChunk(nmsChunk, mask);
for (EntityPlayer player : playerChunk.players) {
player.playerConnection.sendPacket(packet);
}
if (empty) {
for (int i = 0; i < sections.length; i++) {
if (sections[i] == emptySection) {
sections[i] = null;
}
}
}
return true;
}
public boolean hasEntities(net.minecraft.server.v1_13_R2.Chunk nmsChunk) {
try {
final Collection<Entity>[] entities = nmsChunk.entitySlices;
for (int i = 0; i < entities.length; i++) {
Collection<Entity> slice = entities[i];
if (slice != null && !slice.isEmpty()) {
return true;
}
}
} catch (Throwable ignore) {}
return false;
}
@Override
public boolean removeSectionLighting(ChunkSection section, int layer, boolean sky) {
if (section != null) {
Arrays.fill(section.getEmittedLightArray().asBytes(), (byte) 0);
if (sky) {
byte[] light = section.getSkyLightArray().asBytes();
if (light != null) {
Arrays.fill(light, (byte) 0);
}
}
return true;
}
return false;
}
@Override
public void setFullbright(ChunkSection[] sections) {
for (int i = 0; i < sections.length; i++) {
ChunkSection section = sections[i];
if (section != null) {
byte[] bytes = section.getSkyLightArray().asBytes();
Arrays.fill(bytes, (byte) 255);
}
}
}
@Override
public int getSkyLight(ChunkSection section, int x, int y, int z) {
return section.c(x & 15, y & 15, z & 15);
}
@Override
public int getEmmittedLight(ChunkSection section, int x, int y, int z) {
return section.d(x & 15, y & 15, z & 15);
}
@Override
public void relightBlock(int x, int y, int z) {
pos.c(x, y, z);
nmsWorld.c(EnumSkyBlock.BLOCK, pos);
}
@Override
public void relightSky(int x, int y, int z) {
pos.c(x, y, z);
nmsWorld.c(EnumSkyBlock.SKY, pos);
}
@Override
public void relight(int x, int y, int z) {
pos.c(x, y, z);
nmsWorld.r(pos);
}
protected WorldServer nmsWorld;
@Override
public World getImpWorld() {
World world = super.getImpWorld();
if (world != null) {
this.nmsWorld = ((CraftWorld) world).getHandle();
return super.getImpWorld();
} else {
return null;
}
}
public static void setCount(int tickingBlockCount, int nonEmptyBlockCount, ChunkSection section) throws NoSuchFieldException, IllegalAccessException {
fieldTickingBlockCount.set(section, tickingBlockCount);
fieldNonEmptyBlockCount.set(section, nonEmptyBlockCount);
}
public int getNonEmptyBlockCount(ChunkSection section) throws IllegalAccessException {
return (int) fieldNonEmptyBlockCount.get(section);
}
public void setPalette(ChunkSection section, DataPaletteBlock palette) throws NoSuchFieldException, IllegalAccessException {
fieldSection.set(section, palette);
Arrays.fill(section.getEmittedLightArray().asBytes(), (byte) 0);
}
public static ChunkSection newChunkSection(int y2, boolean flag, int[] blocks) {
if (blocks == null) {
return new ChunkSection(y2, flag);
} else {
ChunkSection section = new ChunkSection(y2, flag);
int[] blockToPalette = FaweCache.BLOCK_TO_PALETTE.get();
int[] paletteToBlock = FaweCache.PALETTE_TO_BLOCK.get();
long[] blockstates = FaweCache.BLOCK_STATES.get();
int[] blocksCopy = FaweCache.SECTION_BLOCKS.get();
try {
int num_palette = 0;
int air = 0;
for (int i = 0, j = 0; i < 4096; i++, j++) {
int stateId = blocks[i];
switch (stateId) {
case 0:
case BlockID.AIR:
case BlockID.CAVE_AIR:
case BlockID.VOID_AIR:
air++;
}
int ordinal = BlockState.getFromInternalId(stateId).getOrdinal(); // TODO fixme Remove all use of BlockTypes.BIT_OFFSET so that this conversion isn't necessary
int palette = blockToPalette[ordinal];
if (palette == Integer.MAX_VALUE) {
blockToPalette[ordinal] = palette = num_palette;
paletteToBlock[num_palette] = ordinal;
num_palette++;
}
blocksCopy[j] = palette;
}
// BlockStates
int bitsPerEntry = MathMan.log2nlz(num_palette - 1);
int blockBitArrayEnd = (bitsPerEntry * 4096) >> 6;
if (num_palette == 1) {
// Set a value, because minecraft needs it for some reason
blockstates[0] = 0;
blockBitArrayEnd = 1;
} else {
BitArray4096 bitArray = new BitArray4096(blockstates, bitsPerEntry);
bitArray.fromRaw(blocksCopy);
}
// set palette & data bits
DataPaletteBlock<IBlockData> dataPaletteBlocks = section.getBlocks();
// private DataPalette<T> h;
// protected DataBits a;
long[] bits = Arrays.copyOfRange(blockstates, 0, blockBitArrayEnd);
DataBits nmsBits = new DataBits(bitsPerEntry, 4096, bits);
DataPalette<IBlockData> palette;
// DataPaletteHash<IBlockData> hash = new DataPaletteHash<>(Block.REGISTRY_ID, num_palette, dataPaletteBlocks, GameProfileSerializer::d, GameProfileSerializer::a);
palette = new DataPaletteLinear<>(Block.REGISTRY_ID, num_palette, dataPaletteBlocks, GameProfileSerializer::d);
// set palette
for (int i = 0; i < num_palette; i++) {
int ordinal = paletteToBlock[i];
blockToPalette[ordinal] = Integer.MAX_VALUE;
BlockState state = BlockTypes.states[ordinal];
IBlockData ibd = ((BlockMaterial_1_13) state.getMaterial()).getState();
palette.a(ibd);
}
try {
fieldBits.set(dataPaletteBlocks, nmsBits);
fieldPalette.set(dataPaletteBlocks, palette);
fieldSize.set(dataPaletteBlocks, num_palette);
setCount(0, 4096 - air, section);
} catch (IllegalAccessException | NoSuchFieldException e) {
throw new RuntimeException(e);
}
return section;
} catch (Throwable e){
Arrays.fill(blockToPalette, Integer.MAX_VALUE);
throw e;
}
}
}
protected BlockPosition.MutableBlockPosition pos = new BlockPosition.MutableBlockPosition(0, 0, 0);
@Override
public CompoundTag getTileEntity(net.minecraft.server.v1_13_R2.Chunk chunk, int x, int y, int z) {
Map<BlockPosition, TileEntity> tiles = chunk.getTileEntities();
pos.c(x, y, z);
TileEntity tile = tiles.get(pos);
return tile != null ? getTag(tile) : null;
}
public CompoundTag getTag(TileEntity tile) {
try {
NBTTagCompound tag = new NBTTagCompound();
tile.save(tag); // readTagIntoEntity
return (CompoundTag) toNative(tag);
} catch (Exception e) {
MainUtil.handleError(e);
return null;
}
}
@Deprecated
public boolean unloadChunk(final String world, final Chunk chunk) {
net.minecraft.server.v1_13_R2.Chunk c = ((CraftChunk) chunk).getHandle();
c.mustSave = false;
if (chunk.isLoaded()) {
chunk.unload(false, false);
}
return true;
}
@Override
public BukkitChunk_1_13 getFaweChunk(int x, int z) {
return new BukkitChunk_1_13(this, x, z);
}
}

14
worldedit-bukkit/src/main/java/com/sk89q/worldedit/bukkit/WorldEditListener.java
View File

@ -28,6 +28,7 @@ import com.sk89q.worldedit.entity.Player;
import com.sk89q.worldedit.extension.platform.Actor;
import com.sk89q.worldedit.util.Location;
import com.sk89q.worldedit.util.command.CommandMapping;
import com.sk89q.worldedit.util.command.Dispatcher;
import com.sk89q.worldedit.world.World;
import org.bukkit.block.Block;
import org.bukkit.event.Event.Result;
@ -110,11 +111,14 @@ public class WorldEditListener implements Listener {
public void onPlayerCommand(PlayerCommandSendEvent event) {
CommandLocals locals = new CommandLocals();
locals.put(Actor.class, plugin.wrapCommandSender(event.getPlayer()));
Set<String> toRemove = plugin.getWorldEdit().getPlatformManager().getCommandManager().getDispatcher().getCommands().stream()
.filter(commandMapping -> !commandMapping.getCallable().testPermission(locals))
.map(CommandMapping::getPrimaryAlias)
.collect(Collectors.toSet());
event.getCommands().removeIf(toRemove::contains);
Dispatcher dispatcher = plugin.getWorldEdit().getPlatformManager().getCommandManager().getDispatcher();
if (dispatcher != null) {
Set<String> toRemove = dispatcher.getCommands().stream()
.filter(commandMapping -> !commandMapping.getCallable().testPermission(locals))
.map(CommandMapping::getPrimaryAlias)
.collect(Collectors.toSet());
event.getCommands().removeIf(toRemove::contains);
}
}
/**