Guest User

Untitled

a guest
Jan 2nd, 2017
188
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 7.87 KB | None | 0 0
  1. package com.l2jfrozen.gameserver.util;
  2.  
  3. import com.l2jfrozen.gameserver.model.L2Character;
  4. import com.l2jfrozen.gameserver.model.L2Object;
  5. import com.l2jfrozen.gameserver.model.actor.instance.L2NpcInstance;
  6. import com.l2jfrozen.gameserver.model.actor.instance.L2PcInstance;
  7. import com.l2jfrozen.gameserver.model.actor.position.ObjectPosition;
  8. import com.l2jfrozen.gameserver.templates.L2CharTemplate;
  9. import com.l2jfrozen.gameserver.thread.ThreadPoolManager;
  10. import com.l2jfrozen.gameserver.util.IllegalPlayerAction;
  11. import java.io.File;
  12. import java.net.URI;
  13. import java.util.Collection;
  14. import java.util.Date;
  15. import java.util.concurrent.ScheduledFuture;
  16.  
  17. public final class Util {
  18. public static void handleIllegalPlayerAction(L2PcInstance actor, String message, int punishment) {
  19. ThreadPoolManager.getInstance().scheduleGeneral((Runnable)new IllegalPlayerAction(actor, message, punishment), 5000);
  20. }
  21.  
  22. public static String getRelativePath(File base, File file) {
  23. return file.toURI().getPath().substring(base.toURI().getPath().length());
  24. }
  25.  
  26. public static double calculateAngleFrom(L2Object obj1, L2Object obj2) {
  27. return Util.calculateAngleFrom(obj1.getX(), obj1.getY(), obj2.getX(), obj2.getY());
  28. }
  29.  
  30. public static double calculateAngleFrom(int obj1X, int obj1Y, int obj2X, int obj2Y) {
  31. double angleTarget = Math.toDegrees(Math.atan2(obj1Y - obj2Y, obj1X - obj2X));
  32. if (angleTarget <= 0.0) {
  33. angleTarget += 360.0;
  34. }
  35. return angleTarget;
  36. }
  37.  
  38. public static double calculateDistance(int x1, int y1, int z1, int x2, int y2) {
  39. return Util.calculateDistance(x1, y1, 0, x2, y2, 0, false);
  40. }
  41.  
  42. public static double calculateDistance(int x1, int y1, int z1, int x2, int y2, int z2, boolean includeZAxis) {
  43. double dx = (double)x1 - (double)x2;
  44. double dy = (double)y1 - (double)y2;
  45. if (includeZAxis) {
  46. double dz = z1 - z2;
  47. return Math.sqrt(dx * dx + dy * dy + dz * dz);
  48. }
  49. return Math.sqrt(dx * dx + dy * dy);
  50. }
  51.  
  52. public static double calculateDistance(L2Object obj1, L2Object obj2, boolean includeZAxis) {
  53. if (obj1 == null || obj2 == null) {
  54. return 1000000.0;
  55. }
  56. return Util.calculateDistance(obj1.getPosition().getX(), obj1.getPosition().getY(), obj1.getPosition().getZ(), obj2.getPosition().getX(), obj2.getPosition().getY(), obj2.getPosition().getZ(), includeZAxis);
  57. }
  58.  
  59. public static String capitalizeFirst(String str) {
  60. if ((str = str.trim()).length() > 0 && Character.isLetter(str.charAt(0))) {
  61. return str.substring(0, 1).toUpperCase() + str.substring(1);
  62. }
  63. return str;
  64. }
  65.  
  66. public static String capitalizeWords(String str) {
  67. char[] charArray = str.toCharArray();
  68. String result = "";
  69. charArray[0] = Character.toUpperCase(charArray[0]);
  70. for (int i = 0; i < charArray.length; ++i) {
  71. if (Character.isWhitespace(charArray[i])) {
  72. charArray[i + 1] = Character.toUpperCase(charArray[i + 1]);
  73. }
  74. result = result + Character.toString(charArray[i]);
  75. }
  76. return result;
  77. }
  78.  
  79. public static boolean checkIfInRange(int range, L2Object obj1, L2Object obj2, boolean includeZAxis) {
  80. if (obj1 == null || obj2 == null) {
  81. return false;
  82. }
  83. if (range == -1) {
  84. return true;
  85. }
  86. int rad = 0;
  87. if (obj1 instanceof L2Character) {
  88. rad += ((L2Character)obj1).getTemplate().collisionRadius;
  89. }
  90. if (obj2 instanceof L2Character) {
  91. rad += ((L2Character)obj2).getTemplate().collisionRadius;
  92. }
  93. double dx = obj1.getX() - obj2.getX();
  94. double dy = obj1.getY() - obj2.getY();
  95. if (includeZAxis) {
  96. double dz = obj1.getZ() - obj2.getZ();
  97. double d = dx * dx + dy * dy + dz * dz;
  98. return d <= (double)(range * range + 2 * range * rad + rad * rad);
  99. }
  100. double d = dx * dx + dy * dy;
  101. return d <= (double)(range * range + 2 * range * rad + rad * rad);
  102. }
  103.  
  104. public static double convertHeadingToDegree(int heading) {
  105. if (heading == 0) {
  106. return 360.0;
  107. }
  108. return 9.0 * (double)heading / 1610.0;
  109. }
  110.  
  111. public static int countWords(String str) {
  112. return str.trim().split(" ").length;
  113. }
  114.  
  115. public static String implodeString(String[] strArray, String strDelim) {
  116. String result = "";
  117. for (String strValue : strArray) {
  118. result = result + strValue + strDelim;
  119. }
  120. return result;
  121. }
  122.  
  123. public static String implodeString(Collection<String> strCollection, String strDelim) {
  124. return Util.implodeString(strCollection.toArray(new String[strCollection.size()]), strDelim);
  125. }
  126.  
  127. public static float roundTo(float val, int numPlaces) {
  128. if (numPlaces <= 1) {
  129. return Math.round(val);
  130. }
  131. float exponent = (float)Math.pow(10.0, numPlaces);
  132. return (float)Math.round(val * exponent) / exponent;
  133. }
  134.  
  135. public static boolean isAlphaNumeric(String text) {
  136. char[] chars;
  137. boolean result = true;
  138. for (char aChar : chars = text.toCharArray()) {
  139. if (Character.isLetterOrDigit(aChar)) continue;
  140. result = false;
  141. break;
  142. }
  143. return result;
  144. }
  145.  
  146. public static String formatAdena(int amount) {
  147. String s = "";
  148. int rem = amount % 1000;
  149. s = Integer.toString(rem);
  150. amount = (amount - rem) / 1000;
  151. while (amount > 0) {
  152. if (rem < 99) {
  153. s = "" + '0' + s;
  154. }
  155. if (rem < 9) {
  156. s = "" + '0' + s;
  157. }
  158. rem = amount % 1000;
  159. s = Integer.toString(rem) + "," + s;
  160. amount = (amount - rem) / 1000;
  161. }
  162. return s;
  163. }
  164.  
  165. public static String reverseColor(String color) {
  166. char[] ch1 = color.toCharArray();
  167. char[] ch2 = new char[]{ch1[4], ch1[5], ch1[2], ch1[3], ch1[0], ch1[1]};
  168. return new String(ch2);
  169. }
  170.  
  171. public static int convertMinutesToMiliseconds(int minutesToConvert) {
  172. return minutesToConvert * 60000;
  173. }
  174.  
  175. public static int calculateHeadingFrom(L2Object obj1, L2Object obj2) {
  176. return Util.calculateHeadingFrom(obj1.getX(), obj1.getY(), obj2.getX(), obj2.getY());
  177. }
  178.  
  179. public static int calculateHeadingFrom(int obj1X, int obj1Y, int obj2X, int obj2Y) {
  180. return (int)(Math.atan2(obj1Y - obj2Y, obj1X - obj2X) * 10430.38 + 32768.0);
  181. }
  182.  
  183. public static final int calculateHeadingFrom(double dx, double dy) {
  184. double angleTarget = Math.toDegrees(Math.atan2(dy, dx));
  185. if (angleTarget < 0.0) {
  186. angleTarget = 360.0 + angleTarget;
  187. }
  188. return (int)(angleTarget * 182.044444444);
  189. }
  190.  
  191. public static int calcCameraAngle(int heading) {
  192. int angle = heading == 0 ? 360 : (int)((double)heading / 182.04);
  193. if (angle <= 90) {
  194. angle += 90;
  195. } else if (angle > 90 && angle <= 180) {
  196. angle -= 90;
  197. } else if (angle > 180 && angle <= 270) {
  198. angle += 90;
  199. } else if (angle > 270 && angle <= 360) {
  200. angle -= 90;
  201. }
  202. return angle;
  203. }
  204.  
  205. public static int calcCameraAngle(L2NpcInstance target) {
  206. return Util.calcCameraAngle(target.getHeading());
  207. }
  208.  
  209. public static boolean contains(int[] array, int obj) {
  210. for (int anArray : array) {
  211. if (anArray != obj) continue;
  212. return true;
  213. }
  214. return false;
  215. }
  216.  
  217. public static String formatDate(Date date, String string) {
  218. return null;
  219. }
  220. }
Advertisement
Add Comment
Please, Sign In to add comment