EpicKnarvik97/PlotSquared
1
0
Fork 0
mirror of https://github.com/IntellectualSites/PlotSquared.git synced 2025-07-17 12:54:43 +02:00
Code Issues Projects Releases Wiki Activity

Trying to reduce reliance on Bukkit

Browse Source
This commit is contained in:
boy0001
2015-07-28 16:06:19 +10:00
parent 2b229f49d1
commit 904b75a7cd
36 changed files with 494 additions and 416 deletions
Download Patch File Download Diff File Expand all files Collapse all files

483
src/main/java/com/plotsquared/bukkit/util/BukkitHybridUtils.java Normal file
View File

@ -0,0 +1,483 @@
package com.plotsquared.bukkit.util;
import com.intellectualcrafters.plot.PS;
import com.intellectualcrafters.plot.config.C;
import com.intellectualcrafters.plot.flag.Flag;
import com.intellectualcrafters.plot.flag.FlagManager;
import com.intellectualcrafters.plot.generator.ClassicPlotWorld;
import com.intellectualcrafters.plot.generator.HybridUtils;
import com.intellectualcrafters.plot.object.*;
import com.intellectualcrafters.plot.util.ChunkManager;
import com.intellectualcrafters.plot.util.MainUtil;
import com.intellectualcrafters.plot.util.MathMan;
import com.intellectualcrafters.plot.util.TaskManager;
import com.plotsquared.bukkit.BukkitMain;
import com.plotsquared.bukkit.generator.AugmentedPopulator;
import com.plotsquared.bukkit.util.bukkit.BukkitUtil;
import org.bukkit.Bukkit;
import org.bukkit.Chunk;
import org.bukkit.Material;
import org.bukkit.World;
import org.bukkit.block.Biome;
import org.bukkit.block.Block;
import org.bukkit.generator.ChunkGenerator;
import org.bukkit.generator.ChunkGenerator.BiomeGrid;
import org.bukkit.material.Directional;
import org.bukkit.material.MaterialData;
import org.bukkit.plugin.Plugin;
import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;
public class BukkitHybridUtils extends HybridUtils {
public static List<ChunkLoc> regions;
public static List<ChunkLoc> chunks = new ArrayList<>();
public static String world;
private static boolean UPDATE = false;
public int task;
private long last;
@Override
public void analyzePlot(final Plot plot, final RunnableVal<PlotAnalysis> whenDone) {
// TODO Auto-generated method stub
// int diff, int variety, int verticies, int rotation, int height_sd
/*
* diff: compare to base by looping through all blocks
* variety: add to hashset for each plotblock
* height_sd: loop over all blocks and get top block
*
* verticies: store air map and compare with neighbours
* for each block check the adjacent
* - Store all blocks then go through in second loop
* - recheck each block
*
*/
final World world = Bukkit.getWorld(plot.world);
final ChunkGenerator gen = world.getGenerator();
if (gen == null) {
return;
}
final BiomeGrid base = new BiomeGrid() { @Override public void setBiome(int a, int b, Biome c) {} @Override public Biome getBiome(int a, int b) {return null;}};
Location bot = MainUtil.getPlotBottomLoc(plot.world, plot.id).add(1, 0, 1);
Location top = MainUtil.getPlotTopLoc(plot.world, plot.id);
final int bx = bot.getX();
final int bz = bot.getZ();
final int tx = top.getX();
final int tz = top.getZ();
final int cbx = bx >> 4;
final int cbz = bz >> 4;
final int ctx = tx >> 4;
final int ctz = tz >> 4;
final Random r = new Random();
AugmentedPopulator.initCache();
final int width = tx - bx + 1;
final int length = tz - bz + 1;
System.gc();
System.gc();
final short[][][] oldblocks = new short[256][width][length];
final short[][][] newblocks = new short[256][width][length];
final List<ChunkLoc> chunks = new ArrayList<>();
final List<ChunkLoc> processed_chunks = new ArrayList<>();
for (int X = cbx; X <= ctx; X++) {
for (int Z = cbz; Z <= ctz; Z++) {
// Chunk chunk = world.getChunkAt(X, Z);
chunks.add(new ChunkLoc(X, Z));
}
}
final Runnable run = new Runnable() {
@Override
public void run() {
for (ChunkLoc chunk : processed_chunks) {
short[][] result = gen.generateExtBlockSections(world, r, chunk.x, chunk.z, base);
int X = chunk.x;
int Z = chunk.z;
int xb = ((X) << 4) - bx;
int zb = ((Z) << 4) - bz;
for (int i = 0; i < result.length; i++) {
if (result[i] == null) {
for (int j = 0; j < 4096; j++) {
int x = AugmentedPopulator.x_loc[i][j] + xb;
if (x < 0 || x >= width) continue;
int z = AugmentedPopulator.z_loc[i][j] + zb;
if (z < 0 || z >= length) continue;
int y = AugmentedPopulator.y_loc[i][j];
oldblocks[y][x][z] = 0;
}
continue;
}
for (int j = 0; j < result[i].length; j++) {
int x = AugmentedPopulator.x_loc[i][j] + xb;
if (x < 0 || x >= width) continue;
int z = AugmentedPopulator.z_loc[i][j] + zb;
if (z < 0 || z >= length) continue;
int y = AugmentedPopulator.y_loc[i][j];
oldblocks[y][x][z] = result[i][j];
}
}
}
int size = width * length;
int[] changes = new int[size];
int[] faces = new int[size];
int[] data = new int[size];
int[] air = new int[size];
int[] variety = new int[size];
int i = 0;
for (int x = 0; x < width;x++) {
for (int z = 0; z < length;z++) {
HashSet<Short> types = new HashSet<>();
for (int y = 0; y < 256; y++) {
short old = oldblocks[y][x][z];
short now = newblocks[y][x][z];
if (old != now) {
changes[i]++;
}
if (now == 0) {
air[i]++;
}
else {
// check verticies
// modifications_adjacent
if (x > 0 && z > 0 && y > 0 && x < width - 1 && z < length - 1 && y < 255) {
if (newblocks[y - 1][x][z] == 0) faces[i]++;
if (newblocks[y][x - 1][z] == 0) faces[i]++;
if (newblocks[y][x][z - 1] == 0) faces[i]++;
if (newblocks[y + 1][x][z] == 0) faces[i]++;
if (newblocks[y][x + 1][z] == 0) faces[i]++;
if (newblocks[y][x][z + 1] == 0) faces[i]++;
}
Material material = Material.getMaterial(now);
Class<? extends MaterialData> md = material.getData();
if (md.equals(Directional.class)) {
data[i] += 8;
}
else if (!md.equals(MaterialData.class)) {
data[i]++;
}
types.add(now);
}
}
variety[i] = types.size();
i++;
}
}
// analyze plot
// put in analysis obj
// run whenDone
PlotAnalysis analysis = new PlotAnalysis();
analysis.changes = (int) (MathMan.getMean(changes) * 100);
analysis.faces = (int) (MathMan.getMean(faces) * 100);
analysis.data = (int) (MathMan.getMean(data) * 100);
analysis.air = (int) (MathMan.getMean(air) * 100);
analysis.variety = (int) (MathMan.getMean(variety) * 100);
analysis.changes_sd = (int) (MathMan.getSD(changes, analysis.changes));
analysis.faces_sd = (int) (MathMan.getSD(faces, analysis.faces));
analysis.data_sd = (int) (MathMan.getSD(data, analysis.data));
analysis.air_sd = (int) (MathMan.getSD(air, analysis.air));
analysis.variety_sd = (int) (MathMan.getSD(variety, analysis.variety));
List<Integer> result = new ArrayList<>();
result.add(analysis.changes);
result.add(analysis.faces);
result.add(analysis.data);
result.add(analysis.air);
result.add(analysis.variety);
result.add(analysis.changes_sd);
result.add(analysis.faces_sd);
result.add(analysis.data_sd);
result.add(analysis.air_sd);
result.add(analysis.variety_sd);
Flag flag = new Flag(FlagManager.getFlag("analysis"), result);
FlagManager.addPlotFlag(plot, flag);
System.gc();
System.gc();
whenDone.value = analysis;
whenDone.run();
}
};
System.gc();
AugmentedPopulator.initCache();
TaskManager.index.incrementAndGet();
final Integer currentIndex = TaskManager.index.get();
final Integer task = TaskManager.runTaskRepeat(new Runnable() {
@Override
public void run() {
int index = chunks.size() - 1;
if (index == -1) {
PS.get().TASK.cancelTask(TaskManager.tasks.get(currentIndex));
TaskManager.runTaskAsync(run);
return;
}
ChunkLoc chunk = chunks.remove(0);
world.loadChunk(chunk.x, chunk.z);
processed_chunks.add(chunk);
int X = chunk.x;
int Z = chunk.z;
int minX;
int minZ;
int maxX;
int maxZ;
if (X == cbx) minX = bx & 0x0f;
else minX = 0;
if (Z == cbz) minZ = bz & 0x0f;
else minZ = 0;
if (X == ctx) maxX = tx & 0x0f;
else maxX = 16;
if (Z == ctz) maxZ = tz & 0x0f;
else maxZ = 16;
int cbx = X << 4;
int cbz = Z << 4;
int xb = (cbx) - bx;
int zb = (cbz) - bz;
for (int x = minX; x <= maxX; x++) {
int xx = cbx + cbz;
for (int z = minZ; z <= maxZ; z++) {
int zz = cbz + z;
for (int y = 0; y < 256; y++) {
Block block = world.getBlockAt(xx, y, zz);
int xr = xb + x;
int zr = zb + z;
newblocks[y][xr][zr] = (short) block.getTypeId();
}
}
}
world.unloadChunkRequest(chunk.x, chunk.z, true);
}
}, 1);
TaskManager.tasks.put(currentIndex, task);
}
public void checkModified(final Plot plot, final RunnableVal<Integer> whenDone) {
TaskManager.index.incrementAndGet();
final Location bot = MainUtil.getPlotBottomLoc(plot.world, plot.id).add(1, 0, 1);
final Location top = MainUtil.getPlotTopLoc(plot.world, plot.id);
int bx = bot.getX() >> 4;
int bz = bot.getZ() >> 4;
int tx = top.getX() >> 4;
int tz = top.getZ() >> 4;
World world = BukkitUtil.getWorld(plot.world);
final HashSet<Chunk> chunks = new HashSet<>();
for (int X = bx; X <= tx; X++) {
for (int Z = bz; Z <= tz; Z++) {
chunks.add(world.getChunkAt(X,Z));
}
}
PlotWorld plotworld = PS.get().getPlotWorld(plot.world);
if (!(plotworld instanceof ClassicPlotWorld)) {
whenDone.value = -1;
TaskManager.runTaskLater(whenDone, 1);
return;
}
final ClassicPlotWorld cpw = (ClassicPlotWorld) plotworld;
final AtomicInteger count = new AtomicInteger(0);
final Integer currentIndex = TaskManager.index.get();
final Integer task = TaskManager.runTaskRepeat(new Runnable() {
@Override
public void run() {
if (chunks.size() == 0) {
whenDone.value = count.intValue();
TaskManager.runTaskLater(whenDone, 1);
Bukkit.getScheduler().cancelTask(TaskManager.tasks.get(currentIndex));
TaskManager.tasks.remove(currentIndex);
return;
}
Iterator<Chunk> iter = chunks.iterator();
final Chunk chunk = iter.next();
iter.remove();
int bx = Math.max(chunk.getX() << 4, bot.getX());
int bz = Math.max(chunk.getZ() << 4, bot.getZ());
int ex = Math.min((chunk.getX() << 4) + 15, top.getX());
int ez = Math.min((chunk.getZ() << 4) + 15, top.getZ());
// count changes
count.addAndGet(checkModified(plot.world, bx, ex, 1, cpw.PLOT_HEIGHT - 1, bz, ez, cpw.MAIN_BLOCK));
count.addAndGet(checkModified(plot.world, bx, ex, cpw.PLOT_HEIGHT, cpw.PLOT_HEIGHT, bz, ez, cpw.TOP_BLOCK));
count.addAndGet(checkModified(plot.world, bx, ex, cpw.PLOT_HEIGHT + 1, 255, bz, ez, new PlotBlock[] { new PlotBlock((short) 0, (byte) 0) }));
}
}, 1);
TaskManager.tasks.put(currentIndex, task);
}
@Override
public int checkModified(final String worldname, final int x1, final int x2, final int y1, final int y2, final int z1, final int z2, final PlotBlock[] blocks) {
final World world = BukkitUtil.getWorld(worldname);
int count = 0;
for (int y = y1; y <= y2; y++) {
for (int x = x1; x <= x2; x++) {
for (int z = z1; z <= z2; z++) {
final Block block = world.getBlockAt(x, y, z);
final int id = block.getTypeId();
boolean same = false;
for (final PlotBlock p : blocks) {
if (id == p.id) {
same = true;
break;
}
}
if (!same) {
count++;
}
}
}
}
return count;
}
@Override
public int get_ey(final String worldname, final int sx, final int ex, final int sz, final int ez, final int sy) {
final World world = BukkitUtil.getWorld(worldname);
final int maxY = world.getMaxHeight();
int ey = sy;
for (int x = sx; x <= ex; x++) {
for (int z = sz; z <= ez; z++) {
for (int y = sy; y < maxY; y++) {
if (y > ey) {
final Block block = world.getBlockAt(x, y, z);
if (block.getTypeId() != 0) {
ey = y;
}
}
}
}
}
return ey;
}
public void regenerateChunkChunk(final String worldname, final ChunkLoc loc) {
final World world = BukkitUtil.getWorld(worldname);
final int sx = loc.x << 5;
final int sz = loc.z << 5;
for (int x = sx; x < (sx + 32); x++) {
for (int z = sz; z < (sz + 32); z++) {
final Chunk chunk = world.getChunkAt(x, z);
chunk.load(false);
}
}
final ArrayList<Chunk> chunks2 = new ArrayList<>();
for (int x = sx; x < (sx + 32); x++) {
for (int z = sz; z < (sz + 32); z++) {
final Chunk chunk = world.getChunkAt(x, z);
chunks2.add(chunk);
regenerateRoad(worldname, new ChunkLoc(x, z), 0);
MainUtil.update(world.getName(), new ChunkLoc(chunk.getX(), chunk.getZ()));
}
}
}
public final ArrayList<ChunkLoc> getChunks(ChunkLoc region) {
ArrayList<ChunkLoc> chunks = new ArrayList<ChunkLoc>();
final int sx = region.x << 5;
final int sz = region.z << 5;
for (int x = sx; x < (sx + 32); x++) {
for (int z = sz; z < (sz + 32); z++) {
chunks.add(new ChunkLoc(x, z));
}
}
return chunks;
}
@Override
public boolean scheduleRoadUpdate(final String world, int extend) {
if (BukkitHybridUtils.UPDATE) {
return false;
}
BukkitHybridUtils.UPDATE = true;
final List<ChunkLoc> regions = ChunkManager.manager.getChunkChunks(world);
return scheduleRoadUpdate(world, regions, extend);
}
public boolean scheduleRoadUpdate(final String world, final List<ChunkLoc> rgs, final int extend) {
BukkitHybridUtils.regions = rgs;
BukkitHybridUtils.world = world;
chunks = new ArrayList<ChunkLoc>();
final Plugin plugin = BukkitMain.THIS;
final AtomicInteger count = new AtomicInteger(0);
this.task = Bukkit.getScheduler().scheduleSyncRepeatingTask(plugin, new Runnable() {
@Override
public void run() {
count.incrementAndGet();
if (count.intValue() % 20 == 0) {
PS.log("PROGRESS: " + ((100 * (2048 - chunks.size())) / 2048) + "%");
}
if (regions.size() == 0 && chunks.size() == 0) {
BukkitHybridUtils.UPDATE = false;
PS.log(C.PREFIX.s() + "Finished road conversion");
Bukkit.getScheduler().cancelTask(BukkitHybridUtils.this.task);
return;
} else {
try {
if (chunks.size() < 1024) {
if (regions.size() > 0) {
final ChunkLoc loc = regions.get(0);
PS.log("&3Updating .mcr: " + loc.x + ", " + loc.z + " (aprrox 1024 chunks)");
PS.log(" - Remaining: " + regions.size());
chunks.addAll(getChunks(loc));
regions.remove(0);
System.gc();
}
}
if (chunks.size() > 0) {
long diff = System.currentTimeMillis() + 25;
if (System.currentTimeMillis() - last > 1200 && last != 0) {
last = 0;
PS.log(C.PREFIX.s() + "Detected low TPS. Rescheduling in 30s");
while (chunks.size() > 0) {
ChunkLoc chunk = chunks.get(0);
chunks.remove(0);
regenerateRoad(world, chunk, extend);
ChunkManager.manager.unloadChunk(world, chunk, true, true);
}
Bukkit.getScheduler().cancelTask(BukkitHybridUtils.this.task);
TaskManager.runTaskLater(new Runnable() {
@Override
public void run() {
scheduleRoadUpdate(world, regions, extend);
}
}, 600);
return;
}
if (System.currentTimeMillis() - last < 1000) {
while (System.currentTimeMillis() < diff && chunks.size() > 0) {
ChunkLoc chunk = chunks.get(0);
chunks.remove(0);
regenerateRoad(world, chunk, extend);
ChunkManager.manager.unloadChunk(world, chunk, true, true);
}
}
last = System.currentTimeMillis();
}
} catch (final Exception e) {
e.printStackTrace();
final ChunkLoc loc = regions.get(0);
PS.log("&c[ERROR]&7 Could not update '" + world + "/region/r." + loc.x + "." + loc.z + ".mca' (Corrupt chunk?)");
final int sx = loc.x << 5;
final int sz = loc.z << 5;
for (int x = sx; x < (sx + 32); x++) {
for (int z = sz; z < (sz + 32); z++) {
ChunkManager.manager.unloadChunk(world, new ChunkLoc(x, z), true, true);
}
}
PS.log("&d - Potentially skipping 1024 chunks");
PS.log("&d - TODO: recommend chunkster if corrupt");
}
}
}
}, 20, 20);
return true;
}
}

