package org.moparscape.msc.config;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

import org.moparscape.msc.gs.external.EntityHandler;
import org.moparscape.msc.gs.external.FiremakingDef;
import org.moparscape.msc.gs.external.GameObjectLoc;
import org.moparscape.msc.gs.external.ItemLoc;
import org.moparscape.msc.gs.external.NPCLoc;
import org.moparscape.msc.gs.external.ObjectFishDef;
import org.moparscape.msc.gs.external.ObjectMiningDef;
import org.moparscape.msc.gs.external.ObjectWoodcuttingDef;
import org.moparscape.msc.gs.external.SpellDef;
import org.moparscape.msc.gs.model.Entity;
import org.moparscape.msc.gs.model.GameObject;
import org.moparscape.msc.gs.model.InvItem;
import org.moparscape.msc.gs.model.Mob;
import org.moparscape.msc.gs.model.Npc;
import org.moparscape.msc.gs.model.Player;
import org.moparscape.msc.gs.model.Point;
import org.moparscape.msc.gs.model.Shop;
import org.moparscape.msc.gs.tools.DataConversions;

public class Formulae {
	public static final Point[] noremoveTiles = { new Point(341, 487),
			new Point(343, 581), new Point(92, 649), new Point(434, 682),
			new Point(660, 551), new Point(196, 3266), new Point(59, 573),
			new Point(560, 472), new Point(140, 180), new Point(285, 195),
			new Point(243, 178), new Point(394, 851), new Point(388, 851),
			new Point(512, 550) };
	public static final int[] arrowIDs = { 723, 647, 646, 645, 644, 643, 642,
			641, 640, 639, 638, 574, 11 };
	public static final int[] bodySprites = { 2, 5 };
	public static final int[] boltIDs = { 786, 592, 190 };
	public static final int[] bowIDs = { 188, 189, 648, 649, 650, 651, 652,
			653, 654, 655, 656, 657 };
	// spell
	public static final int[] experienceArray = { 83, 174, 276, 388, 512, 650,
			801, 969, 1154, 1358, 1584, 1833, 2107, 2411, 2746, 3115, 3523,
			3973, 4470, 5018, 5624, 6291, 7028, 7842, 8740, 9730, 10824, 12031,
			13363, 14833, 16456, 18247, 20224, 22406, 24815, 27473, 30408,
			33648, 37224, 41171, 45529, 50339, 55649, 61512, 67983, 75127,
			83014, 91721, 101333, 111945, 123660, 136594, 150872, 166636,
			184040, 203254, 224466, 247886, 273742, 302288, 333804, 368599,
			407015, 449428, 496254, 547953, 605032, 668051, 737627, 814445,
			899257, 992895, 1096278, 1210421, 1336443, 1475581, 1629200,
			1798808, 1986068, 2192818, 2421087, 2673114, 2951373, 3258594,
			3597792, 3972294, 4385776, 4842295, 5346332, 5902831, 6517253,
			7195629, 7944614, 8771558, 9684577, 10692629, 11805606, 13034431,
			14391160 };
	public static final int[] headSprites = { 1, 4, 6, 7, 8 };
	public static final int[] miningAxeIDs = { 1262, 1261, 1260, 1259, 1258,
			156 };
	public static final int[] miningAxeLvls = { 41, 31, 21, 6, 1, 1 };

	/**
	 * Cubic P2P boundaries. MinX, MinY - MaxX, MaxY
	 */
	public static final java.awt.Point[][] F2PWILD_LOCS = { {
			new java.awt.Point(48, 96), new java.awt.Point(335, 142) } };
	public static final java.awt.Point[][] P2P_LOCS = {
			{ new java.awt.Point(436, 432), new java.awt.Point(719, 906) },
			{ new java.awt.Point(48, 96), new java.awt.Point(335, 142) },
			{ new java.awt.Point(343, 567), new java.awt.Point(457, 432) },
			{ new java.awt.Point(203, 3206), new java.awt.Point(233, 3265) },
			{ new java.awt.Point(397, 525), new java.awt.Point(441, 579), },
			{ new java.awt.Point(431, 0), new java.awt.Point(1007, 1007) } };
	public static final int[] potions1Dose = { 224, 476, 479, 482, 485, 488,
			491, 494, 497, 500, 568, 571 };
	public static final int[] potions2Dose = { 223, 475, 478, 481, 484, 487,
			490, 493, 496, 499, 567, 570 };
	public static final int[] potions3Dose = { 222, 474, 477, 480, 483, 486,
			489, 492, 495, 498, 566, 569 };
	public static final int[] potionsUnfinished = { 454, 455, 456, 457, 458,
			459, 460, 461, 462, 463 };

	private static Random r = new Random();
	public static final int[] runeIDs = { 31, 32, 33, 34, 35, 36, 37, 38, 40,
			41, 42, 46, 619, 825 };
	/**
	 * Safe packets:<br>
	 * PlayerAppearanceUpdater<br>
	 * FollowRequest<br>
	 * InvUseOnItem<br>
	 */
	public static final int[] safePacketIDs = { 70, 123, 128, 255 };
	public static final String[] statArray = { "attack", "defense", "strength",
			"hits", "ranged", "prayer", "magic", "cooking", "woodcut",
			"fletching", "fishing", "firemaking", "crafting", "smithing",
			"mining", "herblaw", "agility", "thieving" };

	public static final int[] woodcuttingAxeIDs = { 405, 204, 203, 428, 88, 12,
			87 };

	public static final int[] xbowIDs = { 59, 60 };

	public static ArrayList<Point> dray2edge = new ArrayList<Point>();
	/**
	 * Array of items that cannot be telegrabbed.
	 */
	public static int[] telegrabBlocked = { 828, 831, 832, 1289, 422, 1315,
			1314, 1316, 971 };

	static {
		dray2edge.add(new Point(114, 638));
		dray2edge.add(new Point(120, 621));
		dray2edge.add(new Point(131, 612));
		dray2edge.add(new Point(159, 596));
		dray2edge.add(new Point(195, 583));
		dray2edge.add(new Point(201, 562));
		dray2edge.add(new Point(200, 540));
		dray2edge.add(new Point(227, 501));
		dray2edge.add(new Point(225, 460));
		dray2edge.add(new Point(206, 448));
	}

