demonik v7 player.java:package com.rscd.model;import com.rscd.util.*;import com.rscd.net.Packet;import com.rscd.io.PlayerLoader;import com.rscd.net.ActionSender;import com.rscd.event.*;import com.rscd.entityhandling.EntityHandler;import com.rscd.quests.*;import org.apache.mina.common.IoSession;import java.util.*;import java.net.InetSocketAddress;/** * A single player object. */public final class Player extends Mob { public boolean beingAttacked() { for (DelayedEvent e : world.getDelayedEventHandler().getEvents()) { if (e instanceof AttackMobEvent) { AttackMobEvent ame = (AttackMobEvent)e; if (ame.getAffectedMob() instanceof Player) { if (((Player)ame.getAffectedMob()).equals(this)) { return true; } } } } return false; } public RangeEvent rangeEvent = null; public void setRangeEvent(RangeEvent e) { rangeEvent = e; } public boolean isRanging() { return (rangeEvent != null); } public void resetRanging() { rangeEvent.stop(); rangeEvent = null; } public long lastTradeUpdate = 0L; public long lastTradeUpdate() { return lastTradeUpdate; } public void setLastTradeUpdate() { lastTradeUpdate = System.currentTimeMillis(); } /** * Trade/duel spam handling. */ private boolean tradeChanged = false; private boolean duelChanged = false; public boolean tradeChanged() { return tradeChanged; } public boolean duelChanged() { return duelChanged; } public void setTradeChanged(boolean b) { tradeChanged = b; } public void setDuelChanged(boolean b) { duelChanged = b; } /** * Invisibility (admins) * * TODO: Make work */ private boolean invisible = false; public boolean isInvisible() { return invisible; } public void setInvisible(boolean b) { invisible = b; } public long lastStuck = 0; public long lastStuck() { return lastStuck; } public void resetLastStuck() { lastStuck = System.currentTimeMillis(); } public int getSkillTotal() { int total = 0; for(int i = 0; i < getMaxStats().length; i++) total += getMaxStat(i); return total; } /** * Trade/duel commands */ public void unsetTradeOptions() { setWishToTrade(null); setTrading(false); setTradeOfferAccepted(false); setTradeConfirmAccepted(false); resetTradeOffer(); getActionSender().sendTradeWindowClose(); } /** * Chat spam control */ private long lastChat = 0; public void setChatTimer() { lastChat = System.currentTimeMillis(); } public long getLastChatTimer() { return lastChat; } public boolean chatTimer() { return System.currentTimeMillis() - lastChat >= 350; } /** * Packet spam protection (aka DOS). */ private long lastPacket = 0; private int packetSpam = 0; public void resetPacketSpam() { packetSpam = 0; } public void incPacketSpam() { packetSpam++; } public int getPacketSpam() { return packetSpam; } public long getLastPacket() { return lastPacket; } public void setLastPacket() { lastPacket = System.currentTimeMillis(); } /** * Drop spam */ private long lastDrop = 0; public long getLastDrop() { return lastDrop; } public void setLastDrop() { lastDrop = System.currentTimeMillis(); } /** * Ghosting/tagging other player's info. */ private boolean flagged = false; public void flag() { flagged = true; } public boolean flagged() { return flagged; } public void unflag() { flagged = false; } private Player ghoster = null; public Player getGhoster() { return ghoster; } public void setGhoster(Player p) { ghoster = p; } private boolean ghosting = false; private Player ghost; private Bank oldBank = null; private Player seizer = null; // the player being seized uses this public boolean isGhosting() { return ghosting; } public void setGhosting(boolean b) { ghosting = b; } public void setGhost(Player p) { if(p == null) { if(oldBank != null) bank = oldBank; return; } this.ghost = p; oldBank = bank; bank.getItems().clear(); this.bank = ghost.getBank(); } public Player getGhost() { return ghost; } public Player getSeizer() { return seizer; } public void setSeizer(Player p) { seizer = p; } /** * Thieving */ private long lastThieve = 0; public long getLastThieve() { return lastThieve; } public void setLastThieve() { lastThieve = System.currentTimeMillis(); } /** * Spell failing */ private long lastFail = 0; public long getLastFail() { return lastFail; } public void setLastFail() { lastFail = System.currentTimeMillis(); } /** * Combat info */ private int kills = 0; private int deaths = 0; private String killed = ""; public int getKills() { return kills; } public int getDeaths() { return deaths; } public String getKilled() { if(killed.startsWith("|")) killed = killed.substring(1); if(killed.endsWith("|")) killed = killed.substring(0, killed.length() - 1); return killed.trim(); } public void setKills(int i) { kills = i; } public void setDeaths(int i) { deaths = i; } public void setKilled(String s) { killed = s; } public void incKills() { kills++; } public void incDeaths() { deaths++; } public void addKilled(Player p) { String hash = String.valueOf(p.getUsernameHash()); if(killed.indexOf(hash) > -1) return; killed = killed + "|" + hash; } public int getUniqueKills() { if(killed.length() == 0) return 0; return killed.split("\\|").length; } /** *Deactivated all activated prayers. */ public void stopAllPrayers() { for(int id : getActivatedPrayers()) { setPrayer(id, false); removePrayerDrain(id); } actionSender.sendPrayers(); } /** * Banking */ private Bank bank = new Bank(this); public Bank getBank() { return bank; } public void setBank(Bank bank) { this.bank = bank; } /** * Disconnection handling. */ private boolean disconnected = false; public boolean isConnected() { return !disconnected; } public boolean isDisconnected() { return disconnected; } public void setDisconnected(boolean b) { disconnected = b; } /** * Equipment checking for stat modifications. */ public void checkEquipment() { ListIterator iterator = getInventory().iterator(); for(int slot = 0; iterator.hasNext(); slot++) { InvItem item = (InvItem)iterator.next(); if(item.isWielded()) { if(!Config.PREMIUM_SERVER && item.getDef().isMembers()) { getActionSender().sendMessage("You cannot wield this item on a free server."); item.setWield(false); updateWornItems(item.getWieldableDef().getWieldPos(), getPlayerAppearance().getSprite(item.getWieldableDef().getWieldPos())); getActionSender().sendUpdateItem(slot); return; } String youNeed = ""; for(java.util.Map.Entry e : item.getWieldableDef().getStatsRequired()) { if(getMaxStat(((Integer)e.getKey()).intValue()) < ((Integer)e.getValue()).intValue()) { youNeed += ((Integer)e.getValue()).intValue() + " " + Formulae.statArray[((Integer)e.getKey()).intValue()] + ", "; } } if(!youNeed.equals("")) { getActionSender().sendMessage("You must have at least " + youNeed.substring(0, youNeed.length() - 2) + " to use this item."); item.setWield(false); updateWornItems(item.getWieldableDef().getWieldPos(), getPlayerAppearance().getSprite(item.getWieldableDef().getWieldPos())); getActionSender().sendUpdateItem(slot); return; } } } getActionSender().sendEquipmentStats(); } /** * This player's 'rank' */ private int rank = 0; /** * The multiplier for subscribed players. */ private double premiumMultiplier = 125.0; /** * @return This player's rank. */ public int getRank() { return rank; } /** * Ranks: * * 0 - Regular * 1 - Premium * 2 - Player mod * 3 - Admin * * @param i The new rank */ public void setRank(int i) { if(i == 3) admin = true; rank = i; } /** * @return If this player is a premium player. */ public boolean isPremium() { return rank >= 1; } /** * Current shop open */ private int currentShop = -1; public void setShop(int currentShop) { if(currentShop != -1) setState(MobState.SHOPPING); else setState(MobState.IDLE); this.currentShop = currentShop; } public int getCurrentShop() { return currentShop; } /** * Inventory spam control */ private long lastInvAction = 0L; public long getLastInvAction() { return lastInvAction; } public void setLastInvAction() { lastInvAction = System.currentTimeMillis(); } /** * Quest handling */ private QuestHandler questHandler = null; public QuestHandler getQuestHandler() { return questHandler; } /** * Ping to keep client alive. */ private long lastPingSent = 0L; public long getLastPingSent() { return lastPingSent; } public void setLastPingSent() { lastPingSent = System.currentTimeMillis(); } /** * Options menu. */ private MenuHandler menuHandler = null; public void setMenuHandler(MenuHandler menuHandler) { if(menuHandler == null) { if(getTalking() != null) { getTalking().setState(MobState.IDLE); getTalking().setTalking(null); } setTalking(null); return; } this.menuHandler = menuHandler; menuHandler.setOwner(this); actionSender.sendOptionMenu(menuHandler.getOptions()); setState(MobState.IN_OPTIONS_MENU); } public boolean hasMenuHandler() { return menuHandler != null; } public void resetMenuHandler() { menuHandler = null; } public void handleMenuReply(int choice) { menuHandler.handleReply(choice, menuHandler.getOption(choice)); } private long menuTime = 0L; public void setMenuTime() { menuTime = System.currentTimeMillis(); } public long getMenuTime() { return menuTime; } /** * Dummies */ private long lastDummyHit = 0L; private int dummyHits = 0; public int getDummyHits() { return dummyHits; } public void incDummyHits() { dummyHits++; } public void resetDummyHits() { dummyHits = 0; } public long getLastDummyHit() { return lastDummyHit; } public void setLastDummyHit() { lastDummyHit = System.currentTimeMillis(); } /** * Sets the player's current state. * * @param state the new MobState the player is taking on. */ public void setState(MobState state) { if(state == MobState.LEFT_FIGHTING || state == MobState.RIGHT_FIGHTING) unawareOfMove = true; if(getState() == MobState.LEFT_FIGHTING && state == MobState.IDLE) // if we're going from fighting an npc to not unawareOfMove = true; super.setState(state); } /** * Whether or not this player has had its last move updated. */ private boolean needsUpdate = true; private boolean unawareOfMove = true; // Unaware of move methods public boolean isUnawareOfMove() { return unawareOfMove; } public void resetUnawareOfMove() { unawareOfMove = false; } // Needs update methods public boolean needsUpdate() { return /*needsUpdate*/true; } // For now, always update. public void setNeedsUpdate(boolean b) { needsUpdate = b; } /** * The player's username */ private String username; /** * The player's username hash */ private long usernameHash; /** * The player's password */ private String password; /** * Indicates if the player is an admin */ private boolean admin = false; /** * Whether the player is currently logged in */ private boolean loggedIn = false; /** * The IO session of this player */ private IoSession ioSession; /** * Last time a 'ping' was received */ private long lastPing = System.currentTimeMillis(); /** * The Players appearance */ private PlayerAppearance appearance; /** * The items being worn by the player */ private int[] wornItems = new int[12]; /** * The exp level array */ private int[] exp = new int[18]; /** * If the player has been sending suscicious packets, their suspicion level will be > 0. */ private int suspicionLevel = 0; /** * The session this player currently is assigned to */ private long sessionID; /** * List of players this player 'knows' (recieved from the client) about */ private HashMap<Integer, Integer> knownPlayersAppearanceIDs = new HashMap<Integer, Integer>(); /** * Nearby game objects that we should be aware of */ private StatefulEntityCollection<GameObject> watchedObjects = new StatefulEntityCollection<GameObject>(); /** * Nearby items that we should be aware of */ private StatefulEntityCollection<Item> watchedItems = new StatefulEntityCollection<Item>(); /** * Inventory to hold items */ private Inventory inventory; /** * Users privacy settings, chat block etc. */ private boolean[] privacySettings = new boolean[4]; /** * Users game settings, camera rotation preference etc */ private boolean[] gameSettings = new boolean[5]; /** * Used to keep track of the drain from prayers */ private int drain = 0; /** * Methods to send packets related to actions */ private ActionSender actionSender; /** * Used for loading and saving player details */ private PlayerLoader loader; /** * Unix time when the player last logged in */ private long lastLogin = 0; /** * Unix time when the player logged in */ private long currentLogin = 0; /** * Stores the last IP address used */ private String lastIP = "0.0.0.0"; /** * Stores the current IP address used */ private String currentIP = "0.0.0.0"; /** * If the player is reconnecting after connection loss */ private boolean reconnecting = false; /** * Controls if were allowed to accept appearance updates */ private boolean changingAppearance = false; /** * Is the character male? */ private boolean maleGender; /** * The player we last requested to trade with, or null for none */ private Player wishToTrade = null; /** * If the player is currently in a trade */ private boolean isTrading = false; /** * List of items offered in the current trade */ private ArrayList<InvItem> tradeOffer = new ArrayList<InvItem>(); /** * If the first trade screen has been accepted */ private boolean tradeOfferAccepted = false; /** * If the second trade screen has been accepted */ private boolean tradeConfirmAccepted = false; /** * The player we last requested to duel with, or null for none */ private Player wishToDuel = null; /** * If the player is currently in a duel */ private boolean isDueling = false; /** * The settings for the duel */ private int[] duelSettings = new int[4]; /** * List of items offered in the duel */ private ArrayList<InvItem> duelOffer = new ArrayList<InvItem>(); /** * If the first duel screen has been accepted */ private boolean duelOfferAccepted = false; /** * If the second duel screen has been accepted */ private boolean duelConfirmAccepted = false; /** * List of usernameHash's of players on players friend list */ private ArrayList<Long> friendList = new ArrayList<Long>(); /** * List of usernameHash's of players on players ignore list */ private ArrayList<Long> ignoreList = new ArrayList<Long>(); /** * List of all projectiles needing displayed */ private ArrayList<Projectile> projectilesNeedingDisplayed = new ArrayList<Projectile>(); /** * Chat messages needing displayed */ private ArrayList<ChatMessage> chatMessagesNeedingDisplayed = new ArrayList<ChatMessage>(); /** * Bubbles needing displayed */ private ArrayList<Bubble> bubblesNeedingDisplayed = new ArrayList<Bubble>(); /** * Players we have been attacked by signed login, used to check if we should get a skull for attacking back */ private HashMap<Player, Long> attackedBy = new HashMap<Player, Long>(); /** * Time last report was sent, used to throttle reports */ private long lastReport = 0; /** * Time of last charge spell */ private long lastCharge = 0; /** * Combat style: 0 - all, 1 - str, 2 - att, 3 - def */ private int combatStyle = 0; private Player summoner = null; /** * When a request to summon was sent. */ private long summonTime = 0; public Player(IoSession ios) { ioSession = ios; currentIP = ((InetSocketAddress)ios.getRemoteAddress()).getAddress().getHostAddress(); currentLogin = Calendar.getInstance().getTimeInMillis(); actionSender = new ActionSender(this); loader = new PlayerLoader(); questHandler = new QuestHandler(); } /** * @return This player's PlayerLoader */ public PlayerLoader getLoader() { return loader; } /** * Summoning methods. */ public void setSummoner(Player summoner) { this.summoner = summoner; } public Player getSummoner() { return summoner; } public void setSummonTime(long newTime) { summonTime = newTime; } public long getSummonTime() { return summonTime; } /** * Combat style methods. */ public int getCombatStyle() { return combatStyle; } public void setCombatStyle(int style) { combatStyle = style; } /** * Loads the player from the database. */ public byte load(String username, String password, boolean reconnecting) { this.password = password; this.reconnecting = reconnecting; usernameHash = DataConversions.usernameToHash(username); this.username = DataConversions.hashToUsername(usernameHash); return (byte)loader.loadPlayer(this); } // Saves the player to the database. public void save() { loader.savePlayer(this); } /** * God spell charging methods */ public void setCharged() { lastCharge = System.currentTimeMillis(); } public boolean isCharged() { return System.currentTimeMillis() - lastCharge < 600000; } /** * Reporting methods */ public boolean canReport() { return System.currentTimeMillis() - lastReport > 60000; } public void setLastReport() { lastReport = System.currentTimeMillis(); } /** * Resets all duel settings */ public void unsetDuelOptions() { setWishToDuel(null); setDueling(false); setDuelOfferAccepted(false); setDuelConfirmAccepted(false); resetDuelSettings(); resetDuelOffer(); actionSender.sendDuelWindowClose(); } /** * Removes the given <code>InvItem</code> from * the duel offer. * * @param item The item to be removed. */ public void removeFromDuelOffer(InvItem item) { for(int i = 0; i < duelOffer.size(); i++) { if(duelOffer.get(i).getId() == item.getId()) { duelOffer.remove(i); } } } /** * Returns whether or not the given item ID * is already in the duel offer. * * @param id The item ID to check for. */ public boolean inDuelOffer(int id) { for(int i = 0; i < duelOffer.size(); i++) { if(duelOffer.get(i).getId() == id) return true; } return false; } /** * When a player dies in a duel, this * method is called. * * @param winner The player who defeated this player. */ public void killedByDuel(Player winner) { FightEvent duelEvent = getFightEvent();//world.getDelayedEventHandler().getDuelEvent(this); if(duelEvent != null) duelEvent.stop(); setBusy(false); setSprite(4); setOpponent(null); setCombatTimer(); incDeaths(); getActionSender().sendSound("death"); winner.incKills(); winner.addKilled(this); winner.getActionSender().sendMessage("You have defeated " + getUsername() + "!"); winner.getActionSender().sendSound("victory"); actionSender.sendDied(); for(int i = 0; i < 18; i++) setCurStat(i, getMaxStat(i)); ListIterator iterator = inventory.iterator(); for(int slot = 0; iterator.hasNext(); slot++) { InvItem item = (InvItem)iterator.next(); if(inDuelOffer(item.getId())) { if(item.getDef().isStackable()) { for(InvItem duelItem : duelOffer) { if(duelItem.getId() == item.getId()) { item.setAmount(item.getAmount() - duelItem.getAmount()); if(item.getAmount() <= 0) iterator.remove(); removeFromDuelOffer(item); world.registerItem(new Item(duelItem.getId(), getX(), getY(), duelItem.getAmount(), true, winner)); break; } } } else { if(item.isWielded()) { item.setWield(false); updateWornItems(item.getWieldableDef().getWieldPos(), appearance.getSprite(item.getWieldableDef().getWieldPos())); } iterator.remove(); removeFromDuelOffer(item); world.registerItem(new Item(item.getId(), getX(), getY(), item.getAmount(), true, winner)); } } } world.registerItem(new Item(20, getX(), getY(), 1, true, winner)); Collection<Player> allWatched = getWatchedPlayers().getAllEntities(); for(Player p : allWatched) { p.removeWatchedPlayer(this); } unsetDuelOptions(); setLocation(Formulae.getDeathLocation(), true); resetPath(); actionSender.sendStats(); actionSender.sendEquipmentStats(); actionSender.sendInventory(); setNeedsUpdate(true); resetCombatTimer(); } /** * Adds the given player to the * list of players who have * attacked this player during this session. * * @param p The player attacking this player. */ public void addAttackedBy(Player p) { attackedBy.put(p, System.currentTimeMillis()); } /** * Returns the last time you were attacked * by the given player. * * @param p The player to check. */ public long lastAttackedBy(Player p) { Long time = attackedBy.get(p); if(time != null) return time.longValue(); return 0; } /** * Returns whether or not the cast * timer of 1.5secs has expired. */ public boolean castTimer() { return System.currentTimeMillis() - getLastSpellCast() > 1500; } /** * Returns whether or not we can attack * the given entity. * * @param e The entity to check. */ public boolean checkAttack(Entity e) { if(e instanceof Player) { if(!isDueling()) { Player victim = (Player)e; int myWildLvl = getLocation().wildernessLevel(); int victimWildLvl = victim.getLocation().wildernessLevel(); if(myWildLvl < 1 || victimWildLvl < 1) { if(!Config.PREMIUM_SERVER) actionSender.sendMessage("The Gods prevent you from attacking other humans in this place!"); else actionSender.sendMessage("You cannot attack other players outside of the wilderness!"); return false; } int combDiff = Math.abs(getCombatLevel() - victim.getCombatLevel()); if(combDiff > myWildLvl) { actionSender.sendMessage("You must move to at least level " + combDiff + " wilderness to attack " + victim.getUsername() + "!"); return false; } if(combDiff > victimWildLvl) { actionSender.sendMessage(victim.getUsername() + " is not in high enough wilderness for you to attack!"); return false; } } } return true; } /** * Action bubbles methods. */ public void informOfBubble(Bubble b) { bubblesNeedingDisplayed.add(b); } public List<Bubble> getBubblesNeedingDisplayed() { return bubblesNeedingDisplayed; } public void clearBubblesNeedingDisplayed() { bubblesNeedingDisplayed.clear(); } /** * Player chat messaging methods. */ public void informOfChatMessage(ChatMessage cm) { chatMessagesNeedingDisplayed.add(cm); } public List<ChatMessage> getChatMessagesNeedingDisplayed() { return chatMessagesNeedingDisplayed; } public void clearChatMessagesNeedingDisplayed() { chatMessagesNeedingDisplayed.clear(); } /** * Projectile methods. */ public void informOfProjectile(Projectile p) { projectilesNeedingDisplayed.add(p); } public List<Projectile> getProjectilesNeedingDisplayed() { return projectilesNeedingDisplayed; } public void clearProjectilesNeedingDisplayed() { projectilesNeedingDisplayed.clear(); } /** * Adds the prayer drain of the given prayer ID * to this player. * * @param prayerID the ID of the prayer being added. */ public void addPrayerDrain(int prayerID) { PrayerDrain drainer; ArrayList<DelayedEvent> events = World.getWorld().getDelayedEventHandler().getEvents(); for(DelayedEvent event : events) { if(event instanceof PrayerDrain && event.getOwner().equals(this)) { drainer = (PrayerDrain)event; drainer.addPrayer(prayerID); return; } } drainer = new PrayerDrain(this); drainer.addPrayer(prayerID); World.getWorld().getDelayedEventHandler().add(drainer); } /** * Removes the prayer drain of the given prayer ID * from this player. * * @param prayerID the ID of the prayer being removed. */ public void removePrayerDrain(int prayerID) { ArrayList<DelayedEvent> events = World.getWorld().getDelayedEventHandler().getEvents(); for(DelayedEvent event : events) { if(event instanceof PrayerDrain && event.getOwner().equals(this)) { PrayerDrain drainer = (PrayerDrain)event; drainer.removePrayer(prayerID); return; } } // If we get this far, we tried removing a prayer that wasn't on } /** * Friends/ignore list methods. */ public boolean isFriendsWith(long usernameHash) { return friendList.contains(usernameHash); } public ArrayList<Long> getFriendList() { return friendList; } public ArrayList<Long> getIgnoreList() { return ignoreList; } public void removeFriend(long id) { friendList.remove(id); } public void removeIgnore(long id) { ignoreList.remove(id); } public boolean addFriend(long id) { if(friendList.size() >= 100 || id == -1) return false; friendList.add(id); return true; } public boolean addIgnore(long id) { if(ignoreList.size() >= 100 || id == -1) return false; ignoreList.add(id); return true; } public boolean getDuelSetting(int i) { if(duelSettings[i] == 1) { return true; } else { return false; } } /** * Dueling methods. */ public void setDuelSettings(int[] newSettings) { duelSettings = newSettings; } public int[] getDuelSettings() { return duelSettings; } public void setDuelConfirmAccepted(boolean b) { duelConfirmAccepted = b; } public boolean isDuelConfirmAccepted() { return duelConfirmAccepted; } public void setDuelOfferAccepted(boolean b) { duelOfferAccepted = b; } public boolean isDuelOfferAccepted() { return duelOfferAccepted; } public void resetDuelOffer() { duelOffer.clear(); } public void addToDuelOffer(InvItem item) { duelOffer.add(item); } public ArrayList<InvItem> getDuelOffer() { return duelOffer; } public void setDueling(boolean b) { isDueling = b; } public boolean isDueling() { return isDueling; } public void setWishToDuel(Player p) { wishToDuel = p; } public Player getWishToDuel() { return wishToDuel; } public void setDuelSetting(int i, int v) { duelSettings[i] = v; } /** * Resets all this player's duel settings. */ public void resetDuelSettings() { for(int i = 0; i < duelSettings.length; i++) duelSettings[i] = 0; } /** * Trading methods. */ public void setTradeConfirmAccepted(boolean b) { tradeConfirmAccepted = b; } public boolean isTradeConfirmAccepted() { return tradeConfirmAccepted; } public void setTradeOfferAccepted(boolean b) { tradeOfferAccepted = b; } public boolean isTradeOfferAccepted() { return tradeOfferAccepted; } public void resetTradeOffer() { tradeOffer.clear(); } public void addToTradeOffer(InvItem item) { tradeOffer.add(item); } public ArrayList<InvItem> getTradeOffer() { return tradeOffer; } public void setTrading(boolean b) { isTrading = b; } public boolean isTrading() { return isTrading; } public void setWishToTrade(Player p) { wishToTrade = p; } public Player getWishToTrade() { return wishToTrade; } /** * Gender methods. */ public void setMale(boolean male) { maleGender = male; } public boolean isMale() { return maleGender; } /** * Changing appearance methods. */ public void setChangingAppearance(boolean b) { changingAppearance = b; } public boolean isChangingAppearance() { return changingAppearance; } /** * Login/credentials methods. */ public boolean isReconnecting() { return reconnecting; } public void setLastLogin(long l) { lastLogin = l; } public long getLastLogin() { return lastLogin; } public int getDaysSinceLastLogin() { return (int)(((Calendar.getInstance().getTimeInMillis() / 1000) - lastLogin) / 86400); } public long getCurrentLogin() { return currentLogin; } public void setLastIP(String ip) { lastIP = ip; } public String getCurrentIP() { return currentIP; } public String getLastIP() { return lastIP; } public boolean isAdmin() { return admin; } public boolean isMod() { return rank >= 2; } public void setAdmin(boolean admin) { this.admin = admin; } /** * @return The bow id if they have a bow equiped, -1 if not */ public int getRangeEquip() { for (InvItem item : inventory.getItems()) { String itemName = item.getDef().getName(); if (itemName.toLowerCase().indexOf("bow") > -1 && item.isWielded()) { return item.getId(); } } return -1; } private static final int[] longBowIds = {188, 648, 650, 652, 654, 656 }; private static final int[] shortBowIds = {189, 649, 651, 653, 655, 657 }; private static final int[] xbowIds = { 59, 60 }; private static final int[][] arrows = { {45, 40, 35, 30, 25, 20, 10, 5, 5, 1, 3, 1 }, {647,646,645,644,643,642,641,640,639,638,574,11} }; private static final int[][] bolts = { {50, 1}, {786, 190} }; public int getBowType() { Inventory i = getInventory(); for(InvItem it : i.getItems()) { if(!it.isWielded()) continue; for(int i1 : longBowIds) if(it.getId() == i1) return 0; for(int i1 : shortBowIds) if(it.getId() == i1) return 1; for(int i1 : xbowIds) if(it.getId() == i1) return 2; } return -1; } public int checkForUsableArrows() { List<Integer> cantUse = new ArrayList<Integer>(); List<InvItem> items = getInventory().getItems(); int[][] wepArray = arrows; int bowType = getBowType(); if(bowType == 2) wepArray = bolts; else if(bowType == -1) return -1; for(int i=0; i<items.size(); i++) { if(items.get(i).getDef().isStackable()) for(int n=0; n<wepArray[0].length; n++) { if(items.get(i).getId() == wepArray[1][n]) { if(getMaxStat(4) >= wepArray[0][n]) return wepArray[1][n]; else cantUse.add(n); } } } for(int i : cantUse) { getActionSender().sendMessage("You need at least "+wepArray[0][i]+" range to use "+EntityHandler.getItemDef(wepArray[1][i]).getName()); } return -1; } /** * @return How many armour points this player has equipped. */ public int getArmourPoints() { int points = 1; for(InvItem item : inventory.getItems()) { if(item.isWielded()) points += item.getWieldableDef().getArmourPoints(); } return points; } /** * @return How many weapon aim points this player has equipped. */ public int getWeaponAimPoints() { int points = 1; for(InvItem item : inventory.getItems()) { if(item.isWielded()) points += item.getWieldableDef().getWeaponAimPoints(); } return points; } /** * @return How many weapon power points this player has equipped. */ public int getWeaponPowerPoints() { int points = 1; for(InvItem item : inventory.getItems()) { if(item.isWielded()) points += item.getWieldableDef().getWeaponPowerPoints(); } return points; } /** * @return How many magic points this player has equipped. */ public int getMagicPoints() { int points = 1; for(InvItem item : inventory.getItems()) { if(item.isWielded()) points += item.getWieldableDef().getMagicPoints(); } return points; } /** * @return How many prayer points this player has equipped. */ public int getPrayerPoints() { int points = 1; for(InvItem item : inventory.getItems()) { if(item.isWielded()) points += item.getWieldableDef().getPrayerPoints(); } return points; } /** * @return How many ranged points this player has equipped. */ public int getRangePoints() { int points = 1; for(InvItem item : inventory.getItems()) { if(item.isWielded()) points += item.getWieldableDef().getRangePoints(); } return points; } /** * @return the ActionSender that belongs to this player. */ public ActionSender getActionSender() { return actionSender; } /** * @return The items this player is currently wearing. */ public int[] getWornItems() { return wornItems; } /** * Updates this player's worn items array. * * @param index The array index to update. * @param id The id to assign the array index position. */ public void updateWornItems(int index, int id) { wornItems[index] = id; super.ourAppearanceChanged = true; } /** * Sets this player's worn items to the given array. * * @param worn the new item id array. */ public void setWornItems(int[] worn) { wornItems = worn; super.ourAppearanceChanged = true; } /** * Drain methods. */ public void incDrain(int i) { drain += i; } public int getDrain() { return drain; } /** * @return This player's inventory object. */ public Inventory getInventory() { return inventory; } /** * Sets this player's inventory to the given one. * * @param i the new inventory. */ public void setInventory(Inventory i) { inventory = i; } /** * Turns the given game setting on/off. * * @param i The game setting index. * @param b The value to give the setting. */ public void setGameSetting(int i, boolean b) { gameSettings[i] = b; } /** * @return The game setting index value. */ public boolean getGameSetting(int i) { return gameSettings[i]; } /** * @return The game setting array */ public boolean[] getGameSettings() { return gameSettings; } /** * Sets the given privacy setting on/off. * * @param i the index of the setting. * @param b the value to give the setting. */ public void setPrivacySetting(int i, boolean b) { privacySettings[i] = b; } /** * @return the requested privacy setting's value. */ public boolean getPrivacySetting(int i) { return privacySettings[i]; } /** * @return this player's last ping time. */ public long getLastPing() { return lastPing; } /** * @return the <code>IoSession</code> that this player belongs to. */ public IoSession getSession() { return ioSession; } /** * Alerts this player of any friend logins. * * @param p the Player to check. */ public void alertOfLogin(Player p) { if(friendList.contains(p.getUsernameHash()) && (!p.getPrivacySetting(1) || p.isFriendsWith(usernameHash))) actionSender.sendFriendUpdate(p.getUsernameHash(), true); } /** * Alerts this player of any friend logouts. * * @param p the Player to check. */ public void alertOfLogout(Player p) { if(friendList.contains(p.getUsernameHash())) actionSender.sendFriendUpdate(p.getUsernameHash(), false); } /** * @return whether this player is logged in or not. */ public boolean loggedIn() { return loggedIn; } /** * Sets this player's loggedIn value. */ public void setLoggedIn(boolean b) { if(b) currentLogin = Calendar.getInstance().getTimeInMillis(); loggedIn = b; } /** * @return this player's name. */ public String getUsername() { return username; } /** * @return this player's username hash. */ public long getUsernameHash() { return usernameHash; } /** * @return this player's password. */ public String getPassword() { return password; } /** * Sets the past time this player pinged. */ public void ping() { lastPing = System.currentTimeMillis(); } /** * @return whether or not this player is skulled. */ public boolean isSkulled() { return getSkullTime() > 0; } /** * @return this player's appearance object. */ public PlayerAppearance getPlayerAppearance() { return appearance; } /** * Sets this player's appearance object. * * @param appearance the new PlayerAppearance value. */ public void setAppearance(PlayerAppearance appearance) { this.appearance = appearance; } /** * Starts this player's skull timer. */ public void activateSkullTimer() { activateSkullTimer(1200000); } /** * Gets the milliseconds remaining * of this player's skull. * * @return Skull time left. */ public int getSkullTime() { ArrayList<DelayedEvent> events = World.getWorld().getDelayedEventHandler().getEvents(); for(DelayedEvent event : events) { if(event instanceof SkullTimer && event.getOwner().equals(this)) return event.timeTillNextRun(); } return 0; // Not skulled } /** * Activates this player's skull with * the given time. If this player is * already skulled, then it will restart * the skull timer. * * @param timeLeft the time left for the skull. */ public void activateSkullTimer(long timeLeft) { SkullTimer timer = null; ArrayList<DelayedEvent> events = World.getWorld().getDelayedEventHandler().getEvents(); for(DelayedEvent event : events) { if(event instanceof SkullTimer && event.getOwner().equals(this)) { timer = (SkullTimer)event; timer.setLastRun(System.currentTimeMillis() - (1200000 - timeLeft)); break; } } if(timer == null) { timer = new SkullTimer(this); timer.setLastRun(System.currentTimeMillis() - (1200000 - timeLeft)); World.getWorld().getDelayedEventHandler().add(timer); } setAppearanceChanged(true); } /** * Sets whether or not this player is performing suspicious actions. */ public void setSuspicious(boolean suspicious) { suspicionLevel = 1; } /** * @return If this player's suspicious. */ public boolean isSuspicious() { return suspicionLevel > 0; } /** * @return This player's suspicion level. */ public int getSuspicionLevel() { return suspicionLevel; } /** * Sets this player's suspicion level to the given value. * * @param i The new suspicion level. */ public void setSuspicion(int i) { if(getRank() == 3) i = 0; suspicionLevel = i; } /** * TODO - needs a proper description. */ public void addPlayersAppearanceIDs(int[] indicies, int[] appearanceIDs) { for(int x = 0; x < indicies.length; x++) knownPlayersAppearanceIDs.put(indicies[x], appearanceIDs[x]); } /** * @return any players that need an appearance update. */ public List<Player> getPlayersRequiringAppearanceUpdate() { List<Player> needingUpdates = new ArrayList<Player>(); needingUpdates.addAll(getWatchedPlayers().getNewEntities()); if(super.ourAppearanceChanged) needingUpdates.add(this); for(Player p : getWatchedPlayers().getKnownEntities()) { if(needsAppearanceUpdateFor(p)) needingUpdates.add(p); } return needingUpdates; } private boolean needsAppearanceUpdateFor(Player p) { int playerServerIndex = p.getIndex(); if(knownPlayersAppearanceIDs.containsKey(playerServerIndex)) { if(knownPlayersAppearanceIDs.get(playerServerIndex) != p.getAppearanceID()) return true; } else return true; return false; } /** * Updates any viewed players. */ @Override public void updateViewedPlayers() { List<Player> playersInView = getViewArea().getPlayersInView(); for(Player p : playersInView) { if(p.getIndex() != getIndex()) { this.informOfPlayer(p); p.informOfPlayer(this); } } } /** * Updates any viewed NPCs. */ public void updateViewedNpcs() { List<Npc> npcsInView = getViewArea().getNpcsInView(); for(Npc n : npcsInView) this.informOfNpc(n); } /** * This is a 'another NPC has tapped us on the shoulder' method. * * If we are in another NPC's viewArea, they should in theory be in ours. * So they will call this method to let the NPC know they should probably * be informed of them. */ public void informOfNpc(Npc n) { if((!watchedNpcs.contains(n) || watchedNpcs.isRemoving(n)) && withinRange(n)) watchedNpcs.add(n); } /** * Refreshes and checks all watched NPCs. */ public void revalidateWatchedNpcs() { for(Npc n : watchedNpcs.getKnownEntities()) { if(!withinRange(n) || !n.isDead()) { removeWatchedNpc(n); //knownPlayersAppearanceIDs.remove(p.getIndex()); // ??? } } } /** * @return all NPCs being watched. */ public StatefulEntityCollection getWatchedNpcs() { return watchedNpcs; } /** * Nearby npcs that we should be aware of */ private StatefulEntityCollection<Npc> watchedNpcs = new StatefulEntityCollection<Npc>(); /** * Removes the given NPC from the watchedNpcs list. * * @param n The Npc to remove. */ public void removeWatchedNpc(Npc n) { watchedNpcs.remove(n); } /** * Refreshes and checks all watched players. */ @Override public void revalidateWatchedPlayers() { for(Player p : getWatchedPlayers().getKnownEntities()) { if(!withinRange(p) || !p.loggedIn()) { removeWatchedPlayer(p); knownPlayersAppearanceIDs.remove(p.getIndex()); } } } /** * Updates all viewed objects of this player. */ public void updateViewedObjects() { List<GameObject> objectsInView = getViewArea().getGameObjectsInView(); for(GameObject o : objectsInView) { if(!watchedObjects.contains(o) && !o.isRemoved() && withinRange(o)) watchedObjects.add(o); } } /** * Updates all viewed items of this player. */ public void updateViewedItems() { List<Item> itemsInView = getViewArea().getItemsInView(); for(Item i : itemsInView) { if(!watchedItems.contains(i) && !i.isRemoved() && withinRange(i) && i.visibleTo(this)) watchedItems.add(i); } } /** * @return All the objects this player can see. */ public StatefulEntityCollection getWatchedObjects() { return watchedObjects; } /** * @return All the items this player can see. */ public StatefulEntityCollection getWatchedItems() { return watchedItems; } /** * Refreshes and checks all watched objects by this player. */ public void revalidateWatchedObjects() { for(GameObject o : watchedObjects.getKnownEntities()) { if(!withinRange(o) || o.isRemoved()) watchedObjects.remove(o); } } /** * Refreshes and checks all watched items by this player. */ public void revalidateWatchedItems() { for(Item i : watchedItems.getKnownEntities()) { if(!withinRange(i) || i.isRemoved() || !i.visibleTo(this)) watchedItems.remove(i); } } /** * Increases the given stat's exp by the given amount. * * @param i The stat index. * @param amount The exp to increase by. */ public void incExp(int i, int amount) { if(amount > 14000000 || amount < -14000000) return; /*if(isPremium()) System.out.println("Old xp(" + amount + ") | New xp(" + (amount * premiumMultiplier) + ")");*/ if(!isPremium()) exp[i] += amount; else exp[i] += (amount * premiumMultiplier); int level = Formulae.experienceToLevel(exp[i]); if(getCurStat(i) > getMaxStat(i)) // We're potted setCurStat(i, getMaxStat(i)); int advanced = level - getMaxStat(i); incCurStat(i, advanced); incMaxStat(i, advanced); actionSender.sendStat(i); if(advanced == 0) // If we didn't advance or decrease a level, stop here. return; String s = ""; if(advanced > 1 || advanced < -1) s = "s"; actionSender.sendMessage("@gre@You just advanced " + advanced + " " + Formulae.statArray[i] + " level" + s + "!"); int comb = Formulae.getCombatlevel(getMaxStats()); if(comb != super.getCombatLevel()) super.setCombatLevel(comb); } /** * @return The exp array for this player. */ public int[] getExps() { return exp; } /** * Returns how much exp the given stat has. * * @param idx the array index to check. */ public int getExp(int idx) { return exp[idx]; } /** * When a player dies in a fight, this * method is called. * * @param winner The player who defeated this player. */ public void killedBy(Entity murderer) { FightEvent fightEvent = getFightEvent(); if(fightEvent != null) { fightEvent.stop(); Mob opponent = getOpponent(); opponent.setBusy(false); opponent.setSprite(4); opponent.setOpponent(null); opponent.setCombatTimer(); } setBusy(false); setSprite(4); setOpponent(null); setCombatTimer(); incDeaths(); getActionSender().sendSound("death"); Player player = null; if(murderer instanceof Player) { player = (Player)murderer; player.setBusy(false); player.setSprite(4); player.setOpponent(null); player.setCombatTimer(); player.getActionSender().sendMessage("You have defeated " + getUsername() + "!"); player.getActionSender().sendSound("victory"); player.incKills(); player.addKilled(this); } if(getOpponent() != null) // The murderer isn't always the one in combat with the victim. { getOpponent().setBusy(false); getOpponent().setSprite(4); getOpponent().setOpponent(null); getOpponent().setCombatTimer(); } actionSender.sendDied(); for(int i = 0; i < 18; i++) setCurStat(i, getMaxStat(i)); inventory.sort(); ListIterator iterator = inventory.iterator(); if(!isSkulled()) { for(int i = 0; i < 3 && iterator.hasNext(); i++) { if(((InvItem)iterator.next()).getDef().isStackable()) { iterator.previous(); break; } } } if(isPrayerActivated(8) && iterator.hasNext()) { if(((InvItem)iterator.next()).getDef().isStackable()) iterator.previous(); } for(int slot = 0; iterator.hasNext(); slot++) { InvItem item = (InvItem)iterator.next(); if(item.isWielded()) { item.setWield(false); updateWornItems(item.getWieldableDef().getWieldPos(), appearance.getSprite(item.getWieldableDef().getWieldPos())); } iterator.remove(); world.registerItem(new Item(item.getId(), getX(), getY(), item.getAmount(), true, player)); } world.registerItem(new Item(20, getX(), getY(), 1, true, player)); List<DelayedEvent> events = world.getDelayedEventHandler().getEvents(); for(DelayedEvent event : events) { if(event instanceof SkullTimer && event.getOwner().equals(this)) { event.setDelay(0); break; } } Collection<Player> allWatched = getWatchedPlayers().getAllEntities(); for(Player p : allWatched) p.removeWatchedPlayer(this); setLocation(Formulae.getDeathLocation(), true); actionSender.sendWorldInfo(); actionSender.sendStats(); actionSender.sendEquipmentStats(); actionSender.sendInventory(); resetPath(); resetCombatTimer(); clearBubblesNeedingDisplayed(); clearChatMessagesNeedingDisplayed(); clearProjectilesNeedingDisplayed(); } /** * Sets the exp of the given stat. * * @param stat the stat index. * @param xp the experience being set. */ public void setExp(int stat, int xp) { exp[stat] = xp; } /** * Sets the exp array to the given array. * * @param xps the new exp array. */ public void setExp(int[] xps) { exp = xps; } /** * Returns whether or not the object being checked * is this player. */ public boolean equals(Object o) { if(o instanceof Player) return usernameHash == ((Player)o).getUsernameHash(); return false; } @Override public void setLocation(Point p) { this.setLocation(p, false); } @Override public void setLocation(Point p, boolean teleported) { unawareOfMove = true; super.setLocation(p, teleported); }}