8
src/main/java/com/plotsquared/bukkit/util/bukkit/BukkitChunkManager.java
View File

@ -929,13 +929,13 @@ public class BukkitChunkManager extends ChunkManager {
}
@Override
public boolean loadChunk(final String world, final ChunkLoc loc) {
return BukkitUtil.getWorld(world).getChunkAt(loc.x, loc.z).load(false);
public boolean loadChunk(final String world, final ChunkLoc loc, boolean force) {
return BukkitUtil.getWorld(world).getChunkAt(loc.x, loc.z).load(force);
}
@Override
public boolean unloadChunk(final String world, final ChunkLoc loc) {
return BukkitUtil.getWorld(world).getChunkAt(loc.x, loc.z).unload(true, true);
public boolean unloadChunk(final String world, final ChunkLoc loc, boolean save, boolean safe) {
return BukkitUtil.getWorld(world).unloadChunk(loc.x, loc.z, save, safe);
}
public static void swapChunk(final World world, final Chunk pos1, final Chunk pos2, final RegionWrapper r1, final RegionWrapper r2) {

247
src/main/java/com/plotsquared/bukkit/util/bukkit/BukkitUtil.java
View File

@ -1,13 +1,13 @@
package com.plotsquared.bukkit.util.bukkit;
import com.intellectualcrafters.plot.object.ChunkLoc;
import com.intellectualcrafters.plot.object.Location;
import com.intellectualcrafters.plot.object.PlotBlock;
import com.intellectualcrafters.plot.object.PlotPlayer;
import com.intellectualcrafters.plot.object.schematic.PlotItem;
import com.intellectualcrafters.plot.util.*;
import com.plotsquared.bukkit.object.BukkitPlayer;
import org.bukkit.*;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import org.bukkit.Bukkit;
import org.bukkit.Material;
import org.bukkit.OfflinePlayer;
import org.bukkit.World;
import org.bukkit.block.Biome;
import org.bukkit.block.Block;
import org.bukkit.block.BlockState;
@ -17,11 +17,22 @@ import org.bukkit.entity.Player;
import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.InventoryHolder;
import org.bukkit.inventory.ItemStack;
import org.bukkit.material.*;
import org.bukkit.material.MaterialData;
import org.bukkit.material.Sandstone;
import org.bukkit.material.Step;
import org.bukkit.material.Tree;
import org.bukkit.material.WoodenStep;
import org.bukkit.material.Wool;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import com.intellectualcrafters.plot.object.Location;
import com.intellectualcrafters.plot.object.PlotBlock;
import com.intellectualcrafters.plot.object.PlotPlayer;
import com.intellectualcrafters.plot.object.schematic.PlotItem;
import com.intellectualcrafters.plot.util.BlockManager;
import com.intellectualcrafters.plot.util.MathMan;
import com.intellectualcrafters.plot.util.StringComparison;
import com.intellectualcrafters.plot.util.UUIDHandler;
import com.plotsquared.bukkit.object.BukkitPlayer;
public class BukkitUtil extends BlockManager {
private static HashMap<String, World> worlds = new HashMap<>();
@ -36,12 +47,71 @@ public class BukkitUtil extends BlockManager {
lastPlotPlayer = null;
UUIDHandler.getPlayers().remove(plr);
}
// These weren't being used, but they might be useful later, so I'm just commenting them out
// private static int getMaxHeight(final String world) {
// return getWorld(world).getMaxHeight();
// }
//
// private static void unloadChunkAt(String worldname, int X, int Z, boolean save, boolean safe) {
// final World world = getWorld(worldname);
// world.unloadChunk(X, Z, save, safe);
// }
//
// private static void loadChunkAt(final String worldname, int X, int Z, boolean force) {
// final World world = getWorld(worldname);
// world.loadChunk(X, Z, force);
// }
//
// private static Chunk getChunkAt(final String worldname, final int x, final int z) {
// final World world = getWorld(worldname);
// return world.getChunkAt(x, z);
// }
//
// private static void teleportPlayer(final Player player, final Location loc) {
// final org.bukkit.Location bukkitLoc = new org.bukkit.Location(getWorld(loc.getWorld()), loc.getX(), loc.getY(), loc.getZ());
// player.teleport(bukkitLoc);
// }
//
// private static void setBiome(final String worldname, final int pos1_x, final int pos1_z, final int pos2_x, final int pos2_z, final String biome) {
// final Biome b = Biome.valueOf(biome.toUpperCase());
// final World world = getWorld(worldname);
// for (int x = pos1_x; x <= pos2_x; x++) {
// for (int z = pos1_z; z <= pos2_z; z++) {
// if (world.getBiome(x, z) == b) {
// continue;
// }
// world.setBiome(x, z, b);
// }
// }
// }
//
// private static void refreshChunk(final String name, final int x, final int z) {
// World world = getWorld(name);
// world.refreshChunk(x, z);
// world.loadChunk(x, z);
// }
//
// private static void regenerateChunk(final String world, final int x, final int z) {
// World worldObj = getWorld(world);
// Chunk chunk = worldObj.getChunkAt(x, z);
// if (chunk.isLoaded() || chunk.load(false)) {
// ChunkManager.manager.regenerateChunk(world, new ChunkLoc(x, z));
// }
// }
//
// private static Location getLocationFull(final org.bukkit.Location loc) {
// final String world = loc.getWorld().getName();
// return new Location(world, loc.getBlockX(), loc.getBlockY(), loc.getBlockZ(), loc.getYaw(), loc.getPitch());
// }
//
// private static int getViewDistance() {
// return Bukkit.getViewDistance();
// }
@Override
public boolean isWorld(final String world) {
return getWorld(world) != null;
}
////////////////////////////////////////////////////////////////////////
/////////////////// USED BY EVENT SYSTEM AND SUCH //////////////////////
////////////////////////////////////////////////////////////////////////
public static PlotPlayer getPlayer(final OfflinePlayer op) {
if (op.isOnline()) {
return getPlayer(op.getPlayer());
@ -66,11 +136,6 @@ public class BukkitUtil extends BlockManager {
return lastPlotPlayer;
}
@Override
public String getBiome(final Location loc) {
return getWorld(loc.getWorld()).getBiome(loc.getX(), loc.getZ()).name();
}
public static Location getLocation(final org.bukkit.Location loc) {
return new Location(loc.getWorld().getName(), (int) loc.getX(), (int) loc.getY(), (int) loc.getZ());
}
@ -91,99 +156,14 @@ public class BukkitUtil extends BlockManager {
return world;
}
public static int getMaxHeight(final String world) {
return getWorld(world).getMaxHeight();
}
public static int getHeighestBlock(final String world, final int x, final int z) {
return getWorld(world).getHighestBlockYAt(x, z);
}
public static void unloadChunkAt(String worldname, int X, int Z, boolean save, boolean safe) {
final World world = getWorld(worldname);
world.unloadChunk(X, Z, save, safe);
}
public static void loadChunkAt(final String worldname, int X, int Z, boolean force) {
final World world = getWorld(worldname);
world.loadChunk(X, Z, force);
}
public static Chunk getChunkAt(final String worldname, final int x, final int z) {
final World world = getWorld(worldname);
return world.getChunkAt(x, z);
}
// public static void update(final String world, final int x, final int z) {
// final ArrayList<Chunk> chunks = new ArrayList<>();
// final int distance = Bukkit.getViewDistance();
// for (int cx = -distance; cx < distance; cx++) {
// for (int cz = -distance; cz < distance; cz++) {
// final Chunk chunk = getChunkAt(world, (x >> 4) + cx, (z >> 4) + cz);
// chunks.add(chunk);
// }
// }
// BukkitSetBlockManager.setBlockManager.update(chunks);
// }
public static String getWorld(final Entity entity) {
return entity.getWorld().getName();
}
public static void teleportPlayer(final Player player, final Location loc) {
final org.bukkit.Location bukkitLoc = new org.bukkit.Location(getWorld(loc.getWorld()), loc.getX(), loc.getY(), loc.getZ());
player.teleport(bukkitLoc);
}
public static List<Entity> getEntities(final String worldname) {
return getWorld(worldname).getEntities();
}
public static void setBlock(final World world, final int x, final int y, final int z, final int id, final byte data) {
try {
BukkitSetBlockManager.setBlockManager.set(world, x, y, z, id, data);
} catch (final Throwable e) {
BukkitSetBlockManager.setBlockManager = new SetBlockSlow();
BukkitSetBlockManager.setBlockManager.set(world, x, y, z, id, data);
}
}
public static void setBiome(final String worldname, final int pos1_x, final int pos1_z, final int pos2_x, final int pos2_z, final String biome) {
final Biome b = Biome.valueOf(biome.toUpperCase());
final World world = getWorld(worldname);
for (int x = pos1_x; x <= pos2_x; x++) {
for (int z = pos1_z; z <= pos2_z; z++) {
if (world.getBiome(x, z) == b) {
continue;
}
world.setBiome(x, z, b);
}
}
}
public static void refreshChunk(final String name, final int x, final int z) {
World world = getWorld(name);
world.refreshChunk(x, z);
world.loadChunk(x, z);
}
public static void regenerateChunk(final String world, final int x, final int z) {
World worldObj = getWorld(world);
Chunk chunk = worldObj.getChunkAt(x, z);
if (chunk.isLoaded() || chunk.load(false)) {
ChunkManager.manager.regenerateChunk(world, new ChunkLoc(x, z));
}
}
public static PlotBlock getBlock(final Location loc) {
final World world = getWorld(loc.getWorld());
final Block block = world.getBlockAt(loc.getX(), loc.getY(), loc.getZ());
if (block == null) {
return new PlotBlock((short) 0, (byte) 0);
}
return new PlotBlock((short) block.getTypeId(), block.getData());
}
public static Location getLocation(final Entity entity) {
final org.bukkit.Location loc = entity.getLocation();
final String world = loc.getWorld().getName();
@ -193,10 +173,31 @@ public class BukkitUtil extends BlockManager {
public static Location getLocationFull(final Entity entity) {
return getLocation(entity.getLocation());
}
////////////////////////////////////////////////////////////////////////
public static Location getLocationFull(final org.bukkit.Location loc) {
final String world = loc.getWorld().getName();
return new Location(world, loc.getBlockX(), loc.getBlockY(), loc.getBlockZ(), loc.getYaw(), loc.getPitch());
////////////////////////////////////////////////////////////////////////
////////////////////// CLASS ONLY METHODS //////////////////////////////
////////////////////////////////////////////////////////////////////////
private static void setBlock(final World world, final int x, final int y, final int z, final int id, final byte data) {
try {
BukkitSetBlockManager.setBlockManager.set(world, x, y, z, id, data);
} catch (final Throwable e) {
BukkitSetBlockManager.setBlockManager = new SetBlockSlow();
BukkitSetBlockManager.setBlockManager.set(world, x, y, z, id, data);
}
}
////////////////////////////////////////////////////////////////////////
@Override
public boolean isWorld(final String world) {
return getWorld(world) != null;
}
@Override
public String getBiome(String world, int x, int z) {
return getWorld(world).getBiome(x, z).name();
}
@Override
@ -222,16 +223,12 @@ public class BukkitUtil extends BlockManager {
}
}
public static int getViewDistance() {
return Bukkit.getViewDistance();
}
@Override
public void functionSetBiomes(final String worldname, final int[] x, final int[] z, final int[] biome) {
public void functionSetBiomes(final String worldname, final int[] x, final int[] z, final String biomeStr) {
final World world = getWorld(worldname);
final Biome[] biomes = Biome.values();
final Biome biome = Biome.valueOf(biomeStr.toUpperCase());
for (int i = 0; i < x.length; i++) {
world.setBiome(x[i], z[i], biomes[biome[i]]);
world.setBiome(x[i], z[i], biome);
}
}
@ -259,8 +256,8 @@ public class BukkitUtil extends BlockManager {
}
@Override
public int getHeighestBlock(final Location loc) {
return getWorld(loc.getWorld()).getHighestBlockAt(loc.getX(), loc.getZ()).getY();
public int getHeighestBlock(String world, int x, int z) {
return getWorld(world).getHighestBlockAt(x, z).getY();
}
@Override
@ -383,4 +380,14 @@ public class BukkitUtil extends BlockManager {
catch (Exception e) {}
return null;
}
@Override
public PlotBlock getBlock(Location loc) {
final World world = getWorld(loc.getWorld());
final Block block = world.getBlockAt(loc.getX(), loc.getY(), loc.getZ());
if (block == null) {
return new PlotBlock((short) 0, (byte) 0);
}
return new PlotBlock((short) block.getTypeId(), block.getData());
}
}