mirror of
https://github.com/IntellectualSites/PlotSquared.git
synced 2025-06-25 02:04:44 +02:00
OCD
This commit is contained in:
@ -46,7 +46,7 @@ public class JSONArray {
|
||||
* Construct an empty JSONArray.
|
||||
*/
|
||||
public JSONArray() {
|
||||
myArrayList = new ArrayList<Object>();
|
||||
this.myArrayList = new ArrayList<Object>();
|
||||
}
|
||||
|
||||
/**
|
||||
@ -56,7 +56,7 @@ public class JSONArray {
|
||||
*
|
||||
* @throws JSONException If there is a syntax error.
|
||||
*/
|
||||
public JSONArray(final JSONTokener x) throws JSONException {
|
||||
public JSONArray(JSONTokener x) throws JSONException {
|
||||
this();
|
||||
if (x.nextClean() != '[') {
|
||||
throw x.syntaxError("A JSONArray text must start with '['");
|
||||
@ -66,10 +66,10 @@ public class JSONArray {
|
||||
for (;;) {
|
||||
if (x.nextClean() == ',') {
|
||||
x.back();
|
||||
myArrayList.add(JSONObject.NULL);
|
||||
this.myArrayList.add(JSONObject.NULL);
|
||||
} else {
|
||||
x.back();
|
||||
myArrayList.add(x.nextValue());
|
||||
this.myArrayList.add(x.nextValue());
|
||||
}
|
||||
switch (x.nextClean()) {
|
||||
case ',':
|
||||
@ -95,7 +95,7 @@ public class JSONArray {
|
||||
*
|
||||
* @throws JSONException If there is a syntax error.
|
||||
*/
|
||||
public JSONArray(final String source) throws JSONException {
|
||||
public JSONArray(String source) throws JSONException {
|
||||
this(new JSONTokener(source));
|
||||
}
|
||||
|
||||
@ -104,11 +104,11 @@ public class JSONArray {
|
||||
*
|
||||
* @param collection A Collection.
|
||||
*/
|
||||
public JSONArray(final Collection<Object> collection) {
|
||||
myArrayList = new ArrayList<Object>();
|
||||
public JSONArray(Collection<Object> collection) {
|
||||
this.myArrayList = new ArrayList<Object>();
|
||||
if (collection != null) {
|
||||
for (final Object aCollection : collection) {
|
||||
myArrayList.add(JSONObject.wrap(aCollection));
|
||||
for (Object aCollection : collection) {
|
||||
this.myArrayList.add(JSONObject.wrap(aCollection));
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -118,10 +118,10 @@ public class JSONArray {
|
||||
*
|
||||
* @throws JSONException If not an array.
|
||||
*/
|
||||
public JSONArray(final Object array) throws JSONException {
|
||||
public JSONArray(Object array) throws JSONException {
|
||||
this();
|
||||
if (array.getClass().isArray()) {
|
||||
final int length = Array.getLength(array);
|
||||
int length = Array.getLength(array);
|
||||
for (int i = 0; i < length; i += 1) {
|
||||
this.put(JSONObject.wrap(Array.get(array, i)));
|
||||
}
|
||||
@ -139,8 +139,8 @@ public class JSONArray {
|
||||
*
|
||||
* @throws JSONException If there is no value for the index.
|
||||
*/
|
||||
public Object get(final int index) throws JSONException {
|
||||
final Object object = opt(index);
|
||||
public Object get(int index) throws JSONException {
|
||||
Object object = opt(index);
|
||||
if (object == null) {
|
||||
throw new JSONException("JSONArray[" + index + "] not found.");
|
||||
}
|
||||
@ -156,8 +156,8 @@ public class JSONArray {
|
||||
*
|
||||
* @throws JSONException If there is no value for the index or if the value is not convertible to boolean.
|
||||
*/
|
||||
public boolean getBoolean(final int index) throws JSONException {
|
||||
final Object object = get(index);
|
||||
public boolean getBoolean(int index) throws JSONException {
|
||||
Object object = get(index);
|
||||
if (object.equals(Boolean.FALSE) || ((object instanceof String) && ((String) object).equalsIgnoreCase("false"))) {
|
||||
return false;
|
||||
} else if (object.equals(Boolean.TRUE) || ((object instanceof String) && ((String) object).equalsIgnoreCase("true"))) {
|
||||
@ -175,8 +175,8 @@ public class JSONArray {
|
||||
*
|
||||
* @throws JSONException If the key is not found or if the value cannot be converted to a number.
|
||||
*/
|
||||
public double getDouble(final int index) throws JSONException {
|
||||
final Object object = get(index);
|
||||
public double getDouble(int index) throws JSONException {
|
||||
Object object = get(index);
|
||||
try {
|
||||
return object instanceof Number ? ((Number) object).doubleValue() : Double.parseDouble((String) object);
|
||||
} catch (NumberFormatException e) {
|
||||
@ -193,8 +193,8 @@ public class JSONArray {
|
||||
*
|
||||
* @throws JSONException If the key is not found or if the value is not a number.
|
||||
*/
|
||||
public int getInt(final int index) throws JSONException {
|
||||
final Object object = get(index);
|
||||
public int getInt(int index) throws JSONException {
|
||||
Object object = get(index);
|
||||
try {
|
||||
return object instanceof Number ? ((Number) object).intValue() : Integer.parseInt((String) object);
|
||||
} catch (NumberFormatException e) {
|
||||
@ -211,8 +211,8 @@ public class JSONArray {
|
||||
*
|
||||
* @throws JSONException If there is no value for the index. or if the value is not a JSONArray
|
||||
*/
|
||||
public JSONArray getJSONArray(final int index) throws JSONException {
|
||||
final Object object = get(index);
|
||||
public JSONArray getJSONArray(int index) throws JSONException {
|
||||
Object object = get(index);
|
||||
if (object instanceof JSONArray) {
|
||||
return (JSONArray) object;
|
||||
}
|
||||
@ -228,8 +228,8 @@ public class JSONArray {
|
||||
*
|
||||
* @throws JSONException If there is no value for the index or if the value is not a JSONObject
|
||||
*/
|
||||
public JSONObject getJSONObject(final int index) throws JSONException {
|
||||
final Object object = get(index);
|
||||
public JSONObject getJSONObject(int index) throws JSONException {
|
||||
Object object = get(index);
|
||||
if (object instanceof JSONObject) {
|
||||
return (JSONObject) object;
|
||||
}
|
||||
@ -245,8 +245,8 @@ public class JSONArray {
|
||||
*
|
||||
* @throws JSONException If the key is not found or if the value cannot be converted to a number.
|
||||
*/
|
||||
public long getLong(final int index) throws JSONException {
|
||||
final Object object = get(index);
|
||||
public long getLong(int index) throws JSONException {
|
||||
Object object = get(index);
|
||||
try {
|
||||
return object instanceof Number ? ((Number) object).longValue() : Long.parseLong((String) object);
|
||||
} catch (NumberFormatException e) {
|
||||
@ -263,8 +263,8 @@ public class JSONArray {
|
||||
*
|
||||
* @throws JSONException If there is no string value for the index.
|
||||
*/
|
||||
public String getString(final int index) throws JSONException {
|
||||
final Object object = get(index);
|
||||
public String getString(int index) throws JSONException {
|
||||
Object object = get(index);
|
||||
if (object instanceof String) {
|
||||
return (String) object;
|
||||
}
|
||||
@ -278,7 +278,7 @@ public class JSONArray {
|
||||
*
|
||||
* @return true if the value at the index is null, or if there is no value.
|
||||
*/
|
||||
public boolean isNull(final int index) {
|
||||
public boolean isNull(int index) {
|
||||
return JSONObject.NULL.equals(opt(index));
|
||||
}
|
||||
|
||||
@ -292,14 +292,14 @@ public class JSONArray {
|
||||
*
|
||||
* @throws JSONException If the array contains an invalid number.
|
||||
*/
|
||||
public String join(final String separator) throws JSONException {
|
||||
final int len = length();
|
||||
final StringBuilder sb = new StringBuilder();
|
||||
public String join(String separator) throws JSONException {
|
||||
int len = length();
|
||||
StringBuilder sb = new StringBuilder();
|
||||
for (int i = 0; i < len; i += 1) {
|
||||
if (i > 0) {
|
||||
sb.append(separator);
|
||||
}
|
||||
sb.append(JSONObject.valueToString(myArrayList.get(i)));
|
||||
sb.append(JSONObject.valueToString(this.myArrayList.get(i)));
|
||||
}
|
||||
return sb.toString();
|
||||
}
|
||||
@ -310,7 +310,7 @@ public class JSONArray {
|
||||
* @return The length (or size).
|
||||
*/
|
||||
public int length() {
|
||||
return myArrayList.size();
|
||||
return this.myArrayList.size();
|
||||
}
|
||||
|
||||
/**
|
||||
@ -320,8 +320,8 @@ public class JSONArray {
|
||||
*
|
||||
* @return An object value, or null if there is no object at that index.
|
||||
*/
|
||||
public Object opt(final int index) {
|
||||
return ((index < 0) || (index >= length())) ? null : myArrayList.get(index);
|
||||
public Object opt(int index) {
|
||||
return ((index < 0) || (index >= length())) ? null : this.myArrayList.get(index);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -332,7 +332,7 @@ public class JSONArray {
|
||||
*
|
||||
* @return The truth.
|
||||
*/
|
||||
public boolean optBoolean(final int index) {
|
||||
public boolean optBoolean(int index) {
|
||||
return this.optBoolean(index, false);
|
||||
}
|
||||
|
||||
@ -345,7 +345,7 @@ public class JSONArray {
|
||||
*
|
||||
* @return The truth.
|
||||
*/
|
||||
public boolean optBoolean(final int index, final boolean defaultValue) {
|
||||
public boolean optBoolean(int index, boolean defaultValue) {
|
||||
try {
|
||||
return getBoolean(index);
|
||||
} catch (JSONException e) {
|
||||
@ -361,7 +361,7 @@ public class JSONArray {
|
||||
*
|
||||
* @return The value.
|
||||
*/
|
||||
public double optDouble(final int index) {
|
||||
public double optDouble(int index) {
|
||||
return this.optDouble(index, Double.NaN);
|
||||
}
|
||||
|
||||
@ -374,7 +374,7 @@ public class JSONArray {
|
||||
*
|
||||
* @return The value.
|
||||
*/
|
||||
public double optDouble(final int index, final double defaultValue) {
|
||||
public double optDouble(int index, double defaultValue) {
|
||||
try {
|
||||
return getDouble(index);
|
||||
} catch (JSONException e) {
|
||||
@ -390,7 +390,7 @@ public class JSONArray {
|
||||
*
|
||||
* @return The value.
|
||||
*/
|
||||
public int optInt(final int index) {
|
||||
public int optInt(int index) {
|
||||
return this.optInt(index, 0);
|
||||
}
|
||||
|
||||
@ -403,7 +403,7 @@ public class JSONArray {
|
||||
*
|
||||
* @return The value.
|
||||
*/
|
||||
public int optInt(final int index, final int defaultValue) {
|
||||
public int optInt(int index, int defaultValue) {
|
||||
try {
|
||||
return getInt(index);
|
||||
} catch (JSONException e) {
|
||||
@ -418,8 +418,8 @@ public class JSONArray {
|
||||
*
|
||||
* @return A JSONArray value, or null if the index has no value, or if the value is not a JSONArray.
|
||||
*/
|
||||
public JSONArray optJSONArray(final int index) {
|
||||
final Object o = opt(index);
|
||||
public JSONArray optJSONArray(int index) {
|
||||
Object o = opt(index);
|
||||
return o instanceof JSONArray ? (JSONArray) o : null;
|
||||
}
|
||||
|
||||
@ -431,8 +431,8 @@ public class JSONArray {
|
||||
*
|
||||
* @return A JSONObject value.
|
||||
*/
|
||||
public JSONObject optJSONObject(final int index) {
|
||||
final Object o = opt(index);
|
||||
public JSONObject optJSONObject(int index) {
|
||||
Object o = opt(index);
|
||||
return o instanceof JSONObject ? (JSONObject) o : null;
|
||||
}
|
||||
|
||||
@ -444,7 +444,7 @@ public class JSONArray {
|
||||
*
|
||||
* @return The value.
|
||||
*/
|
||||
public long optLong(final int index) {
|
||||
public long optLong(int index) {
|
||||
return this.optLong(index, 0);
|
||||
}
|
||||
|
||||
@ -457,7 +457,7 @@ public class JSONArray {
|
||||
*
|
||||
* @return The value.
|
||||
*/
|
||||
public long optLong(final int index, final long defaultValue) {
|
||||
public long optLong(int index, long defaultValue) {
|
||||
try {
|
||||
return getLong(index);
|
||||
} catch (JSONException e) {
|
||||
@ -467,13 +467,13 @@ public class JSONArray {
|
||||
|
||||
/**
|
||||
* Get the optional string value associated with an index. It returns an empty string if there is no value at that
|
||||
* index. If the value is not a string and is not null, then it is coverted to a string.
|
||||
* index. If the value is not a string and is not null, then it is converted to a string.
|
||||
*
|
||||
* @param index The index must be between 0 and length() - 1.
|
||||
*
|
||||
* @return A String value.
|
||||
*/
|
||||
public String optString(final int index) {
|
||||
public String optString(int index) {
|
||||
return this.optString(index, "");
|
||||
}
|
||||
|
||||
@ -485,8 +485,8 @@ public class JSONArray {
|
||||
*
|
||||
* @return A String value.
|
||||
*/
|
||||
public String optString(final int index, final String defaultValue) {
|
||||
final Object object = opt(index);
|
||||
public String optString(int index, String defaultValue) {
|
||||
Object object = opt(index);
|
||||
return JSONObject.NULL.equals(object) ? defaultValue : object.toString();
|
||||
}
|
||||
|
||||
@ -497,7 +497,7 @@ public class JSONArray {
|
||||
*
|
||||
* @return this.
|
||||
*/
|
||||
public JSONArray put(final boolean value) {
|
||||
public JSONArray put(boolean value) {
|
||||
this.put(value ? Boolean.TRUE : Boolean.FALSE);
|
||||
return this;
|
||||
}
|
||||
@ -509,7 +509,7 @@ public class JSONArray {
|
||||
*
|
||||
* @return this.
|
||||
*/
|
||||
public JSONArray put(final Collection<Object> value) {
|
||||
public JSONArray put(Collection<Object> value) {
|
||||
this.put(new JSONArray(value));
|
||||
return this;
|
||||
}
|
||||
@ -523,8 +523,8 @@ public class JSONArray {
|
||||
*
|
||||
* @throws JSONException if the value is not finite.
|
||||
*/
|
||||
public JSONArray put(final double value) throws JSONException {
|
||||
final Double d = value;
|
||||
public JSONArray put(double value) throws JSONException {
|
||||
Double d = value;
|
||||
JSONObject.testValidity(d);
|
||||
this.put(d);
|
||||
return this;
|
||||
@ -537,7 +537,7 @@ public class JSONArray {
|
||||
*
|
||||
* @return this.
|
||||
*/
|
||||
public JSONArray put(final int value) {
|
||||
public JSONArray put(int value) {
|
||||
this.put(Integer.valueOf(value));
|
||||
return this;
|
||||
}
|
||||
@ -549,7 +549,7 @@ public class JSONArray {
|
||||
*
|
||||
* @return this.
|
||||
*/
|
||||
public JSONArray put(final long value) {
|
||||
public JSONArray put(long value) {
|
||||
this.put(Long.valueOf(value));
|
||||
return this;
|
||||
}
|
||||
@ -561,7 +561,7 @@ public class JSONArray {
|
||||
*
|
||||
* @return this.
|
||||
*/
|
||||
public JSONArray put(final Map<String, Object> value) {
|
||||
public JSONArray put(Map<String, Object> value) {
|
||||
this.put(new JSONObject(value));
|
||||
return this;
|
||||
}
|
||||
@ -574,8 +574,8 @@ public class JSONArray {
|
||||
*
|
||||
* @return this.
|
||||
*/
|
||||
public JSONArray put(final Object value) {
|
||||
myArrayList.add(value);
|
||||
public JSONArray put(Object value) {
|
||||
this.myArrayList.add(value);
|
||||
return this;
|
||||
}
|
||||
|
||||
@ -590,7 +590,7 @@ public class JSONArray {
|
||||
*
|
||||
* @throws JSONException If the index is negative.
|
||||
*/
|
||||
public JSONArray put(final int index, final boolean value) throws JSONException {
|
||||
public JSONArray put(int index, boolean value) throws JSONException {
|
||||
this.put(index, value ? Boolean.TRUE : Boolean.FALSE);
|
||||
return this;
|
||||
}
|
||||
@ -605,7 +605,7 @@ public class JSONArray {
|
||||
*
|
||||
* @throws JSONException If the index is negative or if the value is not finite.
|
||||
*/
|
||||
public JSONArray put(final int index, final Collection<Object> value) throws JSONException {
|
||||
public JSONArray put(int index, Collection<Object> value) throws JSONException {
|
||||
this.put(index, new JSONArray(value));
|
||||
return this;
|
||||
}
|
||||
@ -621,7 +621,7 @@ public class JSONArray {
|
||||
*
|
||||
* @throws JSONException If the index is negative or if the value is not finite.
|
||||
*/
|
||||
public JSONArray put(final int index, final double value) throws JSONException {
|
||||
public JSONArray put(int index, double value) throws JSONException {
|
||||
this.put(index, new Double(value));
|
||||
return this;
|
||||
}
|
||||
@ -637,7 +637,7 @@ public class JSONArray {
|
||||
*
|
||||
* @throws JSONException If the index is negative.
|
||||
*/
|
||||
public JSONArray put(final int index, final int value) throws JSONException {
|
||||
public JSONArray put(int index, int value) throws JSONException {
|
||||
this.put(index, Integer.valueOf(value));
|
||||
return this;
|
||||
}
|
||||
@ -653,7 +653,7 @@ public class JSONArray {
|
||||
*
|
||||
* @throws JSONException If the index is negative.
|
||||
*/
|
||||
public JSONArray put(final int index, final long value) throws JSONException {
|
||||
public JSONArray put(int index, long value) throws JSONException {
|
||||
this.put(index, Long.valueOf(value));
|
||||
return this;
|
||||
}
|
||||
@ -668,7 +668,7 @@ public class JSONArray {
|
||||
*
|
||||
* @throws JSONException If the index is negative or if the the value is an invalid number.
|
||||
*/
|
||||
public JSONArray put(final int index, final Map<String, Object> value) throws JSONException {
|
||||
public JSONArray put(int index, Map<String, Object> value) throws JSONException {
|
||||
this.put(index, new JSONObject(value));
|
||||
return this;
|
||||
}
|
||||
@ -685,13 +685,13 @@ public class JSONArray {
|
||||
*
|
||||
* @throws JSONException If the index is negative or if the the value is an invalid number.
|
||||
*/
|
||||
public JSONArray put(final int index, final Object value) throws JSONException {
|
||||
public JSONArray put(int index, Object value) throws JSONException {
|
||||
JSONObject.testValidity(value);
|
||||
if (index < 0) {
|
||||
throw new JSONException("JSONArray[" + index + "] not found.");
|
||||
}
|
||||
if (index < length()) {
|
||||
myArrayList.set(index, value);
|
||||
this.myArrayList.set(index, value);
|
||||
} else {
|
||||
while (index != length()) {
|
||||
this.put(JSONObject.NULL);
|
||||
@ -708,8 +708,8 @@ public class JSONArray {
|
||||
*
|
||||
* @return The value that was associated with the index, or null if there was no value.
|
||||
*/
|
||||
public Object remove(final int index) {
|
||||
return (index >= 0) && (index < length()) ? myArrayList.remove(index) : null;
|
||||
public Object remove(int index) {
|
||||
return (index >= 0) && (index < length()) ? this.myArrayList.remove(index) : null;
|
||||
}
|
||||
|
||||
/**
|
||||
@ -719,17 +719,17 @@ public class JSONArray {
|
||||
*
|
||||
* @return true if they are equal
|
||||
*/
|
||||
public boolean similar(final Object other) {
|
||||
public boolean similar(Object other) {
|
||||
if (!(other instanceof JSONArray)) {
|
||||
return false;
|
||||
}
|
||||
final int len = length();
|
||||
int len = length();
|
||||
if (len != ((JSONArray) other).length()) {
|
||||
return false;
|
||||
}
|
||||
for (int i = 0; i < len; i += 1) {
|
||||
final Object valueThis = get(i);
|
||||
final Object valueOther = ((JSONArray) other).get(i);
|
||||
Object valueThis = get(i);
|
||||
Object valueOther = ((JSONArray) other).get(i);
|
||||
if (valueThis instanceof JSONObject) {
|
||||
if (!((JSONObject) valueThis).similar(valueOther)) {
|
||||
return false;
|
||||
@ -754,11 +754,11 @@ public class JSONArray {
|
||||
*
|
||||
* @throws JSONException If any of the names are null.
|
||||
*/
|
||||
public JSONObject toJSONObject(final JSONArray names) throws JSONException {
|
||||
public JSONObject toJSONObject(JSONArray names) throws JSONException {
|
||||
if ((names == null) || (names.length() == 0) || (length() == 0)) {
|
||||
return null;
|
||||
}
|
||||
final JSONObject jo = new JSONObject();
|
||||
JSONObject jo = new JSONObject();
|
||||
for (int i = 0; i < names.length(); i += 1) {
|
||||
jo.put(names.getString(i), opt(i));
|
||||
}
|
||||
@ -795,8 +795,8 @@ public class JSONArray {
|
||||
*
|
||||
* @throws JSONException
|
||||
*/
|
||||
public String toString(final int indentFactor) throws JSONException {
|
||||
final StringWriter sw = new StringWriter();
|
||||
public String toString(int indentFactor) throws JSONException {
|
||||
StringWriter sw = new StringWriter();
|
||||
synchronized (sw.getBuffer()) {
|
||||
return this.write(sw, indentFactor, 0).toString();
|
||||
}
|
||||
@ -811,7 +811,7 @@ public class JSONArray {
|
||||
*
|
||||
* @throws JSONException
|
||||
*/
|
||||
public Writer write(final Writer writer) throws JSONException {
|
||||
public Writer write(Writer writer) throws JSONException {
|
||||
return this.write(writer, 0, 0);
|
||||
}
|
||||
|
||||
@ -827,15 +827,15 @@ public class JSONArray {
|
||||
*
|
||||
* @throws JSONException
|
||||
*/
|
||||
Writer write(final Writer writer, final int indentFactor, final int indent) throws JSONException {
|
||||
Writer write(Writer writer, int indentFactor, int indent) throws JSONException {
|
||||
try {
|
||||
boolean commanate = false;
|
||||
final int length = length();
|
||||
int length = length();
|
||||
writer.write('[');
|
||||
if (length == 1) {
|
||||
JSONObject.writeValue(writer, myArrayList.get(0), indentFactor, indent);
|
||||
JSONObject.writeValue(writer, this.myArrayList.get(0), indentFactor, indent);
|
||||
} else if (length != 0) {
|
||||
final int newindent = indent + indentFactor;
|
||||
int newindent = indent + indentFactor;
|
||||
for (int i = 0; i < length; i += 1) {
|
||||
if (commanate) {
|
||||
writer.write(',');
|
||||
@ -844,7 +844,7 @@ public class JSONArray {
|
||||
writer.write('\n');
|
||||
}
|
||||
JSONObject.indent(writer, newindent);
|
||||
JSONObject.writeValue(writer, myArrayList.get(i), indentFactor, newindent);
|
||||
JSONObject.writeValue(writer, this.myArrayList.get(i), indentFactor, newindent);
|
||||
commanate = true;
|
||||
}
|
||||
if (indentFactor > 0) {
|
||||
@ -854,7 +854,7 @@ public class JSONArray {
|
||||
}
|
||||
writer.write(']');
|
||||
return writer;
|
||||
} catch (final IOException e) {
|
||||
} catch (IOException e) {
|
||||
throw new JSONException(e);
|
||||
}
|
||||
}
|
||||
|
@ -24,26 +24,26 @@ public interface IPlotMain {
|
||||
|
||||
/**
|
||||
* Log a message to console.
|
||||
* @param message
|
||||
* @param message The message to log
|
||||
*/
|
||||
void log(String message);
|
||||
|
||||
/**
|
||||
* Get the `PlotSquared` directory.
|
||||
* @return
|
||||
* @return The plugin directory
|
||||
*/
|
||||
File getDirectory();
|
||||
|
||||
/**
|
||||
* Get the directory containing all the worlds.
|
||||
* @return
|
||||
* @return The directory containing the worlds
|
||||
*/
|
||||
File getWorldContainer();
|
||||
|
||||
/**
|
||||
* Wrap a player into a PlotPlayer object.
|
||||
* @param player
|
||||
* @return
|
||||
* @param player The player to convert to a PlotPlayer
|
||||
* @return A PlotPlayer
|
||||
*/
|
||||
PlotPlayer wrapPlayer(Object player);
|
||||
|
||||
@ -69,20 +69,20 @@ public interface IPlotMain {
|
||||
int[] getServerVersion();
|
||||
|
||||
/**
|
||||
* Get the nms package prefix.
|
||||
* @return
|
||||
* Get the NMS package prefix.
|
||||
* @return The NMS package prefix
|
||||
*/
|
||||
String getNMSPackage();
|
||||
|
||||
/**
|
||||
* Get the schematic handler.
|
||||
* @return
|
||||
* @return The {@link SchematicHandler}
|
||||
*/
|
||||
SchematicHandler initSchematicHandler();
|
||||
|
||||
/**
|
||||
* Get the schematic handler.
|
||||
* @return
|
||||
* Get the Chat Manager.
|
||||
* @return The {@link ChatManager}
|
||||
*/
|
||||
ChatManager initChatManager();
|
||||
|
||||
@ -176,24 +176,27 @@ public interface IPlotMain {
|
||||
|
||||
/**
|
||||
* If a world is already loaded, set the generator (use NMS if required).
|
||||
* @param world
|
||||
* @param world The world to set the generator
|
||||
*/
|
||||
void setGenerator(String world);
|
||||
|
||||
/**
|
||||
* Get the {@link UUIDHandlerImplementation} which will cache and provide UUIDs.
|
||||
* Get the {@link UUIDHandlerImplementation} which will cache and
|
||||
* provide UUIDs.
|
||||
* @return
|
||||
*/
|
||||
UUIDHandlerImplementation initUUIDHandler();
|
||||
|
||||
/**
|
||||
* Get the {@link InventoryUtil} class (used for implementation specific inventory guis).
|
||||
* Get the {@link InventoryUtil} class (used for implementation specific
|
||||
* inventory guis).
|
||||
* @return
|
||||
*/
|
||||
InventoryUtil initInventoryUtil();
|
||||
|
||||
/**
|
||||
* Run the converter for the implementation (not necessarily PlotMe, just any plugin that we can convert from).
|
||||
* Run the converter for the implementation (not necessarily PlotMe, just
|
||||
* any plugin that we can convert from).
|
||||
* @return
|
||||
*/
|
||||
boolean initPlotMeConverter();
|
||||
@ -212,26 +215,23 @@ public interface IPlotMain {
|
||||
*/
|
||||
GeneratorWrapper<?> getGenerator(String world, String name);
|
||||
|
||||
/**
|
||||
*
|
||||
* @param generator
|
||||
* @return
|
||||
*/
|
||||
GeneratorWrapper<?> wrapPlotGenerator(IndependentPlotGenerator generator);
|
||||
|
||||
/**
|
||||
* Register the chunk processor which will clean out chunks that have too many blockstates or entities.
|
||||
* Register the chunk processor which will clean out chunks that have too
|
||||
* many blockstates or entities.
|
||||
*/
|
||||
void registerChunkProcessor();
|
||||
|
||||
/**
|
||||
* Register the world initialization events (used to keep track of worlds being generated).
|
||||
* Register the world initialization events (used to keep track of worlds
|
||||
* being generated).
|
||||
*/
|
||||
void registerWorldEvents();
|
||||
|
||||
/**
|
||||
* Get the name of the server.
|
||||
* @return
|
||||
* @return The server name
|
||||
*/
|
||||
String getServerName();
|
||||
|
||||
|
@ -53,6 +53,7 @@ import com.intellectualcrafters.plot.util.WorldUtil;
|
||||
import com.intellectualcrafters.plot.util.area.QuadMap;
|
||||
import com.plotsquared.listener.WESubscriber;
|
||||
import com.sk89q.worldedit.WorldEdit;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.FileInputStream;
|
||||
import java.io.FileOutputStream;
|
||||
@ -89,11 +90,11 @@ import java.util.zip.ZipInputStream;
|
||||
public class PS {
|
||||
|
||||
private static PS instance;
|
||||
private final HashSet<Integer> plotareaHashCheck = new HashSet<>();
|
||||
private final HashSet<Integer> plotAreaHashCheck = new HashSet<>();
|
||||
/**
|
||||
* All plot areas mapped by world (quick world access).
|
||||
*/
|
||||
private final HashMap<String, PlotArea[]> plotareamap = new HashMap<>();
|
||||
private final HashMap<String, PlotArea[]> plotAreaMap = new HashMap<>();
|
||||
/**
|
||||
* All plot areas mapped by location (quick location based access).
|
||||
*/
|
||||
@ -112,7 +113,7 @@ public class PS {
|
||||
public TaskManager TASK;
|
||||
public WorldEdit worldedit;
|
||||
public URL update;
|
||||
private boolean plotareaHasCollision = false;
|
||||
private boolean plotAreaHasCollision = false;
|
||||
/**
|
||||
* All plot areas (quick global access).
|
||||
*/
|
||||
@ -306,7 +307,7 @@ public class PS {
|
||||
PS.debug(
|
||||
"&8 - &7Are you trying to delete this world? Remember to remove it from the settings.yml, bukkit.yml and "
|
||||
+ "multiverse worlds.yml");
|
||||
PS.debug("&8 - &7Your world management plugin may be faulty (or non existant)");
|
||||
PS.debug("&8 - &7Your world management plugin may be faulty (or non existent)");
|
||||
PS.this.IMP.setGenerator(world);
|
||||
}
|
||||
}
|
||||
@ -441,14 +442,14 @@ public class PS {
|
||||
int hash = world.hashCode();
|
||||
for (PlotArea area : this.plotAreas) {
|
||||
if (hash == area.worldhash) {
|
||||
if (area.contains(location.getX(), location.getZ()) && (!this.plotareaHasCollision || world.equals(area.worldname))) {
|
||||
if (area.contains(location.getX(), location.getZ()) && (!this.plotAreaHasCollision || world.equals(area.worldname))) {
|
||||
return area;
|
||||
}
|
||||
}
|
||||
}
|
||||
return null;
|
||||
default:
|
||||
PlotArea[] areas = this.plotareamap.get(location.getWorld());
|
||||
PlotArea[] areas = this.plotAreaMap.get(location.getWorld());
|
||||
if (areas == null) {
|
||||
return null;
|
||||
}
|
||||
@ -480,7 +481,7 @@ public class PS {
|
||||
}
|
||||
|
||||
public PlotArea getPlotArea(String world, String id) {
|
||||
PlotArea[] areas = this.plotareamap.get(world);
|
||||
PlotArea[] areas = this.plotAreaMap.get(world);
|
||||
if (areas == null) {
|
||||
return null;
|
||||
}
|
||||
@ -499,7 +500,7 @@ public class PS {
|
||||
}
|
||||
|
||||
public PlotArea getPlotAreaAbs(String world, String id) {
|
||||
PlotArea[] areas = this.plotareamap.get(world);
|
||||
PlotArea[] areas = this.plotAreaMap.get(world);
|
||||
if (areas == null) {
|
||||
return null;
|
||||
}
|
||||
@ -513,7 +514,7 @@ public class PS {
|
||||
|
||||
public PlotArea getPlotAreaByString(String search) {
|
||||
String[] split = search.split(";|,");
|
||||
PlotArea[] areas = this.plotareamap.get(split[0]);
|
||||
PlotArea[] areas = this.plotAreaMap.get(split[0]);
|
||||
if (areas == null) {
|
||||
for (PlotArea area : this.plotAreas) {
|
||||
if (area.worldname.equalsIgnoreCase(split[0])) {
|
||||
@ -570,14 +571,14 @@ public class PS {
|
||||
int hash = world.hashCode();
|
||||
for (PlotArea area : this.plotAreas) {
|
||||
if (hash == area.worldhash) {
|
||||
if (area.contains(location.getX(), location.getZ()) && (!this.plotareaHasCollision || world.equals(area.worldname))) {
|
||||
if (area.contains(location.getX(), location.getZ()) && (!this.plotAreaHasCollision || world.equals(area.worldname))) {
|
||||
return area;
|
||||
}
|
||||
}
|
||||
}
|
||||
return null;
|
||||
default:
|
||||
PlotArea[] areas = this.plotareamap.get(location.getWorld());
|
||||
PlotArea[] areas = this.plotAreaMap.get(location.getWorld());
|
||||
if (areas == null) {
|
||||
return null;
|
||||
}
|
||||
@ -630,13 +631,13 @@ public class PS {
|
||||
if (plotArea.TYPE == 2) {
|
||||
plots = this.plots_tmp.get(plotArea.worldname);
|
||||
if (plots != null) {
|
||||
Iterator<Entry<PlotId, Plot>> iter = plots.entrySet().iterator();
|
||||
while (iter.hasNext()) {
|
||||
Entry<PlotId, Plot> next = iter.next();
|
||||
Iterator<Entry<PlotId, Plot>> iterator = plots.entrySet().iterator();
|
||||
while (iterator.hasNext()) {
|
||||
Entry<PlotId, Plot> next = iterator.next();
|
||||
PlotId id = next.getKey();
|
||||
if (plotArea.contains(id)) {
|
||||
next.getValue().setArea(plotArea);
|
||||
iter.remove();
|
||||
iterator.remove();
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -652,12 +653,12 @@ public class PS {
|
||||
if (plotArea.TYPE == 2) {
|
||||
clusters = this.clusters_tmp.get(plotArea.worldname);
|
||||
if (clusters != null) {
|
||||
Iterator<PlotCluster> iter = clusters.iterator();
|
||||
while (iter.hasNext()) {
|
||||
PlotCluster next = iter.next();
|
||||
Iterator<PlotCluster> iterator = clusters.iterator();
|
||||
while (iterator.hasNext()) {
|
||||
PlotCluster next = iterator.next();
|
||||
if (next.intersects(plotArea.getMin(), plotArea.getMax())) {
|
||||
next.setArea(plotArea);
|
||||
iter.remove();
|
||||
iterator.remove();
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -672,7 +673,7 @@ public class PS {
|
||||
localAreas.add(plotArea);
|
||||
globalAreas.add(plotArea);
|
||||
this.plotAreas = globalAreas.toArray(new PlotArea[globalAreas.size()]);
|
||||
this.plotareamap.put(plotArea.worldname, localAreas.toArray(new PlotArea[localAreas.size()]));
|
||||
this.plotAreaMap.put(plotArea.worldname, localAreas.toArray(new PlotArea[localAreas.size()]));
|
||||
QuadMap<PlotArea> map = this.plotAreaGrid.get(plotArea.worldname);
|
||||
if (map == null) {
|
||||
map = new QuadMap<PlotArea>(Integer.MAX_VALUE, 0, 0) {
|
||||
@ -697,10 +698,10 @@ public class PS {
|
||||
areas.remove(area);
|
||||
this.plotAreas = areas.toArray(new PlotArea[areas.size()]);
|
||||
if (areas.isEmpty()) {
|
||||
this.plotareamap.remove(area.worldname);
|
||||
this.plotAreaMap.remove(area.worldname);
|
||||
this.plotAreaGrid.remove(area.worldname);
|
||||
} else {
|
||||
this.plotareamap.put(area.worldname, areas.toArray(new PlotArea[areas.size()]));
|
||||
this.plotAreaMap.put(area.worldname, areas.toArray(new PlotArea[areas.size()]));
|
||||
this.plotAreaGrid.get(area.worldname).remove(area);
|
||||
}
|
||||
setPlotsTmp(area);
|
||||
@ -922,26 +923,26 @@ public class PS {
|
||||
|
||||
@Deprecated
|
||||
public ArrayList<Plot> sortPlotsByTimestamp(Collection<Plot> plots) {
|
||||
int hardmax = 256000;
|
||||
int hardMax = 256000;
|
||||
int max = 0;
|
||||
int overflowSize = 0;
|
||||
for (Plot plot : plots) {
|
||||
int hash = MathMan.getPositiveId(plot.hashCode());
|
||||
if (hash > max) {
|
||||
if (hash >= hardmax) {
|
||||
if (hash >= hardMax) {
|
||||
overflowSize++;
|
||||
} else {
|
||||
max = hash;
|
||||
}
|
||||
}
|
||||
}
|
||||
hardmax = Math.min(hardmax, max);
|
||||
Plot[] cache = new Plot[hardmax + 1];
|
||||
hardMax = Math.min(hardMax, max);
|
||||
Plot[] cache = new Plot[hardMax + 1];
|
||||
List<Plot> overflow = new ArrayList<>(overflowSize);
|
||||
ArrayList<Plot> extra = new ArrayList<>();
|
||||
for (Plot plot : plots) {
|
||||
int hash = MathMan.getPositiveId(plot.hashCode());
|
||||
if (hash < hardmax) {
|
||||
if (hash < hardMax) {
|
||||
if (hash >= 0) {
|
||||
cache[hash] = plot;
|
||||
} else {
|
||||
@ -1025,17 +1026,17 @@ public class PS {
|
||||
|
||||
/**
|
||||
* Sort a collection of plots by world (with a priority world), then by hashcode.
|
||||
* @param myplots
|
||||
* @param myPlots
|
||||
* @param type The sorting method to use for each world (timestamp, or hash)
|
||||
* @param priorityArea Use null, "world", or "gibberish" if you want default world order
|
||||
* @return ArrayList of plot
|
||||
*/
|
||||
public ArrayList<Plot> sortPlots(Collection<Plot> myplots, SortType type, final PlotArea priorityArea) {
|
||||
public ArrayList<Plot> sortPlots(Collection<Plot> myPlots, SortType type, final PlotArea priorityArea) {
|
||||
// group by world
|
||||
// sort each
|
||||
HashMap<PlotArea, Collection<Plot>> map = new HashMap<>();
|
||||
int totalSize = getPlotCount();
|
||||
if (myplots.size() == totalSize) {
|
||||
if (myPlots.size() == totalSize) {
|
||||
for (PlotArea area : this.plotAreas) {
|
||||
map.put(area, area.getPlots());
|
||||
}
|
||||
@ -1045,7 +1046,7 @@ public class PS {
|
||||
}
|
||||
Collection<Plot> lastList = null;
|
||||
PlotArea lastWorld = null;
|
||||
for (Plot plot : myplots) {
|
||||
for (Plot plot : myPlots) {
|
||||
if (lastWorld == plot.getArea()) {
|
||||
lastList.add(plot);
|
||||
} else {
|
||||
@ -1065,7 +1066,7 @@ public class PS {
|
||||
return a.hashCode() - b.hashCode();
|
||||
}
|
||||
});
|
||||
ArrayList<Plot> toReturn = new ArrayList<>(myplots.size());
|
||||
ArrayList<Plot> toReturn = new ArrayList<>(myPlots.size());
|
||||
for (PlotArea area : areas) {
|
||||
switch (type) {
|
||||
case CREATION_DATE:
|
||||
@ -1137,15 +1138,15 @@ public class PS {
|
||||
* @return Set of plot
|
||||
*/
|
||||
public Set<Plot> getPlots(String world, UUID uuid) {
|
||||
ArrayList<Plot> myplots = new ArrayList<>();
|
||||
ArrayList<Plot> myPlots = new ArrayList<>();
|
||||
for (Plot plot : getPlots(world)) {
|
||||
if (plot.hasOwner()) {
|
||||
if (plot.isOwnerAbs(uuid)) {
|
||||
myplots.add(plot);
|
||||
myPlots.add(plot);
|
||||
}
|
||||
}
|
||||
}
|
||||
return new HashSet<>(myplots);
|
||||
return new HashSet<>(myPlots);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -1175,7 +1176,7 @@ public class PS {
|
||||
*/
|
||||
@Deprecated
|
||||
public boolean isPlotWorld(String world) {
|
||||
return this.plotareamap.containsKey(world);
|
||||
return this.plotAreaMap.containsKey(world);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -1190,7 +1191,7 @@ public class PS {
|
||||
return false;
|
||||
case 1:
|
||||
PlotArea a = this.plotAreas[0];
|
||||
return world.hashCode() == a.worldhash && (!this.plotareaHasCollision || a.worldname.equals(world));
|
||||
return world.hashCode() == a.worldhash && (!this.plotAreaHasCollision || a.worldname.equals(world));
|
||||
case 2:
|
||||
case 3:
|
||||
case 4:
|
||||
@ -1200,13 +1201,13 @@ public class PS {
|
||||
case 8:
|
||||
int hash = world.hashCode();
|
||||
for (PlotArea area : this.plotAreas) {
|
||||
if (area.worldhash == hash && (!this.plotareaHasCollision || area.worldname.equals(world))) {
|
||||
if (area.worldhash == hash && (!this.plotAreaHasCollision || area.worldname.equals(world))) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
default:
|
||||
return this.plotareamap.containsKey(world);
|
||||
return this.plotAreaMap.containsKey(world);
|
||||
}
|
||||
}
|
||||
|
||||
@ -1248,16 +1249,16 @@ public class PS {
|
||||
* @return Set of Plot
|
||||
*/
|
||||
public Set<Plot> getPlots(final UUID uuid) {
|
||||
final ArrayList<Plot> myplots = new ArrayList<>();
|
||||
final ArrayList<Plot> myPlots = new ArrayList<>();
|
||||
foreachPlot(new RunnableVal<Plot>() {
|
||||
@Override
|
||||
public void run(Plot value) {
|
||||
if (value.isOwnerAbs(uuid)) {
|
||||
myplots.add(value);
|
||||
myPlots.add(value);
|
||||
}
|
||||
}
|
||||
});
|
||||
return new HashSet<>(myplots);
|
||||
return new HashSet<>(myPlots);
|
||||
}
|
||||
|
||||
public Set<Plot> getBasePlots(final UUID uuid) {
|
||||
@ -1274,21 +1275,21 @@ public class PS {
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the plots for a UUID
|
||||
* @param uuid
|
||||
* Get the plots for a UUID.
|
||||
* @param uuid The UUID of the owner
|
||||
* @return Set of Plot
|
||||
*/
|
||||
public Set<Plot> getPlotsAbs(final UUID uuid) {
|
||||
final ArrayList<Plot> myplots = new ArrayList<>();
|
||||
final ArrayList<Plot> myPlots = new ArrayList<>();
|
||||
foreachPlot(new RunnableVal<Plot>() {
|
||||
@Override
|
||||
public void run(Plot value) {
|
||||
if (value.isOwnerAbs(uuid)) {
|
||||
myplots.add(value);
|
||||
myPlots.add(value);
|
||||
}
|
||||
}
|
||||
});
|
||||
return new HashSet<>(myplots);
|
||||
return new HashSet<>(myPlots);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -1332,15 +1333,15 @@ public class PS {
|
||||
if (world.equals("CheckingPlotSquaredGenerator")) {
|
||||
return;
|
||||
}
|
||||
if (!this.plotareaHasCollision && !this.plotareaHashCheck.add(world.hashCode())) {
|
||||
this.plotareaHasCollision = true;
|
||||
if (!this.plotAreaHasCollision && !this.plotAreaHashCheck.add(world.hashCode())) {
|
||||
this.plotAreaHasCollision = true;
|
||||
}
|
||||
Set<String> worlds = this.config.contains("worlds") ? this.config.getConfigurationSection("worlds").getKeys(false) : new HashSet<String>();
|
||||
String path = "worlds." + world;
|
||||
ConfigurationSection worldSection = this.config.getConfigurationSection(path);
|
||||
int type = worldSection != null ? worldSection.getInt("generator.type") : 0;
|
||||
if (type == 0) {
|
||||
if (this.plotareamap.containsKey(world)) {
|
||||
if (this.plotAreaMap.containsKey(world)) {
|
||||
PS.debug("World possibly already loaded: " + world);
|
||||
return;
|
||||
}
|
||||
@ -1392,7 +1393,7 @@ public class PS {
|
||||
}
|
||||
ConfigurationSection areasSection = worldSection.getConfigurationSection("areas");
|
||||
if (areasSection == null) {
|
||||
if (this.plotareamap.containsKey(world)) {
|
||||
if (this.plotAreaMap.containsKey(world)) {
|
||||
PS.debug("World possibly already loaded: " + world);
|
||||
return;
|
||||
}
|
||||
@ -2297,7 +2298,7 @@ public class PS {
|
||||
}
|
||||
|
||||
/**
|
||||
* Show startup debug information
|
||||
* Show startup debug information.
|
||||
*/
|
||||
private void showDebug() {
|
||||
if (Settings.DEBUG) {
|
||||
@ -2335,7 +2336,7 @@ public class PS {
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the java version
|
||||
* Get the java version.
|
||||
* @return Java version as a double
|
||||
*/
|
||||
public double getJavaVersion() {
|
||||
@ -2378,7 +2379,7 @@ public class PS {
|
||||
}
|
||||
|
||||
public void foreachPlotArea(String world, RunnableVal<PlotArea> runnable) {
|
||||
PlotArea[] array = this.plotareamap.get(world);
|
||||
PlotArea[] array = this.plotAreaMap.get(world);
|
||||
if (array == null) {
|
||||
return;
|
||||
}
|
||||
@ -2404,7 +2405,7 @@ public class PS {
|
||||
}
|
||||
|
||||
public int getPlotAreaCount(String world) {
|
||||
return this.plotareamap.size();
|
||||
return this.plotAreaMap.size();
|
||||
}
|
||||
|
||||
public Set<PlotArea> getPlotAreas() {
|
||||
@ -2419,15 +2420,15 @@ public class PS {
|
||||
*/
|
||||
@Deprecated
|
||||
public Set<String> getPlotWorldStrings() {
|
||||
HashSet<String> set = new HashSet<>(this.plotareamap.size());
|
||||
for (Entry<String, PlotArea[]> entry : this.plotareamap.entrySet()) {
|
||||
HashSet<String> set = new HashSet<>(this.plotAreaMap.size());
|
||||
for (Entry<String, PlotArea[]> entry : this.plotAreaMap.entrySet()) {
|
||||
set.add(entry.getKey());
|
||||
}
|
||||
return set;
|
||||
}
|
||||
|
||||
public boolean isAugmented(String world) {
|
||||
PlotArea[] areas = this.plotareamap.get(world);
|
||||
PlotArea[] areas = this.plotAreaMap.get(world);
|
||||
if (areas == null) {
|
||||
return false;
|
||||
}
|
||||
@ -2443,7 +2444,7 @@ public class PS {
|
||||
* @return Collection of PlotArea objects
|
||||
*/
|
||||
public Set<PlotArea> getPlotAreas(String world) {
|
||||
PlotArea[] areas = this.plotareamap.get(world);
|
||||
PlotArea[] areas = this.plotAreaMap.get(world);
|
||||
if (areas == null) {
|
||||
return new HashSet<>(0);
|
||||
}
|
||||
|
@ -86,17 +86,17 @@ public class Area extends SubCommand {
|
||||
Location pos2 = plr.getMeta("area_pos1");
|
||||
int dx = Math.abs(pos1.getX() - pos2.getX());
|
||||
int dz = Math.abs(pos1.getZ() - pos2.getZ());
|
||||
int numx = Math.max(1, (dx + 1 + area.ROAD_WIDTH + area.SIZE / 2) / area.SIZE);
|
||||
int numz = Math.max(1, (dz + 1 + area.ROAD_WIDTH + area.SIZE / 2) / area.SIZE);
|
||||
int ddx = dx - (numx * area.SIZE - area.ROAD_WIDTH);
|
||||
int ddz = dz - (numz * area.SIZE - area.ROAD_WIDTH);
|
||||
int numX = Math.max(1, (dx + 1 + area.ROAD_WIDTH + area.SIZE / 2) / area.SIZE);
|
||||
int numZ = Math.max(1, (dz + 1 + area.ROAD_WIDTH + area.SIZE / 2) / area.SIZE);
|
||||
int ddx = dx - (numX * area.SIZE - area.ROAD_WIDTH);
|
||||
int ddz = dz - (numZ * area.SIZE - area.ROAD_WIDTH);
|
||||
int bx = Math.min(pos1.getX(), pos2.getX()) + ddx;
|
||||
int bz = Math.min(pos1.getZ(), pos2.getZ()) + ddz;
|
||||
int tx = Math.max(pos1.getX(), pos2.getX()) - ddx;
|
||||
int tz = Math.max(pos1.getZ(), pos2.getZ()) - ddz;
|
||||
int lower = (area.ROAD_WIDTH & 1) == 0 ? area.ROAD_WIDTH / 2 - 1 : area.ROAD_WIDTH / 2;
|
||||
final int offsetx = bx - (area.ROAD_WIDTH == 0 ? 0 : lower);
|
||||
final int offsetz = bz - (area.ROAD_WIDTH == 0 ? 0 : lower);
|
||||
final int offsetX = bx - (area.ROAD_WIDTH == 0 ? 0 : lower);
|
||||
final int offsetZ = bz - (area.ROAD_WIDTH == 0 ? 0 : lower);
|
||||
final RegionWrapper region = new RegionWrapper(bx, tx, bz, tz);
|
||||
Set<PlotArea> areas = PS.get().getPlotAreas(area.worldname, region);
|
||||
if (!areas.isEmpty()) {
|
||||
@ -109,7 +109,7 @@ public class Area extends SubCommand {
|
||||
object.terrain = area.TERRAIN;
|
||||
object.type = area.TYPE;
|
||||
object.min = new PlotId(1, 1);
|
||||
object.max = new PlotId(numx, numz);
|
||||
object.max = new PlotId(numX, numZ);
|
||||
object.plotManager = "PlotSquared";
|
||||
object.setupGenerator = "PlotSquared";
|
||||
object.step = area.getSettingNodes();
|
||||
@ -117,11 +117,11 @@ public class Area extends SubCommand {
|
||||
Runnable run = new Runnable() {
|
||||
@Override
|
||||
public void run() {
|
||||
if (offsetx != 0) {
|
||||
PS.get().config.set(path + ".road.offset.x", offsetx);
|
||||
if (offsetX != 0) {
|
||||
PS.get().config.set(path + ".road.offset.x", offsetX);
|
||||
}
|
||||
if (offsetz != 0) {
|
||||
PS.get().config.set(path + ".road.offset.z", offsetz);
|
||||
if (offsetZ != 0) {
|
||||
PS.get().config.set(path + ".road.offset.z", offsetZ);
|
||||
}
|
||||
final String world = SetupUtils.manager.setupWorld(object);
|
||||
if (WorldUtil.IMP.isWorld(world)) {
|
||||
|
@ -15,6 +15,7 @@ import com.intellectualcrafters.plot.util.MainUtil;
|
||||
import com.intellectualcrafters.plot.util.Permissions;
|
||||
import com.intellectualcrafters.plot.util.UUIDHandler;
|
||||
import com.plotsquared.general.commands.CommandDeclaration;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashSet;
|
||||
import java.util.Set;
|
||||
@ -237,9 +238,9 @@ public class Cluster extends SubCommand {
|
||||
return false;
|
||||
}
|
||||
HashSet<Plot> existing = area.getPlotSelectionOwned(cluster.getP1(), cluster.getP2());
|
||||
HashSet<Plot> newplots = area.getPlotSelectionOwned(pos1, pos2);
|
||||
HashSet<Plot> newPlots = area.getPlotSelectionOwned(pos1, pos2);
|
||||
HashSet<Plot> removed = (HashSet<Plot>) existing.clone();
|
||||
removed.removeAll(newplots);
|
||||
removed.removeAll(newPlots);
|
||||
// Check expand / shrink
|
||||
if (!removed.isEmpty()) {
|
||||
if (!Permissions.hasPermission(plr, "plots.cluster.resize.shrink")) {
|
||||
@ -247,8 +248,8 @@ public class Cluster extends SubCommand {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
newplots.removeAll(existing);
|
||||
if (!newplots.isEmpty()) {
|
||||
newPlots.removeAll(existing);
|
||||
if (!newPlots.isEmpty()) {
|
||||
if (!Permissions.hasPermission(plr, "plots.cluster.resize.expand")) {
|
||||
MainUtil.sendMessage(plr, C.NO_PERMISSION, "plots.cluster.resize.expand");
|
||||
return false;
|
||||
|
@ -3,19 +3,15 @@ package com.intellectualcrafters.plot.commands;
|
||||
import com.intellectualcrafters.plot.object.PlotPlayer;
|
||||
import com.intellectualcrafters.plot.util.Permissions;
|
||||
|
||||
/**
|
||||
* Created by Citymonstret on 2014-08-03.
|
||||
*
|
||||
|
||||
*/
|
||||
public class CommandPermission {
|
||||
|
||||
/**
|
||||
* Permission Node
|
||||
* Permission Node.
|
||||
*/
|
||||
public final String permission;
|
||||
|
||||
/**
|
||||
* Command Permission
|
||||
* @param permission Command Permission
|
||||
*/
|
||||
public CommandPermission(String permission) {
|
||||
@ -23,7 +19,8 @@ public class CommandPermission {
|
||||
}
|
||||
|
||||
/**
|
||||
* @param player Does the player have the permission?
|
||||
* Check the permissions of a player.
|
||||
* @param player The player to check permissions for
|
||||
*
|
||||
* @return true of player has the required permission node
|
||||
*/
|
||||
|
@ -10,6 +10,7 @@ import com.intellectualcrafters.plot.util.MathMan;
|
||||
import com.intellectualcrafters.plot.util.TaskManager;
|
||||
import com.intellectualcrafters.plot.util.WorldUtil;
|
||||
import com.plotsquared.general.commands.CommandDeclaration;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collection;
|
||||
import java.util.HashSet;
|
||||
@ -55,13 +56,13 @@ public class Condense extends SubCommand {
|
||||
int radius = Integer.parseInt(args[2]);
|
||||
ArrayList<Plot> plots = new ArrayList<>(PS.get().getPlots(area));
|
||||
// remove non base plots
|
||||
Iterator<Plot> iter = plots.iterator();
|
||||
Iterator<Plot> iterator = plots.iterator();
|
||||
int maxSize = 0;
|
||||
ArrayList<Integer> sizes = new ArrayList<>();
|
||||
while (iter.hasNext()) {
|
||||
Plot plot = iter.next();
|
||||
while (iterator.hasNext()) {
|
||||
Plot plot = iterator.next();
|
||||
if (!plot.isBasePlot()) {
|
||||
iter.remove();
|
||||
iterator.remove();
|
||||
continue;
|
||||
}
|
||||
int size = plot.getConnectedPlots().size();
|
||||
|
@ -95,7 +95,7 @@ public class DebugClaimTest extends SubCommand {
|
||||
plot.owner = uuid;
|
||||
plots.add(plot);
|
||||
} else {
|
||||
MainUtil.sendMessage(plr, " - &cInvalid playername: " + plot.getId() + " : " + line);
|
||||
MainUtil.sendMessage(plr, " - &cInvalid PlayerName: " + plot.getId() + " : " + line);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -350,10 +350,10 @@ public class ListCmd extends SubCommand {
|
||||
public void displayPlots(final PlotPlayer player, java.util.List<Plot> plots, int pageSize, int page, PlotArea area,
|
||||
String[] args, boolean sort) {
|
||||
// Header
|
||||
Iterator<Plot> iter = plots.iterator();
|
||||
while (iter.hasNext()) {
|
||||
if (!iter.next().isBasePlot()) {
|
||||
iter.remove();
|
||||
Iterator<Plot> iterator = plots.iterator();
|
||||
while (iterator.hasNext()) {
|
||||
if (!iterator.next().isBasePlot()) {
|
||||
iterator.remove();
|
||||
}
|
||||
}
|
||||
if (sort) {
|
||||
|
@ -65,9 +65,9 @@ public class Load extends SubCommand {
|
||||
MainUtil.sendMessage(plr, C.LOAD_NULL);
|
||||
return false;
|
||||
}
|
||||
String schem;
|
||||
String schematic;
|
||||
try {
|
||||
schem = schematics.get(Integer.parseInt(args[0]) - 1);
|
||||
schematic = schematics.get(Integer.parseInt(args[0]) - 1);
|
||||
} catch (NumberFormatException e) {
|
||||
// use /plot load <index>
|
||||
MainUtil.sendMessage(plr, C.NOT_VALID_NUMBER, "(1, " + schematics.size() + ")");
|
||||
@ -75,7 +75,7 @@ public class Load extends SubCommand {
|
||||
}
|
||||
final URL url;
|
||||
try {
|
||||
url = new URL(Settings.WEB_URL + "saves/" + plr.getUUID() + "/" + schem + ".schematic");
|
||||
url = new URL(Settings.WEB_URL + "saves/" + plr.getUUID() + "/" + schematic + ".schematic");
|
||||
} catch (MalformedURLException e) {
|
||||
e.printStackTrace();
|
||||
MainUtil.sendMessage(plr, C.LOAD_FAILED);
|
||||
@ -140,8 +140,8 @@ public class Load extends SubCommand {
|
||||
List<String> schematics = player.getMeta("plot_schematics");
|
||||
for (int i = 0; i < Math.min(schematics.size(), 32); i++) {
|
||||
try {
|
||||
String schem = schematics.get(i);
|
||||
String[] split = schem.split("_");
|
||||
String schematic = schematics.get(i);
|
||||
String[] split = schematic.split("_");
|
||||
if (split.length != 6) {
|
||||
continue;
|
||||
}
|
||||
|
@ -121,8 +121,8 @@ public class Purge extends SubCommand {
|
||||
}
|
||||
if (PS.get().plots_tmp != null) {
|
||||
for (Entry<String, HashMap<PlotId, Plot>> entry : PS.get().plots_tmp.entrySet()) {
|
||||
String worldname = entry.getKey();
|
||||
if (world != null && !world.equalsIgnoreCase(worldname)) {
|
||||
String worldName = entry.getKey();
|
||||
if (world != null && !world.equalsIgnoreCase(worldName)) {
|
||||
continue;
|
||||
}
|
||||
for (Entry<PlotId, Plot> entry2 : entry.getValue().entrySet()) {
|
||||
|
@ -20,16 +20,16 @@ public class Target extends SubCommand {
|
||||
|
||||
@Override
|
||||
public boolean onCommand(PlotPlayer plr, String[] args) {
|
||||
Location ploc = plr.getLocation();
|
||||
if (!ploc.isPlotArea()) {
|
||||
Location plrLocation = plr.getLocation();
|
||||
if (!plrLocation.isPlotArea()) {
|
||||
MainUtil.sendMessage(plr, C.NOT_IN_PLOT_WORLD);
|
||||
return false;
|
||||
}
|
||||
Plot target = null;
|
||||
if (StringMan.isEqualIgnoreCaseToAny(args[0], "near", "nearest")) {
|
||||
int distance = Integer.MAX_VALUE;
|
||||
for (Plot plot : PS.get().getPlots(ploc.getWorld())) {
|
||||
double current = plot.getCenter().getEuclideanDistanceSquared(ploc);
|
||||
for (Plot plot : PS.get().getPlots(plrLocation.getWorld())) {
|
||||
double current = plot.getCenter().getEuclideanDistanceSquared(plrLocation);
|
||||
if (current < distance) {
|
||||
distance = (int) current;
|
||||
target = plot;
|
||||
|
@ -14,6 +14,7 @@ import com.intellectualcrafters.plot.util.MainUtil;
|
||||
import com.intellectualcrafters.plot.util.TaskManager;
|
||||
import com.intellectualcrafters.plot.util.WorldUtil;
|
||||
import com.plotsquared.general.commands.CommandDeclaration;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.IOException;
|
||||
import java.nio.file.Files;
|
||||
@ -164,9 +165,9 @@ public class Trim extends SubCommand {
|
||||
plr.sendMessage("Trim done!");
|
||||
return;
|
||||
}
|
||||
Iterator<ChunkLoc> iter = nonViable.iterator();
|
||||
ChunkLoc mcr = iter.next();
|
||||
iter.remove();
|
||||
Iterator<ChunkLoc> iterator = nonViable.iterator();
|
||||
ChunkLoc mcr = iterator.next();
|
||||
iterator.remove();
|
||||
int cbx = mcr.x << 5;
|
||||
int cbz = mcr.z << 5;
|
||||
// get all 1024 chunks
|
||||
|
@ -9,6 +9,7 @@ import com.intellectualcrafters.plot.util.MathMan;
|
||||
import com.intellectualcrafters.plot.util.Permissions;
|
||||
import com.intellectualcrafters.plot.util.UUIDHandler;
|
||||
import com.plotsquared.general.commands.CommandDeclaration;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collection;
|
||||
import java.util.Collections;
|
||||
@ -85,10 +86,10 @@ public class Visit extends SubCommand {
|
||||
sendMessage(player, C.FOUND_NO_PLOTS);
|
||||
return false;
|
||||
}
|
||||
Iterator<Plot> iter = unsorted.iterator();
|
||||
while (iter.hasNext()) {
|
||||
if (!iter.next().isBasePlot()) {
|
||||
iter.remove();
|
||||
Iterator<Plot> iterator = unsorted.iterator();
|
||||
while (iterator.hasNext()) {
|
||||
if (!iterator.next().isBasePlot()) {
|
||||
iterator.remove();
|
||||
}
|
||||
}
|
||||
if (page < 1 || page > unsorted.size()) {
|
||||
|
@ -1599,7 +1599,7 @@ public class SQLManager implements AbstractDB {
|
||||
*/
|
||||
@Override
|
||||
public HashMap<String, HashMap<PlotId, Plot>> getPlots() {
|
||||
HashMap<String, HashMap<PlotId, Plot>> newplots = new HashMap<>();
|
||||
HashMap<String, HashMap<PlotId, Plot>> newPlots = new HashMap<>();
|
||||
HashMap<Integer, Plot> plots = new HashMap<>();
|
||||
try {
|
||||
HashSet<String> areas = new HashSet<>();
|
||||
@ -1660,7 +1660,7 @@ public class SQLManager implements AbstractDB {
|
||||
long time = timestamp.getTime();
|
||||
Plot p = new Plot(plot_id, user, new HashSet<UUID>(), new HashSet<UUID>(), new HashSet<UUID>(), "", null, null, null,
|
||||
new boolean[]{false, false, false, false}, time, id);
|
||||
HashMap<PlotId, Plot> map = newplots.get(areaid);
|
||||
HashMap<PlotId, Plot> map = newPlots.get(areaid);
|
||||
if (map != null) {
|
||||
Plot last = map.put(p.getId(), p);
|
||||
if (last != null) {
|
||||
@ -1675,7 +1675,7 @@ public class SQLManager implements AbstractDB {
|
||||
}
|
||||
} else {
|
||||
map = new HashMap<>();
|
||||
newplots.put(areaid, map);
|
||||
newPlots.put(areaid, map);
|
||||
map.put(p.getId(), p);
|
||||
}
|
||||
plots.put(id, p);
|
||||
@ -1872,9 +1872,9 @@ public class SQLManager implements AbstractDB {
|
||||
}
|
||||
boolean invalidPlot = false;
|
||||
for (Entry<String, AtomicInteger> entry : noExist.entrySet()) {
|
||||
String worldname = entry.getKey();
|
||||
String worldName = entry.getKey();
|
||||
invalidPlot = true;
|
||||
PS.debug("&c[WARNING] Found " + entry.getValue().intValue() + " plots in DB for non existant world; '" + worldname + "'.");
|
||||
PS.debug("&c[WARNING] Found " + entry.getValue().intValue() + " plots in DB for non existent world; '" + worldName + "'.");
|
||||
}
|
||||
if (invalidPlot) {
|
||||
PS.debug("&c[WARNING] - Please create the world/s or remove the plots using the purge command");
|
||||
@ -1883,7 +1883,7 @@ public class SQLManager implements AbstractDB {
|
||||
PS.debug("&7[WARN] " + "Failed to load plots.");
|
||||
e.printStackTrace();
|
||||
}
|
||||
return newplots;
|
||||
return newPlots;
|
||||
}
|
||||
|
||||
@Override
|
||||
@ -2072,9 +2072,9 @@ public class SQLManager implements AbstractDB {
|
||||
e.printStackTrace();
|
||||
PS.debug("&c[ERROR] " + "FAILED TO PURGE AREA '" + area + "'!");
|
||||
}
|
||||
for (Iterator<PlotId> iter = plots.iterator(); iter.hasNext(); ) {
|
||||
PlotId plotId = iter.next();
|
||||
iter.remove();
|
||||
for (Iterator<PlotId> iterator = plots.iterator(); iterator.hasNext(); ) {
|
||||
PlotId plotId = iterator.next();
|
||||
iterator.remove();
|
||||
PlotId id = new PlotId(plotId.x, plotId.y);
|
||||
area.removePlot(id);
|
||||
}
|
||||
@ -2673,7 +2673,7 @@ public class SQLManager implements AbstractDB {
|
||||
for (Entry<String, Integer> entry : noExist.entrySet()) {
|
||||
String a = entry.getKey();
|
||||
invalidPlot = true;
|
||||
PS.debug("&c[WARNING] Found " + noExist.get(a) + " clusters in DB for non existant area; '" + a + "'.");
|
||||
PS.debug("&c[WARNING] Found " + noExist.get(a) + " clusters in DB for non existent area; '" + a + "'.");
|
||||
}
|
||||
if (invalidPlot) {
|
||||
PS.debug("&c[WARNING] - Please create the world/s or remove the clusters using the purge command");
|
||||
@ -2943,29 +2943,29 @@ public class SQLManager implements AbstractDB {
|
||||
if (plot.temp == -1) {
|
||||
continue;
|
||||
}
|
||||
HashMap<PlotId, Plot> worldplots = database.get(plot.getArea().toString());
|
||||
if (worldplots == null) {
|
||||
HashMap<PlotId, Plot> worldPlots = database.get(plot.getArea().toString());
|
||||
if (worldPlots == null) {
|
||||
PS.debug("&8 - &7Creating plot (1): " + plot);
|
||||
toCreate.add(plot);
|
||||
continue;
|
||||
}
|
||||
Plot dataplot = worldplots.remove(plot.getId());
|
||||
if (dataplot == null) {
|
||||
Plot dataPlot = worldPlots.remove(plot.getId());
|
||||
if (dataPlot == null) {
|
||||
PS.debug("&8 - &7Creating plot (2): " + plot);
|
||||
toCreate.add(plot);
|
||||
continue;
|
||||
}
|
||||
// owner
|
||||
if (!plot.owner.equals(dataplot.owner)) {
|
||||
if (!plot.owner.equals(dataPlot.owner)) {
|
||||
PS.debug("&8 - &7Setting owner: " + plot + " -> " + MainUtil.getName(plot.owner));
|
||||
setOwner(plot, plot.owner);
|
||||
}
|
||||
// trusted
|
||||
if (!plot.getTrusted().equals(dataplot.getTrusted())) {
|
||||
if (!plot.getTrusted().equals(dataPlot.getTrusted())) {
|
||||
HashSet<UUID> toAdd = (HashSet<UUID>) plot.getTrusted().clone();
|
||||
HashSet<UUID> toRemove = (HashSet<UUID>) dataplot.getTrusted().clone();
|
||||
HashSet<UUID> toRemove = (HashSet<UUID>) dataPlot.getTrusted().clone();
|
||||
toRemove.removeAll(plot.getTrusted());
|
||||
toAdd.removeAll(dataplot.getTrusted());
|
||||
toAdd.removeAll(dataPlot.getTrusted());
|
||||
PS.debug("&8 - &7Correcting " + (toAdd.size() + toRemove.size()) + " trusted for: " + plot);
|
||||
if (!toRemove.isEmpty()) {
|
||||
for (UUID uuid : toRemove) {
|
||||
@ -2978,11 +2978,11 @@ public class SQLManager implements AbstractDB {
|
||||
}
|
||||
}
|
||||
}
|
||||
if (!plot.getMembers().equals(dataplot.getMembers())) {
|
||||
if (!plot.getMembers().equals(dataPlot.getMembers())) {
|
||||
HashSet<UUID> toAdd = (HashSet<UUID>) plot.getMembers().clone();
|
||||
HashSet<UUID> toRemove = (HashSet<UUID>) dataplot.getMembers().clone();
|
||||
HashSet<UUID> toRemove = (HashSet<UUID>) dataPlot.getMembers().clone();
|
||||
toRemove.removeAll(plot.getMembers());
|
||||
toAdd.removeAll(dataplot.getMembers());
|
||||
toAdd.removeAll(dataPlot.getMembers());
|
||||
PS.debug("&8 - &7Correcting " + (toAdd.size() + toRemove.size()) + " members for: " + plot);
|
||||
if (!toRemove.isEmpty()) {
|
||||
for (UUID uuid : toRemove) {
|
||||
@ -2995,11 +2995,11 @@ public class SQLManager implements AbstractDB {
|
||||
}
|
||||
}
|
||||
}
|
||||
if (!plot.getDenied().equals(dataplot.getDenied())) {
|
||||
if (!plot.getDenied().equals(dataPlot.getDenied())) {
|
||||
HashSet<UUID> toAdd = (HashSet<UUID>) plot.getDenied().clone();
|
||||
HashSet<UUID> toRemove = (HashSet<UUID>) dataplot.getDenied().clone();
|
||||
HashSet<UUID> toRemove = (HashSet<UUID>) dataPlot.getDenied().clone();
|
||||
toRemove.removeAll(plot.getDenied());
|
||||
toAdd.removeAll(dataplot.getDenied());
|
||||
toAdd.removeAll(dataPlot.getDenied());
|
||||
PS.debug("&8 - &7Correcting " + (toAdd.size() + toRemove.size()) + " denied for: " + plot);
|
||||
if (!toRemove.isEmpty()) {
|
||||
for (UUID uuid : toRemove) {
|
||||
@ -3013,13 +3013,13 @@ public class SQLManager implements AbstractDB {
|
||||
}
|
||||
}
|
||||
boolean[] pm = plot.getMerged();
|
||||
boolean[] dm = dataplot.getMerged();
|
||||
boolean[] dm = dataPlot.getMerged();
|
||||
if (pm[0] != dm[0] || pm[1] != dm[1]) {
|
||||
PS.debug("&8 - &7Correcting merge for: " + plot);
|
||||
setMerged(dataplot, plot.getMerged());
|
||||
setMerged(dataPlot, plot.getMerged());
|
||||
}
|
||||
HashMap<String, Flag> pf = plot.getFlags();
|
||||
HashMap<String, Flag> df = dataplot.getFlags();
|
||||
HashMap<String, Flag> df = dataPlot.getFlags();
|
||||
if (!pf.isEmpty() && !df.isEmpty()) {
|
||||
if (pf.size() != df.size() || !StringMan.isEqual(StringMan.joinOrdered(pf.values(), ","), StringMan.joinOrdered(df.values(), ","))) {
|
||||
PS.debug("&8 - &7Correcting flags for: " + plot);
|
||||
|
@ -172,23 +172,24 @@ public class HybridPlotWorld extends ClassicPlotWorld {
|
||||
|
||||
public void setupSchematics() {
|
||||
this.G_SCH = new HashMap<>();
|
||||
File schem1File = MainUtil.getFile(PS.get().IMP.getDirectory(), "schematics/GEN_ROAD_SCHEMATIC/" + this.worldname + "/sideroad.schematic");
|
||||
File schem2File =
|
||||
File schematic1File =
|
||||
MainUtil.getFile(PS.get().IMP.getDirectory(), "schematics/GEN_ROAD_SCHEMATIC/" + this.worldname + "/sideroad.schematic");
|
||||
File schematic2File =
|
||||
MainUtil.getFile(PS.get().IMP.getDirectory(), "schematics/GEN_ROAD_SCHEMATIC/" + this.worldname + "/intersection.schematic");
|
||||
File schem3File = MainUtil.getFile(PS.get().IMP.getDirectory(), "schematics/GEN_ROAD_SCHEMATIC/" + this.worldname + "/plot.schematic");
|
||||
Schematic schem1 = SchematicHandler.manager.getSchematic(schem1File);
|
||||
Schematic schem2 = SchematicHandler.manager.getSchematic(schem2File);
|
||||
Schematic schem3 = SchematicHandler.manager.getSchematic(schem3File);
|
||||
Schematic schematic1 = SchematicHandler.manager.getSchematic(schematic1File);
|
||||
Schematic schematic2 = SchematicHandler.manager.getSchematic(schematic2File);
|
||||
Schematic schematic3 = SchematicHandler.manager.getSchematic(schem3File);
|
||||
int shift = this.ROAD_WIDTH / 2;
|
||||
int oddshift = 0;
|
||||
if ((this.ROAD_WIDTH & 1) != 0) {
|
||||
oddshift = 1;
|
||||
}
|
||||
if (schem3 != null) {
|
||||
if (schematic3 != null) {
|
||||
this.PLOT_SCHEMATIC = true;
|
||||
short[] ids = schem3.getIds();
|
||||
byte[] datas = schem3.getDatas();
|
||||
Dimension d3 = schem3.getSchematicDimension();
|
||||
short[] ids = schematic3.getIds();
|
||||
byte[] datas = schematic3.getDatas();
|
||||
Dimension d3 = schematic3.getSchematicDimension();
|
||||
short w3 = (short) d3.getX();
|
||||
short l3 = (short) d3.getZ();
|
||||
short h3 = (short) d3.getY();
|
||||
@ -214,7 +215,7 @@ public class HybridPlotWorld extends ClassicPlotWorld {
|
||||
}
|
||||
}
|
||||
}
|
||||
HashSet<PlotItem> items = schem3.getItems();
|
||||
HashSet<PlotItem> items = schematic3.getItems();
|
||||
if (items != null) {
|
||||
this.G_SCH_STATE = new HashMap<>();
|
||||
for (PlotItem item : items) {
|
||||
@ -235,7 +236,7 @@ public class HybridPlotWorld extends ClassicPlotWorld {
|
||||
}
|
||||
}
|
||||
}
|
||||
if (schem1 == null || schem2 == null || this.ROAD_WIDTH == 0) {
|
||||
if (schematic1 == null || schematic2 == null || this.ROAD_WIDTH == 0) {
|
||||
PS.debug(C.PREFIX + "&3 - schematic: &7false");
|
||||
return;
|
||||
}
|
||||
@ -243,17 +244,17 @@ public class HybridPlotWorld extends ClassicPlotWorld {
|
||||
// Do not populate road if using schematic population
|
||||
this.ROAD_BLOCK = new PlotBlock(this.ROAD_BLOCK.id, (byte) 0);
|
||||
|
||||
short[] ids1 = schem1.getIds();
|
||||
byte[] datas1 = schem1.getDatas();
|
||||
short[] ids1 = schematic1.getIds();
|
||||
byte[] datas1 = schematic1.getDatas();
|
||||
|
||||
short[] ids2 = schem2.getIds();
|
||||
byte[] datas2 = schem2.getDatas();
|
||||
short[] ids2 = schematic2.getIds();
|
||||
byte[] datas2 = schematic2.getDatas();
|
||||
|
||||
Dimension d1 = schem1.getSchematicDimension();
|
||||
Dimension d1 = schematic1.getSchematicDimension();
|
||||
short w1 = (short) d1.getX();
|
||||
short l1 = (short) d1.getZ();
|
||||
short h1 = (short) d1.getY();
|
||||
Dimension d2 = schem2.getSchematicDimension();
|
||||
Dimension d2 = schematic2.getSchematicDimension();
|
||||
short w2 = (short) d2.getX();
|
||||
short l2 = (short) d2.getZ();
|
||||
short h2 = (short) d2.getY();
|
||||
@ -293,9 +294,9 @@ public class HybridPlotWorld extends ClassicPlotWorld {
|
||||
x += this.SIZE;
|
||||
}
|
||||
if (rotate) {
|
||||
byte newdata = rotate(id, data);
|
||||
if (data != 0 || newdata != 0) {
|
||||
data = newdata;
|
||||
byte newData = rotate(id, data);
|
||||
if (data != 0 || newData != 0) {
|
||||
data = newData;
|
||||
}
|
||||
}
|
||||
int pair = MathMan.pair(x, z);
|
||||
|
@ -223,9 +223,9 @@ public abstract class HybridUtils {
|
||||
}
|
||||
if (chunks.size() < 1024) {
|
||||
if (!regions.isEmpty()) {
|
||||
Iterator<ChunkLoc> iter = regions.iterator();
|
||||
ChunkLoc loc = iter.next();
|
||||
iter.remove();
|
||||
Iterator<ChunkLoc> iterator = regions.iterator();
|
||||
ChunkLoc loc = iterator.next();
|
||||
iterator.remove();
|
||||
PS.debug("&3Updating .mcr: " + loc.x + ", " + loc.z + " (aprrox 1024 chunks)");
|
||||
PS.debug(" - Remaining: " + regions.size());
|
||||
chunks.addAll(getChunks(loc));
|
||||
@ -237,9 +237,9 @@ public abstract class HybridUtils {
|
||||
if (System.currentTimeMillis() - baseTime - last.get() > 2000 && last.get() != 0) {
|
||||
last.set(0);
|
||||
PS.debug(C.PREFIX.s() + "Detected low TPS. Rescheduling in 30s");
|
||||
Iterator<ChunkLoc> iter = chunks.iterator();
|
||||
final ChunkLoc chunk = iter.next();
|
||||
iter.remove();
|
||||
Iterator<ChunkLoc> iterator = chunks.iterator();
|
||||
final ChunkLoc chunk = iterator.next();
|
||||
iterator.remove();
|
||||
TaskManager.runTask(new Runnable() {
|
||||
@Override
|
||||
public void run() {
|
||||
@ -252,9 +252,9 @@ public abstract class HybridUtils {
|
||||
}
|
||||
if (System.currentTimeMillis() - baseTime - last.get() < 1500 && last.get() != 0) {
|
||||
while (System.currentTimeMillis() < diff && !chunks.isEmpty()) {
|
||||
Iterator<ChunkLoc> iter = chunks.iterator();
|
||||
final ChunkLoc chunk = iter.next();
|
||||
iter.remove();
|
||||
Iterator<ChunkLoc> iterator = chunks.iterator();
|
||||
final ChunkLoc chunk = iterator.next();
|
||||
iterator.remove();
|
||||
TaskManager.runTask(new Runnable() {
|
||||
@Override
|
||||
public void run() {
|
||||
@ -267,9 +267,9 @@ public abstract class HybridUtils {
|
||||
}
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
Iterator<ChunkLoc> iter = regions.iterator();
|
||||
ChunkLoc loc = iter.next();
|
||||
iter.remove();
|
||||
Iterator<ChunkLoc> iterator = regions.iterator();
|
||||
ChunkLoc loc = iterator.next();
|
||||
iterator.remove();
|
||||
PS.debug("&c[ERROR]&7 Could not update '" + area.worldname + "/region/r." + loc.x + "." + loc.z
|
||||
+ ".mca' (Corrupt chunk?)");
|
||||
int sx = loc.x << 5;
|
||||
@ -311,12 +311,12 @@ public abstract class HybridUtils {
|
||||
int tz = sz - 1;
|
||||
int ty = get_ey(world, sx, ex, bz, tz, sy);
|
||||
|
||||
Set<RegionWrapper> sideroad = new HashSet<>(Collections.singletonList(new RegionWrapper(sx, ex, sy, ey, sz, ez)));
|
||||
Set<RegionWrapper> sideRoad = new HashSet<>(Collections.singletonList(new RegionWrapper(sx, ex, sy, ey, sz, ez)));
|
||||
final Set<RegionWrapper> intersection = new HashSet<>(Collections.singletonList(new RegionWrapper(sx, ex, sy, ty, bz, tz)));
|
||||
|
||||
final String dir = "schematics" + File.separator + "GEN_ROAD_SCHEMATIC" + File.separator + plot
|
||||
.getArea().toString() + File.separator;
|
||||
SchematicHandler.manager.getCompoundTag(world, sideroad, new RunnableVal<CompoundTag>() {
|
||||
SchematicHandler.manager.getCompoundTag(world, sideRoad, new RunnableVal<CompoundTag>() {
|
||||
@Override
|
||||
public void run(CompoundTag value) {
|
||||
SchematicHandler.manager.save(value, dir + "sideroad.schematic");
|
||||
|
@ -28,9 +28,9 @@ public abstract class SquarePlotManager extends GridPlotManager {
|
||||
whenDone.run();
|
||||
return;
|
||||
}
|
||||
Iterator<RegionWrapper> iter = regions.iterator();
|
||||
RegionWrapper region = iter.next();
|
||||
iter.remove();
|
||||
Iterator<RegionWrapper> iterator = regions.iterator();
|
||||
RegionWrapper region = iterator.next();
|
||||
iterator.remove();
|
||||
Location pos1 = new Location(plot.getArea().worldname, region.minX, region.minY, region.minZ);
|
||||
Location pos2 = new Location(plot.getArea().worldname, region.maxX, region.maxY, region.maxZ);
|
||||
ChunkManager.manager.regenerateRegion(pos1, pos2, false, this);
|
||||
|
@ -11,8 +11,8 @@ public abstract class SquarePlotWorld extends GridPlotWorld {
|
||||
public int ROAD_OFFSET_X = 0;
|
||||
public int ROAD_OFFSET_Z = 0;
|
||||
|
||||
public SquarePlotWorld(String worldname, String id, IndependentPlotGenerator generator, PlotId min, PlotId max) {
|
||||
super(worldname, id, generator, min, max);
|
||||
public SquarePlotWorld(String worldName, String id, IndependentPlotGenerator generator, PlotId min, PlotId max) {
|
||||
super(worldName, id, generator, min, max);
|
||||
}
|
||||
|
||||
@Override
|
||||
|
@ -81,12 +81,12 @@ public class PlotAnalysis {
|
||||
TaskManager.runTaskAsync(new Runnable() {
|
||||
@Override
|
||||
public void run() {
|
||||
Iterator<Plot> iter = plots.iterator();
|
||||
Iterator<Plot> iterator = plots.iterator();
|
||||
PS.debug(" - $1Reducing " + plots.size() + " plots to those with sufficient data");
|
||||
while (iter.hasNext()) {
|
||||
Plot plot = iter.next();
|
||||
while (iterator.hasNext()) {
|
||||
Plot plot = iterator.next();
|
||||
if (plot.getSettings().ratings == null || plot.getSettings().getRatings().isEmpty()) {
|
||||
iter.remove();
|
||||
iterator.remove();
|
||||
} else {
|
||||
plot.addRunning();
|
||||
}
|
||||
@ -393,7 +393,7 @@ public class PlotAnalysis {
|
||||
}
|
||||
|
||||
/**
|
||||
* Get correllation coefficient.
|
||||
* Get correlation coefficient.
|
||||
* @return
|
||||
*/
|
||||
public static double getCC(int n, int sum) {
|
||||
|
@ -72,8 +72,8 @@ public abstract class PlotArea {
|
||||
private ConcurrentHashMap<String, Object> meta;
|
||||
private QuadMap<PlotCluster> clusters;
|
||||
|
||||
public PlotArea(String worldname, String id, IndependentPlotGenerator generator, PlotId min, PlotId max) {
|
||||
this.worldname = worldname;
|
||||
public PlotArea(String worldName, String id, IndependentPlotGenerator generator, PlotId min, PlotId max) {
|
||||
this.worldname = worldName;
|
||||
this.id = id;
|
||||
this.manager = generator != null ? generator.getNewPlotManager() : null;
|
||||
this.generator = generator;
|
||||
@ -87,7 +87,7 @@ public abstract class PlotArea {
|
||||
this.min = min;
|
||||
this.max = max;
|
||||
}
|
||||
this.worldhash = worldname.hashCode();
|
||||
this.worldhash = worldName.hashCode();
|
||||
}
|
||||
|
||||
/**
|
||||
@ -303,7 +303,7 @@ public abstract class PlotArea {
|
||||
public abstract void loadConfiguration(ConfigurationSection config);
|
||||
|
||||
/**
|
||||
* Saving core plotarea settings
|
||||
* Saving core PlotArea settings
|
||||
*
|
||||
* @param config Configuration Section
|
||||
*/
|
||||
@ -457,16 +457,16 @@ public abstract class PlotArea {
|
||||
}
|
||||
|
||||
public Set<Plot> getPlotsAbs(final UUID uuid) {
|
||||
final HashSet<Plot> myplots = new HashSet<>();
|
||||
final HashSet<Plot> myPlots = new HashSet<>();
|
||||
foreachPlotAbs(new RunnableVal<Plot>() {
|
||||
@Override
|
||||
public void run(Plot value) {
|
||||
if (value.owner.equals(uuid)) {
|
||||
myplots.add(value);
|
||||
myPlots.add(value);
|
||||
}
|
||||
}
|
||||
});
|
||||
return myplots;
|
||||
return myPlots;
|
||||
}
|
||||
|
||||
public Set<Plot> getPlots(UUID uuid) {
|
||||
@ -595,14 +595,14 @@ public abstract class PlotArea {
|
||||
}
|
||||
|
||||
public Set<Plot> getBasePlots() {
|
||||
HashSet<Plot> myplots = new HashSet<>(getPlots());
|
||||
Iterator<Plot> iter = myplots.iterator();
|
||||
while (iter.hasNext()) {
|
||||
if (!iter.next().isBasePlot()) {
|
||||
iter.remove();
|
||||
HashSet<Plot> myPlots = new HashSet<>(getPlots());
|
||||
Iterator<Plot> iterator = myPlots.iterator();
|
||||
while (iterator.hasNext()) {
|
||||
if (!iterator.next().isBasePlot()) {
|
||||
iterator.remove();
|
||||
}
|
||||
}
|
||||
return myplots;
|
||||
return myPlots;
|
||||
}
|
||||
|
||||
public void foreachPlotAbs(RunnableVal<Plot> run) {
|
||||
|
@ -128,14 +128,14 @@ public class ExpireManager {
|
||||
}
|
||||
final Runnable task = this;
|
||||
long start = System.currentTimeMillis();
|
||||
Iterator<Plot> iter = plots.iterator();
|
||||
while (iter.hasNext() && System.currentTimeMillis() - start < 2) {
|
||||
Iterator<Plot> iterator = plots.iterator();
|
||||
while (iterator.hasNext() && System.currentTimeMillis() - start < 2) {
|
||||
if (ExpireManager.this.running != 2) {
|
||||
ExpireManager.this.running = 0;
|
||||
return;
|
||||
}
|
||||
final Plot plot = iter.next();
|
||||
iter.remove();
|
||||
final Plot plot = iterator.next();
|
||||
iterator.remove();
|
||||
if (!isExpired(plot)) {
|
||||
continue;
|
||||
}
|
||||
|
@ -277,19 +277,19 @@ public class MainUtil {
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a list of plot ids within a selection
|
||||
* Get a list of plot ids within a selection.
|
||||
* @param pos1
|
||||
* @param pos2
|
||||
* @return
|
||||
*/
|
||||
public static ArrayList<PlotId> getPlotSelectionIds(PlotId pos1, PlotId pos2) {
|
||||
ArrayList<PlotId> myplots = new ArrayList<>();
|
||||
ArrayList<PlotId> myPlots = new ArrayList<>();
|
||||
for (int x = pos1.x; x <= pos2.x; x++) {
|
||||
for (int y = pos1.y; y <= pos2.y; y++) {
|
||||
myplots.add(new PlotId(x, y));
|
||||
myPlots.add(new PlotId(x, y));
|
||||
}
|
||||
}
|
||||
return myplots;
|
||||
return myPlots;
|
||||
}
|
||||
|
||||
/**
|
||||
@ -346,7 +346,7 @@ public class MainUtil {
|
||||
}
|
||||
|
||||
/**
|
||||
* Fuzzy plot search with spaces separating terms<br>
|
||||
* Fuzzy plot search with spaces separating terms.
|
||||
* - Terms: type, alias, world, owner, trusted, member
|
||||
* @param search
|
||||
* @return
|
||||
@ -421,7 +421,7 @@ public class MainUtil {
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the plot from a string<br>
|
||||
* Get the plot from a string.
|
||||
* @param player Provides a context for what world to search in. Prefixing the term with 'world_name;' will override this context.
|
||||
* @param arg The search term
|
||||
* @param message If a message should be sent to the player if a plot cannot be found
|
||||
@ -533,13 +533,13 @@ public class MainUtil {
|
||||
* @param world
|
||||
* @param pos1
|
||||
* @param pos2
|
||||
* @param newblock
|
||||
* @param newBlock
|
||||
*/
|
||||
public static void setSimpleCuboidAsync(String world, Location pos1, Location pos2, PlotBlock newblock) {
|
||||
public static void setSimpleCuboidAsync(String world, Location pos1, Location pos2, PlotBlock newBlock) {
|
||||
for (int y = pos1.getY(); y <= Math.min(255, pos2.getY()); y++) {
|
||||
for (int x = pos1.getX(); x <= pos2.getX(); x++) {
|
||||
for (int z = pos1.getZ(); z <= pos2.getZ(); z++) {
|
||||
SetQueue.IMP.setBlock(world, x, y, z, newblock);
|
||||
SetQueue.IMP.setBlock(world, x, y, z, newBlock);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -1,30 +1,50 @@
|
||||
package com.intellectualcrafters.plot.util;
|
||||
|
||||
public class MathMan {
|
||||
public static double getMean(final int[] array) {
|
||||
|
||||
private static final int ATAN2_BITS = 7;
|
||||
private static final int ATAN2_BITS2 = ATAN2_BITS << 1;
|
||||
private static final int ATAN2_MASK = ~(-1 << ATAN2_BITS2);
|
||||
private static final int ATAN2_COUNT = ATAN2_MASK + 1;
|
||||
private static final int ATAN2_DIM = (int) Math.sqrt(ATAN2_COUNT);
|
||||
private static final float INV_ATAN2_DIM_MINUS_1 = 1.0f / (ATAN2_DIM - 1);
|
||||
private static final float[] atan2 = new float[ATAN2_COUNT];
|
||||
|
||||
static {
|
||||
for (int i = 0; i < ATAN2_DIM; i++) {
|
||||
for (int j = 0; j < ATAN2_DIM; j++) {
|
||||
float x0 = (float) i / ATAN2_DIM;
|
||||
float y0 = (float) j / ATAN2_DIM;
|
||||
|
||||
atan2[(j * ATAN2_DIM) + i] = (float) Math.atan2(y0, x0);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static double getMean(int[] array) {
|
||||
double count = 0;
|
||||
for (final int i : array) {
|
||||
for (int i : array) {
|
||||
count += i;
|
||||
}
|
||||
return count / array.length;
|
||||
}
|
||||
|
||||
public static double getMean(final double[] array) {
|
||||
|
||||
public static double getMean(double[] array) {
|
||||
double count = 0;
|
||||
for (final double i : array) {
|
||||
for (double i : array) {
|
||||
count += i;
|
||||
}
|
||||
return count / array.length;
|
||||
}
|
||||
|
||||
|
||||
public static int pair(short x, short y) {
|
||||
return (x << 16) | (y & 0xFFFF);
|
||||
}
|
||||
|
||||
|
||||
public static short unpairX(int hash) {
|
||||
return (short) (hash >> 16);
|
||||
}
|
||||
|
||||
|
||||
public static short unpairY(int hash) {
|
||||
return (short) (hash & 0xFFFF);
|
||||
}
|
||||
@ -35,15 +55,15 @@ public class MathMan {
|
||||
* @param pitch
|
||||
* @return
|
||||
*/
|
||||
public static float[] getDirection(final float yaw, final float pitch) {
|
||||
final double pitch_sin = Math.sin(pitch);
|
||||
return new float[] { (float) (pitch_sin * Math.cos(yaw)), (float) (pitch_sin * Math.sin(yaw)), (float) Math.cos(pitch) };
|
||||
public static float[] getDirection(float yaw, float pitch) {
|
||||
double pitch_sin = Math.sin(pitch);
|
||||
return new float[]{(float) (pitch_sin * Math.cos(yaw)), (float) (pitch_sin * Math.sin(yaw)), (float) Math.cos(pitch)};
|
||||
}
|
||||
|
||||
public static int roundInt(final double value) {
|
||||
|
||||
public static int roundInt(double value) {
|
||||
return (int) (value < 0 ? (value == (int) value) ? value : value - 1 : value);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns [ pitch, yaw ]
|
||||
* @param x
|
||||
@ -51,47 +71,25 @@ public class MathMan {
|
||||
* @param z
|
||||
* @return
|
||||
*/
|
||||
public static float[] getPitchAndYaw(final float x, final float y, final float z) {
|
||||
final float distance = sqrtApprox((z * z) + (x * x));
|
||||
return new float[] { atan2(y, distance), atan2(x, z) };
|
||||
public static float[] getPitchAndYaw(float x, float y, float z) {
|
||||
float distance = sqrtApprox((z * z) + (x * x));
|
||||
return new float[]{atan2(y, distance), atan2(x, z)};
|
||||
}
|
||||
|
||||
private static final int ATAN2_BITS = 7;
|
||||
|
||||
private static final int ATAN2_BITS2 = ATAN2_BITS << 1;
|
||||
private static final int ATAN2_MASK = ~(-1 << ATAN2_BITS2);
|
||||
private static final int ATAN2_COUNT = ATAN2_MASK + 1;
|
||||
private static final int ATAN2_DIM = (int) Math.sqrt(ATAN2_COUNT);
|
||||
|
||||
private static final float INV_ATAN2_DIM_MINUS_1 = 1.0f / (ATAN2_DIM - 1);
|
||||
|
||||
private static final float[] atan2 = new float[ATAN2_COUNT];
|
||||
|
||||
static {
|
||||
for (int i = 0; i < ATAN2_DIM; i++) {
|
||||
for (int j = 0; j < ATAN2_DIM; j++) {
|
||||
final float x0 = (float) i / ATAN2_DIM;
|
||||
final float y0 = (float) j / ATAN2_DIM;
|
||||
|
||||
atan2[(j * ATAN2_DIM) + i] = (float) Math.atan2(y0, x0);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
public static final float atan2(float y, float x) {
|
||||
float add, mul;
|
||||
|
||||
|
||||
if (x < 0.0f) {
|
||||
if (y < 0.0f) {
|
||||
x = -x;
|
||||
y = -y;
|
||||
|
||||
|
||||
mul = 1.0f;
|
||||
} else {
|
||||
x = -x;
|
||||
mul = -1.0f;
|
||||
}
|
||||
|
||||
|
||||
add = -3.141592653f;
|
||||
} else {
|
||||
if (y < 0.0f) {
|
||||
@ -100,47 +98,47 @@ public class MathMan {
|
||||
} else {
|
||||
mul = 1.0f;
|
||||
}
|
||||
|
||||
|
||||
add = 0.0f;
|
||||
}
|
||||
|
||||
final float invDiv = 1.0f / (((x < y) ? y : x) * INV_ATAN2_DIM_MINUS_1);
|
||||
|
||||
final int xi = (int) (x * invDiv);
|
||||
final int yi = (int) (y * invDiv);
|
||||
|
||||
|
||||
float invDiv = 1.0f / (((x < y) ? y : x) * INV_ATAN2_DIM_MINUS_1);
|
||||
|
||||
int xi = (int) (x * invDiv);
|
||||
int yi = (int) (y * invDiv);
|
||||
|
||||
return (atan2[(yi * ATAN2_DIM) + xi] + add) * mul;
|
||||
}
|
||||
|
||||
public static float sqrtApprox(final float f) {
|
||||
|
||||
public static float sqrtApprox(float f) {
|
||||
return f * Float.intBitsToFloat(0x5f375a86 - (Float.floatToIntBits(f) >> 1));
|
||||
}
|
||||
|
||||
public static double sqrtApprox(final double d) {
|
||||
|
||||
public static double sqrtApprox(double d) {
|
||||
return Double.longBitsToDouble(((Double.doubleToLongBits(d) - (1l << 52)) >> 1) + (1l << 61));
|
||||
}
|
||||
|
||||
|
||||
public static float invSqrt(float x) {
|
||||
final float xhalf = 0.5f * x;
|
||||
float xhalf = 0.5f * x;
|
||||
int i = Float.floatToIntBits(x);
|
||||
i = 0x5f3759df - (i >> 1);
|
||||
x = Float.intBitsToFloat(i);
|
||||
x = x * (1.5f - (xhalf * x * x));
|
||||
return x;
|
||||
}
|
||||
|
||||
public static int getPositiveId(final int i) {
|
||||
|
||||
public static int getPositiveId(int i) {
|
||||
if (i < 0) {
|
||||
return (-i * 2) - 1;
|
||||
}
|
||||
return i * 2;
|
||||
}
|
||||
|
||||
public static boolean isInteger(final String str) {
|
||||
|
||||
public static boolean isInteger(String str) {
|
||||
if (str == null) {
|
||||
return false;
|
||||
}
|
||||
final int length = str.length();
|
||||
int length = str.length();
|
||||
if (length == 0) {
|
||||
return false;
|
||||
}
|
||||
@ -152,45 +150,45 @@ public class MathMan {
|
||||
i = 1;
|
||||
}
|
||||
for (; i < length; i++) {
|
||||
final char c = str.charAt(i);
|
||||
char c = str.charAt(i);
|
||||
if ((c <= '/') || (c >= ':')) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
public static double getSD(final double[] array, final double av) {
|
||||
|
||||
public static double getSD(double[] array, double av) {
|
||||
double sd = 0;
|
||||
for (final double element : array) {
|
||||
for (double element : array) {
|
||||
sd += Math.pow(Math.abs(element - av), 2);
|
||||
}
|
||||
return Math.sqrt(sd / array.length);
|
||||
}
|
||||
|
||||
public static double getSD(final int[] array, final double av) {
|
||||
|
||||
public static double getSD(int[] array, double av) {
|
||||
double sd = 0;
|
||||
for (final int element : array) {
|
||||
for (int element : array) {
|
||||
sd += Math.pow(Math.abs(element - av), 2);
|
||||
}
|
||||
return Math.sqrt(sd / array.length);
|
||||
}
|
||||
|
||||
public static int mod(final int x, final int y) {
|
||||
|
||||
public static int mod(int x, int y) {
|
||||
if (isPowerOfTwo(y)) {
|
||||
return x & (y - 1);
|
||||
}
|
||||
return x % y;
|
||||
}
|
||||
|
||||
public static int unsignedmod(final int x, final int y) {
|
||||
|
||||
public static int unsignedmod(int x, int y) {
|
||||
if (isPowerOfTwo(y)) {
|
||||
return x & (y - 1);
|
||||
}
|
||||
return x % y;
|
||||
}
|
||||
|
||||
public static boolean isPowerOfTwo(final int x) {
|
||||
|
||||
public static boolean isPowerOfTwo(int x) {
|
||||
return (x & (x - 1)) == 0;
|
||||
}
|
||||
}
|
||||
|
@ -162,10 +162,10 @@ public abstract class SchematicHandler {
|
||||
}
|
||||
}
|
||||
|
||||
Dimension demensions = schematic.getSchematicDimension();
|
||||
final int WIDTH = demensions.getX();
|
||||
final int LENGTH = demensions.getZ();
|
||||
final int HEIGHT = demensions.getY();
|
||||
Dimension dimension = schematic.getSchematicDimension();
|
||||
final int WIDTH = dimension.getX();
|
||||
final int LENGTH = dimension.getZ();
|
||||
final int HEIGHT = dimension.getY();
|
||||
// Validate dimensions
|
||||
RegionWrapper region = plot.getLargestRegion();
|
||||
if (((region.maxX - region.minX + xOffset + 1) < WIDTH) || ((region.maxZ - region.minZ + zOffset + 1) < LENGTH) || (HEIGHT
|
||||
@ -468,8 +468,8 @@ public abstract class SchematicHandler {
|
||||
}
|
||||
return schem;
|
||||
}
|
||||
|
||||
public abstract void restoreTag(CompoundTag ct, short x, short y, short z, Schematic schem);
|
||||
|
||||
public abstract void restoreTag(CompoundTag ct, short x, short y, short z, Schematic schematic);
|
||||
|
||||
/**
|
||||
* Get a schematic
|
||||
@ -616,11 +616,11 @@ public abstract class SchematicHandler {
|
||||
* Create a compound tag from blocks
|
||||
* - Untested
|
||||
* @param blocks
|
||||
* @param blockdata
|
||||
* @param blockData
|
||||
* @param dimension
|
||||
* @return
|
||||
*/
|
||||
public CompoundTag createTag(byte[] blocks, byte[] blockdata, Dimension dimension) {
|
||||
public CompoundTag createTag(byte[] blocks, byte[] blockData, Dimension dimension) {
|
||||
HashMap<String, Tag> schematic = new HashMap<>();
|
||||
schematic.put("Width", new ShortTag("Width", (short) dimension.getX()));
|
||||
schematic.put("Length", new ShortTag("Length", (short) dimension.getZ()));
|
||||
@ -633,7 +633,7 @@ public abstract class SchematicHandler {
|
||||
schematic.put("WEOffsetY", new IntTag("WEOffsetY", 0));
|
||||
schematic.put("WEOffsetZ", new IntTag("WEOffsetZ", 0));
|
||||
schematic.put("Blocks", new ByteArrayTag("Blocks", blocks));
|
||||
schematic.put("Data", new ByteArrayTag("Data", blockdata));
|
||||
schematic.put("Data", new ByteArrayTag("Data", blockData));
|
||||
schematic.put("Entities", new ListTag("Entities", CompoundTag.class, new ArrayList<Tag>()));
|
||||
schematic.put("TileEntities", new ListTag("TileEntities", CompoundTag.class, new ArrayList<Tag>()));
|
||||
return new CompoundTag("Schematic", schematic);
|
||||
|
@ -42,21 +42,6 @@ public class StringMan {
|
||||
return count;
|
||||
}
|
||||
|
||||
public Collection match(Collection col, String startsWith) {
|
||||
if (col == null) {
|
||||
return null;
|
||||
}
|
||||
startsWith = startsWith.toLowerCase();
|
||||
Iterator iter = col.iterator();
|
||||
while (iter.hasNext()) {
|
||||
Object item = iter.next();
|
||||
if (item == null || !item.toString().toLowerCase().startsWith(startsWith)) {
|
||||
iter.remove();
|
||||
}
|
||||
}
|
||||
return col;
|
||||
}
|
||||
|
||||
public static String getString(Object obj) {
|
||||
if (obj == null) {
|
||||
return "null";
|
||||
@ -279,4 +264,19 @@ public class StringMan {
|
||||
}
|
||||
return sb.toString();
|
||||
}
|
||||
|
||||
public Collection match(Collection col, String startsWith) {
|
||||
if (col == null) {
|
||||
return null;
|
||||
}
|
||||
startsWith = startsWith.toLowerCase();
|
||||
Iterator iterator = col.iterator();
|
||||
while (iterator.hasNext()) {
|
||||
Object item = iterator.next();
|
||||
if (item == null || !item.toString().toLowerCase().startsWith(startsWith)) {
|
||||
iterator.remove();
|
||||
}
|
||||
}
|
||||
return col;
|
||||
}
|
||||
}
|
||||
|
@ -88,14 +88,14 @@ public abstract class TaskManager {
|
||||
* @param whenDone
|
||||
*/
|
||||
public static <T> void objectTask(Collection<T> objects, final RunnableVal<T> task, final Runnable whenDone) {
|
||||
final Iterator<T> iter = objects.iterator();
|
||||
final Iterator<T> iterator = objects.iterator();
|
||||
TaskManager.runTask(new Runnable() {
|
||||
@Override
|
||||
public void run() {
|
||||
long start = System.currentTimeMillis();
|
||||
boolean hasNext;
|
||||
while ((hasNext = iter.hasNext()) && System.currentTimeMillis() - start < 5) {
|
||||
task.value = iter.next();
|
||||
while ((hasNext = iterator.hasNext()) && System.currentTimeMillis() - start < 5) {
|
||||
task.value = iterator.next();
|
||||
task.run();
|
||||
}
|
||||
if (!hasNext) {
|
||||
|
@ -26,7 +26,7 @@ public abstract class WorldUtil {
|
||||
|
||||
public abstract String getMainWorld();
|
||||
|
||||
public abstract boolean isWorld(String worldname);
|
||||
public abstract boolean isWorld(String worldName);
|
||||
|
||||
public abstract String[] getSign(Location location);
|
||||
|
||||
|
@ -14,6 +14,7 @@ import com.intellectualcrafters.plot.util.MathMan;
|
||||
import com.intellectualcrafters.plot.util.Permissions;
|
||||
import com.intellectualcrafters.plot.util.StringComparison;
|
||||
import com.intellectualcrafters.plot.util.StringMan;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.lang.annotation.Annotation;
|
||||
import java.lang.reflect.InvocationTargetException;
|
||||
@ -101,8 +102,8 @@ public abstract class Command {
|
||||
}
|
||||
|
||||
public String getFullId() {
|
||||
if (parent != null && parent.getParent() != null) {
|
||||
return parent.getFullId() + "." + id;
|
||||
if (this.parent != null && this.parent.getParent() != null) {
|
||||
return this.parent.getFullId() + "." + this.id;
|
||||
}
|
||||
return this.id;
|
||||
}
|
||||
@ -118,16 +119,16 @@ public abstract class Command {
|
||||
}
|
||||
|
||||
public List<Command> getCommands(CommandCategory cat, PlotPlayer player) {
|
||||
List<Command> cmds = getCommands(player);
|
||||
List<Command> commands = getCommands(player);
|
||||
if (cat != null) {
|
||||
Iterator<Command> iter = cmds.iterator();
|
||||
while (iter.hasNext()) {
|
||||
if (iter.next().category != cat) {
|
||||
iter.remove();
|
||||
Iterator<Command> iterator = commands.iterator();
|
||||
while (iterator.hasNext()) {
|
||||
if (iterator.next().category != cat) {
|
||||
iterator.remove();
|
||||
}
|
||||
}
|
||||
}
|
||||
return cmds;
|
||||
return commands;
|
||||
}
|
||||
|
||||
public List<Command> getCommands() {
|
||||
@ -302,8 +303,8 @@ public abstract class Command {
|
||||
// Command recommendation
|
||||
MainUtil.sendMessage(player, C.NOT_VALID_SUBCOMMAND);
|
||||
{
|
||||
List<Command> cmds = getCommands(player);
|
||||
if (cmds.isEmpty()) {
|
||||
List<Command> commands = getCommands(player);
|
||||
if (commands.isEmpty()) {
|
||||
MainUtil.sendMessage(player, C.DID_YOU_MEAN, MainCommand.getInstance().help.getUsage());
|
||||
return;
|
||||
}
|
||||
@ -313,7 +314,7 @@ public abstract class Command {
|
||||
}
|
||||
String[] allargs = setargs.toArray(new String[setargs.size()]);
|
||||
int best = 0;
|
||||
for (Command current : cmds) {
|
||||
for (Command current : commands) {
|
||||
int match = getMatch(allargs, current);
|
||||
if (match > best) {
|
||||
cmd = current;
|
||||
|
Reference in New Issue
Block a user