下面列出了org.bukkit.entity.Slime#org.bukkit.World.Environment 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
private static int toPocketDimension(Environment dimId) {
switch (dimId) {
case NETHER: {
return 1;
}
case THE_END: {
return 2;
}
case NORMAL: {
return 0;
}
default: {
throw new IllegalArgumentException(String.format("Unknown dim id %s", dimId));
}
}
}
public static void transferEntityToDimension(Entity ent, int dim, ServerConfigurationManager manager, Environment environ) {
if (ent instanceof EntityPlayerMP) {
transferPlayerToDimension((EntityPlayerMP) ent, dim, manager, environ);
return;
}
WorldServer worldserver = manager.getServerInstance().worldServerForDimension(ent.dimension);
ent.dimension = dim;
WorldServer worldserver1 = manager.getServerInstance().worldServerForDimension(ent.dimension);
worldserver.removePlayerEntityDangerously(ent);
if (ent.riddenByEntity != null) {
ent.riddenByEntity.mountEntity(null);
}
if (ent.ridingEntity != null) {
ent.mountEntity(null);
}
ent.isDead = false;
transferEntityToWorld(ent, worldserver, worldserver1);
}
private static World createArenaWorld(ConfigArena arena, String name) {
World world;
world = Bukkit.getServer().getWorld(name);
if (world == null) {
WorldCreator wc = new WorldCreator(name);
wc.environment(Environment.NORMAL);
wc.type(WorldType.FLAT);
wc.generateStructures(false);
world = Bukkit.getServer().createWorld(wc);
world.setAutoSave(false);
world.setSpawnFlags(false, false);
world.setKeepSpawnInMemory(false);
ChunkCoord.addWorld(world);
}
return world;
}
@Test
public void testOilResource() {
NamespacedKey key = new NamespacedKey(plugin, "oil");
GEOResource resource = testResource(key, "Oil", SlimefunItems.OIL_BUCKET, false, 8);
Assertions.assertEquals(0, resource.getDefaultSupply(Environment.NETHER, Biome.NETHER_WASTES));
Assertions.assertNotEquals(0, resource.getDefaultSupply(Environment.NORMAL, Biome.BEACH));
Assertions.assertTrue(resource.getDefaultSupply(Environment.NORMAL, Biome.DESERT) > 10);
Assertions.assertTrue(resource.getDefaultSupply(Environment.NORMAL, Biome.MOUNTAINS) > 10);
Assertions.assertTrue(resource.getDefaultSupply(Environment.NORMAL, Biome.ICE_SPIKES) > 10);
Assertions.assertTrue(resource.getDefaultSupply(Environment.NORMAL, Biome.BADLANDS) > 10);
Assertions.assertTrue(resource.getDefaultSupply(Environment.NORMAL, Biome.OCEAN) > 10);
Assertions.assertTrue(resource.getDefaultSupply(Environment.NORMAL, Biome.SWAMP) > 10);
Assertions.assertEquals(10, resource.getDefaultSupply(Environment.NORMAL, Biome.SUNFLOWER_PLAINS));
}
/**
* Prevents water from being dispensed in hell biomes
*
* @param e - event
*/
@EventHandler(priority = EventPriority.LOW)
public void onNetherDispenser(final BlockDispenseEvent e) {
if (DEBUG) {
plugin.getLogger().info(e.getEventName());
}
if (e.getBlock().getWorld().getEnvironment().equals(Environment.NETHER) || !inWorld(e.getBlock().getLocation()) || !e.getBlock().getBiome().equals(Biome.HELL)) {
return;
}
// plugin.getLogger().info("DEBUG: Item being dispensed is " +
// e.getItem().getType().toString());
if (e.getItem().getType().equals(Material.WATER_BUCKET)) {
e.setCancelled(true);
if (plugin.getServer().getVersion().contains("(MC: 1.8") || plugin.getServer().getVersion().contains("(MC: 1.7")) {
e.getBlock().getWorld().playSound(e.getBlock().getLocation(), Sound.valueOf("FIZZ"), 1F, 2F);
} else {
e.getBlock().getWorld().playSound(e.getBlock().getLocation(), Sound.ENTITY_CREEPER_PRIMED, 1F, 2F);
}
}
}
@SuppressWarnings("deprecation")
public byte[][] generateBlockSections(World world, Random random, int chunkX, int chunkZ, BiomeGrid biomeGrid) {
// Bukkit.getLogger().info("DEBUG: world environment = " +
// world.getEnvironment().toString());
if (world.getEnvironment().equals(World.Environment.NETHER)) {
return generateNetherBlockSections(world, random, chunkX, chunkZ, biomeGrid);
}
byte[][] result = new byte[world.getMaxHeight() / 16][];
if (Settings.seaHeight == 0) {
return result;
} else {
for (int x = 0; x < 16; x++) {
for (int z = 0; z < 16; z++) {
for (int y = 0; y < Settings.seaHeight; y++) {
setBlock(result, x, y, z, (byte) Material.STATIONARY_WATER.getId()); // Stationary
// Water
// Allows stuff to fall through into oblivion, thus
// keeping lag to a minimum
}
}
}
return result;
}
}
private void makeWorld(Environment env, String name) {
WorldCreator wc = new WorldCreator(name);
wc.type(WorldType.FLAT);
wc.generateStructures(false);
wc.generator(new SkyblockGenerator());
wc.environment(env);
wc.createWorld();
}
@Override
public Environment getDimension(CommandContext cmdCtx, String key) {
DimensionManager manager = ArgumentDimension.a(cmdCtx, key);
switch (manager.getDimensionID()) {
case 0:
return Environment.NORMAL;
case -1:
return Environment.NETHER;
case 1:
return Environment.THE_END;
}
return null;
}
@Override
public Environment getDimension(CommandContext cmdCtx, String key) {
DimensionManager manager = ArgumentDimension.a(cmdCtx, key);
switch (manager.getDimensionID()) {
case 0:
return Environment.NORMAL;
case -1:
return Environment.NETHER;
case 1:
return Environment.THE_END;
}
return null;
}
@Override
public Environment getDimension(CommandContext cmdCtx, String key) {
DimensionManager manager = ArgumentDimension.a(cmdCtx, key);
switch (manager.getDimensionID()) {
case 0:
return Environment.NORMAL;
case -1:
return Environment.NETHER;
case 1:
return Environment.THE_END;
}
return null;
}
@Override
public Environment getDimension(CommandContext cmdCtx, String key) {
DimensionManager manager = ArgumentDimension.a(cmdCtx, key);
switch (manager.getDimensionID()) {
case 0:
return Environment.NORMAL;
case -1:
return Environment.NETHER;
case 1:
return Environment.THE_END;
}
return null;
}
@Override
public Environment getDimension(CommandContext cmdCtx, String key) {
DimensionManager manager = ArgumentDimension.a(cmdCtx, key);
switch (manager.getDimensionID()) {
case 0:
return Environment.NORMAL;
case -1:
return Environment.NETHER;
case 1:
return Environment.THE_END;
}
return null;
}
@Override
public Environment getDimension(CommandContext cmdCtx, String key) {
DimensionManager manager = ArgumentDimension.a(cmdCtx, key);
switch (manager.getDimensionID()) {
case 0:
return Environment.NORMAL;
case -1:
return Environment.NETHER;
case 1:
return Environment.THE_END;
}
return null;
}
public MapInfo(SemanticVersion proto,
@Nullable String slug,
String name,
SemanticVersion version,
MapDoc.Edition edition,
MapDoc.Phase phase,
@Nullable BaseComponent game,
MapDoc.Genre genre,
Set<MapDoc.Gamemode> gamemodes,
BaseComponent objective,
List<Contributor> authors,
List<Contributor> contributors,
List<String> rules,
@Nullable Difficulty difficulty,
Environment dimension,
boolean friendlyFire) {
this.id = new MapId(slug != null ? slug : MapId.slugifyName(name), edition, phase);
this.proto = checkNotNull(proto);
this.name = checkNotNull(name);
this.version = checkNotNull(version);
this.game = game;
this.genre = checkNotNull(genre);
this.gamemodes = checkNotNull(gamemodes);
this.objective = checkNotNull(objective);
this.authors = checkNotNull(authors);
this.contributors = checkNotNull(contributors);
this.rules = checkNotNull(rules);
this.difficulty = difficulty;
this.dimension = checkNotNull(dimension);
this.friendlyFire = friendlyFire;
}
public void loadOldWorld(String uuid, Environment env){
if(uuid == null || uuid.equals("null")){
Bukkit.getLogger().info("[UhcCore] No world to load, defaulting to default behavior");
this.createNewWorld(env);
}else{
File worldDir = new File(uuid);
if(worldDir.exists()){
// Loading existing world
Bukkit.getServer().createWorld(new WorldCreator(uuid));
}else{
this.createNewWorld(env);
}
}
}
@Override
public void onExecute(String[] args, CommandSender sender) {
File target = new File(DungeonsXL.MAPS, args[1]);
File source = new File(Bukkit.getWorldContainer(), args[1]);
if (!source.exists()) {
MessageUtil.sendMessage(sender, DMessage.ERROR_NO_SUCH_MAP.getMessage(args[1]));
return;
}
if (target.exists()) {
MessageUtil.sendMessage(sender, DMessage.ERROR_NAME_IN_USE.getMessage(args[1]));
return;
}
World world = Bukkit.getWorld(args[1]);
if (world != null) {
world.save();
}
MessageUtil.log(plugin, "&6Creating new map.");
MessageUtil.log(plugin, "&6Importing world...");
FileUtil.copyDir(source, target, "playerdata", "stats");
DResourceWorld resource = new DResourceWorld(plugin, args[1]);
plugin.getDungeonRegistry().add(args[1], new DDungeon(plugin, resource));
if (world.getEnvironment() != Environment.NORMAL) {
WorldConfig config = resource.getConfig(true);
config.setWorldEnvironment(world.getEnvironment());
config.save();
}
plugin.getMapRegistry().add(resource.getName(), resource);
MessageUtil.sendMessage(sender, DMessage.CMD_IMPORT_SUCCESS.getMessage(args[1]));
}
public void create_cmd() throws CivException {
String name = getNamedString(1, "enter a world name");
WorldCreator wc = new WorldCreator(name);
wc.environment(Environment.NORMAL);
wc.type(WorldType.FLAT);
wc.generateStructures(false);
World world = Bukkit.getServer().createWorld(wc);
world.setSpawnFlags(false, false);
ChunkCoord.addWorld(world);
CivMessage.sendSuccess(sender, "World "+name+" created.");
}
private boolean hasSunlight(Player p) {
World world = p.getWorld();
if (world.getEnvironment() != Environment.NORMAL) {
// The End and Nether have no sunlight
return false;
}
return (world.getTime() < 12300 || world.getTime() > 23850) && p.getEyeLocation().getBlock().getLightFromSky() == 15;
}
@Override
public int getDefaultSupply(Environment envionment, Biome biome) {
if (envionment == Environment.NORMAL) {
return 5;
}
return 0;
}
@Override
public int getDefaultSupply(Environment environment, Biome biome) {
if (environment != Environment.NORMAL) {
return 0;
}
switch (biome) {
case SNOWY_BEACH:
case STONE_SHORE:
case BEACH:
case DESERT_LAKES:
case RIVER:
case ICE_SPIKES:
case FROZEN_RIVER:
return 40;
case DEEP_OCEAN:
case OCEAN:
case COLD_OCEAN:
case DEEP_COLD_OCEAN:
case DEEP_FROZEN_OCEAN:
case DEEP_LUKEWARM_OCEAN:
case DEEP_WARM_OCEAN:
case FROZEN_OCEAN:
case LUKEWARM_OCEAN:
case WARM_OCEAN:
return 60;
case SWAMP:
case SWAMP_HILLS:
return 20;
default:
return 6;
}
}
@Test
public void testNetherIceResource() {
NamespacedKey key = new NamespacedKey(plugin, "nether_ice");
GEOResource resource = testResource(key, "Nether Ice", SlimefunItems.NETHER_ICE, true, 6);
Assertions.assertNotEquals(0, resource.getDefaultSupply(Environment.NETHER, Biome.NETHER_WASTES));
Assertions.assertEquals(0, resource.getDefaultSupply(Environment.NORMAL, Biome.DESERT));
}
@Test
public void testUraniumResource() {
NamespacedKey key = new NamespacedKey(plugin, "uranium");
GEOResource resource = testResource(key, "Small Chunks of Uranium", SlimefunItems.SMALL_URANIUM, true, 2);
Assertions.assertNotEquals(0, resource.getDefaultSupply(Environment.NORMAL, Biome.MOUNTAINS));
Assertions.assertEquals(0, resource.getDefaultSupply(Environment.NETHER, Biome.NETHER_WASTES));
Assertions.assertEquals(0, resource.getDefaultSupply(Environment.THE_END, Biome.THE_END));
}
@Test
public void testSaltResource() {
NamespacedKey key = new NamespacedKey(plugin, "salt");
GEOResource resource = testResource(key, "Salt", SlimefunItems.SALT, true, 18);
Assertions.assertEquals(0, resource.getDefaultSupply(Environment.NETHER, Biome.NETHER_WASTES));
Assertions.assertEquals(0, resource.getDefaultSupply(Environment.THE_END, Biome.THE_END));
Assertions.assertNotEquals(0, resource.getDefaultSupply(Environment.NORMAL, Biome.MOUNTAINS));
Assertions.assertTrue(resource.getDefaultSupply(Environment.NORMAL, Biome.BEACH) > 10);
Assertions.assertTrue(resource.getDefaultSupply(Environment.NORMAL, Biome.OCEAN) > 10);
Assertions.assertTrue(resource.getDefaultSupply(Environment.NORMAL, Biome.SWAMP) > 10);
}
private ResourceKey<WorldDimension> getWorldDimKey(Environment env) {
switch (env) {
case NETHER:
return WorldDimension.THE_NETHER;
case THE_END:
return WorldDimension.THE_END;
case NORMAL:
default:
return WorldDimension.OVERWORLD;
}
}
@EventHandler
public void onWorldInit(WorldInitEvent event) {
//Add new chunkprovidergenerate
if (plugin.getConfig().getStringList("options.worlds").contains(event.getWorld().getName()) && event.getWorld().getEnvironment() == Environment.NORMAL) {
WorldServer nmsWorld = ((CraftWorld) event.getWorld()).getHandle();
nmsWorld.chunkProviderServer.chunkProvider = new ChunkProviderGenerate(nmsWorld, nmsWorld.getSeed(), nmsWorld.getWorldData().shouldGenerateMapFeatures());
}
}
private void makeWorld() {
makeWorld(Environment.NORMAL, IridiumSkyblock.getConfiguration().worldName);
if (IridiumSkyblock.getConfiguration().netherIslands)
makeWorld(Environment.NETHER, IridiumSkyblock.getConfiguration().netherWorldName);
}
@EventHandler(priority = EventPriority.LOWEST)
public void onEntityExplodeEvent(EntityExplodeEvent event) {
final World world = event.getEntity().getLocation().getWorld();
if (!GDFlags.EXPLOSION_BLOCK || !GriefDefenderPlugin.getInstance().claimsEnabledForWorld(world.getUID())) {
return;
}
GDCauseStackManager.getInstance().pushCause(event.getEntity());
// check entity tracker
final GDEntity gdEntity = EntityTracker.getCachedEntity(event.getEntity().getEntityId());
GDPermissionUser user = null;
if (gdEntity != null) {
user = PermissionHolderCache.getInstance().getOrCreateUser(gdEntity.getOwnerUUID());
}
Entity source = event.getEntity();
if (GriefDefenderPlugin.isSourceIdBlacklisted(Flags.EXPLOSION_BLOCK.toString(), source, world.getUID())) {
return;
}
final String sourceId = GDPermissionManager.getInstance().getPermissionIdentifier(source);
boolean denySurfaceExplosion = GriefDefenderPlugin.getActiveConfig(world.getUID()).getConfig().claim.explosionBlockSurfaceBlacklist.contains(sourceId);
if (!denySurfaceExplosion) {
denySurfaceExplosion = GriefDefenderPlugin.getActiveConfig(world.getUID()).getConfig().claim.explosionBlockSurfaceBlacklist.contains("any");
}
GDTimings.EXPLOSION_EVENT.startTiming();
GDClaim targetClaim = null;
final int cancelBlockLimit = GriefDefenderPlugin.getGlobalConfig().getConfig().claim.explosionCancelBlockLimit;
final List<Block> filteredLocations = new ArrayList<>();
for (Block block : event.blockList()) {
final Location location = block.getLocation();
targetClaim = GriefDefenderPlugin.getInstance().dataStore.getClaimAt(location);
if (denySurfaceExplosion && block.getWorld().getEnvironment() != Environment.NETHER && location.getBlockY() >= location.getWorld().getSeaLevel()) {
filteredLocations.add(block);
GDPermissionManager.getInstance().processEventLog(event, location, targetClaim, Flags.EXPLOSION_BLOCK.getPermission(), source, block, user, "explosion-surface", Tristate.FALSE);
continue;
}
final Tristate result = GDPermissionManager.getInstance().getFinalPermission(event, location, targetClaim, Flags.EXPLOSION_BLOCK, source, block, user, true);
if (result == Tristate.FALSE) {
// Avoid lagging server from large explosions.
if (event.blockList().size() > cancelBlockLimit) {
event.setCancelled(true);
break;
}
filteredLocations.add(block);
}
}
if (event.isCancelled()) {
event.blockList().clear();
} else if (!filteredLocations.isEmpty()) {
event.blockList().removeAll(filteredLocations);
}
GDTimings.EXPLOSION_EVENT.stopTiming();
}
@EventHandler(priority = EventPriority.LOWEST)
public void onExplosionEvent(BlockExplodeEvent event) {
final World world = event.getBlock().getLocation().getWorld();
if (!GDFlags.EXPLOSION_BLOCK || !GriefDefenderPlugin.getInstance().claimsEnabledForWorld(world.getUID())) {
return;
}
Block source = event.getBlock();
GDCauseStackManager.getInstance().pushCause(source);
if (GriefDefenderPlugin.isSourceIdBlacklisted(Flags.EXPLOSION_BLOCK.toString(), source, world.getUID())) {
return;
}
final GDPermissionUser user = CauseContextHelper.getEventUser(event.getBlock().getLocation(), PlayerTracker.Type.OWNER);
GDTimings.EXPLOSION_EVENT.startTiming();
GDClaim targetClaim = null;
final List<Block> filteredLocations = new ArrayList<>();
final String sourceId = GDPermissionManager.getInstance().getPermissionIdentifier(source);
final int cancelBlockLimit = GriefDefenderPlugin.getGlobalConfig().getConfig().claim.explosionCancelBlockLimit;
boolean denySurfaceExplosion = GriefDefenderPlugin.getActiveConfig(world.getUID()).getConfig().claim.explosionBlockSurfaceBlacklist.contains(sourceId);
if (!denySurfaceExplosion) {
denySurfaceExplosion = GriefDefenderPlugin.getActiveConfig(world.getUID()).getConfig().claim.explosionBlockSurfaceBlacklist.contains("any");
}
for (Block block : event.blockList()) {
final Location location = block.getLocation();
targetClaim = GriefDefenderPlugin.getInstance().dataStore.getClaimAt(location);
if (denySurfaceExplosion && block.getWorld().getEnvironment() != Environment.NETHER && location.getBlockY() >= location.getWorld().getSeaLevel()) {
filteredLocations.add(block);
GDPermissionManager.getInstance().processEventLog(event, location, targetClaim, Flags.EXPLOSION_BLOCK.getPermission(), source, block, user, "explosion-surface", Tristate.FALSE);
continue;
}
Tristate result = GDPermissionManager.getInstance().getFinalPermission(event, location, targetClaim, Flags.EXPLOSION_BLOCK, source, block, user, true);
if (result == Tristate.FALSE) {
// Avoid lagging server from large explosions.
if (event.blockList().size() > cancelBlockLimit) {
event.setCancelled(true);
break;
}
filteredLocations.add(block);
}
}
if (event.isCancelled()) {
event.blockList().clear();
} else if (!filteredLocations.isEmpty()) {
event.blockList().removeAll(filteredLocations);
}
GDTimings.EXPLOSION_EVENT.stopTiming();
}
public static Consumer<CommandSender> createTeleportConsumer(CommandSender src, Location location, Claim claim, boolean isClaimSpawn) {
return teleport -> {
if (!(src instanceof Player)) {
// ignore
return;
}
final Player player = (Player) src;
// check if world is loaded
if (Bukkit.getWorld(location.getWorld().getUID()) == null) {
TextAdapter.sendComponent(player, MessageCache.getInstance().TELEPORT_NO_SAFE_LOCATION);
return;
}
final GDPlayerData playerData = GriefDefenderPlugin.getInstance().dataStore.getPlayerData(player.getWorld(), player.getUniqueId());
final int teleportDelay = GDPermissionManager.getInstance().getInternalOptionValue(TypeToken.of(Integer.class), player, Options.PLAYER_TELEPORT_DELAY, claim);
if (isClaimSpawn) {
if (teleportDelay > 0) {
playerData.teleportDelay = teleportDelay + 1;
playerData.teleportSourceLocation = player.getLocation();
playerData.teleportLocation = location;
return;
}
player.teleport(location, TeleportCause.PLUGIN);
return;
}
final double safeY = location.getWorld().getHighestBlockYAt(location);
location.setY(safeY);
int currentY = location.getBlockY();
while (currentY > 0 && currentY < location.getWorld().getMaxHeight()) {
if (PlayerUtil.getInstance().isSafeLocation(location)) {
if (teleportDelay > 0) {
playerData.teleportDelay = teleportDelay + 1;
playerData.teleportLocation = location;
return;
}
player.teleport(location, TeleportCause.PLUGIN);
return;
}
if (location.getWorld().getEnvironment() == Environment.NETHER) {
currentY--;
} else {
currentY++;
}
location.setY(currentY);
}
TextAdapter.sendComponent(player, MessageCache.getInstance().TELEPORT_NO_SAFE_LOCATION);
};
}
public World createWorld(String name, Environment environment) {
return WorldCreator.name(name).environment(environment).createWorld();
}