	/**
	 * Adds the prayers together to calculate what perecntage the stat should be
	 * increased
	 */
	public static double addPrayers(boolean first, boolean second, boolean third) {
		if (third) {
			return 1.15D;
		}
		if (second) {
			return 1.1D;
		}
		if (first) {
			return 1.05D;
		}
		return 1.0D;
	}

	/**
	 * Returns a power to assosiate with each arrow
	 */
	private static double arrowPower(int arrowID) {
		switch (arrowID) {
		case 11: // bronze arrows
		case 574: // poison bronze arrows
		case 190: // crossbow bolts
		case 592: // poison cross bow bolts
		case 1013: // bronze throwing dart
		case 1122: // poison bronze throwing dart
			return 0;
		case 638:// iron arrows
		case 639:// poison iron arrows
		case 1015: // iron throwing dart
		case 1123:// poison iron throwing dart
			return 0.5;
		case 640:// steel arrows
		case 641:// poison steel arrows
		case 1024: // steel throwing dart
		case 1124: // poison steel throwing dart
		case 1076:// bronze throwing dart
		case 1128:// poison bronze throwing knife
		case 827:// bronze spear
		case 1135:// poison bronze spear
			return 1;
		case 642:// mith arrows
		case 643:// poison mith arrows
		case 786:// pearle crossbow bolts
		case 1068:// mith throwing dart
		case 1125: // poison mith throwing dart
		case 1075:// iron throwing dart
		case 1129:// poison iron throwing knife
		case 1088:// iron spear
		case 1136:// poison iron spear
			return 1.5;
		case 644:// addy arrows
		case 645:// poison addy arrows
		case 1069:// addy throwing dart
		case 1126:// poison addy throwing dart
		case 1077:// steel throwing knife
		case 1130:// poison steel throwing knife
		case 1089:// steel spear
		case 1137:// poison steel spear
			return 1.75;
		case 1081:// black throwing knife
		case 1132:// poison black throwing knife
			return 2;
		case 646:// rune arrows
		case 647:// poison rune arrows
		case 1070:// rune throwing dart
		case 1127:// poison rune throwing dart
		case 1078:// mith throwing knife
		case 1131:// poison mith throwing knife
		case 1090:// mith spear
		case 1138:// poison mith spear
			return 5;
		case 723:// ice arrows
		case 1079:// addy throwing knife
		case 1133:// poison addy throwing knife
		case 1091:// addy spear
		case 1139:// poison addy spear
			return 6;
		case 1080:// rune throwing knife
		case 1134:// poison rune throwing knife
		case 1092:// rune spear
		case 1140:// poison rune spear
			return 7;
		case 785:// lit arrow (not stackable, why not?)
			return 10;
		default:
			return 0;
		}
	}

	public static int bitToDoorDir(int bit) {
		switch (bit) {
		case 1:
			return 0;
		case 2:
			return 1;
		case 4:
			return -1;
		case 8:
			return -1;
		}
		return -1;
	}

	public static int bitToObjectDir(int bit) {
		switch (bit) {
		case 1:
			return 6;
		case 2:
			return 0;
		case 4:
			return 2;
		case 8:
			return 4;
		}
		return -1;
	}

	/**
	 * Decide if the food we are cooking should be burned or not
	 */
	public static boolean burnFood(int foodId, int cookingLevel) {
		int levelDiff = cookingLevel
				- EntityHandler.getItemCookingDef(foodId).getReqLevel();
		if (levelDiff < 0) {
			return true;
		}
		if (levelDiff >= 20) {
			return false;
		}
		return DataConversions.random(0, levelDiff + 1) == 0;
	}

	/**
	 * Calulates what one mob should hit on another with meelee
	 */
	public static int calcFightHit(Mob attacker, Mob defender) {
		int max = maxHit(attacker.getStrength(),
				attacker.getWeaponPowerPoints(), attacker.isPrayerActivated(1),
				attacker.isPrayerActivated(4), attacker.isPrayerActivated(10),
				styleBonus(attacker, 2));
		int newAtt = (int) (addPrayers(attacker.isPrayerActivated(2),
				attacker.isPrayerActivated(5), attacker.isPrayerActivated(11))
				* (attacker.getAttack() / 0.8D)
				+ ((DataConversions.random(0, 4) == 0 ? attacker
						.getWeaponPowerPoints() : attacker.getWeaponAimPoints()) / 2.5D)
				+ (attacker.getCombatStyle() == 1
						&& DataConversions.random(0, 2) == 0 ? 4 : 0)
				+ (DataConversions.random(0, 100) <= 10 ? (attacker
						.getStrength() / 5D) : 0) + (styleBonus(attacker, 0) * 2));
		int newDef = (int) (addPrayers(defender.isPrayerActivated(0),
				defender.isPrayerActivated(3), defender.isPrayerActivated(9))
				* ((DataConversions.random(0, 100) <= 5 ? 0 : defender
						.getDefense()) * 1.1D)
				+ ((DataConversions.random(0, 100) <= 5 ? 0 : defender
						.getArmourPoints()) / 2.75D)
				+ (defender.getStrength() / 4D) + (styleBonus(defender, 1) * 2));

		int hitChance = DataConversions.random(0, 100) + (newAtt - newDef);
		if (attacker instanceof Npc) {
			hitChance -= 5;
		}
		if (DataConversions.random(0, 100) <= 10) {
			hitChance += 20;
		}
		if (hitChance > (defender instanceof Npc ? 40 : 50)) {
			int maxProb = 5; // 5%
			int nearMaxProb = 7; // 7%
			int avProb = 73; // 73%
			int lowHit = 10; // 15%

			// Probablities are shifted up/down based on armour
			int shiftValue = (int) Math
					.round(defender.getArmourPoints() * 0.02D);
			maxProb -= shiftValue;
			nearMaxProb -= (int) Math.round(shiftValue * 1.5);
			avProb -= (int) Math.round(shiftValue * 2.0);
			lowHit += (int) Math.round(shiftValue * 3.5);

			int hitRange = DataConversions.random(0, 100);

			if (hitRange >= (100 - maxProb)) {
				return max;
			} else if (hitRange >= (100 - nearMaxProb)) {
				return DataConversions
						.roundUp(Math.abs((max - (max * (DataConversions
								.random(0, 10) * 0.01D)))));
			} else if (hitRange >= (100 - avProb)) {
				int newMax = (int) DataConversions
						.roundUp((max - (max * 0.1D)));
				return DataConversions
						.roundUp(Math.abs((newMax - (newMax * (DataConversions
								.random(0, 50) * 0.01D)))));
			} else {
				int newMax = (int) DataConversions
						.roundUp((max - (max * 0.5D)));
				return DataConversions
						.roundUp(Math.abs((newMax - (newMax * (DataConversions
								.random(0, 95) * 0.01D)))));
			}
		}
		return 0;
	}

