Thread: [Pi] Callypsis v2 npc error!

Results 1 to 3 of 3
  1. #1 [Pi] Callypsis v2 npc error! 
    Registered Member 2nubs1cup's Avatar
    Join Date
    Jan 2013
    Posts
    972
    Thanks given
    77
    Thanks received
    90
    Rep Power
    15
    I am using aeronis source which is a edited version of callypsis v2 source, and npcs walk all over the place like when you ever walk near them they walk away...
    here's my npchandler class:
    Code:
    package org.aeronis.rs2.model;
    
    import java.io.BufferedReader;
    import java.io.FileNotFoundException;
    import java.io.FileReader;
    import java.io.IOException;
    import java.util.ArrayList;
    
    import org.aeronis.Config;
    import org.aeronis.Server;
    import org.aeronis.pf.PathFinder;
    import org.aeronis.pf.TileControl;
    import org.aeronis.rs2.content.minigames.WarriorsGuild;
    import org.aeronis.rs2.content.randomevents.FreakyForester;
    import org.aeronis.rs2.content.skills.crafting.SheepCrafting;
    import org.aeronis.rs2.model.combat.CombatAssistant;
    import org.aeronis.rs2.model.region.Region;
    import org.aeronis.util.Misc;
    
    public class NPCHandler {
    	/*
    	 * relog drop shit have an npc att u xlog log on a dif acc log out login to
    	 * duping accu keep ur shit u die other person keeps ur shit
    	 */
    
    	public static int maxNPCs = 10000;
    	public static int maxListedNPCs = 10000;
    	public static int maxNPCDrops = 10000;
    	public static NPC npcs[] = new NPC[maxNPCs];
    
    	public NPCHandler() {
    		for (int i = 0; i < maxNPCs; i++) {
    			npcs[i] = null;
    			NPCDefinitions.getDefinitions()[i] = null;
    		}
    
    		loadNPCList("./Data/CFG/npc.cfg");
    		loadAutoSpawn("./Data/CFG/spawns.cfg");
    	}
    
    	public static boolean pathBlocked(NPC attacker, Player victim) {
    
    		if (attacker != null && victim != null) {
    
    			double offsetX = Math.abs(attacker.absX - victim.absX);
    			double offsetY = Math.abs(attacker.absY - victim.absY);
    
    			int distance = TileControl.calculateDistance(attacker, victim);
    
    			if (distance == 0) {
    				return true;
    			}
    
    			offsetX = offsetX > 0 ? offsetX / distance : 0;
    			offsetY = offsetY > 0 ? offsetY / distance : 0;
    
    			int[][] path = new int[distance][5];
    
    			int curX = attacker.absX;
    			int curY = attacker.absY;
    			int next = 0;
    			int nextMoveX = 0;
    			int nextMoveY = 0;
    
    			double currentTileXCount = 0.0;
    			double currentTileYCount = 0.0;
    
    			while (distance > 0) {
    				distance--;
    				nextMoveX = 0;
    				nextMoveY = 0;
    				if (curX > victim.absX) {
    					currentTileXCount += offsetX;
    					if (currentTileXCount >= 1.0) {
    						nextMoveX--;
    						curX--;
    						currentTileXCount -= offsetX;
    					}
    				} else if (curX < victim.absX) {
    					currentTileXCount += offsetX;
    					if (currentTileXCount >= 1.0) {
    						nextMoveX++;
    						curX++;
    						currentTileXCount -= offsetX;
    					}
    				}
    				if (curY > victim.absY) {
    					currentTileYCount += offsetY;
    					if (currentTileYCount >= 1.0) {
    						nextMoveY--;
    						curY--;
    						currentTileYCount -= offsetY;
    					}
    				} else if (curY < victim.absY) {
    					currentTileYCount += offsetY;
    					if (currentTileYCount >= 1.0) {
    						nextMoveY++;
    						curY++;
    						currentTileYCount -= offsetY;
    					}
    				}
    				path[next][0] = curX;
    				path[next][1] = curY;
    				path[next][2] = attacker.heightLevel;// getHeightLevel();
    				path[next][3] = nextMoveX;
    				path[next][4] = nextMoveY;
    				next++;
    			}
    			for (int i = 0; i < path.length; i++) {
    				if (!Region./* getSingleton(). */getClipping(path[i][0],
    						path[i][1], path[i][2], path[i][3], path[i][4])
    						&& !Region.blockedShot(path[i][0], path[i][1],
    								path[i][2])) {
    					return true;
    				}
    			}
    		}
    		return false;
    	}
    
    	public void handleClipping(int i) {
    		NPC npc = npcs[i];
    		if (npc.moveX == 1 && npc.moveY == 1) {
    			if ((Region
    					.getClipping(npc.absX + 1, npc.absY + 1, npc.heightLevel) & 0x12801e0) != 0) {
    				npc.moveX = 0;
    				npc.moveY = 0;
    				if ((Region
    						.getClipping(npc.absX, npc.absY + 1, npc.heightLevel) & 0x1280120) == 0)
    					npc.moveY = 1;
    				else
    					npc.moveX = 1;
    			}
    		} else if (npc.moveX == -1 && npc.moveY == -1) {
    			if ((Region
    					.getClipping(npc.absX - 1, npc.absY - 1, npc.heightLevel) & 0x128010e) != 0) {
    				npc.moveX = 0;
    				npc.moveY = 0;
    				if ((Region
    						.getClipping(npc.absX, npc.absY - 1, npc.heightLevel) & 0x1280102) == 0)
    					npc.moveY = -1;
    				else
    					npc.moveX = -1;
    			}
    		} else if (npc.moveX == 1 && npc.moveY == -1) {
    			if ((Region
    					.getClipping(npc.absX + 1, npc.absY - 1, npc.heightLevel) & 0x1280183) != 0) {
    				npc.moveX = 0;
    				npc.moveY = 0;
    				if ((Region
    						.getClipping(npc.absX, npc.absY - 1, npc.heightLevel) & 0x1280102) == 0)
    					npc.moveY = -1;
    				else
    					npc.moveX = 1;
    			}
    		} else if (npc.moveX == -1 && npc.moveY == 1) {
    			if ((Region
    					.getClipping(npc.absX - 1, npc.absY + 1, npc.heightLevel) & 0x128013) != 0) {
    				npc.moveX = 0;
    				npc.moveY = 0;
    				if ((Region
    						.getClipping(npc.absX, npc.absY + 1, npc.heightLevel) & 0x1280120) == 0)
    					npc.moveY = 1;
    				else
    					npc.moveX = -1;
    			}
    		} // Checking Diagonal movement.
    
    		if (npc.moveY == -1) {
    			if ((Region.getClipping(npc.absX, npc.absY - 1, npc.heightLevel) & 0x1280102) != 0)
    				npc.moveY = 0;
    		} else if (npc.moveY == 1) {
    			if ((Region.getClipping(npc.absX, npc.absY + 1, npc.heightLevel) & 0x1280120) != 0)
    				npc.moveY = 0;
    		} // Checking Y movement.
    		if (npc.moveX == 1) {
    			if ((Region.getClipping(npc.absX + 1, npc.absY, npc.heightLevel) & 0x1280180) != 0)
    				npc.moveX = 0;
    		} else if (npc.moveX == -1) {
    			if ((Region.getClipping(npc.absX - 1, npc.absY, npc.heightLevel) & 0x1280108) != 0)
    				npc.moveX = 0;
    		} // Checking X movement.
    	}
    
    	public int[] zamorak = { 6218, 6257, 6256, 6255, 6229, 6230, 6231, 6270,
    			6216, 6214, 6211, 6221, 6276, 6277, 6219 };
    
    	public int[] saradomin = { 6257, 6256, 6259, 6258, 6254, 6255, 6229, 6230,
    			6231, 6221, 6276, 6277, 6219 };
    
    	public int[] armadyl = { 6246, 6233, 6257, 6256, 6255, 6229, 6230, 6231,
    			6232, 6234, 6235, 6236, 6237, 6238, 6239, 6240, 6241, 6242, 6243,
    			6246, 6244, 6221, 6276, 6277, 6219 };
    
    	public int[] bandos = { 6269, 6210, 6212, 6257, 6256, 6255, 6229, 6230,
    			6231, 6268, 6274, 6283, 6282, 6275, 6221, 6273, 6276, 6272, 6213,
    			6277, 6219
    
    	};
    
    	public int getDeleteTime(int i) {
    		switch (i) {
    		case 5666:
    			return 10;
    		default:
    			return 4;
    		}
    	}
    
    	public void multiAttackGfx(int i, int gfx) {
    		if (npcs[i].projectileId < 0)
    			return;
    		for (int j = 0; j < PlayerHandler.players.length; j++) {
    			if (PlayerHandler.players[j] != null) {
    				Player c = (Player) PlayerHandler.players[j];
    				if (c.heightLevel != npcs[i].heightLevel)
    					continue;
    				if (Misc.goodDistance(PlayerHandler.players[j].absX,
    						PlayerHandler.players[j].absY, npcs[i].absX,
    						npcs[i].absY, 15)) {
    					int nX = npcs[i].getX() + offset(i);
    					int nY = npcs[i].getY() + offset(i);
    					int pX = c.getX();
    					int pY = c.getY();
    					int offX = (nY - pY) * -1;
    					int offY = (nX - pX) * -1;
    					PlayerAssistant.createPlayersProjectile(c, nX, nY, offX,
    							offY, 50, getProjectileSpeed(i),
    							npcs[i].projectileId, 43, 31, -c.getId() - 1, 65);
    				}
    			}
    		}
    	}
    
    	public static void createAbyssTele(Player c, int i) {
    		startAnimation(1818, i);
    		npcs[i].forceChat("Veniens! Sallakar! Rinnesset!");
    		PlayerAssistant.createPlayersStillGfx(c, 343, npcs[i].getX(), npcs[i]
    				.getY(), 0, 0);
    	}
    
    	public boolean switchesAttackers(int i) {
    		switch (npcs[i].npcType) {
    		case 2551:
    		case 2552:
    		case 2553:
    		case 6225:
    		case 6223:
    		case 6227:
    		case 6248:
    		case 6250:
    		case 6252:
    		case 2892:
    		case 2894:
    			return true;
    		}
    		return false;
    	}
    
    	public void multiAttackDamage(int i) {
    		int max = getMaxHit(i);
    		for (int j = 0; j < PlayerHandler.players.length; j++) {
    			if (PlayerHandler.players[j] != null) {
    				Player c = (Player) PlayerHandler.players[j];
    				if (c.isDead() || c.heightLevel != npcs[i].heightLevel)
    					continue;
    				if (c.vengOn && max > 0) {
    					CombatAssistant.appendVengeanceNPC(c, i, max);
    				}
    				if (Misc.goodDistance(PlayerHandler.players[j].absX,
    						PlayerHandler.players[j].absY, npcs[i].absX,
    						npcs[i].absY, 15)) {
    					if (npcs[i].attackType == 2) {
    						if (!c.prayerActive[16]) {
    							if (Misc.random(500) + 200 > Misc
    									.random(CombatAssistant.mageDef(c))) {
    								int dam = Misc.random(max);
    								c.dealDamage(dam);
    								c.handleHitMask(dam);
    							} else {
    								c.dealDamage(0);
    								c.handleHitMask(0);
    							}
    						} else {
    							c.dealDamage(0);
    							c.handleHitMask(0);
    						}
    					} else if (npcs[i].attackType == 1) {
    						if (!c.prayerActive[17]) {
    							int dam = Misc.random(max);
    							if (Misc.random(500) + 200 > Misc
    									.random(CombatAssistant
    											.calculateRangeDefence(c))) {
    								c.dealDamage(dam);
    								c.handleHitMask(dam);
    							} else {
    								c.dealDamage(0);
    								c.handleHitMask(0);
    							}
    						} else {
    							c.dealDamage(0);
    							c.handleHitMask(0);
    						}
    					}
    					if (npcs[i].endGfx > 0) {
    						c.gfx0(npcs[i].endGfx);
    					}
    				}
    				PlayerAssistant.refreshSkill(c, 3);
    			}
    		}
    	}
    
    	public int getClosePlayer(int i) {
    		for (int j = 0; j < PlayerHandler.players.length; j++) {
    			if (PlayerHandler.players[j] != null) {
    				if (j == npcs[i].spawnedBy)
    					return j;
    				if (Misc.goodDistance(PlayerHandler.players[j].absX,
    						PlayerHandler.players[j].absY, npcs[i].absX,
    						npcs[i].absY, 2 + distanceRequired(i)
    								+ followDistance(i))
    						|| isFightCaveNpc(i)) {
    					
    					if ((PlayerHandler.players[j].underAttackBy <= 0 && PlayerHandler.players[j].underAttackBy2 <= 0)
    							|| PlayerHandler.players[j].inMulti())
    						if (PlayerHandler.players[j].heightLevel == npcs[i].heightLevel)
    							return j;
    					if(npcs[i].npcType == 1266)
    						npcs[i].requestTransform(1265);
    				}
    				
    			}
    		}
    		return 0;
    	}
    
    	public int getCloseRandomPlayer(int i) {
    		ArrayList<Integer> players = new ArrayList<Integer>();
    		for (int j = 0; j < PlayerHandler.players.length; j++) {
    			if (PlayerHandler.players[j] != null) {
    				if (Misc.goodDistance(PlayerHandler.players[j].absX,
    						PlayerHandler.players[j].absY, npcs[i].absX,
    						npcs[i].absY, 2 + distanceRequired(i)
    								+ followDistance(i))
    						|| isFightCaveNpc(i)) {
    					if ((PlayerHandler.players[j].underAttackBy <= 0 && PlayerHandler.players[j].underAttackBy2 <= 0)
    							|| PlayerHandler.players[j].inMulti())
    						if (PlayerHandler.players[j].heightLevel == npcs[i].heightLevel)
    							players.add(j);
    				}
    			}
    		}
    		if (players.size() > 0)
    			return players.get(Misc.random(players.size() - 1));
    		else
    			return 0;
    	}
    
    	public boolean isAggressive(int i) {
    		int[] data = { 2550, 2551, 2552, 2553, 6222, 6225, 6223, 6227, 6247,
    				6248, 6250, 6252, 2892, 2894, 2881, 2882, 2883, 6203, 6204,
    				6206, 6208, 5666, 1931 };
    		for (int l = 0; l < data.length; l++) {
    			if (npcs[i].npcType == data[l]) {
    				return true;
    			}
    		}
    		if (npcs[i].inWild() && npcs[i].MaxHP > 0)
    			return true;
    		if (isFightCaveNpc(i))
    			return true;
    		return false;
    	}
    
    	public boolean isFightCaveNpc(int i) {
    		switch (npcs[i].npcType) {
    		case 2627:
    		case 2630:
    		case 2631:
    		case 2741:
    		case 2743:
    		case 2745:
    			return true;
    		}
    		return false;
    	}
    
    	public boolean resetAttackNpc(int i) {
    		if (npcs[i] == null)
    			return false;
    		npcs[i].attackNpc = -1;
    		npcs[i].underAttackNpc = false;
    		npcs[i].attackingNpc = false;
    		// npcs[i].randomWalk = true;
    		return true;
    	}
    
    	/**
    	 * Npc names
    	 **/
    
    	public String getNpcName(int npcId) {
    		if (npcId <= -1) {
    			return "None";
    		}
    		if (NPCDefinitions.getDefinitions()[npcId] == null) {
    			return "None";
    		}
    		return NPCDefinitions.getDefinitions()[npcId].getNpcName();
    	}
    
    	/**
    	 * Summon npc, barrows, etc
    	 **/
    	public static void spawnNpc(Player c, int npcType, int x, int y,
    			int heightLevel, int WalkingType, int HP, int maxHit, int attack,
    			int defence, boolean attackPlayer, boolean headIcon) {
    		// first, search for a free slot
    		int slot = -1;
    		for (int i = 1; i < maxNPCs; i++) {
    			if (npcs[i] == null) {
    				slot = i;
    				break;
    			}
    		}
    		if (slot == -1) {
    			return;
    		}
    		NPC newNPC = new NPC(slot, npcType);
    		newNPC.absX = x;
    		newNPC.absY = y;
    		newNPC.makeX = x;
    		newNPC.makeY = y;
    		newNPC.heightLevel = heightLevel;
    		newNPC.walkingType = WalkingType;
    		newNPC.HP = HP;
    		newNPC.MaxHP = HP;
    		newNPC.maxHit = maxHit;
    		newNPC.attack = attack;
    		newNPC.defence = defence;
    		newNPC.spawnedBy = c.getId();
    		if (headIcon)
    			PlayerAssistant.drawHeadicon(c, 1, slot, 0, 0);
    		for (int anim = 4277; anim < 4285; anim++) {
    			if (npcType == anim) {
    				newNPC.forceChat("I'M ALIVE!");
    			}
    		}
    		if (npcType == 3117) {
    			newNPC.forceChat("Hello there " + c.playerName + "!");
    			newNPC.gfx0(580);
    		}
    		if (npcType == 2458) {
    			newNPC.forceChat("Hello there " + c.playerName
    					+ ", I need your help!");
    			newNPC.gfx0(580);
    		}
    		if (attackPlayer) {
    			newNPC.underAttack = true;
    			if (c != null) {
    				newNPC.killerId = c.playerId;
    			}
    		}
    		npcs[slot] = newNPC;
    	}
    
    	public void newNPC(int npcType, int x, int y, int heightLevel,
    			int WalkingType, int HP, int maxHit, int attack, int defence) {
    		// first, search for a free slot
    		int slot = -1;
    		for (int i = 1; i < maxNPCs; i++) {
    			if (npcs[i] == null) {
    				slot = i;
    				break;
    			}
    		}
    
    		if (slot == -1)
    			return; // no free slot found
    
    		NPC newNPC = new NPC(slot, npcType);
    		newNPC.absX = x;
    		newNPC.absY = y;
    		newNPC.makeX = x;
    		newNPC.makeY = y;
    		newNPC.heightLevel = heightLevel;
    		newNPC.walkingType = WalkingType;
    		newNPC.HP = HP;
    		newNPC.MaxHP = HP;
    		newNPC.maxHit = maxHit;
    		newNPC.attack = attack;
    		newNPC.defence = defence;
    		npcs[slot] = newNPC;
    	}
    
    	public void spawnNpc2(int npcType, int x, int y, int heightLevel,
    			int WalkingType, int HP, int maxHit, int attack, int defence) {
    		// first, search for a free slot
    		int slot = -1;
    		for (int i = 1; i < maxNPCs; i++) {
    			if (npcs[i] == null) {
    				slot = i;
    				break;
    			}
    		}
    		if (slot == -1) {
    			// Misc.println("No Free Slot");
    			return; // no free slot found
    		}
    		NPC newNPC = new NPC(slot, npcType);
    		newNPC.absX = x;
    		newNPC.absY = y;
    		newNPC.makeX = x;
    		newNPC.makeY = y;
    		newNPC.heightLevel = heightLevel;
    		newNPC.walkingType = WalkingType;
    		newNPC.HP = HP;
    		newNPC.MaxHP = HP;
    		newNPC.maxHit = maxHit;
    		newNPC.attack = attack;
    		newNPC.defence = defence;
    		npcs[slot] = newNPC;
    	}
    
    	public void spawnNpc3(int npcType, int x, int y, int heightLevel,
    			int WalkingType, int HP, int maxHit, int attack, int defence) {
    		// first, search for a free slot
    		int slot = -1;
    		for (int i = 1; i < maxNPCs; i++) {
    			if (npcs[i] == null) {
    				slot = i;
    				break;
    			}
    		}
    		if (slot == -1) {
    			// Misc.println("No Free Slot");
    			return; // no free slot found
    		}
    		NPC newNPC = new NPC(slot, npcType);
    		newNPC.absX = x;
    		newNPC.absY = y;
    		newNPC.makeX = x;
    		newNPC.makeY = y;
    		newNPC.heightLevel = heightLevel;
    		newNPC.walkingType = WalkingType;
    		newNPC.HP = HP;
    		newNPC.MaxHP = HP;
    		newNPC.maxHit = maxHit;
    		newNPC.attack = attack;
    		newNPC.defence = defence;
    		npcs[slot] = newNPC;
    	}
    
    	/**
    	 * Emotes
    	 **/
    	public int getDeadEmote(int i) {
    		switch (npcs[i].npcType) {
    		case 3835:
    			return 6242;
    		case 3836:
    			return 6233;
    
    		case 1153:
    		case 1154:
    		case 1155:
    		case 1156:
    		case 1157:
    			return 6228;
    
    		case 709:
    		case 708:
    			return 172;
    		case 3497:
    			return 1342;
    		case 3496:
    			return 3509;
    		case 3493:
    			return 3503;
    		case 3494:
    			return 1752;
    		case 5666:
    			return 5898;
    		case 6203:
    			return 6946;
    		case 6204:
    		case 6206:
    		case 6208:
    			return 67;
    
    		case 6282:
    			return 6182;
    		case 6275:
    			return 167;
    		case 6276:
    		case 6277:
    			return 4321;
    		case 6279:
    		case 6280:
    		case 6283:
    			return 6182;
    		case 6211:
    			return 172;
    		case 6212:
    			return 6537;
    		case 6219:
    		case 6221:
    		case 6254:
    		case 6255:
    		case 6256:
    		case 6257:
    		case 6258:
    		case 6214:
    			return 0x900;
    		case 6216:
    			return 1580;
    		case 6218:
    			return 4302;
    		case 6268:
    			return 2938;
    		case 6269:
    		case 6270:
    			return 4653;
    		case 6229:
    		case 6230:
    		case 6231:
    		case 6232:
    		case 6233:
    		case 6234:
    		case 6235:
    		case 6236:
    		case 6237:
    		case 6238:
    		case 6239:
    		case 6240:
    		case 6241:
    		case 6242:
    		case 6243:
    		case 6244:
    		case 6245:
    		case 6246:
    			return 6956;
    		case 6210:
    			return 6576;
    		case 6271:
    		case 6272:
    		case 6274:
    			return 4321;
    			// sara gwd
    		case 6247:
    			return 6965;
    		case 6248:
    			return 6377;
    		case 6250:
    			return 7016;
    		case 6252:
    			return 7011;
    			// bandos gwd
    		case 2551:
    		case 2552:
    		case 2553:
    			return 6156;
    		case 2550:
    			return 7062;
    		case 2892:
    		case 2894:
    			return 2865;
    		case 1612: // banshee
    			return 1524;
    		case 6222:
    			return 6975;
    		case 6225:
    		case 6223:
    		case 6227:
    			return 6956;
    		case 2607:
    			return 2607;
    		case 2627:
    			return 2620;
    		case 2630:
    			return 2627;
    		case 2631:
    			return 2630;
    		case 2738:
    			return 2627;
    		case 2741:
    			return 2638;
    		case 2746:
    			return 2638;
    		case 2743:
    			return 2646;
    		case 2745:
    			return 2654;
    
    		case 3777:
    		case 3778:
    		case 3779:
    		case 3780:
    			return -1;
    
    		case 3200:
    			return 3147;
    
    		case 2035: // spider
    			return 146;
    
    		case 2033: // rat
    			return 141;
    
    		case 2031: // bloodvel
    			return 2073;
    
    		case 100:
    			return 6182;
    		case 101: // goblins
    		case 102:
    			return 6190;
    
    		case 81: // cow
    			return 0x03E;
    
    		case 41: // chicken
    			return 57;
    
    		case 1338: // dagannoth
    		case 1340:
    		case 1342:
    			return 1342;
    
    		case 2881:
    		case 2882:
    		case 2883:
    			return 2856;
    
    		case 111: // ice giant
    			return 131;
    
    		case 125: // ice warrior
    			return 843;
    
    		case 751:// Zombies!!
    			return 302;
    
    		case 1626:
    		case 1627:
    		case 1628:
    		case 1629:
    		case 1630:
    		case 1631:
    		case 1632: // turoth!
    			return 1597;
    
    		case 1616: // basilisk
    			return 1548;
    
    		case 1653: // hand
    			return 1590;
    
    		case 82:// demons
    		case 83:
    		case 84:
    			return 67;
    
    		case 1605:// abby spec
    			return 1508;
    
    		case 51:// baby drags
    		case 52:
    		case 1589:
    		case 3376:
    			return 28;
    
    		case 1610:
    		case 1611:
    			return 1518;
    
    		case 1618:
    		case 1619:
    			return 1553;
    
    		case 1620:
    		case 1621:
    			return 1563;
    
    		case 2783:
    			return 2733;
    
    		case 1615:
    			return 1538;
    
    		case 1624:
    			return 1558;
    
    		case 1613:
    			return 1530;
    
    		case 1633:
    		case 1634:
    		case 1635:
    		case 1636:
    			return 1580;
    
    		case 1648:
    		case 1649:
    		case 1650:
    		case 1651:
    		case 1652:
    		case 1654:
    		case 1655:
    		case 1656:
    		case 1657:
    			return 1590;
    
    		case 105:
    		case 106:
    			return 4929;
    
    		case 412:
    		case 78:
    			return 36;
    
    		case 122:
    		case 123:
    			return 167;
    
    		case 58:
    		case 59:
    		case 60:
    		case 61:
    		case 62:
    		case 63:
    		case 64:
    		case 134:
    			return 146;
    
    		case 103:
    		case 104:
    			return 123;
    
    		case 118:
    		case 119:
    			return 102;
    
    		case 50:// drags
    			return 4642;
    
    		case 53:
    		case 54:
    		case 55:
    		case 941:
    		case 1590:
    		case 1591:
    		case 1592:
    			return 92;
    
    		case 3581:
    			return 5491;
    		case 5359:
    		case 1973:
    			return 5503;
    		case 3291:
    			return 5491;
    		case 94:
    			return 5491;
    		case 1471:
    			return 5521;
    		case 1575:
    			return 6576;
    
    		default:
    			return 2304;
    		}
    	}
    
    	public static int getAttackEmote(int i) {
    		switch (npcs[i].npcType) {
    
    		case 3835:
    			return 6240;
    		case 3836:
    			return 6234;
    
    		case 1153:
    		case 1154:
    		case 1156:
    			return 6223;
    
    		case 1155:
    		case 1157:
    			return 6224;
    
    		case 3581:
    			return Misc.random(1) == 0 ? 5485 : 5487;
    		case 5359:
    		case 1973:
    			return 5499;
    		case 3291:
    			return 5485;
    		case 1575:
    			return 6581;
    		case 1471:
    			return 5519;
    		case 94:
    			return 5485;
    
    		case 709:
    		case 708:
    			return 169;
    		case 3497:
    			return 1341;
    		case 3496:
    			return 3508;
    		case 3493:
    			return 3501;
    		case 3494:
    			return 1750;
    
    		case 2550:
    			if (npcs[i].attackType == 0)
    				return 7060;
    			else
    				return 7063;
    		case 5666:
    			if (npcs[i].attackType == 0)
    				return 5894;
    			else
    				return 5895;
    		case 6203:
    			return 6945;
    		case 6204:
    		case 6206:
    		case 6208:
    			return 64;
    		case 6222:
    			return 6977;
    		case 2892:
    		case 2894:
    			return 2868;
    		case 2627:
    			return 2621;
    		case 2630:
    			return 2625;
    		case 2631:
    			return 2633;
    		case 2741:
    			return 2637;
    		case 2746:
    			return 2637;
    		case 2607:
    			return 2611;
    		case 2743:// 360
    			return 2647;
    
    			// bandos gwd
    		case 6261:
    		case 6263:
    		case 6265:
    			return 6154;
    			// end of gwd
    			// arma gwd
    		case 6223:
    		case 6225:
    		case 6227:
    			return 6953;
    
    			// end of arma gwd
    			// sara gwd
    		case 6247:
    			return 6964;
    		case 6248:
    			return 6376;
    		case 6250:
    			return 7018;
    		case 6252:
    			return 7009;
    			// end of sara gwd
    
    		case 13: // wizards
    			return 711;
    
    		case 103:
    		case 655:
    			return 123;
    
    		case 1624:
    			return 1557;
    
    		case 1648:
    			return 1590;
    
    		case 2783: // dark beast
    			return 2731;
    
    		case 1615: // abby demon
    			return 1537;
    
    		case 1613: // nech
    			return 1528;
    
    		case 1610:
    		case 1611: // garg
    			return 1519;
    
    		case 1616: // basilisk
    			return 1546;
    
    		case 5365: // skele
    			return 260;
    
    		case 50:// drags
    			return 6446;
    		case 53:
    		case 54:
    		case 55:
    		case 941:
    		case 1590:
    		case 1591:
    		case 1592:
    			return -1;
    
    		case 124: // earth warrior
    			return 390;
    
    		case 803: // monk
    			return 422;
    
    		case 52: // baby drag
    			return 25;
    
    		case 58: // Shadow Spider
    		case 59: // Giant Spider
    		case 60: // Giant Spider
    		case 61: // Spider
    		case 62: // Jungle Spider
    		case 63: // Deadly Red Spider
    		case 64: // Ice Spider
    		case 134:
    			return 143;
    
    		case 105: // Bear
    		case 106: // Bear
    			return Misc.random(1) == 0 ? 4921 : 4925;
    
    		case 412:
    		case 78:
    			return 30;
    
    		case 2033: // rat
    			return 138;
    
    		case 2031: // bloodworm
    			return 2070;
    
    		case 100:
    			return 6185;
    		case 101: // goblins
    		case 102:
    			return Misc.random(1) == 0 ? 6184 : 6188;
    
    		case 81: // cow
    			return 0x03B;
    
    		case 21: // hero
    			return 451;
    
    		case 41: // chicken
    			return 55;
    
    		case 9: // guard
    		case 32: // guard
    		case 20: // paladin
    			return 451;
    
    		case 1338: // dagannoth
    		case 1340:
    		case 1342:
    			return 1341;
    
    		case 19: // white knight
    			return 406;
    
    		case 110:
    		case 111: // ice giant
    		case 112:
    		case 117:
    			return 128;
    
    		case 2452:
    			return 1312;
    
    		case 2889:
    			return 2859;
    
    		case 118:
    		case 119:
    			return 99;
    
    		case 82:// Lesser Demon
    		case 83:// Greater Demon
    		case 84:// Black Demon
    		case 1472:// jungle demon
    			return 64;
    
    		case 1267:
    		case 1265:
    			return 1312;
    
    		case 125: // ice warrior
    		case 178:
    			return 451;
    
    		case 123:
    		case 122:
    			return 164;
    
    		case 2028: // karil
    			return 2075;
    
    		case 2025: // ahrim
    			return 729;
    
    		case 2026: // dharok
    			return 2067;
    
    		case 2027: // guthan
    			return 2080;
    
    		case 2029: // torag
    			return 0x814;
    
    		case 2030: // verac
    			return 2062;
    
    		case 2881: // supreme
    			return 2855;
    
    		case 2882: // prime
    			return 2854;
    
    		case 2883: // rex
    			return 2851;
    
    		case 3200:
    			return 3146;
    
    		case 2745:
    			if (npcs[i].attackType == 2)
    				return 2656;
    			else if (npcs[i].attackType == 1)
    				return 2652;
    			else if (npcs[i].attackType == 0)
    				return 2655;
    
    		case 6213:
    		case 6212:
    			return 6547;
    		case 6219:
    		case 6254:
    		case 6255:
    		case 6256:
    		case 6257:
    		case 6258:
    		case 6214:
    			return 806;
    		case 6216:
    			return 1582;
    		case 6218:
    			return 4300;
    		case 6221:
    			return 811;
    
    		case 6229:
    		case 6230:
    		case 6231:
    		case 6232:
    		case 6233:
    		case 6234:
    		case 6235:
    		case 6236:
    		case 6237:
    		case 6238:
    		case 6239:
    		case 6240:
    		case 6241:
    		case 6242:
    		case 6243:
    		case 6244:
    		case 6245:
    		case 6246:
    			return 6953;
    		case 6210:
    			return 6581;
    		case 6211:
    			return 169;
    		case 6268:
    			return 2935;
    		case 6269:
    		case 6270:
    			return 4652;
    
    		case 6271:
    		case 6272:
    		case 6274:
    			return 4320;
    		case 6279:
    		case 6280:
    		case 6283:
    			return 6184;
    		case 6276:
    		case 6277:
    			return 4320;
    		case 6275:
    			return 164;
    		case 6282:
    			return 6188;
    		default:
    			// return 0x326;
    			int punch_or_kick[] = { 422, 423 };
    			return punch_or_kick[Misc.random(1)];
    		}
    	}
    
    	/**
    	 * Attack delays
    	 **/
    	public int getNpcDelay(int i) {
    		switch (npcs[i].npcType) {
    		case 2025:
    		case 2028:
    			return 7;
    
    		case 53:
    		case 54:
    		case 55:
    		case 941:
    		case 1590:
    		case 1591:
    		case 1592:
    			return 7;
    
    		case 2745:
    			return 8;
    
    		case 6222:
    		case 6225:
    		case 6223:
    		case 6227:
    		case 2550:
    			return 6;
    
    		case 6203:
    			return 5;
    		case 6204:
    		case 6206:
    		case 6208:
    			return 6;
    			// saradomin gw boss
    		case 6247:
    		case 3491:
    			return 2;
    
    		default:
    			return 5;
    		}
    	}
    
    	/**
    	 * Hit delays
    	 **/
    	public int getHitDelay(int i) {
    		switch (npcs[i].npcType) {
    
    		case 2881:
    		case 2882:
    		case 3200:
    		case 2892:
    		case 2894:
    			return 3;
    
    		case 2743:
    		case 2631:
    		case 6222:
    		case 6225:
    		case 6223:
    			return 3;
    
    		case 6203:
    			return 3;
    		case 6204:
    		case 6206:
    		case 6208:
    			return 3;
    		case 2745:
    			if (npcs[i].attackType == 1 || npcs[i].attackType == 2)
    				return 5;
    			else
    				return 2;
    
    		case 2025:
    			return 4;
    		case 2028:
    			return 3;
    
    		default:
    			return 2;
    		}
    	}
    
    	/**
    	 * Npc respawn time
    	 **/
    	public int getRespawnTime(int i) {
    		switch (npcs[i].npcType) {
    		case 2881:
    		case 2882:
    		case 2883:
    		case 6222:
    		case 6225:
    		case 6223:
    		case 6227:
    		case 6247:
    		case 6248:
    		case 6250:
    		case 2550:
    		case 2551:
    		case 2552:
    		case 2553:
    		case 6203:
    		case 6204:
    		case 6206:
    		case 6208:
    			return 100;
    		case 3777:
    		case 3778:
    		case 3779:
    		case 3780:
    		case 5666:
    			return 500;
    		default:
    			return 25;
    		}
    	}
    
    	public void newNPCList(int npcType, String npcName, int combat, int HP) {
    		NPCDefinitions newNPCList = new NPCDefinitions(npcType);
    		newNPCList.setNpcName(npcName);
    		newNPCList.setNpcCombat(combat);
    		newNPCList.setNpcHealth(HP);
    		NPCDefinitions.getDefinitions()[npcType] = newNPCList;
    	}
    
    	public int getDeathTimer(int i) {
    		switch (npcs[i].npcType) {
    		case 1265:
    			return 2;
    		default:
    			return 4;
    		}
    	}
    
    	public void process() {
    //		for (int i = 0; i < maxNPCs; i++) {
    //			if (npcs[i] == null)
    //				continue;
    //			npcs[i].clearUpdateFlags();
    //
    //		}
    
    		for (int i = 0; i < maxNPCs; i++) {
    			if (npcs[i] != null) {
    				if (npcs[i].actionTimer > 0) {
    					npcs[i].actionTimer--;
    				}
    				if (npcs[i].lastX != npcs[i].getX()
    						|| npcs[i].lastY != npcs[i].getY()) {
    					npcs[i].lastX = npcs[i].getX();
    					npcs[i].lastY = npcs[i].getY();
    				}
    				if (npcs[i].animTime > 0) {
    					if (npcs[i].animTime < 0) {
    						npcs[i].animTime = 0;
    					}
    					npcs[i].animTime--;
    				}
    				if (npcs[i].freezeTimer > 0) {
    					npcs[i].freezeTimer--;
    				}
    
    				if (npcs[i].hitDelayTimer > 0) {
    					npcs[i].hitDelayTimer--;
    				}
    
    				if (npcs[i].hitDelayTimer == 1) {
    					npcs[i].hitDelayTimer = 0;
    					applyDamage(i);
    				}
    
    				if (npcs[i].attackTimer > 0) {
    					npcs[i].attackTimer--;
    				}
    				
    //				if(npcs[i].sheepChange > 0 && System.currentTimeMillis() - npcs[i].sheepChange > 7000) {
    //					SheepCrafting.getCrafting().shearSheep(npcs[i].absX, npcs[i].absY, npcs[i].npcId);
    //				}
    
    				if (npcs[i].spawnedBy > 0) { // delete summons npc
    					if (PlayerHandler.players[npcs[i].spawnedBy] == null
    							|| PlayerHandler.players[npcs[i].spawnedBy].heightLevel != npcs[i].heightLevel
    							|| PlayerHandler.players[npcs[i].spawnedBy].respawnTimer > 0
    							|| !Misc.goodDistance(npcs[i].getX(), npcs[i]
    									.getY(),
    									PlayerHandler.players[npcs[i].spawnedBy]
    											.getX(),
    									PlayerHandler.players[npcs[i].spawnedBy]
    											.getY(), 20)) {
    						npcs[i] = null;
    					}
    				}
    				if (npcs[i] == null)
    					continue;
    
    				/**
    				 * Attacking player
    				 **/
    				if (isAggressive(i) && !npcs[i].underAttack && !npcs[i].isDead
    						&& !switchesAttackers(i)) {
    					npcs[i].killerId = getCloseRandomPlayer(i);
    				} else if (isAggressive(i) && !npcs[i].underAttack
    						&& !npcs[i].isDead && switchesAttackers(i)) {
    					npcs[i].killerId = getCloseRandomPlayer(i);
    				}
    				if (System.currentTimeMillis() - npcs[i].lastDamageTaken > 5000)
    					npcs[i].underAttackBy = 0;
    				if ((npcs[i].killerId > 0 || npcs[i].underAttack)
    						&& !npcs[i].walkingHome && retaliates(npcs[i].npcType)) {
    					if (!npcs[i].isDead) {
    						int p = npcs[i].killerId;
    						if (PlayerHandler.players[p] != null) {
    							Player c = (Player) PlayerHandler.players[p];
    							followPlayer(i, c.playerId);
    							npcs[i].facePlayer(c.playerId);
    
    							if (npcs[i] == null)
    								continue;
    							if (npcs[i].attackTimer == 0) {
    								if (c != null) {
    									attackPlayer(c, i);
    								}
    							}
    						} else {
    							npcs[i].killerId = 0;
    							npcs[i].underAttack = false;
    							npcs[i].facePlayer(0);
    						}
    					}
    				}
    
    				/**
    				 * Random walking and walking home
    				 **/
    				if (npcs[i] == null)
    					continue;
    				if ((!npcs[i].underAttack || npcs[i].walkingHome)
    						&& npcs[i].randomWalk && !npcs[i].isDead) {
    					npcs[i].facePlayer(0);
    					npcs[i].killerId = 0;
    					if (npcs[i].spawnedBy == 0) {
    						if ((npcs[i].absX > npcs[i].makeX
    								+ Config.NPC_RANDOM_WALK_DISTANCE)
    								|| (npcs[i].absX < npcs[i].makeX
    										- Config.NPC_RANDOM_WALK_DISTANCE)
    								|| (npcs[i].absY > npcs[i].makeY
    										+ Config.NPC_RANDOM_WALK_DISTANCE)
    								|| (npcs[i].absY < npcs[i].makeY
    										- Config.NPC_RANDOM_WALK_DISTANCE)) {
    							npcs[i].walkingHome = true;
    						}
    					}
    
    					if (npcs[i].walkingHome && npcs[i].absX == npcs[i].makeX
    							&& npcs[i].absY == npcs[i].makeY) {
    						npcs[i].walkingHome = false;
    					} else if (npcs[i].walkingHome) {
    						npcs[i].moveX = GetMove(npcs[i].absX, npcs[i].makeX);
    						npcs[i].moveY = GetMove(npcs[i].absY, npcs[i].makeY);
    						handleClipping(i);
    						npcs[i].getNextNPCMovement(i);
    						npcs[i].updateRequired = true;
    					}
    					if (npcs[i].walkingType >= 2) {
    						switch (npcs[i].walkingType) {
    						case 5: // WEST
    							npcs[i].turnNpc(npcs[i].absX - 1, npcs[i].absY);
    							break;
    
    						case 4: // EAST
    							npcs[i].turnNpc(npcs[i].absX + 1, npcs[i].absY);
    							break;
    
    						case 3: // SOUTH
    							npcs[i].turnNpc(npcs[i].absX, npcs[i].absY - 1);
    							break;
    						case 2: // NORTH
    							npcs[i].turnNpc(npcs[i].absX, npcs[i].absY + 1);
    							break;
    
    						default:
    							// npcs[i].turnNpc(npcs[i].absX, npcs[i].absY);
    							break;
    						}
    					}
    					if (npcs[i].walkingType == 1) {
    						if (Misc.random(3) == 1 && !npcs[i].walkingHome) {
    							int MoveX = 0;
    							int MoveY = 0;
    							int Rnd = Misc.random(9);
    							if (Rnd == 1) {
    								MoveX = 1;
    								MoveY = 1;
    							} else if (Rnd == 2) {
    								MoveX = -1;
    							} else if (Rnd == 3) {
    								MoveY = -1;
    							} else if (Rnd == 4) {
    								MoveX = 1;
    							} else if (Rnd == 5) {
    								MoveY = 1;
    							} else if (Rnd == 6) {
    								MoveX = -1;
    								MoveY = -1;
    							} else if (Rnd == 7) {
    								MoveX = -1;
    								MoveY = 1;
    							} else if (Rnd == 8) {
    								MoveX = 1;
    								MoveY = -1;
    							}
    
    							if (MoveX == 1) {
    								if (npcs[i].absX + MoveX < npcs[i].makeX + 1) {
    									npcs[i].moveX = MoveX;
    								} else {
    									npcs[i].moveX = 0;
    								}
    							}
    
    							if (MoveX == -1) {
    								if (npcs[i].absX - MoveX > npcs[i].makeX - 1) {
    									npcs[i].moveX = MoveX;
    								} else {
    									npcs[i].moveX = 0;
    								}
    							}
    
    							if (MoveY == 1) {
    								if (npcs[i].absY + MoveY < npcs[i].makeY + 1) {
    									npcs[i].moveY = MoveY;
    								} else {
    									npcs[i].moveY = 0;
    								}
    							}
    
    							if (MoveY == -1) {
    								if (npcs[i].absY - MoveY > npcs[i].makeY - 1) {
    									npcs[i].moveY = MoveY;
    								} else {
    									npcs[i].moveY = 0;
    								}
    							}
    							handleClipping(i);
    							npcs[i].getNextNPCMovement(i);
    							npcs[i].updateRequired = true;
    						}
    					}
    				}
    				if (npcs[i].isDead) {
    					if (npcs[i].actionTimer == 0 && npcs[i].applyDead == false
    							&& npcs[i].needRespawn == false) {
    						npcs[i].updateRequired = true;
    						npcs[i].facePlayer(0);
    						npcs[i].killedBy = getNpcKillerId(i);
    						npcs[i].animNumber = getDeadEmote(i); // dead emote
    						npcs[i].animUpdateRequired = true;
    						npcs[i].freezeTimer = 0;
    						killedRestlessGhostSkeleton(i);
    						npcs[i].applyDead = true;
    						npcs[i].actionTimer = getDeathTimer(i); // delete time
    						resetPlayersInCombat(i);
    					} else if (npcs[i].actionTimer == 0
    							&& npcs[i].applyDead == true
    							&& npcs[i].needRespawn == false) {
    						npcs[i].needRespawn = true;
    						npcs[i].actionTimer = getRespawnTime(i); // respawn time
    						dropItems(i); // npc drops items!
    						appendSlayerExperience(i);
    						appendKillCount(i);
    						npcs[i].absX = npcs[i].makeX;
    						npcs[i].absY = npcs[i].makeY;
    						npcs[i].HP = npcs[i].MaxHP;
    						npcs[i].animNumber = 0x328;
    						npcs[i].updateRequired = true;
    						npcs[i].animUpdateRequired = true;
    						if (npcs[i].npcType >= 2440 && npcs[i].npcType <= 2446) {
    							Server.objectManager.removeObject(npcs[i].absX,
    									npcs[i].absY);
    						}
    					} else if (npcs[i].actionTimer == 0
    							&& npcs[i].needRespawn == true) {
    						if (npcs[i].spawnedBy > 0) {
    							npcs[i] = null;
    						} else {
    							int old1 = npcs[i].npcType;
    							int old2 = npcs[i].makeX;
    							int old3 = npcs[i].makeY;
    							int old4 = npcs[i].heightLevel;
    							int old5 = npcs[i].walkingType;
    							int old6 = npcs[i].MaxHP;
    							int old7 = npcs[i].maxHit;
    							int old8 = npcs[i].attack;
    							int old9 = npcs[i].defence;
    
    							npcs[i] = null;
    							newNPC(old1, old2, old3, old4, old5, old6, old7,
    									old8, old9);
    						}
    					}
    				}
    			}
    		}
    	}
    
    	private void killedRestlessGhostSkeleton(int i) {
    		Player c = (Player) Server.playerHandler.players[npcs[i].killedBy];
    		if (c != null) {
    			if (npcs[i].npcType == 459 && c.quest_2 == 3) {
    				if(c.getItems().freeSlots()==0){
    					c.sendMessage("You need a free inventory spot to collect the skull.");
    					return;
    				}
    				c.getItems().addItem(553, 1);
    				c.quest_2 = 4;
    				c.sendMessage("You defeated the reckless skeleton!");
    			}
    
    		}
    
    	}
    
    	public boolean getsPulled(int i) {
    		switch (npcs[i].npcType) {
    		case 2550:
    			if (npcs[i].firstAttacker > 0)
    				return false;
    			break;
    		}
    		return true;
    	}
    
    	public boolean multiAttacks(int i) {
    		switch (npcs[i].npcType) {
    		case 6222:
    			return true;
    		case 6247:
    			if (npcs[i].attackType == 2)
    				return true;
    		case 2550:
    			if (npcs[i].attackType == 1)
    				return true;
    		default:
    			return false;
    		}
    
    	}
    
    	/**
    	 * Npc killer id?
    	 **/
    	public int getNpcKillerId(int npcId) {
    		int oldDamage = 0;
    		int killerId = 0;
    		for (int p = 1; p < Config.MAX_PLAYERS; p++) {
    			if (PlayerHandler.players[p] != null) {
    				if (PlayerHandler.players[p].lastNpcAttacked == npcId) {
    					if (PlayerHandler.players[p].totalDamageDealt > oldDamage) {
    						oldDamage = PlayerHandler.players[p].totalDamageDealt;
    						killerId = p;
    					}
    					PlayerHandler.players[p].totalDamageDealt = 0;
    				}
    			}
    		}
    		return killerId;
    	}
    
    	public void dropItems(int i) {
    		int npc = 0;
    		Player c = (Player) PlayerHandler.players[npcs[i].killedBy];
    		if (c != null) {
    
    			if (npcs[i].npcType == 4291 && c.inCyclops) {
    				int random2 = Misc.random(4);
    				if (random2 == 1) {
    					Server.itemHandler.createGroundItem(c, WarriorsGuild
    							.getCyclopsDrop(c), npcs[i].absX, npcs[i].absY, 1,
    							c.playerId);
    				}
    			}
    
    			if ((npcs[i].npcType == 4278 || npcs[i].npcType == 4279
    					|| npcs[i].npcType == 4280 || npcs[i].npcType == 4281
    					|| npcs[i].npcType == 4282 || npcs[i].npcType == 4283 || npcs[i].npcType == 4284)) {
    				c.sendMessage("You gain some tokens.");
    				c.spawned = false;
    			}
    
    			switch (npcs[i].npcType) {
    			case 2459:
    				FreakyForester.killedPheasant(c, 0);
    				Server.itemHandler.createGroundItem(c, 6178, npcs[i].absX,
    						npcs[i].absY, 1, c.playerId);
    				break;
    			case 2460:
    				FreakyForester.killedPheasant(c, 1);
    				Server.itemHandler.createGroundItem(c, 6178, npcs[i].absX,
    						npcs[i].absY, 1, c.playerId);
    				break;
    			case 2461:
    				FreakyForester.killedPheasant(c, 2);
    				Server.itemHandler.createGroundItem(c, 6178, npcs[i].absX,
    						npcs[i].absY, 1, c.playerId);
    				break;
    			case 2462:
    				FreakyForester.killedPheasant(c, 3);
    				Server.itemHandler.createGroundItem(c, 6178, npcs[i].absX,
    						npcs[i].absY, 1, c.playerId);
    				break;
    
    			}
    			int itemDrop = boneDrop(npcs[i].npcType);
    
    			for (npc = 0; npc < NPCDrops.NPC_DROPS.length; npc++) {
    				if (npcs[i].npcType == NPCDrops.NPC_DROPS[npc][0]) {
    					if (Misc.random(NPCDrops.NPC_DROPS[npc][3]) == 0) {
    						Server.itemHandler.createGroundItem(c,
    								NPCDrops.NPC_DROPS[npc][1], npcs[i].absX,
    								npcs[i].absY, NPCDrops.NPC_DROPS[npc][2],
    								c.playerId);
    					}
    				}
    			}
    
    			Server.itemHandler.createGroundItem(c, itemDrop, npcs[i].absX,
    					npcs[i].absY, getStackedDropAmount(itemDrop,
    							npcs[i].npcType), c.playerId);
    		}
    	}
    
    	public void appendKillCount(int i) {
    
    	}
    
    	// id of bones dropped by npcs
    	public int boneDrop(int type) {
    		switch (type) {
    		case 4278:
    		case 4279:
    		case 4280:
    		case 4281:
    		case 4282:
    		case 4283:
    		case 4284:
    			return 8851;
    
    		case 709:
    		case 708:
    			return 592;
    		case 116:
    		case 117:
    		case 1681:
    		case 4291:
    		case 4292:
    		case 6269:
    		case 6270:
    			return 532;// big bones
    		case 50:// drags
    		case 53:
    		case 54:
    		case 55:
    		case 941:
    		case 1590:
    		case 1591:
    		case 1592:
    			return 536;
    		case 84:
    		case 1615:
    		case 1613:
    		case 82:
    		case 3200:
    			return 592;
    		case 2881:
    		case 2882:
    		case 2883:
    			return 6729;
    		}
    		return 526;
    	}
    
    	public int getStackedDropAmount(int itemId, int npcId) {
    		switch (itemId) {
    		case 8851:
    			switch (npcId) {
    			case 4278:
    				return 5;
    			case 4279:
    				return 5;
    			case 4280:
    				return 10;
    			case 4281:
    				return 20;
    			case 4282:
    				return 30;
    			case 4283:
    				return 40;
    			case 4284:
    				return 50;
    			}
    			break;
    		case 995:
    			switch (npcId) {
    			case 1:
    				return 50 + Misc.random(50);
    			case 9:
    				return 133 + Misc.random(100);
    			case 1624:
    				return 1000 + Misc.random(300);
    			case 1618:
    				return 1000 + Misc.random(300);
    			case 1643:
    				return 1000 + Misc.random(3042340);
    			case 1610:
    				return 1000 + Misc.random(1000);
    			case 1613:
    				return 1500 + Misc.random(1250);
    			case 1615:
    				return 3000;
    			case 18:
    				return 500;
    			case 101:
    				return 60;
    			case 913:
    			case 912:
    			case 914:
    				return 750 + Misc.random(500);
    			case 1612:
    				return 250 + Misc.random(500);
    			case 1648:
    				return 250 + Misc.random(250);
    			case 5365:
    				return 200;
    			case 82:
    				return 1000 + Misc.random(455);
    			case 52:
    				return 400 + Misc.random(200);
    			case 49:
    				return 1500 + Misc.random(2000);
    			case 1341:
    				return 1500 + Misc.random(500);
    			case 26:
    				return 500 + Misc.random(100);
    			case 20:
    				return 750 + Misc.random(100);
    			case 21:
    				return 890 + Misc.random(125);
    			case 117:
    				return 500 + Misc.random(250);
    			case 2607:
    				return 500 + Misc.random(350);
    			}
    			break;
    		case 11212:
    			return 10 + Misc.random(4);
    		case 565:
    		case 561:
    			return 10;
    		case 560:
    		case 563:
    		case 562:
    			return 15;
    		case 555:
    		case 554:
    		case 556:
    		case 557:
    			return 20;
    		case 892:
    			return 40;
    		case 886:
    			return 100;
    		case 6522:
    			return 6 + Misc.random(5);
    
    		}
    
    		return 1;
    	}
    
    	/**
    	 * Slayer Experience
    	 **/
    	public void appendSlayerExperience(int i) {
    		Player c = (Player) PlayerHandler.players[npcs[i].killedBy];
    		if (c != null) {
    			if (c.slayerTask == npcs[i].npcType) {
    				c.taskAmount--;
    				PlayerAssistant.addSkillXP(c, npcs[i].MaxHP, 18);
    				if (c.taskAmount <= 0) {
    					PlayerAssistant.addSkillXP(c, (npcs[i].MaxHP * 8), 18);
    					c.slayerTask = -1;
    					c
    							.sendMessage("You completed your slayer task. Please see a slayer master to get a new one.");
    				}
    			}
    		}
    	}
    
    	/**
    	 * Resets players in combat
    	 */
    	public void resetPlayersInCombat(int i) {
    		for (int j = 0; j < PlayerHandler.players.length; j++) {
    			if (PlayerHandler.players[j] != null)
    				if (PlayerHandler.players[j].underAttackBy2 == i) {
    					PlayerHandler.players[j].underAttackBy2 = 0;
    					// PlayerHandler.players[j].npcIndex = 0;
    				}
    		}
    	}
    
    	/**
    	 * Npc Follow Player
    	 **/
    	public int GetMove(int Place1, int Place2) {
    		if ((Place1 - Place2) == 0) {
    			return 0;
    		} else if ((Place1 - Place2) < 0) {
    			return 1;
    		} else if ((Place1 - Place2) > 0) {
    			return -1;
    		}
    		return 0;
    	}
    
    	public boolean followPlayer(int i) {
    		switch (npcs[i].npcType) {
    		case 2892:
    		case 2894:
    			return false;
    		}
    		return true;
    	}
    
    	private Player c;
    
    	public void followPlayer(int i, int playerId) {
    		NPC npc = npcs[i];
    		Player player = PlayerHandler.players[playerId];
    		if (player == null) {
    			return;
    		}
    		if (player.respawnTimer > 0) {
    			npc.facePlayer(0);
    			npc.randomWalk = true;
    			npc.underAttack = false;
    			return;
    		}
    
    		if (!followPlayer(i)) {
    			npc.facePlayer(c.playerId);
    			return;
    		}
    
    		int playerX = player.absX;
    		int playerY = player.absY;
    
    		int x = npc.absX;
    		int y = npc.absY;
    
    		@SuppressWarnings("unused")
    		int size = NPCSize.getNPCSize(i);
    		int distanceReq = distanceRequired(i);
    
    		npcs[i].randomWalk = false;
    		if (Misc.goodDistance(x, y, playerX, playerY, distanceReq/* , size */))
    			// {//System.out.println(""+ x +" "+ y +" ; "+ playerX +" "+ playerY
    			// +" ; "+ size);
    			return;
    		// }
    
    		if ((npcs[i].spawnedBy > 0)
    				|| ((x < npc.makeX + Config.NPC_FOLLOW_DISTANCE)
    						&& (x > npc.makeX - Config.NPC_FOLLOW_DISTANCE)
    						&& (y < npc.makeY + Config.NPC_FOLLOW_DISTANCE) && (y > npc.makeY
    						- Config.NPC_FOLLOW_DISTANCE))) {
    			if (npc.heightLevel == player.heightLevel /*
    													 * &&
    													 * !goodDistance(x+GetMove
    													 * (x, playerX),
    													 * y+GetMove(y, playerY),
    													 * playerX, playerY,
    													 * distanceReq, size)
    													 */) {
    				if (player != null && npc != null) {
    					if (playerY < y) {
    						npc.moveX = GetMove(x, playerX);
    						npc.moveY = GetMove(y, playerY);
    					} else if (playerY > y) {
    						npc.moveX = GetMove(x, playerX);
    						npc.moveY = GetMove(y, playerY);
    					} else if (playerX < x) {
    						npc.moveX = GetMove(x, playerX);
    						npc.moveY = GetMove(y, playerY);
    					} else if (playerX > x) {
    						npc.moveX = GetMove(x, playerX);
    						npc.moveY = GetMove(y, playerY);
    						/*
    						 * } else if (playerX == npcs[i].absX || playerY ==
    						 * npcs[i].absY) { int o = Misc.random(3); switch (o) {
    						 * case 0: npcs[i].moveX = GetMove(npcs[i].absX,
    						 * playerX); npcs[i].moveY = GetMove(npcs[i].absY,
    						 * playerY + 1); break;
    						 * 
    						 * case 1: npcs[i].moveX = GetMove(npcs[i].absX,
    						 * playerX); npcs[i].moveY = GetMove(npcs[i].absY,
    						 * playerY - 1); break;
    						 * 
    						 * case 2: npcs[i].moveX = GetMove(npcs[i].absX, playerX
    						 * + 1); npcs[i].moveY = GetMove(npcs[i].absY, playerY);
    						 * break;
    						 * 
    						 * case 3: npcs[i].moveX = GetMove(npcs[i].absX, playerX
    						 * - 1); npcs[i].moveY = GetMove(npcs[i].absY, playerY);
    						 * break; }
    						 */
    					}
    					npc.facePlayer(playerId);
    					handleClipping(i);
    					npc.getRandomAndHomeNPCWalking(i);
    					npc.updateRequired = true;
    				}
    			}
    		} else {
    			npc.facePlayer(0);
    			npc.randomWalk = true;
    			npc.underAttack = false;
    		}
    	}
    
    	/**
    	 * load spell
    	 **/
    	public void loadSpell2(int i) {
    		npcs[i].attackType = 3;
    		int random = Misc.random(3);
    		if (random == 0) {
    			npcs[i].projectileId = 393; // red
    			npcs[i].endGfx = 430;
    		} else if (random == 1) {
    			npcs[i].projectileId = 394; // green
    			npcs[i].endGfx = 429;
    		} else if (random == 2) {
    			npcs[i].projectileId = 395; // white
    			npcs[i].endGfx = 431;
    		} else if (random == 3) {
    			npcs[i].projectileId = 396; // blue
    			npcs[i].endGfx = 428;
    		}
    	}
    
    	public void loadSpell(Player c, int i) {
    		switch (npcs[i].npcType) {
    		case 2892:
    			npcs[i].projectileId = 94;
    			npcs[i].attackType = 2;
    			npcs[i].endGfx = 95;
    			break;
    		case 2894:
    			npcs[i].projectileId = 298;
    			npcs[i].attackType = 1;
    			break;
    		case 54:
    		case 55:
    		case 941:
    		case 1590:
    		case 1591:
    		case 1592:
    		case 3590:
    		case 5363:
    			npcs[i].attackType = 4;
    			break;
    		case 50:
    			int random = Misc.random(4);
    			if (random == 0) {
    				npcs[i].projectileId = 393; // red
    				npcs[i].endGfx = 430;
    				npcs[i].attackType = 3;
    			} else if (random == 1) {
    				npcs[i].projectileId = 394; // green
    				npcs[i].endGfx = 429;
    				npcs[i].attackType = 3;
    			} else if (random == 2) {
    				npcs[i].projectileId = 395; // white
    				npcs[i].endGfx = 431;
    				npcs[i].attackType = 3;
    			} else if (random == 3) {
    				npcs[i].projectileId = 396; // blue
    				npcs[i].endGfx = 428;
    				npcs[i].attackType = 3;
    			} else if (random == 4) {
    				npcs[i].projectileId = -1; // melee
    				npcs[i].endGfx = -1;
    				npcs[i].attackType = 0;
    			}
    			break;
    
    		// arma npcs
    		case 6227:
    			npcs[i].attackType = 0;
    			break;
    		case 6223:
    			npcs[i].attackType = 1;
    			npcs[i].projectileId = 1190;
    			break;
    		case 6203:
    		case 6204:
    		case 6206:
    		case 6208:
    			npcs[i].attackType = 0;
    			break;
    		case 6225:
    			npcs[i].attackType = 2;
    			npcs[i].projectileId = 1203;
    			break;
    		case 6222:
    			random = Misc.random(1);
    			npcs[i].attackType = 1 + random;
    			if (npcs[i].attackType == 1) {
    				npcs[i].projectileId = 1197;
    			} else {
    				npcs[i].attackType = 2;
    				npcs[i].projectileId = 1198;
    			}
    			break;
    		// sara npcs
    		case 6247: // sara
    			random = Misc.random(1);
    			if (random == 0) {
    				npcs[i].attackType = 2;
    				npcs[i].endGfx = 1224;
    				npcs[i].projectileId = -1;
    			} else if (random == 1)
    				npcs[i].attackType = 0;
    			break;
    		case 6248: // star
    			npcs[i].attackType = 0;
    			break;
    		case 6250: // growler
    			npcs[i].attackType = 2;
    			npcs[i].projectileId = 1203;
    			break;
    		case 6252: // bree
    			npcs[i].attackType = 1;
    			npcs[i].projectileId = 9;
    			break;
    		// bandos npcs
    		case 2550:
    			random = Misc.random(2);
    			if (random == 0 || random == 1)
    				npcs[i].attackType = 0;
    			else {
    				npcs[i].attackType = 1;
    				npcs[i].endGfx = 1211;
    				npcs[i].projectileId = 288;
    			}
    			break;
    		case 2551:
    			npcs[i].attackType = 0;
    			break;
    		case 2552:
    			npcs[i].attackType = 2;
    			npcs[i].projectileId = 1203;
    			break;
    		case 2553:
    			npcs[i].attackType = 1;
    			npcs[i].projectileId = 1206;
    			break;
    		case 13:
    			npcs[i].gfx100(99);
    			npcs[i].projectileId = 100;
    			npcs[i].endGfx = 101;
    			npcs[i].attackType = 0;
    			break;
    
    		case 2025:
    			npcs[i].attackType = 2;
    			int r = Misc.random(3);
    			if (r == 0) {
    				npcs[i].gfx100(158);
    				npcs[i].projectileId = 159;
    				npcs[i].endGfx = 160;
    			}
    			if (r == 1) {
    				npcs[i].gfx100(161);
    				npcs[i].projectileId = 162;
    				npcs[i].endGfx = 163;
    			}
    			if (r == 2) {
    				npcs[i].gfx100(164);
    				npcs[i].projectileId = 165;
    				npcs[i].endGfx = 166;
    			}
    			if (r == 3) {
    				npcs[i].gfx100(155);
    				npcs[i].projectileId = 156;
    			}
    			break;
    		case 2881:// supreme
    			npcs[i].attackType = 1;
    			npcs[i].projectileId = 298;
    			break;
    
    		case 2882:// prime
    			npcs[i].attackType = 2;
    			npcs[i].projectileId = 162;
    			npcs[i].endGfx = 477;
    			break;
    
    		case 2028:
    			npcs[i].attackType = 1;
    			npcs[i].projectileId = 27;
    			break;
    		case 5666:
    			int l04fg = Misc.random(5);
    			if (l04fg == 0) {
    				npcs[i].attackType = 1;
    			} else {
    				npcs[i].attackType = 0;
    			}
    			break;
    		case 3497:
    			npcs[i].gfx100(132);
    			npcs[i].projectileId = 133;
    			npcs[i].endGfx = 134;
    			npcs[i].attackType = 5 + Misc.random(4);
    			break;
    		case 3496:
    			npcs[i].gfx100(194);
    			npcs[i].projectileId = 195;
    			npcs[i].endGfx = 196;
    			// npcs[i].forceChat("Hssssssssssss", i);
    			npcs[i].attackType = 5 + Misc.random(4);
    			break;
    
    		case 3495:
    			if (!Misc.goodDistance(npcs[i].getX(), npcs[i].getY(), c.getX(), c
    					.getY(), 1)) {
    				c.gfx0(369);
    				if (c.freezeTimer <= 0) {
    					c.freezeTimer = 15;
    				}
    				// npcs[i].forceChat("Semolina-Go!", i);
    			}
    			break;
    		case 3493:
    			if (!Misc.goodDistance(npcs[i].getX(), npcs[i].getY(), c.getX(), c
    					.getY(), 3)) {
    				npcs[i].gfx100(155);
    				npcs[i].projectileId = 156;
    				npcs[i].endGfx = 157;
    			}
    			npcs[i].attackType = 5 + Misc.random(4);
    			break;
    		case 3494:
    			npcs[i].attackType = 10;
    			break;
    
    		case 3200:
    			int r2 = Misc.random(5);
    			if (r2 == 0) {
    				npcs[i].attackType = 1;
    				npcs[i].gfx100(550);
    				npcs[i].projectileId = 551;
    				npcs[i].endGfx = 552;
    				PlayerAssistant.chaosElementalEffect(c, 1);
    			} else if (r2 == 1) {
    				npcs[i].attackType = 2;
    				npcs[i].gfx100(553);
    				npcs[i].projectileId = 554;
    				npcs[i].endGfx = 555;
    				PlayerAssistant.chaosElementalEffect(c, 0);
    			} else {
    				npcs[i].attackType = 0;
    				npcs[i].gfx100(556);
    				npcs[i].projectileId = 557;
    				npcs[i].endGfx = 558;
    			}
    			break;
    		case 2745:
    			int r3 = 0;
    			if (Misc.goodDistance(npcs[i].absX, npcs[i].absY,
    					PlayerHandler.players[npcs[i].spawnedBy].absX,
    					PlayerHandler.players[npcs[i].spawnedBy].absY, 1))
    				r3 = Misc.random(2);
    			else
    				r3 = Misc.random(1);
    			if (r3 == 0) {
    				npcs[i].attackType = 2;
    				npcs[i].endGfx = 157;
    				npcs[i].projectileId = 448;
    			} else if (r3 == 1) {
    				npcs[i].attackType = 1;
    				npcs[i].endGfx = 451;
    				npcs[i].projectileId = -1;
    			} else if (r3 == 2) {
    				npcs[i].attackType = 0;
    				npcs[i].projectileId = -1;
    			}
    			break;
    		case 2743:
    			npcs[i].attackType = 2;
    			npcs[i].projectileId = 445;
    			npcs[i].endGfx = 446;
    			break;
    
    		case 2631:
    			npcs[i].attackType = 1;
    			npcs[i].projectileId = 443;
    			break;
    		default:
    			npcs[i].attackType = 0;
    			break;
    		}
    	}
    
    	/**
    	 * Distanced required to attack
    	 **/
    	public int distanceRequired(int i) {
    		switch (npcs[i].npcType) {
    		case 2025:
    		case 2028:
    			return 6;
    		case 50:
    		case 54:
    		case 55:
    		case 941:
    		case 1590:
    		case 1591:
    		case 3590:
    		case 5363:
    		case 6247:
    			return 6;
    		case 2881:// dag kings
    		case 2882:
    		case 3200:// chaos ele
    		case 2743:
    		case 2631:
    		case 2745:
    			return 8;
    		case 3495:
    		case 3496:
    		case 3497:
    			return 15;
    		case 2883:// rex
    			return 1;
    		case 2552:
    		case 2553:
    		case 2556:
    		case 2557:
    		case 6222:
    		case 6225:
    		case 6227:
    		case 6223:
    		case 6250:
    		case 6252:
    			// case 6203:
    			// case 6204:
    			// case 6206:
    			// case 6208:
    			return 9;
    			// things around dags
    		case 2892:
    		case 2894:
    			return 10;
    		case 3493:
    			return 3;
    		default:
    			return 1;
    		}
    	}
    
    	public int followDistance(int i) {
    		switch (npcs[i].npcType) {
    		case 2550:
    		case 2551:
    		case 6247:
    		case 6248:
    			return 8;
    		case 2883:
    			return 4;
    		case 2881:
    		case 2882:
    			return 1;
    
    		}
    		return 0;
    
    	}
    
    	public int getProjectileSpeed(int i) {
    		switch (npcs[i].npcType) {
    		case 2881:
    		case 2882:
    		case 3200:
    			return 85;
    
    		case 2745:
    			return 130;
    
    		case 50:
    			return 90;
    
    		case 2025:
    			return 85;
    
    		case 2028:
    			return 80;
    
    		default:
    			return 85;
    		}
    	}
    
    	/**
    	 * NPC Attacking Player
    	 **/
    	public void attackPlayer(Player c, final int i) {
    		if (npcs[i] != null) {
    			@SuppressWarnings("unused")
    			NPC npc = npcs[i];
    			if (npcs[i].isDead)
    				return;
    			c.npcIndex2 = i;
    			if (!npcs[i].inMulti() && npcs[i].underAttackBy > 0
    					&& npcs[i].underAttackBy != c.playerId) {
    				npcs[i].killerId = 0;
    				return;
    			}
    			if (!npcs[i].inMulti()
    					&& (c.underAttackBy > 0 || (c.underAttackBy2 > 0 && c.underAttackBy2 != i))) {
    				npcs[i].killerId = 0;
    				return;
    			}
    			if (npcs[i].heightLevel != c.heightLevel) {
    				npcs[i].killerId = 0;
    				return;
    			}
    			if (npcs[i].lastX != npcs[i].getX()
    					|| npcs[i].lastY != npcs[i].getY()) {
    				return;
    			}
    
    			if (PathFinder.clipAllowsAttack(npcs[i], c))
    				return;
    
    			// npcs[i].facePlayer(c.playerId);
    			/*
    			 * if(c.attackTimer <= 0 && c.npcIndex == 0 && c.oldNpcIndex == 0) {
    			 * startAnimation(CombatAssistant.npcDefenceAnim(i), i); }
    			 */
    			boolean special = false;// specialCase(c,i);
    			if (Misc.goodDistance(npcs[i].getX(), npcs[i].getY(), c.getX(), c
    					.getY(), distanceRequired(i))
    					|| special) {
    				if (c.respawnTimer <= 0) {
    					// npcs[i].facePlayer(c.playerId);
    					npcs[i].attackTimer = getNpcDelay(i);
    					npcs[i].hitDelayTimer = getHitDelay(i);
    					npcs[i].attackType = 0;
    					if (special)
    						loadSpell2(i);
    					else
    						loadSpell(c, i);
    					if (npcs[i].attackType == 3)
    						npcs[i].hitDelayTimer += 2;
    					if (multiAttacks(i)) {
    						multiAttackGfx(i, npcs[i].projectileId);
    						startAnimation(getAttackEmote(i), i);
    						npcs[i].oldIndex = c.playerId;
    						return;
    					}
    					if (npcs[i].projectileId > 0) {
    						int nX = npcs[i].getX() + offset(i);
    						int nY = npcs[i].getY() + offset(i);
    						int pX = c.getX();
    						int pY = c.getY();
    						int offX = (nY - pY) * -1;
    						int offY = (nX - pX) * -1;
    						PlayerAssistant.createPlayersProjectile(c, nX, nY,
    								offX, offY, 50, getProjectileSpeed(i),
    								npcs[i].projectileId, 43, 31, -c.getId() - 1,
    								65);
    					}
    					c.underAttackBy2 = i;
    					c.singleCombatDelay2 = System.currentTimeMillis();
    					npcs[i].oldIndex = c.playerId;
    					startAnimation(getAttackEmote(i), i);
    					c.killerId = c.playerId;
    					PlayerAssistant.removeAllWindows(c);
    				}
    			}
    		}
    	}
    
    	public int offset(int i) {
    		switch (npcs[i].npcType) {
    		case 54:
    		case 55:
    		case 941:
    		case 1590:
    		case 1591:
    		case 3590:
    		case 5363:
    		case 50:
    			return 4;
    		case 2881:
    		case 2882:
    			return 1;
    		case 2745:
    		case 2743:
    			return 1;
    		}
    		return 0;
    	}
    
    	public boolean specialCase(Player c, int i) { // responsible for npcs that
    		// much
    		if (Misc.goodDistance(npcs[i].getX(), npcs[i].getY(), c.getX(), c
    				.getY(), 8)
    				&& !Misc.goodDistance(npcs[i].getX(), npcs[i].getY(), c.getX(),
    						c.getY(), distanceRequired(i)))
    			return true;
    		return false;
    	}
    
    	public boolean retaliates(int npcType) {
    		return npcType < 3777 || npcType > 3780
    				&& !(npcType >= 2440 && npcType <= 2446);
    	}
    
    	public void applyDamage(int i) {
    		if (npcs[i] != null) {
    			if (PlayerHandler.players[npcs[i].oldIndex] == null) {
    				return;
    			}
    			if (npcs[i].isDead)
    				return;
    			Player c = (Player) PlayerHandler.players[npcs[i].oldIndex];
    			if (multiAttacks(i)) {
    				multiAttackDamage(i);
    				return;
    			}
    			if (c.playerIndex <= 0 && c.npcIndex <= 0)
    				if (c.autoRet == 1)
    					c.npcIndex = i;
    			if (c.respawnTimer <= 0) {
    				int damage = 0;
    				if (npcs[i].attackType == 0) {
    					damage = Misc.random(npcs[i].maxHit);
    					if (10 + Misc.random(CombatAssistant
    							.calculateMeleeDefence(c)) > Misc
    							.random(npcs[i].attack)) {
    						damage = 0;
    					}
    					if (c.prayerActive[18]) { // protect from melee
    						damage = 0;
    					}
    					if (c.playerLevel[3] - damage < 0) {
    						damage = c.playerLevel[3];
    					}
    				} else if (npcs[i].attackType == 1) { // range
    					damage = Misc.random(npcs[i].maxHit);
    					if (10 + Misc.random(CombatAssistant
    							.calculateRangeDefence(c)) > Misc
    							.random(npcs[i].attack)) {
    						damage = 0;
    					}
    					if (c.prayerActive[17]) { // protect from range
    						damage = 0;
    					}
    					if (c.playerLevel[3] - damage < 0) {
    						damage = c.playerLevel[3];
    					}
    				} else if (npcs[i].attackType == 2) { // magic
    					damage = Misc.random(npcs[i].maxHit);
    					boolean magicFailed = false;
    					if (10 + Misc.random(CombatAssistant.mageDef(c)) > Misc
    							.random(npcs[i].attack)) {
    						damage = 0;
    						magicFailed = true;
    					}
    					if (c.prayerActive[16]) { // protect from magic
    						damage = 0;
    						magicFailed = true;
    					}
    					if (c.playerLevel[3] - damage < 0) {
    						damage = c.playerLevel[3];
    					}
    					if (npcs[i].endGfx > 0
    							&& (!magicFailed || isFightCaveNpc(i))) {
    						c.gfx100(npcs[i].endGfx);
    					} else {
    						c.gfx100(85);
    					}
    				} else if (npcs[i].attackType == 3) { // fire breath
    					int anti = PlayerAssistant.antiFire(c);
    					if (anti == 0) {
    						damage = Misc.random(30) + 10;
    					} else if (anti == 1) {
    						damage = Misc.random(20);
    					} else if (anti == 2) {
    						damage = Misc.random(5);
    					}
    					if (c.playerLevel[3] - damage < 0)
    						damage = c.playerLevel[3];
    					c.gfx100(npcs[i].endGfx);
    				} else if (npcs[i].attackType == 4) {
    					int anti = PlayerAssistant.antiFire(c);
    					int newint = 0;
    					if (anti == 0) {
    						newint = 40;
    					} else if (anti == 1) {
    						newint = 30;
    					} else if (anti == 2) {
    						newint = 20;
    					}
    					if (c.playerEquipment[c.playerShield] == 11283
    							|| c.playerEquipment[c.playerShield] == 1540) {
    						newint -= 10;
    					}
    					if (c.prayerActive[16]) {
    						newint -= 20;
    						c
    								.sendMessage("You prayer absorbs a lot of the dragon fire!");
    					}
    					if (newint < 0) {
    						newint = 10;
    					}
    					startAnimation(81, i);
    					npcs[i].gfx100(1);
    					if (c.playerLevel[3] - newint < 0) {
    						newint = c.playerLevel[3];
    					}
    					damage = Misc.random(newint);
    				} else if (npcs[i].attackType == 5) {
    					damage = Misc.random(npcs[i].maxHit);
    					if (damage <= 5) {
    						c.playerLevel[2] -= (damage / 2);
    						c.sendMessage("Your strength has been reduced!");
    						PlayerAssistant.refreshSkill(c, 2);
    					}
    				} else if (npcs[i].attackType == 6) {
    					damage = Misc.random(npcs[i].maxHit);
    					if (damage <= 5) {
    						c.playerLevel[0] -= (damage / 2);
    						c.sendMessage("Your attack has been reduced!");
    						PlayerAssistant.refreshSkill(c, 0);
    					}
    				} else if (npcs[i].attackType == 7) {
    					damage = Misc.random(npcs[i].maxHit);
    					if (damage <= 5) {
    						c.playerLevel[1] -= (damage / 2);
    						c.sendMessage("Your defence has been reduced!");
    						PlayerAssistant.refreshSkill(c, 1);
    					}
    				} else if (npcs[i].attackType == 8) {
    					damage = Misc.random(npcs[i].maxHit);
    					if (damage <= 5) {
    						c.playerLevel[4] -= (damage / 2);
    						c.sendMessage("Your range has been reduced!");
    						PlayerAssistant.refreshSkill(c, 4);
    					}
    				} else if (npcs[i].attackType == 9) {
    					damage = Misc.random(npcs[i].maxHit);
    					if (damage <= 5) {
    						c.playerLevel[6] -= (damage / 2);
    						c.sendMessage("Your magic has been reduced!");
    						PlayerAssistant.refreshSkill(c, 6);
    					}
    				} else if (npcs[i].attackType == 10) {
    					damage = Misc.random(npcs[i].maxHit);
    					if (damage <= 15) {
    						c.playerLevel[2] -= (damage / 2);
    						c.sendMessage("Your strength has been reduced!");
    						PlayerAssistant.refreshSkill(c, 2);
    					}
    				}
    				if (c.playerLevel[3] - damage < 0) {
    					damage = c.playerLevel[3];
    				}
    
    				int playerDef = 10 + Misc.random(CombatAssistant
    						.calculateMeleeDefence(c));
    				int npcAttack = Misc.random(npcs[i].attack);
    				if (playerDef > npcAttack) {
    					damage = 0;
    				}
    
    				// c.sendMessage("playerDef: "+playerDef+", npcAttack: "+npcAttack+".");
    				handleSpecialEffects(c, i, damage);
    				if (c.vengOn && damage > 0) {
    					CombatAssistant.appendVengeanceNPC(c, i, damage);
    				}
    				if (damage > 0) {
    					CombatAssistant.applyRecoilNPC(c, damage, i);
    				}
    				c.logoutDelay = System.currentTimeMillis(); // logout delay
    				c.handleHitMask(damage);
    				c.playerLevel[3] -= damage;
    				PlayerAssistant.refreshSkill(c, 3);
    				c.updateRequired = true;
    			}
    			if (c.attackTimer < 9 || c.attackTimer == 0) { // block animation
    				c.startAnimation(CombatAssistant.getBlockEmote(c));
    			}
    		}
    	}
    
    	public void handleSpecialEffects(Player c, int i, int damage) {
    		if (npcs[i].npcType == 2892 || npcs[i].npcType == 2894) {
    			if (damage > 0) {
    				if (c != null) {
    					if (c.playerLevel[5] > 0) {
    						c.playerLevel[5]--;
    						PlayerAssistant.refreshSkill(c, 5);
    						PlayerAssistant.appendPoison(c, 12);
    					}
    				}
    			}
    		}
    
    	}
    
    	public static void startAnimation(int animId, int i) {
    		npcs[i].animNumber = animId;
    		npcs[i].animUpdateRequired = true;
    		npcs[i].updateRequired = true;
    
    	}
    
    	// public boolean goodDistance(int objectX, int objectY, int playerX, int
    	// playerY, int distance, int monsterSize) {
    	// // return ((objectX - playerX <= distance+monsterSize && objectX -
    	// playerX >= -distance-monsterSize) && (objectY - playerY <=
    	// distance+monsterSize && objectY - playerY >= -distance+monsterSize));
    	// System.out.println(Math.sqrt(Math.pow((playerX-centerX(objectX,playerX,monsterSize)),2))+Math.pow((playerY-centerY(objectY,playerY,monsterSize)),2)
    	// < distance+1);
    	// System.out.println(Math.sqrt(Math.pow((playerX-centerX(objectX,playerX,monsterSize)),2))+Math.pow((playerY-centerY(objectY,playerY,monsterSize)),2));
    	// System.out.println(""+objectX+ " "+objectY+ " "+playerX+ " "+playerY +
    	// " " + centerX(objectX,playerX,monsterSize) + " " +
    	// centerY(objectY,playerY,monsterSize));
    	// return
    	// (Math.sqrt(Math.pow((playerX-centerX(objectX,playerX,monsterSize)),2))+Math.pow((playerY-centerY(objectY,playerY,monsterSize)),2))
    	// < distance+1;
    	// }
    
    	public boolean goodDistance(int objectX, int objectY, int playerX,
    			int playerY, int distance) {
    		return ((objectX - playerX <= distance && objectX - playerX >= -distance) && (objectY
    				- playerY <= distance && objectY - playerY >= -distance));
    	}
    
    	public int getMaxHit(int i) {
    		switch (npcs[i].npcType) {
    		case 6222:
    			if (npcs[i].attackType == 2)
    				return 28;
    			else
    				return 68;
    		case 6247:
    			return 31;
    		case 2550:
    			return 36;
    		}
    		return 1;
    	}
    
    	public boolean loadAutoSpawn(String FileName) {
    		String line = "";
    		String token = "";
    		String token2 = "";
    		String token2_2 = "";
    		String[] token3 = new String[10];
    		boolean EndOfFile = false;
    		BufferedReader characterfile = null;
    		try {
    			characterfile = new BufferedReader(new FileReader("./" + FileName));
    		} catch (FileNotFoundException fileex) {
    			Misc.println(FileName + ": file not found.");
    			return false;
    		}
    		try {
    			line = characterfile.readLine();
    		} catch (IOException ioexception) {
    			Misc.println(FileName + ": error loading file.");
    			return false;
    		}
    		while (EndOfFile == false && line != null) {
    			line = line.trim();
    			int spot = line.indexOf("=");
    			if (spot > -1) {
    				token = line.substring(0, spot);
    				token = token.trim();
    				token2 = line.substring(spot + 1);
    				token2 = token2.trim();
    				token2_2 = token2.replaceAll("\t\t", "\t");
    				token2_2 = token2_2.replaceAll("\t\t", "\t");
    				token2_2 = token2_2.replaceAll("\t\t", "\t");
    				token2_2 = token2_2.replaceAll("\t\t", "\t");
    				token2_2 = token2_2.replaceAll("\t\t", "\t");
    				token3 = token2_2.split("\t");
    				if (token.equals("spawn")) {
    					newNPC(Integer.parseInt(token3[0]), Integer
    							.parseInt(token3[1]), Integer.parseInt(token3[2]),
    							Integer.parseInt(token3[3]), Integer
    									.parseInt(token3[4]), getNpcListHP(Integer
    									.parseInt(token3[0])), Integer
    									.parseInt(token3[5]), Integer
    									.parseInt(token3[6]), Integer
    									.parseInt(token3[7]));
    				}
    			} else {
    				if (line.equals("[ENDOFSPAWNLIST]")) {
    					try {
    						characterfile.close();
    					} catch (IOException ioexception) {
    					}
    					return true;
    				}
    			}
    			try {
    				line = characterfile.readLine();
    			} catch (IOException ioexception1) {
    				EndOfFile = true;
    			}
    		}
    		try {
    			characterfile.close();
    		} catch (IOException ioexception) {
    		}
    		return false;
    	}
    
    	public int getNpcListHP(int npcId) {
    		if (npcId <= -1) {
    			return 0;
    		}
    		if (NPCDefinitions.getDefinitions()[npcId] == null) {
    			return 0;
    		}
    		return NPCDefinitions.getDefinitions()[npcId].getNpcHealth();
    
    	}
    
    	public String getNpcListName(int npcId) {
    		if (npcId <= -1) {
    			return "None";
    		}
    		if (NPCDefinitions.getDefinitions()[npcId] == null) {
    			return "None";
    		}
    		return NPCDefinitions.getDefinitions()[npcId].getNpcName();
    	}
    
    	public boolean loadNPCList(String FileName) {
    		String line = "";
    		String token = "";
    		String token2 = "";
    		String token2_2 = "";
    		String[] token3 = new String[10];
    		boolean EndOfFile = false;
    		BufferedReader characterfile = null;
    		try {
    			characterfile = new BufferedReader(new FileReader("./" + FileName));
    		} catch (FileNotFoundException fileex) {
    			Misc.println(FileName + ": file not found.");
    			return false;
    		}
    		try {
    			line = characterfile.readLine();
    		} catch (IOException ioexception) {
    			Misc.println(FileName + ": error loading file.");
    			return false;
    		}
    		while (EndOfFile == false && line != null) {
    			line = line.trim();
    			int spot = line.indexOf("=");
    			if (spot > -1) {
    				token = line.substring(0, spot);
    				token = token.trim();
    				token2 = line.substring(spot + 1);
    				token2 = token2.trim();
    				token2_2 = token2.replaceAll("\t\t", "\t");
    				token2_2 = token2_2.replaceAll("\t\t", "\t");
    				token2_2 = token2_2.replaceAll("\t\t", "\t");
    				token2_2 = token2_2.replaceAll("\t\t", "\t");
    				token2_2 = token2_2.replaceAll("\t\t", "\t");
    				token3 = token2_2.split("\t");
    				if (token.equals("npc")) {
    					newNPCList(Integer.parseInt(token3[0]), token3[1], Integer
    							.parseInt(token3[2]), Integer.parseInt(token3[3]));
    				}
    			} else {
    				if (line.equals("[ENDOFNPCLIST]")) {
    					try {
    						characterfile.close();
    					} catch (IOException ioexception) {
    					}
    					return true;
    				}
    			}
    			try {
    				line = characterfile.readLine();
    			} catch (IOException ioexception1) {
    				EndOfFile = true;
    			}
    		}
    		try {
    			characterfile.close();
    		} catch (IOException ioexception) {
    		}
    		return false;
    	}
    
    	private float centerX(int x, int x2, int size) {
    		float zero = 0;
    		@SuppressWarnings("unused")
    		int d = 1;
    		/*
    		 * if (x>=x2){ d=-1; } switch (size) { case 1: zero=x; break; case 2:
    		 * zero=(float) (x+0.5*d); break; case 3: zero=(float) (x+1*d); break;
    		 * case 4: zero=(float) (x+1.5*d); break; case 5: zero=(float) (x+2*d);
    		 * break; }
    		 */
    		zero = (x + x + size) / 2;
    		return zero;
    	}
    
    	private float centerY(int x, int x2, int size) {
    		float zero = 0;
    		@SuppressWarnings("unused")
    		int d = 1;
    		/*
    		 * if (x>=x2){ d=-1; } switch (size) { case 1: zero=x; break; case 2:
    		 * zero=(float) (x+0.5*d); break; case 3: zero=(float) (x+1*d); break;
    		 * case 4: zero=(float) (x+1.5*d); break; case 5: zero=(float) (x+2*d);
    		 * break; }
    		 */
    		zero = (x + x + size) / 2;
    		return zero;
    	}
    	
    	
    	public void shearSheep(int x, int y, int oldSlot) {
    		if(oldSlot == -1)
    			return;
    		int slot = oldSlot;
    		int sheepId = npcs[slot].npcType == 42 ? 43 : 42;
    		int sheepX = npcs[slot].makeX;
    		int sheepY = npcs[slot].makeY;
    		npcs[slot].absX = 0;
    		npcs[slot].absY = 0;
    		npcs[slot] = null;
    		NPC newNPC = new NPC(slot, sheepId);
    		newNPC.absX = x;
    		newNPC.absY = y;
    		newNPC.makeX = sheepX;
    		newNPC.makeY = sheepY;
    		newNPC.heightLevel = 0;
    		newNPC.walkingType = 1;
    		newNPC.HP = 0;
    		newNPC.MaxHP = 0;
    		newNPC.maxHit = 0;
    		newNPC.attack = 0;
    		newNPC.defence = 0;
    		if(sheepId == 42) {
    			newNPC.sheepChange = System.currentTimeMillis();
    		}
    		npcs[slot] = newNPC;
    	}
    
    }
    Reply With Quote  
     

  2. #2  
    Registered Member

    Join Date
    Jun 2013
    Posts
    1,083
    Thanks given
    78
    Thanks received
    162
    Rep Power
    104
    Bump!!! Just wanted to help.. I'm having same issues you're having lol
    Reply With Quote  
     

  3. #3  
    Registered Member
    rsnerd's Avatar
    Join Date
    Mar 2010
    Posts
    1,084
    Thanks given
    70
    Thanks received
    88
    Rep Power
    84
    What do you mean they move away from someone if someone is to close?
    Reply With Quote  
     


Thread Information
Users Browsing this Thread

There are currently 1 users browsing this thread. (0 members and 1 guests)


User Tag List

Similar Threads

  1. [Pi] Callypsis v2 wc error!
    By 2nubs1cup in forum Help
    Replies: 15
    Last Post: 08-26-2013, 06:09 AM
  2. (PI) MTP V2 Npc Drops.
    By Clamarus in forum Help
    Replies: 3
    Last Post: 10-17-2011, 01:56 PM
  3. Replies: 4
    Last Post: 05-14-2011, 05:47 PM
  4. [PI] Npc error - help me :(
    By The Ricky in forum Help
    Replies: 8
    Last Post: 10-08-2010, 06:24 PM
  5. [PI] Some kind of error when npc dies
    By 3lou 55 in forum Help
    Replies: 7
    Last Post: 07-13-2010, 08:57 AM
Posting Permissions
  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts
  •