/******************************************************************************
* Multiverse 2 Copyright (c) the Multiverse Team 2011. *
* Multiverse 2 is licensed under the BSD License. *
* For more information please check the README.md file included *
* with this project. *
******************************************************************************/
package com.onarandombox.MultiverseCore;
import com.dumptruckman.minecraft.util.Logging;
import com.onarandombox.MultiverseCore.api.BlockSafety;
import com.onarandombox.MultiverseCore.api.MultiverseWorld;
import com.onarandombox.MultiverseCore.api.SafeTTeleporter;
import com.onarandombox.MultiverseCore.configuration.SpawnLocation;
import com.onarandombox.MultiverseCore.configuration.WorldPropertyValidator;
import com.onarandombox.MultiverseCore.enums.AllowedPortalType;
import com.onarandombox.MultiverseCore.enums.EnglishChatColor;
import com.onarandombox.MultiverseCore.exceptions.PropertyDoesNotExistException;
import me.main__.util.SerializationConfig.ChangeDeniedException;
import me.main__.util.SerializationConfig.NoSuchPropertyException;
import me.main__.util.SerializationConfig.VirtualProperty;
import org.bukkit.ChatColor;
import org.bukkit.Difficulty;
import org.bukkit.GameMode;
import org.bukkit.Location;
import org.bukkit.World;
import org.bukkit.World.Environment;
import org.bukkit.WorldType;
import org.bukkit.command.CommandSender;
import org.bukkit.configuration.serialization.SerializableAs;
import org.bukkit.entity.Player;
import org.bukkit.permissions.Permission;
import org.bukkit.permissions.PermissionDefault;
import org.bukkit.util.Vector;
import org.json.simple.JSONObject;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.logging.Level;
/**
* The implementation of a Multiverse handled world.
*/
public class MVWorld implements MultiverseWorld {
private static final int SPAWN_LOCATION_SEARCH_TOLERANCE = 16;
private static final int SPAWN_LOCATION_SEARCH_RADIUS = 16;
private final MultiverseCore plugin; // Hold the Plugin Instance.
private final String name; // The Worlds Name, EG its folder name.
private final UUID worldUID;
private final WorldProperties props;
public MVWorld(MultiverseCore plugin, World world, WorldProperties properties) {
this(plugin, world, properties, true);
}
/*
* We have to use setCBWorld(), setPlugin() and initPerms() to prepare this object for use.
*/
public MVWorld(MultiverseCore plugin, World world, WorldProperties properties, boolean fixSpawn) {
this.plugin = plugin;
this.name = world.getName();
this.worldUID = world.getUID();
this.props = properties;
setupProperties();
if (!fixSpawn) {
props.setAdjustSpawn(false);
}
// Setup spawn separately so we can use the validator with the world spawn value..
final SpawnLocationPropertyValidator spawnValidator = new SpawnLocationPropertyValidator();
this.props.setValidator("spawn", spawnValidator);
this.props.spawnLocation.setWorld(world);
if (this.props.spawnLocation instanceof NullLocation) {
final SpawnLocation newLoc = new SpawnLocation(readSpawnFromWorld(world));
this.props.spawnLocation = newLoc;
world.setSpawnLocation(newLoc.getBlockX(), newLoc.getBlockY(), newLoc.getBlockZ());
}
this.props.environment = world.getEnvironment();
this.props.seed = world.getSeed();
this.initPerms();
this.props.flushChanges();
validateProperties();
}
private void setupProperties() {
this.props.setMVWorld(this);
this.props.pvp = new VirtualProperty<Boolean>() {
@Override
public void set(Boolean newValue) {
final World world = getCBWorld();
if (world != null) {
world.setPVP(newValue);
}
}
@Override
public Boolean get() {
final World world = getCBWorld();
return world != null ? world.getPVP() : null;
}
};
this.props.difficulty = new VirtualProperty<Difficulty>() {
@Override
public void set(Difficulty newValue) {
final World world = getCBWorld();
if (world != null) {
world.setDifficulty(newValue);
}
}
@Override
public Difficulty get() {
final World world = getCBWorld();
return world != null ? world.getDifficulty() : null;
}
};
this.props.keepSpawnInMemory = new VirtualProperty<Boolean>() {
@Override
public void set(Boolean newValue) {
final World world = getCBWorld();
if (world != null) {
world.setKeepSpawnInMemory(newValue);
}
}
@Override
public Boolean get() {
final World world = getCBWorld();
return world != null ? world.getKeepSpawnInMemory() : null;
}
};
this.props.spawn = new VirtualProperty<Location>() {
@Override
public void set(Location newValue) {
if (getCBWorld() != null)
getCBWorld().setSpawnLocation(newValue.getBlockX(), newValue.getBlockY(), newValue.getBlockZ());
props.spawnLocation = new SpawnLocation(newValue);
}
@Override
public Location get() {
props.spawnLocation.setWorld(getCBWorld());
// basically, everybody should accept our "SpawnLocation", right?
// so just returning it should be fine
return props.spawnLocation;
}
};
this.props.time = new VirtualProperty<Long>() {
@Override
public void set(Long newValue) {
final World world = getCBWorld();
if (world != null) {
world.setTime(newValue);
}
}
@Override
public Long get() {
final World world = getCBWorld();
return world != null ? world.getTime() : null;
}
};
this.props.setValidator("scale", new ScalePropertyValidator());
this.props.setValidator("respawnWorld", new RespawnWorldPropertyValidator());
this.props.setValidator("allowWeather", new AllowWeatherPropertyValidator());
this.props.setValidator("spawning", new SpawningPropertyValidator());
this.props.setValidator("gameMode", new GameModePropertyValidator());
//this.props.validate();
}
private void validateProperties() {
setPVPMode(isPVPEnabled());
setDifficulty(getDifficulty());
setKeepSpawnInMemory(isKeepingSpawnInMemory());
setScaling(getScaling());
setRespawnToWorld(this.props.getRespawnToWorld());
setAllowAnimalSpawn(canAnimalsSpawn());
setAllowMonsterSpawn(canMonstersSpawn());
setGameMode(getGameMode());
}
/**
* Validates the scale-property.
*/
private final class ScalePropertyValidator extends WorldPropertyValidator<Double> {
@Override
public Double validateChange(String property, Double newValue, Double oldValue,
MVWorld object) throws ChangeDeniedException {
if (newValue <= 0) {
plugin.log(Level.FINE, "Someone tried to set a scale <= 0, aborting!");
throw new ChangeDeniedException();
}
return super.validateChange(property, newValue, oldValue, object);
}
}
/**
* Validates the respawnWorld-property.
*/
private final class RespawnWorldPropertyValidator extends WorldPropertyValidator<String> {
@Override
public String validateChange(String property, String newValue, String oldValue,
MVWorld object) throws ChangeDeniedException {
if (!newValue.isEmpty() && !plugin.getMVWorldManager().isMVWorld(newValue))
throw new ChangeDeniedException();
return super.validateChange(property, newValue, oldValue, object);
}
}
/**
* Used to apply the allowWeather-property.
*/
private final class AllowWeatherPropertyValidator extends WorldPropertyValidator<Boolean> {
@Override
public Boolean validateChange(String property, Boolean newValue, Boolean oldValue,
MVWorld object) throws ChangeDeniedException {
if (!newValue) {
final World world = getCBWorld();
if (world != null) {
world.setStorm(false);
world.setThundering(false);
}
}
return super.validateChange(property, newValue, oldValue, object);
}
}
/**
* Used to apply the spawning-property.
*/
private final class SpawningPropertyValidator extends WorldPropertyValidator<Boolean> {
@Override
public Boolean validateChange(String property, Boolean newValue, Boolean oldValue,
MVWorld object) throws ChangeDeniedException {
boolean allowMonsters, allowAnimals;
if (getAnimalList().isEmpty()) {
allowAnimals = canAnimalsSpawn();
} else {
allowAnimals = true;
}
if (getMonsterList().isEmpty()) {
allowMonsters = canMonstersSpawn();
} else {
allowMonsters = true;
}
final World world = getCBWorld();
if (world != null) {
if (MVWorld.this.props.getAnimalSpawnRate() != -1) {
world.setTicksPerAnimalSpawns(MVWorld.this.props.getAnimalSpawnRate());
}
if (MVWorld.this.props.getMonsterSpawnRate() != -1) {
world.setTicksPerMonsterSpawns(MVWorld.this.props.getMonsterSpawnRate());
}
world.setSpawnFlags(allowMonsters, allowAnimals);
}
plugin.getMVWorldManager().getTheWorldPurger().purgeWorld(MVWorld.this);
return super.validateChange(property, newValue, oldValue, object);
}
}
/**
* Used to apply the gameMode-property.
*/
private final class GameModePropertyValidator extends WorldPropertyValidator<GameMode> {
@Override
public GameMode validateChange(String property, GameMode newValue, GameMode oldValue,
MVWorld object) throws ChangeDeniedException {
for (Player p : plugin.getServer().getWorld(getName()).getPlayers()) {
plugin.log(Level.FINER, String.format("Setting %s's GameMode to %s",
p.getName(), newValue.toString()));
plugin.getPlayerListener().handleGameModeAndFlight(p, MVWorld.this);
}
return super.validateChange(property, newValue, oldValue, object);
}
}
/**
* Validator for the spawnLocation-property.
*/
private final class SpawnLocationPropertyValidator extends WorldPropertyValidator<Location> {
@Override
public Location validateChange(String property, Location newValue, Location oldValue,
MVWorld object) throws ChangeDeniedException {
if (newValue == null)
throw new ChangeDeniedException();
if (props.getAdjustSpawn()) {
BlockSafety bs = plugin.getBlockSafety();
// verify that the location is safe
if (!bs.playerCanSpawnHereSafely(newValue)) {
// it's not ==> find a better one!
plugin.log(Level.WARNING, String.format("Somebody tried to set the spawn location for '%s' to an unsafe value! Adjusting...", getAlias()));
plugin.log(Level.WARNING, "Old Location: " + plugin.getLocationManipulation().strCoordsRaw(oldValue));
plugin.log(Level.WARNING, "New (unsafe) Location: " + plugin.getLocationManipulation().strCoordsRaw(newValue));
SafeTTeleporter teleporter = plugin.getSafeTTeleporter();
newValue = teleporter.getSafeLocation(newValue, SPAWN_LOCATION_SEARCH_TOLERANCE, SPAWN_LOCATION_SEARCH_RADIUS);
if (newValue == null) {
plugin.log(Level.WARNING, "Couldn't fix the location. I have to abort the spawn location-change :/");
throw new ChangeDeniedException();
}
plugin.log(Level.WARNING, "New (safe) Location: " + plugin.getLocationManipulation().strCoordsRaw(newValue));
}
}
return super.validateChange(property, newValue, oldValue, object);
}
}
private Permission permission;
private Permission exempt;
private Permission ignoreperm;
private Permission limitbypassperm;
/**
* Null-location.
*/
@SerializableAs("MVNullLocation (It's a bug if you see this in your config file)")
public static final class NullLocation extends SpawnLocation {
public NullLocation() {
super(0, -1, 0);
}
@Override
public Location clone() {
throw new UnsupportedOperationException();
};
@Override
public Map<String, Object> serialize() {
return Collections.EMPTY_MAP;
}
/**
* Let Bukkit be able to deserialize this.
* @param args The map.
* @return The deserialized object.
*/
public static NullLocation deserialize(Map<String, Object> args) {
return new NullLocation();
}
@Override
public Vector toVector() {
throw new UnsupportedOperationException();
}
@Override
public int hashCode() {
return -1;
};
@Override
public String toString() {
return "NULL LOCATION";
};
}
/**
* Initializes permissions.
*/
private void initPerms() {
this.permission = new Permission("multiverse.access." + this.getName(), "Allows access to " + this.getName(), PermissionDefault.OP);
// This guy is special. He shouldn't be added to any parent perms.
this.ignoreperm = new Permission("mv.bypass.gamemode." + this.getName(),
"Allows players with this permission to ignore gamemode changes.", PermissionDefault.FALSE);
this.exempt = new Permission("multiverse.exempt." + this.getName(),
"A player who has this does not pay to enter this world, or use any MV portals in it " + this.getName(), PermissionDefault.OP);
this.limitbypassperm = new Permission("mv.bypass.playerlimit." + this.getName(),
"A player who can enter this world regardless of wether its full", PermissionDefault.OP);
try {
this.plugin.getServer().getPluginManager().addPermission(this.permission);
this.plugin.getServer().getPluginManager().addPermission(this.exempt);
this.plugin.getServer().getPluginManager().addPermission(this.ignoreperm);
this.plugin.getServer().getPluginManager().addPermission(this.limitbypassperm);
// Add the permission and exempt to parents.
this.addToUpperLists(this.permission);
// Add ignore to it's parent:
this.ignoreperm.addParent("mv.bypass.gamemode.*", true);
// Add limit bypass to it's parent
this.limitbypassperm.addParent("mv.bypass.playerlimit.*", true);
} catch (IllegalArgumentException e) {
this.plugin.log(Level.FINER, "Permissions nodes were already added for " + this.name);
}
}
private Location readSpawnFromWorld(World w) {
Location location = w.getSpawnLocation();
// Set the worldspawn to our configspawn
BlockSafety bs = this.plugin.getBlockSafety();
// Verify that location was safe
if (!bs.playerCanSpawnHereSafely(location)) {
if (!this.getAdjustSpawn()) {
this.plugin.log(Level.FINE, "Spawn location from world.dat file was unsafe!!");
this.plugin.log(Level.FINE, "NOT adjusting spawn for '" + this.getAlias() + "' because you told me not to.");
this.plugin.log(Level.FINE, "To turn on spawn adjustment for this world simply type:");
this.plugin.log(Level.FINE, "/mvm set adjustspawn true " + this.getAlias());
return location;
}
// If it's not, find a better one.
SafeTTeleporter teleporter = this.plugin.getSafeTTeleporter();
this.plugin.log(Level.WARNING, "Spawn location from world.dat file was unsafe. Adjusting...");
this.plugin.log(Level.WARNING, "Original Location: " + plugin.getLocationManipulation().strCoordsRaw(location));
Location newSpawn = teleporter.getSafeLocation(location,
SPAWN_LOCATION_SEARCH_TOLERANCE, SPAWN_LOCATION_SEARCH_RADIUS);
// I think we could also do this, as I think this is what Notch does.
// Not sure how it will work in the nether...
//Location newSpawn = this.spawnLocation.getWorld().getHighestBlockAt(this.spawnLocation).getLocation();
if (newSpawn != null) {
Logging.info("New Spawn for '%s' is located at: %s",
this.getName(), plugin.getLocationManipulation().locationToString(newSpawn));
return newSpawn;
} else {
// If it's a standard end world, let's check in a better place:
Location newerSpawn;
newerSpawn = bs.getTopBlock(new Location(w, 0, 0, 0));
if (newerSpawn != null) {
Logging.info("New Spawn for '%s' is located at: %s",
this.getName(), plugin.getLocationManipulation().locationToString(newerSpawn));
return newerSpawn;
} else {
this.plugin.log(Level.SEVERE, "Safe spawn NOT found!!!");
}
}
}
return location;
}
private void addToUpperLists(Permission perm) {
Permission all = this.plugin.getServer().getPluginManager().getPermission("multiverse.*");
Permission allWorlds = this.plugin.getServer().getPluginManager().getPermission("multiverse.access.*");
Permission allExemption = this.plugin.getServer().getPluginManager().getPermission("multiverse.exempt.*");
if (allWorlds == null) {
allWorlds = new Permission("multiverse.access.*");
this.plugin.getServer().getPluginManager().addPermission(allWorlds);
}
allWorlds.getChildren().put(perm.getName(), true);
if (allExemption == null) {
allExemption = new Permission("multiverse.exempt.*");
this.plugin.getServer().getPluginManager().addPermission(allExemption);
}
allExemption.getChildren().put(this.exempt.getName(), true);
if (all == null) {
all = new Permission("multiverse.*");
this.plugin.getServer().getPluginManager().addPermission(all);
}
all.getChildren().put("multiverse.access.*", true);
all.getChildren().put("multiverse.exempt.*", true);
this.plugin.getServer().getPluginManager().recalculatePermissionDefaults(all);
this.plugin.getServer().getPluginManager().recalculatePermissionDefaults(allWorlds);
}
/**
* Copies all properties from another {@link MVWorld} object.
* @param other The other world object.
*/
public void copyValues(MVWorld other) {
props.copyValues(other.props);
}
/**
* Copies all properties from a {@link WorldProperties} object.
* @param other The world properties object.
*/
public void copyValues(WorldProperties other) {
props.copyValues(other);
}
/**
* {@inheritDoc}
*/
@Override
public World getCBWorld() {
final World world = plugin.getServer().getWorld(worldUID);
if (world == null) {
throw new IllegalStateException("Lost reference to bukkit world '" + name + "'");
}
return world;
}
/**
* {@inheritDoc}
*/
@Override
public String getColoredWorldString() {
if (props.getAlias().length() == 0) {
props.setAlias(this.getName());
}
if ((props.getColor() == null) || (props.getColor().getColor() == null)) {
this.props.setColor(EnglishChatColor.WHITE);
}
StringBuilder nameBuilder = new StringBuilder().append(props.getColor().getColor());
if (props.getStyle().getColor() != null)
nameBuilder.append(props.getStyle().getColor());
nameBuilder.append(props.getAlias()).append(ChatColor.WHITE).toString();
return nameBuilder.toString();
}
/**
* {@inheritDoc}
*
* @deprecated This is deprecated.
*/
@Override
@Deprecated
public boolean clearList(String property) {
return clearVariable(property);
}
/**
* {@inheritDoc}
*
* @deprecated This is deprecated.
*/
@Override
@Deprecated
public boolean clearVariable(String property) {
List<String> list = getOldAndEvilList(property);
if (list == null)
return false;
list.clear();
return true;
}
/**
* {@inheritDoc}
*
* @deprecated This is deprecated.
*/
@Override
@Deprecated
public boolean addToVariable(String property, String value) {
List<String> list = getOldAndEvilList(property);
if (list == null)
return false;
list.add(value);
return true;
}
/**
* {@inheritDoc}
*
* @deprecated This is deprecated.
*/
@Override
@Deprecated
public boolean removeFromVariable(String property, String value) {
List<String> list = getOldAndEvilList(property);
if (list == null)
return false;
list.remove(value);
return true;
}
/**
* @deprecated This is deprecated.
*/
@Deprecated
private List<String> getOldAndEvilList(String property) {
if (property.equalsIgnoreCase("worldblacklist"))
return this.props.getWorldBlacklist();
else if (property.equalsIgnoreCase("animals"))
return this.props.getAnimalList();
else if (property.equalsIgnoreCase("monsters"))
return this.props.getMonsterList();
return null;
}
/**
* {@inheritDoc}
*
* @deprecated This is deprecated.
*/
@Override
@Deprecated
public <T> com.onarandombox.MultiverseCore.configuration.MVConfigProperty<T> getProperty(String property,
Class<T> expected) throws PropertyDoesNotExistException {
throw new UnsupportedOperationException("'MVConfigProperty<T> getProperty(String,Class<T>)' is no longer supported!");
}
/**
* {@inheritDoc}
*
* @deprecated This is deprecated.
*/
@Override
@Deprecated
public boolean setProperty(String name, String value, CommandSender sender) throws PropertyDoesNotExistException {
return this.setPropertyValue(name, value);
}
/**
* {@inheritDoc}
*/
@Override
public String getPropertyValue(String property) throws PropertyDoesNotExistException {
try {
return this.props.getProperty(property, true);
} catch (NoSuchPropertyException e) {
throw new PropertyDoesNotExistException(property, e);
}
}
/**
* {@inheritDoc}
*/
@Override
public boolean setPropertyValue(String property, String value) throws PropertyDoesNotExistException {
try {
return this.props.setProperty(property, value, true);
} catch (NoSuchPropertyException e) {
throw new PropertyDoesNotExistException(property, e);
}
}
/**
* {@inheritDoc}
*/
@Override
public String getPropertyHelp(String property) throws PropertyDoesNotExistException {
try {
return this.props.getPropertyDescription(property, true);
} catch (NoSuchPropertyException e) {
throw new PropertyDoesNotExistException(property, e);
}
}
/**
* {@inheritDoc}
*/
@Override
public WorldType getWorldType() {
// This variable is not settable in-game, therefore does not get a property.
final World world = getCBWorld();
return world != null ? world.getWorldType() : null;
}
/**
* {@inheritDoc}
*/
@Override
public Environment getEnvironment() {
return this.props.getEnvironment();
}
/**
* {@inheritDoc}
*/
@Override
public void setEnvironment(Environment environment) {
this.props.setEnvironment(environment);
}
/**
* {@inheritDoc}
*/
@Override
public long getSeed() {
return this.props.getSeed();
}
/**
* {@inheritDoc}
*/
@Override
public void setSeed(long seed) {
this.props.setSeed(seed);
}
/**
* {@inheritDoc}
*/
@Override
public String getGenerator() {
return this.props.getGenerator();
}
/**
* {@inheritDoc}
*/
@Override
public void setGenerator(String generator) {
this.props.setGenerator(generator);
}
/**
* {@inheritDoc}
*/
@Override
public int getPlayerLimit() {
return this.props.getPlayerLimit();
}
/**
* {@inheritDoc}
*/
@Override
public void setPlayerLimit(int limit) {
this.props.setPlayerLimit(limit);
}
/**
* {@inheritDoc}
*/
@Override
public String getName() {
// This variable is not settable in-game, therefore does not get a property.
return this.name;
}
/**
* {@inheritDoc}
*/
@Override
public String getPermissibleName() {
return this.name.toLowerCase();
}
/**
* {@inheritDoc}
*/
@Override
public String getAlias() {
if (this.props.getAlias() == null || this.props.getAlias().length() == 0) {
return this.name;
}
return this.props.getAlias();
}
/**
* {@inheritDoc}
*/
@Override
public void setAlias(String alias) {
this.props.setAlias(alias);
}
/**
* {@inheritDoc}
*/
@Override
public boolean canAnimalsSpawn() {
return this.props.canAnimalsSpawn();
}
/**
* {@inheritDoc}
*/
@Override
public void setAllowAnimalSpawn(boolean animals) {
this.props.setAllowAnimalSpawn(animals);
}
/**
* {@inheritDoc}
*/
@Override
public List<String> getAnimalList() {
// These don't fire events at the moment. Should they?
return this.props.getAnimalList();
}
/**
* {@inheritDoc}
*/
@Override
public boolean canMonstersSpawn() {
return this.props.canMonstersSpawn();
}
/**
* {@inheritDoc}
*/
@Override
public void setAllowMonsterSpawn(boolean monsters) {
this.props.setAllowMonsterSpawn(monsters);
}
/**
* {@inheritDoc}
*/
@Override
public List<String> getMonsterList() {
// These don't fire events at the moment. Should they?
return this.props.getMonsterList();
}
/**
* {@inheritDoc}
*/
@Override
public boolean isPVPEnabled() {
return this.props.isPVPEnabled();
}
/**
* {@inheritDoc}
*/
@Override
public void setPVPMode(boolean pvp) {
this.props.setPVPMode(pvp);
}
/**
* {@inheritDoc}
*/
@Override
public boolean isHidden() {
return this.props.isHidden();
}
/**
* {@inheritDoc}
*/
@Override
public void setHidden(boolean hidden) {
this.props.setHidden(hidden);
}
/**
* {@inheritDoc}
*/
@Override
public List<String> getWorldBlacklist() {
return this.props.getWorldBlacklist();
}
/**
* {@inheritDoc}
*/
@Override
public double getScaling() {
return this.props.getScaling();
}
/**
* {@inheritDoc}
*/
@Override
public boolean setScaling(double scaling) {
return this.props.setScaling(scaling);
}
/**
* {@inheritDoc}
*/
@Override
public boolean setColor(String aliasColor) {
return props.setColor(aliasColor);
}
/**
* {@inheritDoc}
*
* @deprecated This is deprecated.
*/
@Override
@Deprecated
public boolean isValidAliasColor(String aliasColor) {
return (EnglishChatColor.fromString(aliasColor) != null);
}
/**
* {@inheritDoc}
*/
@Override
public ChatColor getColor() {
return this.props.getColor().getColor();
}
/**
* {@inheritDoc}
*
* @deprecated This is deprecated.
*/
@Override
@Deprecated
public boolean getFakePVP() {
return false;
}
/**
* {@inheritDoc}
*/
@Override
public World getRespawnToWorld() {
return this.plugin.getServer().getWorld(props.getRespawnToWorld());
}
/**
* {@inheritDoc}
*/
@Override
public boolean setRespawnToWorld(String respawnToWorld) {
if (!this.plugin.getMVWorldManager().isMVWorld(respawnToWorld)) return false;
return this.props.setRespawnToWorld(respawnToWorld);
}
/**
* {@inheritDoc}
*/
@Override
public Permission getAccessPermission() {
return this.permission;
}
/**
* {@inheritDoc}
*/
@Override
public int getCurrency() {
return this.props.getCurrency();
}
/**
* {@inheritDoc}
*/
@Override
public void setCurrency(int currency) {
this.props.setCurrency(currency);
}
/**
* {@inheritDoc}
*/
@Override
public double getPrice() {
return this.props.getPrice();
}
/**
* {@inheritDoc}
*/
@Override
public void setPrice(double price) {
this.props.setPrice(price);
}
/**
* {@inheritDoc}
*/
@Override
public Permission getExemptPermission() {
return this.exempt;
}
/**
* {@inheritDoc}
*/
@Override
public boolean setGameMode(String mode) {
return this.props.setGameMode(mode);
}
@Override
public boolean setGameMode(GameMode mode) {
return this.props.setGameMode(mode);
}
/**
* {@inheritDoc}
*/
@Override
public GameMode getGameMode() {
return this.props.getGameMode();
}
/**
* {@inheritDoc}
*/
@Override
public void setEnableWeather(boolean weather) {
this.props.setEnableWeather(weather);
}
/**
* {@inheritDoc}
*/
@Override
public boolean isWeatherEnabled() {
return this.props.isWeatherEnabled();
}
/**
* {@inheritDoc}
*/
@Override
public boolean isKeepingSpawnInMemory() {
return this.props.isKeepingSpawnInMemory();
}
/**
* {@inheritDoc}
*/
@Override
public void setKeepSpawnInMemory(boolean value) {
this.props.setKeepSpawnInMemory(value);
}
/**
* {@inheritDoc}
*/
@Override
public boolean getHunger() {
return this.props.getHunger();
}
/**
* {@inheritDoc}
*/
@Override
public void setHunger(boolean hunger) {
this.props.setHunger(hunger);
}
/**
* {@inheritDoc}
*/
@Override
public Location getSpawnLocation() {
return this.props.getSpawnLocation();
}
/**
* {@inheritDoc}
*/
@Override
public void setSpawnLocation(Location l) {
this.props.setSpawnLocation(l);
}
/**
* {@inheritDoc}
*/
@Override
public Difficulty getDifficulty() {
return this.props.getDifficulty();
}
/**
* {@inheritDoc}
*
* @deprecated This is deprecated.
*/
@Override
@Deprecated
public boolean setDifficulty(String difficulty) {
return this.props.setDifficulty(difficulty);
}
@Override
public boolean setDifficulty(Difficulty difficulty) {
return this.props.setDifficulty(difficulty);
}
/**
* {@inheritDoc}
*/
@Override
public boolean getAutoHeal() {
return this.props.getAutoHeal();
}
/**
* {@inheritDoc}
*/
@Override
public void setAutoHeal(boolean heal) {
this.props.setAutoHeal(heal);
}
/**
* {@inheritDoc}
*/
@Override
public void setAdjustSpawn(boolean adjust) {
this.props.setAdjustSpawn(adjust);
}
/**
* {@inheritDoc}
*/
@Override
public boolean getAdjustSpawn() {
return this.props.getAdjustSpawn();
}
/**
* {@inheritDoc}
*/
@Override
public void setAutoLoad(boolean load) {
this.props.setAutoLoad(load);
}
/**
* {@inheritDoc}
*/
@Override
public boolean getAutoLoad() {
return this.props.getAutoLoad();
}
/**
* {@inheritDoc}
*/
@Override
public void setBedRespawn(boolean respawn) {
this.props.setBedRespawn(respawn);
}
/**
* {@inheritDoc}
*/
@Override
public boolean getBedRespawn() {
return this.props.getBedRespawn();
}
/**
* {@inheritDoc}
*/
@Override
public String getAllPropertyNames() {
return this.props.getAllPropertyNames();
}
/**
* {@inheritDoc}
*/
@Override
public String getTime() {
return this.props.getTime();
}
/**
* {@inheritDoc}
*/
@Override
public boolean setTime(String timeAsString) {
return this.props.setTime(timeAsString);
}
/**
* {@inheritDoc}
*/
@Override
public AllowedPortalType getAllowedPortals() {
return props.getAllowedPortals();
}
/**
* {@inheritDoc}
*/
@Override
public void allowPortalMaking(AllowedPortalType portalType) {
this.props.allowPortalMaking(portalType);
}
/**
* {@inheritDoc}
*/
@Override
public ChatColor getStyle() {
return this.props.getStyle().getColor();
}
/**
* {@inheritDoc}
*/
@Override
public boolean setStyle(String style) {
return this.props.setStyle(style);
}
/**
* {@inheritDoc}
*/
@Override
public boolean getAllowFlight() {
return this.props.getAllowFlight();
}
/**
* {@inheritDoc}
*/
@Override
public void setAllowFlight(final boolean allowFlight) {
this.props.setAllowFlight(allowFlight);
}
@Override
public String toString() {
final JSONObject jsonData = new JSONObject();
jsonData.put("Name", getName());
jsonData.put("Env", getEnvironment().toString());
jsonData.put("Type", getWorldType().toString());
jsonData.put("Gen", getGenerator());
final JSONObject topLevel = new JSONObject();
topLevel.put(getClass().getSimpleName() + "@" + hashCode(), jsonData);
return topLevel.toString();
}
}