	public static int calcFightHitWithNPC(Mob attacker, Mob defender) {

		int max = maxHit(attacker.getStrength(),
				attacker.getWeaponPowerPoints(), attacker.isPrayerActivated(1),
				attacker.isPrayerActivated(4), attacker.isPrayerActivated(10),
				styleBonus(attacker, 2));
		if (attacker instanceof Npc) {
			Npc n = (Npc) attacker;
			if (n.getID() == 3) // Chickens only doing 1 damage.
				max = 1;
		}

		// int newAtt = (int) (addPrayers(attacker.isPrayerActivated(2),
		// attacker.isPrayerActivated(5), attacker.isPrayerActivated(11)) *
		// (attacker.getAttack() / 0.7D) + ((DataConversions.random(0, 4) == 0 ?
		// attacker.getWeaponPowerPoints() : attacker.getWeaponAimPoints()) /
		// 3D) + (attacker.getCombatStyle() == 1 && DataConversions.random(0, 2)
		// == 0 ? 4 : 0) + (styleBonus(attacker, 0) * 2));

		int newAtt = (int) (addPrayers(attacker.isPrayerActivated(2),
				attacker.isPrayerActivated(5), attacker.isPrayerActivated(11))
				* (attacker.getAttack())
				+ ((DataConversions.random(0, 4) == 0 ? attacker
						.getWeaponPowerPoints() : attacker.getWeaponAimPoints()) / 3D)
				+ (attacker.getCombatStyle() == 1
						&& DataConversions.random(0, 2) == 0 ? 4 : 0) + (styleBonus(
				attacker, 0) * 2));

		int newDef = (int) (addPrayers(defender.isPrayerActivated(0),
				defender.isPrayerActivated(3), defender.isPrayerActivated(9))
				* defender.getDefense()
				+ (defender.getArmourPoints() / 4D)
				+ (defender.getStrength() / 4D) + (styleBonus(defender, 1) * 2));

		/*
		 * if(defender instanceof Player) { if(defender.getCombatLevel() < 70 &&
		 * defender.getCombatLevel() > 45) newDef = newDef + (int)(newDef *
		 * 0.25); else if(defender.getCombatLevel() > 25 &&
		 * defender.getCombatLevel() < 45) newDef = newDef + (int)(newDef *
		 * 0.35);
		 * 
		 * else if(defender.getCombatLevel() > 8 && defender.getCombatLevel() <
		 * 25) newDef = newDef + (int)(newDef * 0.45);
		 * 
		 * else if(defender.getCombatLevel() > 1 && defender.getCombatLevel() <
		 * 8) newDef = newDef + (int)(newDef * 0.55); }
		 */
		if (attacker instanceof Player) {
			// newDef += newDef / 8;
			newDef -= newDef / 8;
		}

		int hitChance = DataConversions.random(0, 100) + (newAtt - newDef);
		// Added this
		if (attacker instanceof Player)
			hitChance += (int) (DataConversions.random(0, attacker.getAttack()) + 1) / 1.33;

		if (attacker instanceof Npc) {
			hitChance -= 5;
		}
		if (hitChance > (defender instanceof Npc ? 40 : 50)) {
			int maxProb = 5; // 5%
			int nearMaxProb = 10; // 10%
			int avProb = 80; // 70%
			int lowHit = 10; // 15%

			// Probablities are shifted up/down based on armour
			int shiftValue = (int) Math
					.round(defender.getArmourPoints() * 0.02D);
			maxProb -= shiftValue;
			nearMaxProb -= (int) Math.round(shiftValue * 1.5);
			avProb -= (int) Math.round(shiftValue * 2.0);
			lowHit += (int) Math.round(shiftValue * 3.5);

			int hitRange = DataConversions.random(0, 100);

			if (hitRange >= (100 - maxProb)) {
				return max;
			} else if (hitRange >= (100 - nearMaxProb)) {
				return DataConversions
						.roundUp(Math.abs((max - (max * (DataConversions
								.random(0, 10) * 0.01D)))));
			} else if (hitRange >= (100 - avProb)) {
				int newMax = (int) DataConversions
						.roundUp((max - (max * 0.1D)));
				return DataConversions
						.roundUp(Math.abs((newMax - (newMax * (DataConversions
								.random(0, 50) * 0.01D)))));
			} else {
				int newMax = (int) DataConversions
						.roundUp((max - (max * 0.5D)));
				return DataConversions
						.roundUp(Math.abs((newMax - (newMax * (DataConversions
								.random(0, 95) * 0.01D)))));
			}
		}
		return 0;
	}

