mirror of
https://github.com/IntellectualSites/PlotSquared.git
synced 2024-11-29 08:36:45 +01:00
563 lines
16 KiB
Java
563 lines
16 KiB
Java
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// PlotSquared - A plot manager and world generator for the Bukkit API /
|
|
// Copyright (c) 2014 IntellectualSites/IntellectualCrafters /
|
|
// /
|
|
// This program is free software; you can redistribute it and/or modify /
|
|
// it under the terms of the GNU General Public License as published by /
|
|
// the Free Software Foundation; either version 3 of the License, or /
|
|
// (at your option) any later version. /
|
|
// /
|
|
// This program is distributed in the hope that it will be useful, /
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of /
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the /
|
|
// GNU General Public License for more details. /
|
|
// /
|
|
// You should have received a copy of the GNU General Public License /
|
|
// along with this program; if not, write to the Free Software Foundation, /
|
|
// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA /
|
|
// /
|
|
// You can contact us via: support@intellectualsites.com /
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
package com.intellectualcrafters.plot.object;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Collection;
|
|
import java.util.HashMap;
|
|
import java.util.HashSet;
|
|
import java.util.List;
|
|
import java.util.Map.Entry;
|
|
import java.util.UUID;
|
|
|
|
import sun.awt.SunHints.Value;
|
|
|
|
import com.intellectualcrafters.plot.PS;
|
|
import com.intellectualcrafters.plot.database.DBFunc;
|
|
import com.intellectualcrafters.plot.flag.Flag;
|
|
import com.intellectualcrafters.plot.flag.FlagManager;
|
|
import com.intellectualcrafters.plot.util.ChunkManager;
|
|
import com.intellectualcrafters.plot.util.MainUtil;
|
|
|
|
/**
|
|
* The plot class
|
|
*
|
|
* @author Citymonstret
|
|
* @author Empire92
|
|
*/
|
|
@SuppressWarnings("javadoc")
|
|
public class Plot implements Cloneable {
|
|
/**
|
|
* plot ID
|
|
*/
|
|
public final PlotId id;
|
|
/**
|
|
* plot world
|
|
*/
|
|
public final String world;
|
|
/**
|
|
* plot owner
|
|
*/
|
|
public UUID owner;
|
|
/**
|
|
* List of trusted (with plot permissions)
|
|
*/
|
|
public HashSet<UUID> trusted;
|
|
/**
|
|
* List of members users (with plot permissions)
|
|
*/
|
|
public HashSet<UUID> members;
|
|
/**
|
|
* List of denied players
|
|
*/
|
|
public HashSet<UUID> denied;
|
|
/**
|
|
* External settings class<br>
|
|
* - Please favor the methods over direct access to this class<br>
|
|
* - The methods are more likely to be left unchanged from version changes<br>
|
|
*/
|
|
public PlotSettings settings;
|
|
/**
|
|
* Has the plot changed since the last save cycle?
|
|
*/
|
|
public boolean hasChanged = false;
|
|
public boolean countsTowardsMax = true;
|
|
|
|
/**
|
|
* If this plot is temporary i.e. not stored in the DB
|
|
*/
|
|
public final boolean temp;
|
|
|
|
/**
|
|
* Constructor for a new plot
|
|
*
|
|
* @param world
|
|
* @param id
|
|
* @param owner
|
|
*/
|
|
public Plot(String world, PlotId id, UUID owner) {
|
|
this.world = world;
|
|
this.id = id;
|
|
this.owner = owner;
|
|
this.settings = new PlotSettings(this);
|
|
this.trusted = new HashSet<>();
|
|
this.members = new HashSet<>();
|
|
this.denied = new HashSet<>();
|
|
this.temp = false;
|
|
}
|
|
|
|
/**
|
|
* Constructor for a temporary plot
|
|
*
|
|
* @param world
|
|
* @param id
|
|
* @param owner
|
|
* @param temp
|
|
*/
|
|
public Plot(String world, PlotId id, UUID owner, boolean temp) {
|
|
this.world = world;
|
|
this.id = id;
|
|
this.owner = owner;
|
|
this.settings = new PlotSettings(this);
|
|
this.trusted = new HashSet<>();
|
|
this.members = new HashSet<>();
|
|
this.denied = new HashSet<>();
|
|
this.temp = temp;
|
|
}
|
|
|
|
/**
|
|
* Constructor for a saved plots
|
|
*
|
|
* @param id
|
|
* @param owner
|
|
* @param trusted
|
|
* @param denied
|
|
* @param merged
|
|
*/
|
|
public Plot(final PlotId id, final UUID owner, final HashSet<UUID> trusted, final HashSet<UUID> members, final HashSet<UUID> denied, final String alias, final BlockLoc position, final Collection<Flag> flags, final String world, final boolean[] merged) {
|
|
this.id = id;
|
|
this.settings = new PlotSettings(this);
|
|
this.owner = owner;
|
|
this.members = members;
|
|
this.trusted = trusted;
|
|
this.denied = denied;
|
|
this.settings.setAlias(alias);
|
|
this.settings.setPosition(position);
|
|
this.settings.setMerged(merged);
|
|
if (flags != null) {
|
|
for (Flag flag : flags) {
|
|
this.settings.flags.put(flag.getKey(), flag);
|
|
}
|
|
}
|
|
this.world = world;
|
|
this.temp = false;
|
|
}
|
|
|
|
/**
|
|
* Check if the plot has a set owner
|
|
*
|
|
* @return false if there is no owner
|
|
*/
|
|
public boolean hasOwner() {
|
|
return this.owner != null;
|
|
}
|
|
|
|
public boolean isOwner(UUID uuid) {
|
|
return PlotHandler.isOwner(this, uuid);
|
|
}
|
|
|
|
/**
|
|
* Get a list of owner UUIDs for a plot (supports multi-owner mega-plots)
|
|
* @return
|
|
*/
|
|
public HashSet<UUID> getOwners() {
|
|
return PlotHandler.getOwners(this);
|
|
}
|
|
|
|
/**
|
|
* Check if the player is either the owner or on the trusted list
|
|
*
|
|
* @param uuid
|
|
*
|
|
* @return true if the player is added as a helper or is the owner
|
|
*/
|
|
public boolean isAdded(final UUID uuid) {
|
|
return PlotHandler.isAdded(this, uuid);
|
|
}
|
|
|
|
/**
|
|
* Should the player be allowed to enter?
|
|
*
|
|
* @param uuid
|
|
*
|
|
* @return boolean false if the player is allowed to enter
|
|
*/
|
|
public boolean isDenied(final UUID uuid) {
|
|
return (this.denied != null) && ((this.denied.contains(DBFunc.everyone) && !this.isAdded(uuid)) || (!this.isAdded(uuid) && this.denied.contains(uuid)));
|
|
}
|
|
|
|
/**
|
|
* Get the plot ID
|
|
*/
|
|
public PlotId getId() {
|
|
return this.id;
|
|
}
|
|
|
|
/**
|
|
* Get a clone of the plot
|
|
*
|
|
* @return Plot
|
|
*/
|
|
@Override
|
|
public Object clone() throws CloneNotSupportedException {
|
|
final Plot p = (Plot) super.clone();
|
|
if (!p.equals(this) || (p != this)) {
|
|
return new Plot(this.id, this.owner, this.trusted, this.members, this.denied, this.settings.getAlias(), this.settings.getPosition(), this.settings.flags.values(), this.world, this.settings.getMerged());
|
|
}
|
|
return p;
|
|
}
|
|
|
|
/**
|
|
* Deny someone (use DBFunc.addDenied() as well)
|
|
*
|
|
* @param uuid
|
|
*/
|
|
public void addDenied(final UUID uuid) {
|
|
if (this.denied.add(uuid)) DBFunc.setDenied(this, uuid);
|
|
}
|
|
|
|
/**
|
|
* Add someone as a helper (use DBFunc as well)
|
|
*
|
|
* @param uuid
|
|
*/
|
|
public void addTrusted(final UUID uuid) {
|
|
if (this.trusted.add(uuid)) DBFunc.setTrusted(this, uuid);
|
|
}
|
|
|
|
/**
|
|
* Add someone as a trusted user (use DBFunc as well)
|
|
*
|
|
* @param uuid
|
|
*/
|
|
public void addMember(final UUID uuid) {
|
|
if (this.members.add(uuid)) DBFunc.setMember(this, uuid);
|
|
}
|
|
|
|
/**
|
|
* Set the plot owner
|
|
* @param owner
|
|
*/
|
|
public void setOwner(final UUID owner) {
|
|
if (!this.owner.equals(owner)) {
|
|
this.owner = owner;
|
|
DBFunc.setOwner(this, owner);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Clear a plot
|
|
* @see MainUtil#clear(Plot, boolean, Runnable)
|
|
* @see MainUtil#clearAsPlayer(Plot, boolean, Runnable)
|
|
* @see #delete() to clear and delete a plot
|
|
* @param whenDone A runnable to execute when clearing finishes, or null
|
|
*/
|
|
public void clear(Runnable whenDone) {
|
|
MainUtil.clear(this, false, whenDone);
|
|
}
|
|
|
|
/**
|
|
* This will return null if the plot hasn't been analyzed
|
|
* @return analysis of plot
|
|
*/
|
|
public PlotAnalysis getComplexity() {
|
|
return PlotAnalysis.getAnalysis(this);
|
|
}
|
|
|
|
public void analyze(RunnableVal<PlotAnalysis> whenDone) {
|
|
PlotAnalysis.analyzePlot(this, whenDone);
|
|
}
|
|
|
|
/**
|
|
* Delete a plot
|
|
* @see PS#removePlot(String, PlotId, boolean)
|
|
* @see #clear(Runnable) to simply clear a plot
|
|
*/
|
|
public void delete() {
|
|
MainUtil.removeSign(this);
|
|
MainUtil.clear(this, true, new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
if (PS.get().removePlot(world, id, true)) {
|
|
DBFunc.delete(Plot.this);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
public void unclaim() {
|
|
if (PS.get().removePlot(world, id, true)) {
|
|
DBFunc.delete(Plot.this);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Unlink a plot and remove the roads
|
|
* @see MainUtil#unlinkPlot(Plot)
|
|
* @return true if plot was linked
|
|
*/
|
|
public boolean unlink() {
|
|
return MainUtil.unlinkPlot(this);
|
|
}
|
|
|
|
/**
|
|
* Return the home location for the plot
|
|
* @see MainUtil#getPlotHome(Plot)
|
|
* @return Home location
|
|
*/
|
|
public Location getHome() {
|
|
return MainUtil.getPlotHome(this);
|
|
}
|
|
|
|
/**
|
|
* Get the ratings associated with a plot<br>
|
|
* - The rating object may contain multiple categories
|
|
* @return Map of user who rated to the rating
|
|
*/
|
|
public HashMap<UUID, Rating> getRatings() {
|
|
HashMap<UUID, Rating> map = new HashMap<UUID, Rating>();
|
|
for (Entry<UUID, Integer> entry : settings.ratings.entrySet()) {
|
|
map.put(entry.getKey(), new Rating(entry.getValue()));
|
|
}
|
|
return map;
|
|
}
|
|
|
|
/**
|
|
* Set the home location
|
|
* @param loc
|
|
*/
|
|
public void setHome(BlockLoc loc) {
|
|
BlockLoc pos = this.settings.getPosition();
|
|
if ((pos == null && loc == null) || (pos != null && pos.equals(loc))) {
|
|
return;
|
|
}
|
|
this.settings.setPosition(loc);
|
|
if (this.settings.getPosition() == null) {
|
|
DBFunc.setPosition(this, "");
|
|
}
|
|
else {
|
|
DBFunc.setPosition(this, this.settings.getPosition().toString());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set the plot alias
|
|
* @param alias
|
|
*/
|
|
public void setAlias(String alias) {
|
|
String name = this.settings.getAlias();
|
|
if (alias == null) {
|
|
alias = "";
|
|
}
|
|
if (name.equals(alias)) {
|
|
return;
|
|
}
|
|
this.settings.setAlias(alias);
|
|
DBFunc.setAlias(this, alias);
|
|
}
|
|
|
|
/**
|
|
* Resend all chunks inside the plot to nearby players<br>
|
|
* This should not need to be called
|
|
* @see MainUtil#update(Plot)
|
|
*/
|
|
public void refreshChunks() {
|
|
MainUtil.update(this);
|
|
}
|
|
|
|
/**
|
|
* Remove the plot sign if it is set
|
|
*/
|
|
public void removeSign() {
|
|
MainUtil.removeSign(this);
|
|
}
|
|
|
|
/**
|
|
* Set the plot sign if plot signs are enabled
|
|
*/
|
|
public void setSign() {
|
|
MainUtil.setSign(this);
|
|
}
|
|
|
|
/**
|
|
* Register a plot and create it in the database<br>
|
|
* - The plot will not be created if the owner is null<br>
|
|
* - This will not save any trusted etc in the DB, those should be set after plot creation
|
|
* @return true if plot was created successfully
|
|
*/
|
|
public boolean create() {
|
|
return MainUtil.createPlot(owner, this);
|
|
}
|
|
|
|
/**
|
|
* Auto merge the plot with any adjacent plots of the same owner
|
|
* @see MainUtil#autoMerge(Plot, UUID) to specify the owner
|
|
*/
|
|
public void autoMerge() {
|
|
MainUtil.autoMerge(this, owner);
|
|
}
|
|
|
|
/**
|
|
* Set the plot biome
|
|
*/
|
|
public void setBiome(String biome) {
|
|
MainUtil.setBiome(this, biome);
|
|
}
|
|
|
|
/**
|
|
* Return the top location for the plot
|
|
* @return
|
|
*/
|
|
public Location getTop() {
|
|
return MainUtil.getPlotTopLoc(world, id);
|
|
}
|
|
|
|
/**
|
|
* Return the bottom location for the plot
|
|
* @return
|
|
*/
|
|
public Location getBottom() {
|
|
return MainUtil.getPlotBottomLoc(world, id);
|
|
}
|
|
|
|
/**
|
|
* Get the top plot, or this plot if it is not part of a mega plot
|
|
* @return The bottom plot
|
|
*/
|
|
public Plot getTopPlot() {
|
|
return MainUtil.getTopPlot(this);
|
|
}
|
|
|
|
/**
|
|
* Get the bottom plot, or this plot if it is not part of a mega plot
|
|
* @return The bottom plot
|
|
*/
|
|
public Plot getBottomPlot() {
|
|
return MainUtil.getBottomPlot(this);
|
|
}
|
|
|
|
/**
|
|
* Swap the plot contents and settings with another location<br>
|
|
* - The destination must correspond to a valid plot of equal dimensions
|
|
* @see ChunkManager#swap(String, bot1, top1, bot2, top2) to swap terrain
|
|
* @see MainUtil#getPlotSelectionIds(PlotId, PlotId) to get the plots inside a selection
|
|
* @see MainUtil#swapData(String, PlotId, PlotId, Runnable) to swap plot settings
|
|
* @param other The other plot id to swap with
|
|
* @param whenDone A task to run when finished, or null
|
|
* @see MainUtil#swapData(String, PlotId, PlotId, Runnable)
|
|
* @return boolean if swap was successful
|
|
*/
|
|
public boolean swap(PlotId destination, Runnable whenDone) {
|
|
return MainUtil.swap(world, id, destination, whenDone);
|
|
}
|
|
|
|
/**
|
|
* Move the plot to an empty location<br>
|
|
* - The location must be empty
|
|
* @param destination Where to move the plot
|
|
* @param whenDone A task to run when done, or null
|
|
* @return if the move was successful
|
|
*/
|
|
public boolean move(Plot destination, Runnable whenDone) {
|
|
return MainUtil.move(this, destination, whenDone);
|
|
}
|
|
|
|
/**
|
|
* Copy the plot contents and settings to another location<br>
|
|
* - The destination must correspond to an empty location
|
|
* @param destination The location to copy to
|
|
* @param whenDone The task to run when done
|
|
* @return If the copy was successful
|
|
*/
|
|
public boolean copy(PlotId destination, Runnable whenDone) {
|
|
return MainUtil.copy(world, id, destination, whenDone);
|
|
}
|
|
|
|
/**
|
|
* Get plot display name
|
|
*
|
|
* @return alias if set, else id
|
|
*/
|
|
@Override
|
|
public String toString() {
|
|
if (this.settings.getAlias().length() > 1) {
|
|
return this.settings.getAlias();
|
|
}
|
|
return this.world + ";" + this.getId().x + ";" + this.getId().y;
|
|
}
|
|
|
|
/**
|
|
* Remove a denied player (use DBFunc as well)
|
|
*
|
|
* @param uuid
|
|
*/
|
|
public boolean removeDenied(final UUID uuid) {
|
|
if (this.denied.remove(uuid)) {
|
|
DBFunc.removeDenied(this, uuid);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Remove a helper (use DBFunc as well)
|
|
*
|
|
* @param uuid
|
|
*/
|
|
public boolean removeTrusted(final UUID uuid) {
|
|
if (this.trusted.remove(uuid)) {
|
|
DBFunc.removeTrusted(this, uuid);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Remove a trusted user (use DBFunc as well)
|
|
*
|
|
* @param uuid
|
|
*/
|
|
public boolean removeMember(final UUID uuid) {
|
|
if (this.members.remove(uuid)) {
|
|
DBFunc.removeMember(this, uuid);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public boolean equals(final Object obj) {
|
|
if (this == obj) {
|
|
return true;
|
|
}
|
|
if (obj == null) {
|
|
return false;
|
|
}
|
|
if (getClass() != obj.getClass()) {
|
|
return false;
|
|
}
|
|
final Plot other = (Plot) obj;
|
|
return ((this.id.x.equals(other.id.x)) && (this.id.y.equals(other.id.y)) && (this.world.equals(other.world)));
|
|
}
|
|
|
|
|
|
/**
|
|
* Get the plot hashcode
|
|
*
|
|
* @return integer. You can easily make this a character array <br> xI = c[0] x = c[1 -> xI...] yI = c[xI ... + 1] y
|
|
* = c[xI ... + 2 -> yI ...]
|
|
*/
|
|
@Override
|
|
public int hashCode() {
|
|
return this.id.hashCode();
|
|
}
|
|
}
|