426 lines
11 KiB
Java
426 lines
11 KiB
Java
/*
|
|
* $Header: Util.java, 21/10/2005 23:17:40 luisantonioa Exp $
|
|
*
|
|
* $Author: luisantonioa $
|
|
* $Date: 21/10/2005 23:17:40 $
|
|
* $Revision: 1 $
|
|
* $Log: Util.java,v $
|
|
* Revision 1 21/10/2005 23:17:40 luisantonioa
|
|
* Added copyright notice
|
|
*
|
|
*
|
|
* 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, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
package com.l2jserver.gameserver.util;
|
|
|
|
import java.io.File;
|
|
|
|
import javolution.text.TextBuilder;
|
|
|
|
import com.l2jserver.gameserver.ThreadPoolManager;
|
|
import com.l2jserver.gameserver.model.L2Object;
|
|
import com.l2jserver.gameserver.model.actor.L2Character;
|
|
import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
|
|
|
|
/**
|
|
* General Utility functions related to Gameserver
|
|
*/
|
|
public final class Util
|
|
{
|
|
public static void handleIllegalPlayerAction(L2PcInstance actor, String message, int punishment)
|
|
{
|
|
ThreadPoolManager.getInstance().scheduleGeneral(new IllegalPlayerAction(actor, message, punishment), 5000);
|
|
}
|
|
|
|
public static String getRelativePath(File base, File file)
|
|
{
|
|
return file.toURI().getPath().substring(base.toURI().getPath().length());
|
|
}
|
|
|
|
/**
|
|
* Return degree value of object 2 to the horizontal line with object 1 being the origin
|
|
*/
|
|
public static double calculateAngleFrom(L2Object obj1, L2Object obj2)
|
|
{
|
|
return calculateAngleFrom(obj1.getX(), obj1.getY(), obj2.getX(), obj2.getY());
|
|
}
|
|
|
|
/**
|
|
* Return degree value of object 2 to the horizontal line with object 1 being the origin
|
|
*/
|
|
public final static double calculateAngleFrom(int obj1X, int obj1Y, int obj2X, int obj2Y)
|
|
{
|
|
double angleTarget = Math.toDegrees(Math.atan2(obj2Y - obj1Y, obj2X - obj1X));
|
|
if (angleTarget < 0)
|
|
{
|
|
angleTarget = 360 + angleTarget;
|
|
}
|
|
return angleTarget;
|
|
}
|
|
|
|
public final static double convertHeadingToDegree(int clientHeading)
|
|
{
|
|
double degree = clientHeading / 182.044444444;
|
|
return degree;
|
|
}
|
|
|
|
public final static int convertDegreeToClientHeading(double degree)
|
|
{
|
|
if (degree < 0)
|
|
{
|
|
degree = 360 + degree;
|
|
}
|
|
return (int) (degree * 182.044444444);
|
|
}
|
|
|
|
public final static int calculateHeadingFrom(L2Object obj1, L2Object obj2)
|
|
{
|
|
return calculateHeadingFrom(obj1.getX(), obj1.getY(), obj2.getX(), obj2.getY());
|
|
}
|
|
|
|
public final static int calculateHeadingFrom(int obj1X, int obj1Y, int obj2X, int obj2Y)
|
|
{
|
|
double angleTarget = Math.toDegrees(Math.atan2(obj2Y - obj1Y, obj2X - obj1X));
|
|
if (angleTarget < 0)
|
|
{
|
|
angleTarget = 360 + angleTarget;
|
|
}
|
|
return (int) (angleTarget * 182.044444444);
|
|
}
|
|
|
|
public final static int calculateHeadingFrom(double dx, double dy)
|
|
{
|
|
double angleTarget = Math.toDegrees(Math.atan2(dy, dx));
|
|
if (angleTarget < 0)
|
|
{
|
|
angleTarget = 360 + angleTarget;
|
|
}
|
|
return (int) (angleTarget * 182.044444444);
|
|
}
|
|
|
|
/**
|
|
* @return the distance between the two coordinates in 2D plane
|
|
*/
|
|
public static double calculateDistance(int x1, int y1, int x2, int y2)
|
|
{
|
|
return calculateDistance(x1, y1, 0, x2, y2, 0, false);
|
|
}
|
|
|
|
/**
|
|
* @param includeZAxis - if true, includes also the Z axis in the calculation
|
|
* @return the distance between the two coordinates
|
|
*/
|
|
public static double calculateDistance(int x1, int y1, int z1, int x2, int y2, int z2, boolean includeZAxis)
|
|
{
|
|
double dx = (double) x1 - x2;
|
|
double dy = (double) y1 - y2;
|
|
|
|
if (includeZAxis)
|
|
{
|
|
double dz = z1 - z2;
|
|
return Math.sqrt((dx * dx) + (dy * dy) + (dz * dz));
|
|
}
|
|
return Math.sqrt((dx * dx) + (dy * dy));
|
|
}
|
|
|
|
/**
|
|
* @param includeZAxis - if true, includes also the Z axis in the calculation
|
|
* @return the distance between the two objects
|
|
*/
|
|
public static double calculateDistance(L2Object obj1, L2Object obj2, boolean includeZAxis)
|
|
{
|
|
if ((obj1 == null) || (obj2 == null))
|
|
{
|
|
return 1000000;
|
|
}
|
|
|
|
return calculateDistance(obj1.getPosition().getX(), obj1.getPosition().getY(), obj1.getPosition().getZ(), obj2.getPosition().getX(), obj2.getPosition().getY(), obj2.getPosition().getZ(), includeZAxis);
|
|
}
|
|
|
|
/**
|
|
* @param str - the string whose first letter to capitalize
|
|
* @return a string with the first letter of the {@code str} capitalized
|
|
*/
|
|
public static String capitalizeFirst(String str)
|
|
{
|
|
if ((str == null) || str.isEmpty())
|
|
{
|
|
return str;
|
|
}
|
|
|
|
final char[] arr = str.toCharArray();
|
|
final char c = arr[0];
|
|
|
|
if (Character.isLetter(c))
|
|
{
|
|
arr[0] = Character.toUpperCase(c);
|
|
}
|
|
|
|
return arr.toString();
|
|
}
|
|
|
|
/**
|
|
* (Based on ucwords() function of PHP) DrHouse: still functional but must be rewritten to avoid += to concat strings
|
|
* @param str - the string to capitalize
|
|
* @return a string with the first letter of every word in {@code str} capitalized
|
|
*/
|
|
@Deprecated
|
|
public static String capitalizeWords(String str)
|
|
{
|
|
if ((str == null) || str.isEmpty())
|
|
{
|
|
return str;
|
|
}
|
|
|
|
char[] charArray = str.toCharArray();
|
|
String result = "";
|
|
|
|
// Capitalize the first letter in the given string!
|
|
charArray[0] = Character.toUpperCase(charArray[0]);
|
|
|
|
for (int i = 0; i < charArray.length; i++)
|
|
{
|
|
if (Character.isWhitespace(charArray[i]))
|
|
{
|
|
charArray[i + 1] = Character.toUpperCase(charArray[i + 1]);
|
|
}
|
|
|
|
result += Character.toString(charArray[i]);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* @return {@code true} if the two objects are within specified range between each other, {@code false} otherwise
|
|
*/
|
|
public static boolean checkIfInRange(int range, L2Object obj1, L2Object obj2, boolean includeZAxis)
|
|
{
|
|
if ((obj1 == null) || (obj2 == null))
|
|
{
|
|
return false;
|
|
}
|
|
if (obj1.getInstanceId() != obj2.getInstanceId())
|
|
{
|
|
return false;
|
|
}
|
|
if (range == -1)
|
|
{
|
|
return true; // not limited
|
|
}
|
|
|
|
int rad = 0;
|
|
if (obj1 instanceof L2Character)
|
|
{
|
|
rad += ((L2Character) obj1).getTemplate().collisionRadius;
|
|
}
|
|
if (obj2 instanceof L2Character)
|
|
{
|
|
rad += ((L2Character) obj2).getTemplate().collisionRadius;
|
|
}
|
|
|
|
double dx = obj1.getX() - obj2.getX();
|
|
double dy = obj1.getY() - obj2.getY();
|
|
|
|
if (includeZAxis)
|
|
{
|
|
double dz = obj1.getZ() - obj2.getZ();
|
|
double d = (dx * dx) + (dy * dy) + (dz * dz);
|
|
|
|
return d <= ((range * range) + (2 * range * rad) + (rad * rad));
|
|
}
|
|
double d = (dx * dx) + (dy * dy);
|
|
|
|
return d <= ((range * range) + (2 * range * rad) + (rad * rad));
|
|
}
|
|
|
|
/**
|
|
* Checks if object is within short (sqrt(int.max_value)) radius, not using collisionRadius. Faster calculation than checkIfInRange if distance is short and collisionRadius isn't needed. Not for long distance checks (potential teleports, far away castles etc).
|
|
* @param range - the maximum range between the two objects
|
|
* @param includeZAxis - if true, check also Z axis (3-dimensional check), otherwise only 2D
|
|
* @return {@code true} if objects are within specified range between each other, {@code false} otherwise
|
|
*/
|
|
public static boolean checkIfInShortRadius(int radius, L2Object obj1, L2Object obj2, boolean includeZAxis)
|
|
{
|
|
if ((obj1 == null) || (obj2 == null))
|
|
{
|
|
return false;
|
|
}
|
|
if (radius == -1)
|
|
{
|
|
return true; // not limited
|
|
}
|
|
|
|
int dx = obj1.getX() - obj2.getX();
|
|
int dy = obj1.getY() - obj2.getY();
|
|
|
|
if (includeZAxis)
|
|
{
|
|
int dz = obj1.getZ() - obj2.getZ();
|
|
return ((dx * dx) + (dy * dy) + (dz * dz)) <= (radius * radius);
|
|
}
|
|
return ((dx * dx) + (dy * dy)) <= (radius * radius);
|
|
}
|
|
|
|
/**
|
|
* @param str - the String to count
|
|
* @return the number of "words" in a given string.
|
|
*/
|
|
public static int countWords(String str)
|
|
{
|
|
return str.trim().split("\\s+").length;
|
|
}
|
|
|
|
/**
|
|
* (Based on implode() in PHP)
|
|
* @param strArray - an array of strings to concatenate
|
|
* @param strDelim - the delimiter to put between the strings
|
|
* @return a delimited string for a given array of string elements.
|
|
*/
|
|
public static String implodeString(Iterable<String> strArray, String strDelim)
|
|
{
|
|
final TextBuilder sbString = TextBuilder.newInstance();
|
|
|
|
for (String strValue : strArray)
|
|
{
|
|
sbString.append(strValue);
|
|
sbString.append(strDelim);
|
|
}
|
|
|
|
String result = sbString.toString();
|
|
TextBuilder.recycle(sbString);
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* (Based on round() in PHP)
|
|
* @param number - the number to round
|
|
* @param numPlaces - how many digits after decimal point to leave intact
|
|
* @return the value of {@code number} rounded to specified number of digits after the decimal point.
|
|
*/
|
|
public static float roundTo(float number, int numPlaces)
|
|
{
|
|
if (numPlaces <= 1)
|
|
{
|
|
return Math.round(number);
|
|
}
|
|
|
|
float exponent = (float) Math.pow(10, numPlaces);
|
|
|
|
return Math.round(number * exponent) / exponent;
|
|
}
|
|
|
|
/**
|
|
* @param text - the text to check
|
|
* @return {@code true} if {@code text} contains only numbers, {@code false} otherwise
|
|
*/
|
|
public static boolean isDigit(String text)
|
|
{
|
|
if ((text == null) || text.isEmpty())
|
|
{
|
|
return false;
|
|
}
|
|
for (char c : text.toCharArray())
|
|
{
|
|
if (!Character.isDigit(c))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* @param text - the text to check
|
|
* @return {@code true} if {@code text} contains only letters and/or numbers, {@code false} otherwise
|
|
*/
|
|
public static boolean isAlphaNumeric(String text)
|
|
{
|
|
if ((text == null) || text.isEmpty())
|
|
{
|
|
return false;
|
|
}
|
|
for (char c : text.toCharArray())
|
|
{
|
|
if (!Character.isLetterOrDigit(c))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Format the specified digit using the digit grouping symbol "," (comma). For example, 123456789 becomes 123,456,789.
|
|
* @param amount - the amount of adena
|
|
* @return the formatted adena amount
|
|
*/
|
|
public static String formatAdena(long amount)
|
|
{
|
|
String s = "";
|
|
long rem = amount % 1000;
|
|
s = Long.toString(rem);
|
|
amount = (amount - rem) / 1000;
|
|
while (amount > 0)
|
|
{
|
|
if (rem < 99)
|
|
{
|
|
s = '0' + s;
|
|
}
|
|
if (rem < 9)
|
|
{
|
|
s = '0' + s;
|
|
}
|
|
rem = amount % 1000;
|
|
s = Long.toString(rem) + "," + s;
|
|
amount = (amount - rem) / 1000;
|
|
}
|
|
return s;
|
|
}
|
|
|
|
/**
|
|
* @param array - the array to look into
|
|
* @param obj - the object to search for
|
|
* @return {@code true} if the {@code array} contains the {@code obj}, {@code false} otherwise
|
|
*/
|
|
public static <T> boolean contains(T[] array, T obj)
|
|
{
|
|
for (T element : array)
|
|
{
|
|
if (element == obj)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* @param array - the array to look into
|
|
* @param obj - the integer to search for
|
|
* @return {@code true} if the {@code array} contains the {@code obj}, {@code false} otherwise
|
|
*/
|
|
public static boolean contains(int[] array, int obj)
|
|
{
|
|
for (int element : array)
|
|
{
|
|
if (element == obj)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
}
|