	public static int calcGodSpells(Mob attacker, Mob defender) {
		if (attacker instanceof Player) {
			Player owner = (Player) attacker;
			int newAtt = (int) ((owner.getMagicPoints()) + owner.getCurStat(6));
			int newDef = (int) ((addPrayers(defender.isPrayerActivated(0),
					defender.isPrayerActivated(3),
					defender.isPrayerActivated(9))
					* defender.getDefense() / 4D) + (defender.getArmourPoints() / 4D));
			int hitChance = DataConversions.random(0, 150 + (newAtt - newDef));
			// int hitChance = (int)(50D + (double)owner.getMagicPoints() -
			// newDef);

			if (hitChance > (defender instanceof Npc ? 50 : 60)) {
				// int max = owner.isCharged() ? Rand(15, 25) : Rand(0, 10);
				int max;
				if (owner.isCharged()) {
					max = Rand(14, 25);

				} else {
					max = Rand(0, 10);
				}
				int maxProb = 5; // 5%
				int nearMaxProb = 10; // 10%
				int avProb = 80; // 80%
				int lowHit = 5; // 5%

				// Probablities are shifted up/down based on armour
				int shiftValue = (int) Math
						.round(defender.getArmourPoints() * 0.02D);
				maxProb -= shiftValue;
				nearMaxProb -= (int) Math.round(shiftValue * 1.5);
				avProb -= (int) Math.round(shiftValue * 2.0);
				lowHit += (int) Math.round(shiftValue * 3.5);

				int hitRange = DataConversions.random(0, 100);

				if (hitRange >= (100 - maxProb)) {
					return max;
				} else if (hitRange >= (100 - nearMaxProb)) {
					return DataConversions
							.roundUp(Math.abs((max - (max * (DataConversions
									.random(0, 10) * 0.01D)))));
				} else if (hitRange >= (100 - avProb)) {
					int newMax = (int) DataConversions
							.roundUp((max - (max * 0.1D)));
					return DataConversions.roundUp(Math
							.abs((newMax - (newMax * (DataConversions.random(0,
									50) * 0.01D)))));
				} else {
					int newMax = (int) DataConversions
							.roundUp((max - (max * 0.5D)));
					return DataConversions.roundUp(Math
							.abs((newMax - (newMax * (DataConversions.random(0,
									95) * 0.01D)))));
				}
			}
		}
		return 0;
	}

	/**
	 * Calculates what one mob should hit on another with range
	 */
	public static int calcRangeHit(int rangeLvl, int rangeEquip,
			int armourEquip, int arrowID) {
		int armourRatio = (int) (60D + ((double) ((rangeEquip * 3D) - armourEquip) / 300D) * 40D);

		if (DataConversions.random(0, 100) > armourRatio
				&& DataConversions.random(0, 1) == 0) {
			return 0;
		}

		int max = (int) (((double) rangeLvl * 0.15D) + 0.85D + arrowPower(arrowID));
		int peak = (int) (((double) max / 100D) * (double) armourRatio);
		int dip = (int) (((double) peak / 3D) * 2D);
		return DataConversions.randomWeighted(0, dip, peak, max);
	}

	/**
	 * Calculates what a spell should hit based on its strength and the magic
	 * equipment stats of the caster
	 */
	public static int calcSpellHit(int spellStr, int magicEquip) {
		int mageRatio = (int) (45D + (double) magicEquip);
		int max = spellStr;
		int peak = (int) (((double) spellStr / 100D) * (double) mageRatio);
		int dip = (int) ((peak / 3D) * 2D);
		return DataConversions.randomWeighted(0, dip, peak, max);
	}

	/**
	 * Should the spell cast or fail?
	 */
	public static boolean castSpell(SpellDef def, int magicLevel, int magicEquip) {
		int levelDiff = magicLevel - def.getReqLevel();

		if (magicEquip >= 30 && levelDiff >= 5)
			return true;
		if (magicEquip >= 25 && levelDiff >= 6)
			return true;
		if (magicEquip >= 20 && levelDiff >= 7)
			return true;
		if (magicEquip >= 15 && levelDiff >= 8)
			return true;
		if (magicEquip >= 10 && levelDiff >= 9)
			return true;
		if (levelDiff < 0) {
			return false;
		}
		if (levelDiff >= 10) {
			return true;
		}
		return DataConversions.random(0, (levelDiff + 2) * 2) != 0;
	}

	/**
	 * Calculate how much experience a Mob gives
	 */
	public static int combatExperience(Mob mob) {
		double exp = ((mob.getCombatLevel() * 2) + 10) * 1.5D;
		return (int) (mob instanceof Player ? (exp / 4D) : exp);
	}

	/*
	 * Should the pot crack?
	 */
	public static boolean crackPot(int requiredLvl, int craftingLvl) {
		int levelDiff = craftingLvl - requiredLvl;
		if (levelDiff < 0) {
			return true;
		}
		if (levelDiff >= 20) {
			return false;
		}
		return DataConversions.random(0, levelDiff + 1) == 0;
	}

	/**
	 * Should the web be cut?
	 */
	public static boolean cutWeb() {
		return DataConversions.random(0, 4) != 0;
	}

	public static boolean doorAtFacing(Entity e, int x, int y, int dir) {
		if (dir >= 0 && e instanceof GameObject) {
			GameObject obj = (GameObject) e;
			return obj.getType() == 1 && obj.getDirection() == dir
					&& obj.isOn(x, y);
		}
		return false;
	}

	/**
	 * Check what level the given experience corresponds to
	 */
	public static int experienceToLevel(int exp) {
		for (int level = 0; level < 98; level++) {
			if (exp >= experienceArray[level]) {
				continue;
			}
			return (level + 1);
		}
		return 99;
	}

	/**
	 * Decide if we fall off the obstacle or not
	 */
	public static int failObstacle(Player player, int reqLvl) {
		int levelDiff = player.getCurStat(16) - reqLvl;
		if (levelDiff < 0)
			return 1;

		if (levelDiff >= (reqLvl * 2))
			return -1;

		if (DataConversions.random(0, levelDiff + 1) == 0)
			return DataConversions.roundUp(player.getMaxStat(3)
					* DataConversions.random(0.02, 0.04));
		else
			return -1;
	}

	public static int firemakingExp(int level, int baseExp) {
		return DataConversions.roundUp(baseExp + (level * 1.75D));
	}

	/**
	 * Generates a session id
	 */
	public static long generateSessionKey(byte userByte) {
		return DataConversions.getRandom().nextLong();
	}

	/**
	 * Gets the type of bar we have
	 */
	public static int getBarType(int barID) {
		switch (barID) {
		case 169:
			return 0;
		case 170:
			return 1;
		case 171:
			return 2;
		case 173:
			return 3;
		case 174:
			return 4;
		case 408:
			return 5;
		}
		return -1;
	}

	/**
	 * Calculate a mobs combat level based on their stats
	 */
	public static int getCombatlevel(int[] stats) {
		return getCombatLevel(stats[0], stats[1], stats[2], stats[3], stats[6],
				stats[5], stats[4]);
	}

	/**
	 * Calculate a mobs combat level based on their stats
	 */
	public static int getCombatLevel(int att, int def, int str, int hits,
			int magic, int pray, int range) {
		double attack = att + str;
		double defense = def + hits;
		double mage = pray + magic;
		mage /= 8D;

		if (attack < ((double) range * 1.5D)) {
			return (int) ((defense / 4D) + ((double) range * 0.375D) + mage);
		} else {
			return (int) ((attack / 4D) + (defense / 4D) + mage);
		}
	}

	/**
	 * gets the new sprite direction to face
	 * 
	 */
	public static int getDirection(Mob you, Mob them) {

		if (you.getX() == them.getX() + 1 && you.getY() == them.getY() + 1) // bottom
			// left
			return 3;
		else if (you.getX() == them.getX() + 1 && you.getY() == them.getY() - 1) // top
			// left
			return 1;
		else if (you.getX() == them.getX() - 1 && you.getY() == them.getY() - 1) // right
			// up
			return 7;
		else if (you.getX() == them.getX() - 1 && you.getY() == them.getY() + 1) // right/down
			return 5;
		else if (you.getX() == them.getX() - 1) // face right
			return 6;
		else if (you.getX() == them.getX() + 1) // face left
			return 2;
		else if (you.getY() == them.getY() + 1) // face down
			return 4;
		else if (you.getY() == them.getY() - 1) // face up
			return 0;

		return -1;
	}

	/**
	 * Gets the empty jug ID
	 */
	public static int getEmptyJug(int fullJug) {
		switch (fullJug) {
		case 50:
			return 21;
		case 141:
			return 140;
		case 342:
			return 341;
		}
		return -1;
	}

	/**
	 * Decide what fish, if any, we should get from the water
	 */
	public static ObjectFishDef getFish(int waterId, int fishingLevel, int click) {
		ArrayList<ObjectFishDef> fish = new ArrayList<ObjectFishDef>();
		for (ObjectFishDef def : EntityHandler.getObjectFishingDef(waterId,
				click).getFishDefs()) {
			if (fishingLevel >= def.getReqLevel()) {
				fish.add(def);
			}
		}
		if (fish.size() <= 0) {
			return null;
		}
		ObjectFishDef thisFish = fish.get(DataConversions.random(0,
				fish.size() - 1));
		int levelDiff = fishingLevel - thisFish.getReqLevel();
		if (levelDiff < 0) {
			return null;
		}
		return DataConversions.percentChance(offsetToPercent(levelDiff)) ? thisFish
				: null;
	}

	/**
	 * Returns a gem ID
	 */
	public static int getGem() {
		int rand = DataConversions.random(0, 100);
		if (rand < 10) {
			return 157;
		} else if (rand < 30) {
			return 158;
		} else if (rand < 60) {
			return 159;
		} else {
			return 160;
		}
	}

	/**
	 * Check what height we are currently at on the map
	 */
	public static int getHeight(int y) {
		return (int) (y / 944);
	}

	/**
	 * Check what height we are currently at on the map
	 */
	public static int getHeight(Point location) {
		return getHeight(location.getY());
	}

	public static int getItemPos(Shop shop, int id) {
		for (int i = 0; i < shop.getItems().size(); i++) {
			if (shop.getItems().get(i).getID() == id)
				return i;
		}
		return -1;
	}

	public static List<InvItem> getKeyChestLoot() {
		@SuppressWarnings("unchecked")
		List<InvItem>[] possibleLoots = (List<InvItem>[]) EntityHandler
				.getKeyChestLoots();
		return possibleLoots[DataConversions
				.random(0, possibleLoots.length - 1)];
	}

	/**
	 * Should we get a log from the tree?
	 */
	public static boolean getLog(ObjectWoodcuttingDef def, int woodcutLevel,
			int axeId) {
		int levelDiff = woodcutLevel - def.getReqLevel();
		if (levelDiff < 0) {
			return false;
		}
		switch (axeId) {
		case 87:
			levelDiff += 0;
			break;
		case 12:
			levelDiff += 2;
			break;
		case 428:
			levelDiff += 4;
			break;
		case 88:
			levelDiff += 6;
			break;
		case 203:
			levelDiff += 8;
			break;
		case 204:
			levelDiff += 10;
			break;
		case 405:
			levelDiff += 12;
			break;
		}
		if (def.getReqLevel() == 1 && levelDiff >= 40) {
			return true;
		}
		return DataConversions.percentChance(offsetToPercent(levelDiff));
	}

	/*
	 * public static int calcFightHitWithNPC(Mob attacker, Mob defender) { int
	 * newAtt = (int)((addPrayers(attacker.isPrayerActivated(2),
	 * attacker.isPrayerActivated(5), attacker.isPrayerActivated(11)) *
	 * attacker.getAttack()) + (attacker.getWeaponAimPoints() / 4D) +
	 * styleBonus(attacker, 0)); int newDef =
	 * (int)((addPrayers(defender.isPrayerActivated(0),
	 * defender.isPrayerActivated(3), defender.isPrayerActivated(9)) *
	 * defender.getDefense()) + (defender.getArmourPoints() / 4D) +
	 * styleBonus(attacker, 1));
	 * 
	 * int hitChance = DataConversions.random(0, 100) + (newAtt - newDef);
	 * 
	 * if(hitChance > (defender instanceof Npc ? 50 : 60)) { int max =
	 * maxHit(attacker.getStrength(), attacker.getWeaponPowerPoints(),
	 * attacker.isPrayerActivated(1), attacker.isPrayerActivated(4),
	 * attacker.isPrayerActivated(10), styleBonus(attacker, 2));
	 * 
	 * int maxProb = 5; // 5% int nearMaxProb = 10; // 10% int avProb = 80; //
	 * 80% int lowHit = 5; // 5%
	 * 
	 * // Probablities are shifted up/down based on armour int shiftValue =
	 * (int)Math.round(defender.getArmourPoints() * 0.02D); maxProb -=
	 * shiftValue; nearMaxProb -= (int)Math.round(shiftValue * 1.5); avProb -=
	 * (int)Math.round(shiftValue * 2.0); lowHit += (int)Math.round(shiftValue *
	 * 3.5);
	 * 
	 * int hitRange = DataConversions.random(0, 100);
	 * 
	 * if(hitRange >= (100 - maxProb)) { return max; } else if(hitRange >= (100
	 * - nearMaxProb)) { return DataConversions.roundUp(Math.abs((max - (max *
	 * (DataConversions.random(0, 10) * 0.01D))))); } else if(hitRange >= (100 -
	 * avProb)) { int newMax = (int)DataConversions.roundUp((max - (max *
	 * 0.1D))); return DataConversions.roundUp(Math.abs((newMax - (newMax *
	 * (DataConversions.random(0, 50) * 0.01D))))); } else { int newMax =
	 * (int)DataConversions.roundUp((max - (max * 0.5D))); return
	 * DataConversions.roundUp(Math.abs((newMax - (newMax *
	 * (DataConversions.random(0, 95) * 0.01D))))); } } return 0; }
	 */

	public static String getLvlDiffColour(int lvlDiff) {
		if (lvlDiff < -9) {
			return "@red@";
		} else if (lvlDiff < -6) {
			return "@or3@";
		} else if (lvlDiff < -3) {
			return "@or2@";
		} else if (lvlDiff < 0) {
			return "@or1@";
		} else if (lvlDiff > 9) {
			return "@gre@";
		} else if (lvlDiff > 6) {
			return "@gr3@";
		} else if (lvlDiff > 3) {
			return "@gr2@";
		} else if (lvlDiff > 0) {
			return "@gr1@";
		}
		return "@whi@";
	}

	public static int getNewY(int currentY, boolean up) {
		int height = getHeight(currentY);
		int newHeight;
		if (up) {
			if (height == 3) {
				newHeight = 0;
			} else if (height >= 2) {
				return currentY;
			} else {
				newHeight = height + 1;
			}
		} else {
			if (height == 0) {
				newHeight = 3;
			} else if (height >= 3) {
				return currentY;
			} else {
				newHeight = height - 1;
			}
		}
		return (newHeight * 944) + (currentY % 944);
	}

	/**
	 * Should we can get an ore from the rock?
	 */
	public static boolean getOre(ObjectMiningDef def, int miningLevel, int axeId) {

		int levelDiff = miningLevel - def.getReqLevel();
		if (levelDiff > 50)
			return Formulae.Rand(0, 9) != 1;
		if (levelDiff < 0) {
			return false;
		}
		int bonus = 0;
		switch (axeId) {
		case 156:
			bonus = 0;
			break;
		case 1258:
			bonus = 2;
			break;
		case 1259:
			bonus = 6;
			break;
		case 1260:
			bonus = 8;
			break;
		case 1261:
			bonus = 10;
			break;
		case 1262:
			bonus = 12;
			break;
		}
		return DataConversions
				.percentChance(offsetToPercent(levelDiff + bonus));
	}

	public static int getPotionDose(int id) {
		if (DataConversions.inArray(potions1Dose, id)) {
			return 1;
		}
		if (DataConversions.inArray(potions2Dose, id)) {
			return 2;
		}
		if (DataConversions.inArray(potions3Dose, id)) {
			return 3;
		}
		return 0;
	}

	/**
	 * @author xEnt
	 * 
	 *         This method will calculate the new price for all items in the
	 *         shop there are 3 different types of calculations. 1. Buy price -
	 *         if the item is sold in the shop by default, use the base quantity
	 *         for the calculations in the new price.
	 * 
	 *         2. Buy price - if a player has sold an item to a general store,
	 *         leaving it to have no base quantity and player driven, we perform
	 *         some secondary calculations.
	 * 
	 *         3. Sell price (this works like the second buy price, calculates
	 *         depending on a static number of stock and does not use any type
	 *         of base quantity calculations, may do a second one in future.
	 * 
	 * @param i
	 *            - the selected Shop item, represented as an InvItem
	 * @param shop
	 *            - the shop model object
	 * @param buy
	 *            - if the item is for sale, or being sold
	 * @return the item's calculated price of value
	 */
	public static int getPrice(InvItem i, Shop shop, boolean buy) {
		if (buy)
			return i.getDef().getBasePrice();
		else
			return i.getDef().getBasePrice() / 2;
		/*
		 * final double GENERAL_STORE_BUY_MODIFIER = 0.685;
		 * 
		 * int newPrice = -1; // the newly given price. boolean playerSoldItem =
		 * false; // If true, there is no base quantity (a // player has sold
		 * this item to general // store) int curAmount = i.getAmount(); //
		 * current quantity the selected item has int maxStockAmount =
		 * shop.getEquilibrium(i.getID()); // the base // quantity of // the
		 * selected // shop item (if // has one)
		 * 
		 * if (maxStockAmount == 0 && shop.isGeneral()) playerSoldItem = true;
		 * // This item is an item that has no base // quantity, was sold by a
		 * player in general // store
		 * 
		 * if (buy) { // Decide if this item is being brought if (maxStockAmount
		 * == 0 && !shop.isGeneral()) // this should not // happen return
		 * 999999999; // rofl error price if (playerSoldItem) { // General
		 * store, no maximum quantity for a // player sold item. (requires
		 * different // calculations) // cost 15% more buying a 3rd party item
		 * from a general store int basePrice = shop.isGeneral() ?
		 * i.getDef().basePrice + (int) (i.getDef().basePrice * 0.15) :
		 * i.getDef().basePrice; if (basePrice > 10000) // forget any items that
		 * are worth past // 10k return basePrice; if (curAmount > 28) // after
		 * 28 quantity from a player sold // item, stick to a static price
		 * newPrice = basePrice - (int) (basePrice *
		 * GENERAL_STORE_BUY_MODIFIER); else { // do calculations to decide a
		 * price depending on the // quantity newPrice = basePrice - (int)
		 * (curAmount * 5); if (newPrice < basePrice - (int) (basePrice *
		 * GENERAL_STORE_BUY_MODIFIER)) newPrice = basePrice - (int) (basePrice
		 * * GENERAL_STORE_BUY_MODIFIER); } } else { // Has a base quantity if
		 * (curAmount >= maxStockAmount) // leave base price is full // stock is
		 * avaliable newPrice = i.getDef().basePrice; else // 75-100% quantity
		 * is in stock if (curAmount > maxStockAmount * 0.75 && curAmount <
		 * maxStockAmount) newPrice = i.getDef().basePrice + (int)
		 * (i.getDef().basePrice * getShopPercentage( i, 0, true)); else //
		 * 50-75% quantity is in stock if (curAmount > maxStockAmount * 0.50 &&
		 * curAmount <= maxStockAmount * 0.75) newPrice = i.getDef().basePrice +
		 * (int) (i.getDef().basePrice * getShopPercentage( i, 1, true)); else
		 * // 25-50% quantity is in stock if (curAmount > maxStockAmount * 0.25
		 * && curAmount <= maxStockAmount * 0.50) newPrice =
		 * i.getDef().basePrice + (int) (i.getDef().basePrice *
		 * getShopPercentage( i, 2, true)); else // 0-25% quantity is in stock
		 * if (curAmount > maxStockAmount * 0.0 && curAmount <= maxStockAmount *
		 * 0.25) newPrice = i.getDef().basePrice + (int) (i.getDef().basePrice *
		 * getShopPercentage( i, 3, true)); } if (newPrice == -1) return
		 * 99999999; // error? return newPrice; } else { // Sell if (i.getID()
		 * == 117) Logging.debug("Current stock: " + curAmount); int base =
		 * i.getDef().basePrice - (int) (i.getDef().basePrice / 2.5); // Sell
		 * price is 125% // lower than base // price to begin // with if
		 * (shop.isGeneral()) // 3rd party item (player sold) base = base -
		 * (int) (base * 0.10); // 10% less value, if general // store.
		 * 
		 * if (curAmount < 1) return base;
		 * 
		 * int price; // new price if (curAmount > 12) { price = base - (int)
		 * (base * 0.75); // 75% loss (believe it or // not, thats how it was) }
		 * else { price = base;
		 * 
		 * if (curAmount > 1) price = base - (int) (curAmount * (base * 0.045));
		 * if (price < base - (int) (base * 0.75)) base = base - (int) (base *
		 * 0.75); } if (price < 1) // should not happen return 0; // error price
		 * else return price; }
		 */
	}

	public static int getRangeDirection(Mob you, Mob them) {
		if (you.getX() > them.getX() && you.getY() == them.getY()) // face right
			return 6;
		else if (you.getX() < them.getX() && you.getY() == them.getY()) // face
			// left
			return 2;
		else if (you.getY() < them.getY() && you.getX() == them.getX()) // face
			// down
			return 4;
		else if (you.getY() > them.getY() && you.getX() == them.getX()) // face
			// up
			return 0;
		else if (you.getX() <= them.getX() && you.getY() <= them.getY()) // bottom
			// left
			return 3;
		else if (you.getX() <= them.getX() && you.getY() >= them.getY()) // top
			// left
			return 1;
		else if (you.getX() >= them.getX() && you.getY() >= them.getY()) // right
			// up
			return 7;
		else if (you.getX() >= them.getX() && you.getY() <= them.getY()) // right/down
			return 5;

		return -1;
	}

	// This is needed for the above method
	public static double getShopPercentage(InvItem item, int pos, boolean buy) {
		int[] prices = { 0, 10, 100, 1000, 10000 }; // base prices of the items.
		double[][] percentages = { { 0.5, 1.0, 1.5, 2.0 }, // in between 0 and
				// 10GP.
				{ 0.1, 0.3, 0.45, 0.6 }, // 10-100gp
				{ 0.1, 0.2, 0.3, 0.4 }, // 100-1000gp
				{ 0.5, 0.1, 0.15, 0.2 }, // 1000-10000gp
		};
		int key = -1;
		for (int i = 0; i < prices.length - 1; i++)
			if (item.getDef().basePrice > prices[i]
					&& item.getDef().basePrice < prices[i + 1])
				key = i;
		if (key == -1)
			return -1;
		return percentages[key][pos];
	}

	/**
	 * Gets the smithing exp for the given amount of the right bars
	 */
	public static int getSmithingExp(int barID, int barCount) {
		int[] exps = { 13, 25, 37, 50, 83, 74 };
		int type = getBarType(barID);
		if (type < 0) {
			return 0;
		}
		return exps[type] * barCount;
	}

	public static int getStat(String stat) {
		for (int i = 0; i < statArray.length; i++) {
			if (statArray[i].equalsIgnoreCase(stat))
				return i;
		}

		return -1;
	}

	/**
	 * Given a stat string get its index returns -1 on failure
	 */
	public static int getStatIndex(String stat) {
		for (int index = 0; index < statArray.length; index++) {
			if (stat.equalsIgnoreCase(statArray[index])) {
				return index;
			}
		}
		return -1;
	}

	public static boolean isP2P(Object... objs) {
		return isP2P(false, objs);
	}

	/**
	 * Performs coordinate checks on the locations in the P2P_LOCS array to
	 * decide whether items/object/npc's/general x,y coordinates are in P2P area
	 * 
	 * @param objs
	 *            - ItemLoc, GameObjectLoc, NPCLoc or an Integer.
	 * @return - true if inside P2P area, otherwise false.
	 */
	public static boolean isP2P(Boolean f2pwildy, Object... objs) {
		int x = -1;
		int y = -1;
		if (objs.length == 1) {
			Object obj = objs[0];
			if (obj instanceof GameObjectLoc) {
				x = ((GameObjectLoc) obj).x;
				y = ((GameObjectLoc) obj).y;
			} else if ((obj instanceof ItemLoc)) {
				x = ((ItemLoc) obj).x;
				y = ((ItemLoc) obj).y;
			} else if (obj instanceof NPCLoc) {
				x = ((NPCLoc) obj).startX;
				y = ((NPCLoc) obj).startY;
			}
		} else {
			if (objs[0] instanceof Integer && objs[1] instanceof Integer) {
				x = (Integer) objs[0];
				y = (Integer) objs[1];
			}
		}

		if (x == -1)
			return false;
		if (!f2pwildy) {
			for (int i = 0; i < P2P_LOCS.length; i++) {
				for (int ele = 0; ele < 4; ele++) {
					if (x >= P2P_LOCS[i][0].getX()
							&& x <= P2P_LOCS[i][1].getX()
							&& y >= P2P_LOCS[i][0].getY() + ((ele) * 944)
							&& y <= P2P_LOCS[i][1].getY() + ((ele) * 944))
						return true;
				}
			}
		} else {
			for (int i = 0; i < F2PWILD_LOCS.length; i++) {
				for (int ele = 0; ele < 4; ele++) {
					if (x >= F2PWILD_LOCS[i][0].getX()
							&& x <= F2PWILD_LOCS[i][1].getX()
							&& y >= F2PWILD_LOCS[i][0].getY() + ((ele) * 944)
							&& y <= F2PWILD_LOCS[i][1].getY() + ((ele) * 944))
						return true;
				}
			}
		}
		return false;
	}

	public static int levelToExperience(int level) {
		if (level <= 1)
			return 0;

		return experienceArray[level];
	}

	/**
	 * Should the fire light or fail?
	 */
	public static boolean lightLogs(FiremakingDef def, int firemakingLvl) {
		int levelDiff = firemakingLvl - def.getRequiredLevel();
		if (levelDiff < 0) {
			return false;
		}
		if (levelDiff >= 20) {
			return true;
		}
		return DataConversions.random(0, levelDiff + 1) != 0;
	}

	// maxHit
	/**
	 * Should the arrow be dropped or disappear
	 */
	public static boolean looseArrow(int damage) {
		return DataConversions.random(0, 6) == 0;
	}

	/**
	 * Calculate the max hit possible with the given stats
	 */
	public static int maxHit(int strength, int weaponPower, boolean burst,
			boolean superhuman, boolean ultimate, int bonus) {
		double newStrength = (double) ((strength * addPrayers(burst,
				superhuman, ultimate)) + bonus);

		int fin = (int) ((newStrength
				* ((((double) weaponPower * 0.00175D) + 0.1D)) + 1.05D) * 0.95D);
		// if (fin > 31)
		// fin = 31;
		return fin;

	}

	/**
	 * Gets the min level required to smith a bar
	 */
	public static int minSmithingLevel(int barID) {
		int[] levels = { 1, 15, 30, 50, 70, 85 };
		int type = getBarType(barID);
		if (type < 0) {
			return -1;
		}
		return levels[type];
	}

	public static boolean objectAtFacing(Entity e, int x, int y, int dir) {
		if (dir >= 0 && e instanceof GameObject) {
			GameObject obj = (GameObject) e;
			return obj.getType() == 0 && obj.getDirection() == dir
					&& obj.isOn(x, y);
		}
		return false;
	}

	private static int offsetToPercent(int levelDiff) {
		return levelDiff > 40 ? 70 : 30 + levelDiff;
	}

	/**
	 * Calulates what one mob should hit on another with meelee
	 */
	public static double parseDouble(double number) {
		String numberString = String.valueOf(number);
		return Double.valueOf(numberString.substring(0,
				numberString.indexOf(".") + 2));
	}

	public static int Rand(int low, int high) {
		return low + r.nextInt(high - low);
	}

	public static int styleBonus(Mob mob, int skill) {
		int style = mob.getCombatStyle();
		if (style == 0) {
			return 1;
		}
		return (skill == 0 && style == 2) || (skill == 1 && style == 3)
				|| (skill == 2 && style == 1) ? 3 : 0;
	}

	public static int[] rares = new int[] { 828, 831, 832, 575, 576, 577, 578,
			579, 580, 581, 971, 1316, 1315, 1314, 422, 1289, 1156, 677 };

	public static boolean isRareItem(int id) {
		return DataConversions.inArray(rares, id);
	}

	public static int getBarIdFromItem(int itemID) {
		if (DataConversions.inArray(BRONZE, itemID))
			return 169;
		if (DataConversions.inArray(IRON, itemID))
			return 170;
		if (DataConversions.inArray(STEEL, itemID))
			return 171;
		if (DataConversions.inArray(MITH, itemID))
			return 173;
		if (DataConversions.inArray(ADDY, itemID))
			return 174;
		if (DataConversions.inArray(RUNE, itemID))
			return 408;
		return -1;
	}

	public final static int[] IRON = { 6, 5, 7, 8, 2, 3, 9, 28, 1075, 1, 71,
			83, 77, 12, 1258, 89, 0, 670, 1063 };
	public final static int[] RUNE = { 112, 399, 400, 401, 404, 403, 402, 396,
			1080, 397, 75, 398, 81, 405, 1262, 93, 98, 674, 1067 };
	public final static int[] ADDY = { 111, 107, 116, 120, 131, 127, 123, 65,
			1079, 69, 74, 86, 80, 204, 1261, 92, 97, 673, 1066 };
	public final static int[] MITH = { 110, 106, 115, 119, 130, 126, 122, 64,
			1078, 68, 73, 85, 79, 203, 1260, 91, 96, 672, 1065 };
	public final static int[] STEEL = { 109, 105, 114, 118, 129, 125, 121, 63,
			1077, 67, 72, 84, 78, 88, 1259, 90, 95, 671, 1064 };
	public final static int[] BRONZE = { 108, 104, 113, 117, 128, 124, 206, 62,
			1076, 66, 70, 82, 76, 87, 156, 87, 205, 669, 1062 };

}