Thread: error

Results 1 to 2 of 2
  1. #1 error 
    Registered Member PhaseGFX's Avatar
    Join Date
    Oct 2012
    Age
    28
    Posts
    156
    Thanks given
    19
    Thanks received
    42
    Rep Power
    51
    Im getting the following error after putting a new quest :
    Code:
    java.lang.NullPointerException
    	at com.rs.game.player.Player.getPackets(Player.java:1583)
    	at com.rs.game.player.Player.init(Player.java:381)
    	at com.rs.net.decoders.LoginPacketsDecoder.decodeWorldLogin(LoginPacketsDecoder.java:227)
    	at com.rs.net.decoders.LoginPacketsDecoder.decode(LoginPacketsDecoder.java:36)
    	at com.rs.net.ServerChannelHandler.messageReceived(ServerChannelHandler.java:93)
    	at org.jboss.netty.channel.SimpleChannelHandler.handleUpstream(SimpleChannelHandler.java:95)
    	at org.jboss.netty.channel.DefaultChannelPipeline.sendUpstream(DefaultChannelPipeline.java:563)
    	at org.jboss.netty.channel.DefaultChannelPipeline.sendUpstream(DefaultChannelPipeline.java:558)
    	at org.jboss.netty.channel.Channels.fireMessageReceived(Channels.java:268)
    	at org.jboss.netty.channel.Channels.fireMessageReceived(Channels.java:255)
    	at org.jboss.netty.channel.socket.nio.NioWorker.read(NioWorker.java:91)
    	at org.jboss.netty.channel.socket.nio.AbstractNioWorker.processSelectedKeys(AbstractNioWorker.java:373)
    	at org.jboss.netty.channel.socket.nio.AbstractNioWorker.run(AbstractNioWorker.java:247)
    	at org.jboss.netty.channel.socket.nio.NioWorker.run(NioWorker.java:35)
    	at org.jboss.netty.util.ThreadRenamingRunnable.run(ThreadRenamingRunnable.java:102)
    	at org.jboss.netty.util.internal.DeadLockProofWorker$1.run(DeadLockProofWorker.java:42)
    	at java.util.concurrent.ThreadPoolExecutor.runWorker(Unknown Source)
    	at java.util.concurrent.ThreadPoolExecutor$Worker.run(Unknown Source)
    	at java.lang.Thread.run(Unknown Source)
    ERROR! THREAD NAME: New I/O  worker #1
    java.lang.NullPointerException
    	at com.rs.game.player.Player.getPackets(Player.java:1583)
    	at com.rs.game.player.Player.init(Player.java:381)
    	at com.rs.net.decoders.LoginPacketsDecoder.decodeWorldLogin(LoginPacketsDecoder.java:227)
    	at com.rs.net.decoders.LoginPacketsDecoder.decode(LoginPacketsDecoder.java:36)
    	at com.rs.net.ServerChannelHandler.messageReceived(ServerChannelHandler.java:93)
    	at org.jboss.netty.channel.SimpleChannelHandler.handleUpstream(SimpleChannelHandler.java:95)
    	at org.jboss.netty.channel.DefaultChannelPipeline.sendUpstream(DefaultChannelPipeline.java:563)
    	at org.jboss.netty.channel.DefaultChannelPipeline.sendUpstream(DefaultChannelPipeline.java:558)
    	at org.jboss.netty.channel.Channels.fireMessageReceived(Channels.java:268)
    	at org.jboss.netty.channel.Channels.fireMessageReceived(Channels.java:255)
    	at org.jboss.netty.channel.socket.nio.NioWorker.read(NioWorker.java:91)
    	at org.jboss.netty.channel.socket.nio.AbstractNioWorker.processSelectedKeys(AbstractNioWorker.java:373)
    	at org.jboss.netty.channel.socket.nio.AbstractNioWorker.run(AbstractNioWorker.java:247)
    	at org.jboss.netty.channel.socket.nio.NioWorker.run(NioWorker.java:35)
    	at org.jboss.netty.util.ThreadRenamingRunnable.run(ThreadRenamingRunnable.java:102)
    	at org.jboss.netty.util.internal.DeadLockProofWorker$1.run(DeadLockProofWorker.java:42)
    	at java.util.concurrent.ThreadPoolExecutor.runWorker(Unknown Source)
    	at java.util.concurrent.ThreadPoolExecutor$Worker.run(Unknown Source)
    	at java.lang.Thread.run(Unknown Source)
    my player.java:

    Code:
    package com.rs.game.player;
    
    import com.rs.Settings;
    import com.rs.cores.CoresManager;
    import com.rs.game.*;
    import com.rs.game.Hit.HitLook;
    import com.rs.game.item.FloorItem;
    import com.rs.game.item.Item;
    import com.rs.game.minigames.clanwars.FfaZone;
    import com.rs.game.minigames.clanwars.WarControler;
    import com.rs.game.minigames.duel.DuelArena;
    import com.rs.game.minigames.duel.DuelRules;
    import com.rs.game.npc.NPC;
    import com.rs.game.npc.familiar.BeastOfBurden;
    import com.rs.game.npc.familiar.Familiar;
    import com.rs.game.npc.godwars.zaros.Nex;
    import com.rs.game.npc.pet.Pet;
    import com.rs.game.player.actions.PlayerCombat;
    import com.rs.game.player.content.*;
    import com.rs.game.player.content.construction.*;
    import com.rs.game.player.content.pet.PetManager;
    import com.rs.game.player.controlers.*;
    import com.rs.game.player.controlers.castlewars.CastleWarsPlaying;
    import com.rs.game.player.controlers.castlewars.CastleWarsWaiting;
    import com.rs.game.player.controlers.fightpits.FightPitsArena;
    import com.rs.game.player.controlers.pestcontrol.PestControlGame;
    import com.rs.game.player.controlers.pestcontrol.PestControlLobby;
    import com.rs.game.tasks.WorldTask;
    import com.rs.game.tasks.WorldTasksManager;
    import com.rs.net.Session;
    import com.rs.net.decoders.WorldPacketsDecoder;
    import com.rs.net.decoders.handlers.ButtonHandler;
    import com.rs.net.encoders.WorldPacketsEncoder;
    import com.rs.store.Duration;
    import com.rs.utils.*;
    
    import java.io.BufferedReader;
    import java.io.FileReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.net.InetAddress;
    import java.net.URL;
    import java.net.UnknownHostException;
    import java.text.SimpleDateFormat;
    import java.util.*;
    import java.util.concurrent.ConcurrentLinkedQueue;
    import java.util.concurrent.CopyOnWriteArrayList;
    import java.util.concurrent.ScheduledFuture;
    import java.util.concurrent.TimeUnit;
    
    public class Player extends Entity {
    
        public static final int TELE_MOVE_TYPE = 127, WALK_MOVE_TYPE = 1,
                RUN_MOVE_TYPE = 2;
        private static final long serialVersionUID = 2011932556974180375L;
        // saving stuff
        public int money;
        public int timesVoted;
        public boolean hasSetupCannon;
        public boolean hasSetupGoldCannon;
        public boolean hasSetupRoyalCannon;
        public int[] lastLogin;
        public int memberShipDays;
        private int dungeoneeringTokens;
        private transient Notes notes;
        private ArrayList<Notes.Note> pnotes;
        private int alcoholIntake = 0;
        private List<Status> statuses = new ArrayList<Status>();
        private double extraExp;
        private int extraExpMinutes;
        private String wandererTitle = "wanderer";
        // transient stuff
        private transient boolean flashGuide;
        private transient String username;
        private transient Session session;
        private transient boolean clientLoadedMapRegion;
        private int tasksComplete;
        private transient int displayMode;
        private transient int screenWidth;
        private transient int screenHeight;
        private transient InterfaceManager interfaceManager;
        private transient DialogueManager dialogueManager;
        private transient HintIconsManager hintIconsManager;
        private transient ActionManager actionManager;
        private transient CutscenesManager cutscenesManager;
        private transient PriceCheckManager priceCheckManager;
        private transient CoordsEvent coordsEvent;
        private transient FriendChatsManager currentFriendChat;
        private transient Trade trade;
        private transient DuelRules lastDuelRules;
        private transient IsaacKeyPair isaacKeyPair;
        private transient Pet pet;
        private transient boolean teleport = true;
        private IntroductionControler introductionControler;
        // used for packets logic
        private transient ConcurrentLinkedQueue<LogicPacket> logicPackets;
        // used for update
        private transient LocalPlayerUpdate localPlayerUpdate;
        private transient LocalNPCUpdate localNPCUpdate;
        private int temporaryMovementType;
        /**
         * The time units.
         */
        private boolean updateMovementType;
        private int doubleExpActive = 0;
        /**
         * Recruitment Drive ints/booleans
         */
        private boolean startRD;
        private boolean isRomanGuard;
        private boolean finishedRD;
        private int lastBought;
    	/*
    	 * Quest Dwarf
    	 */
    	public boolean startedDwarfCannon = false;
    	public boolean completedDwarfCannonquest = false;
    	public boolean inProgressDwarfCannon = false;
    	public boolean inProgressDwarfCannon2 = false;
    	public boolean inProgressDwarfCannon3 = false;
    	public boolean checkGilob = false;
    	public boolean getLolk = false;
    	public boolean gotLolk = false;
    	public DwarfCannon dwarfQuest;
    
    	/**
    	 * Dwarf Cannon quest
    	 */
    	public int fixedRailings = 0;
    	public boolean fixedRailing1 = false;
    	public boolean fixedRailing2 = false;
    	public boolean fixedRailing3 = false;
    	public boolean fixedRailing4 = false;
    	public boolean fixedRailing5 = false;
    	public boolean fixedRailing6 = false;
    	
    
      
    //bottom
        /**
         * Dwarf Cannon
         */
        private DwarfCannon dwarfCannon;
        private int seconds, minutes, hours, days, weeks, months, years;
        // player stages
        private transient boolean started;
        private boolean clickedGnomeDoor;
        private boolean clickedWildernessDoor;
        private transient boolean running;
        private transient long packetsDecoderPing;
        private transient boolean resting;
        private transient boolean canPvp;
        private int minutesPlayed;
        private int kills;
        private transient boolean cantTrade;
        private transient long lockDelay; // used for doors and stuff like that
        private transient long foodDelay;
        private transient long potDelay;
        private transient long boneDelay;
        private transient Runnable closeInterfacesEvent;
        private transient long lastPublicMessage;
        private transient long polDelay;
        private transient List<Integer> switchItemCache;
        private transient boolean disableEquip;
        private transient MachineInformation machineInformation;
        private transient boolean spawnsMode;
        private transient boolean castedVeng;
        private transient boolean invulnerable;
        private boolean[] skillcapesAdded = new boolean[25];
        // interface
        private transient boolean typeAction;
        private transient double hpBoostMultiplier;
        private transient boolean largeSceneView;
        private transient int firstColumn = 1;
        private transient int secondColumn = 1;
        private transient int thirdColumn = 1;
        private Status status;
        private String referralCode;
        private String password;
        private int rights;
        private String displayName;
        private String lastIP;
        private long creationDate;
        private Appearence appearence;
        private Inventory inventory;
        private Equipment equipment;
        private Skills skills;
        private CombatDefinitions combatDefinitions;
        private Prayer prayer;
        private Bank bank;
        private ControlerManager controlerManager;
        private MusicsManager musicsManager;
        private EmotesManager emotesManager;
        private FriendsIgnores friendsIgnores;
        private DominionTower dominionTower;
        private Familiar familiar;
        private FarmingManager farmingManager;
        private AuraManager auraManager;
        private QuestManager questManager;
        private PetManager petManager;
        private SlayerManager slayerManager;
        private byte runEnergy;
        private boolean allowChatEffects;
        private boolean mouseButtons;
        private int privateChatSetup;
        private int friendChatSetup;
        private int skullDelay;
        private int skullId;
        private boolean forceNextMapLoadRefresh;
        private long poisonImmune;
        private long fireImmune;
        private boolean killedQueenBlackDragon;
        private int runeSpanPoints;
        private int lastBonfire;
        private int[] pouches;
        private long displayTime;
        private long muted;
        private String customTitle = "";
        private long jailed;
        private long banned;
        private boolean permBanned;
        private boolean filterGame;
        private boolean xpLocked;
        private boolean yellOff;
        private boolean[] textSent = new boolean[6];
        //game bar status
        private int publicStatus;
        private int clanStatus;
        private int tradeStatus;
        private int assistStatus;
        private boolean lord;
        private boolean praetorians;
        private long lordTill;
        //Recovery ques. & ans.
        private String recovQuestion;
        private String recovAnswer;
        private String lastMsg;
        //Used for storing recent ips and password
        private ArrayList<String> passwordList = new ArrayList<String>();
        private ArrayList<String> ipList = new ArrayList<String>();
        // honor
        private int killCount, deathCount;
        private ChargesManager charges;
        // barrows
        private boolean[] killedBarrowBrothers;
        private int hiddenBrother;
        private int barrowsKillCount;
        private int pestPoints;
        // skill capes customizing
        private int[] maxedCapeCustomized;
        private int[] completionistCapeCustomized;
        //completionistcape reqs
        private boolean completedFightCaves;
        private boolean completedFightKiln;
        private boolean wonFightPits;
        //crucible
        private boolean talkedWithMarv;
        private int crucibleHighScore;
        private int overloadDelay;
        private int prayerRenewalDelay;
        private String currentFriendChatOwner;
        private int summoningLeftClickOption;
        private List<String> ownedObjectsManagerKeys;
        //objects
        private boolean khalphiteLairEntranceSetted;
        private boolean khalphiteLairSetted;
        //supportteam
        private boolean isSupporter;
        private boolean allowsProfanity;
        //voting
        
        private int votes;
        private boolean oldItemsLook;
        private String yellColor = "ff0000";
        private long voted;
        private boolean isGraphicDesigner;
        private boolean isForumModerator;
        private boolean isFromBeta;
        private transient boolean fromSlave;
        private transient boolean finishing;
        private boolean learnedBroad;
        private boolean learnedSlayerRing;
        private boolean learnedSlayerHelmet;
        private String[] removedTasks = new String[]{"", "", "", ""};
        private long lastVote;
        private long alchDelay;
        private HouseController houseController;
        private int houseX;
        private int houseY;
        private int[] boundChuncks;
        private boolean buildMode;
        private boolean beenToHouse;
        private int place;
        private FurnitureInterface furnInterface;
        private List<RoomReference> rooms = new ArrayList<RoomReference>();
        private List<WorldObject> conObjectsToBeLoaded = new ArrayList<WorldObject>();
        private byte roomX;
        private byte roomY;
        private House house;
        private SquealOfFortune sof;
        //squeal of fortune
        private int spins = 2;
        private int random;
        private Item[] rewardz;
        private Item reward;
        private Slaves slave;
        private transient boolean forceNoClose;
        private int pageNumber;
        private boolean accountCleaned;
        private transient VarsManager varsManager;
        private String titleColor = "NO_CUSTOM";
        private boolean[] announced = new boolean[25];
        private transient WorldTile duelLocation;
        private transient boolean onSpotDueling = false;
        private transient boolean onSpotDuelingRequest;
        private int lotteryTickets;
        private transient Duration membersCredit;
        private boolean helpedTrader;
        private int[] gems = new int[4];
        private int coalAmount;
        private boolean wastelessHerblore;
        private boolean teled;
        private int favorPoints;
        private int hungerPoints;
        private int votePoints;
        private boolean pendingItems;
        private boolean killedGraardor, killedCommanderZilyana, killedKril, killedKreeara;
    	public boolean inProgressCooksAssistant;
    	public int questPoints;
    	public boolean startedCooksAssistant;
    
        // creates Player and saved classes
        public Player(String password) {
            super(/*Settings.HOSTED ? */Settings.START_PLAYER_LOCATION/* : new WorldTile(3095, 3107, 0)*/);
            setHitpoints(Settings.START_PLAYER_HITPOINTS);
            this.password = password;
            appearence = new Appearence();
            inventory = new Inventory();
            equipment = new Equipment();
            skills = new Skills();
            combatDefinitions = new CombatDefinitions();
            prayer = new Prayer();
            bank = new Bank();
            controlerManager = new ControlerManager();
            musicsManager = new MusicsManager();
            emotesManager = new EmotesManager();
            friendsIgnores = new FriendsIgnores();
            dominionTower = new DominionTower();
            charges = new ChargesManager();
            auraManager = new AuraManager();
            questManager = new QuestManager();
            petManager = new PetManager();
            farmingManager = new FarmingManager();
            slayerManager = new SlayerManager();
            sof = new SquealOfFortune();
            pnotes = new ArrayList<Notes.Note>(30);
            runEnergy = 100;
            allowChatEffects = true;
            mouseButtons = true;
            pouches = new int[4];
            resetBarrows();
            SkillCapeCustomizer.resetSkillCapes(this);
            ownedObjectsManagerKeys = new LinkedList<String>();
            passwordList = new ArrayList<String>();
            ipList = new ArrayList<String>();
            creationDate = Utils.currentTimeMillis();
        }
    
        public void init(
                Session session, String username, int displayMode,
                int screenWidth, int screenHeight, MachineInformation machineInformation, IsaacKeyPair isaacKeyPair
        ) {
            // temporary deleted after reset all chars
            if (dominionTower == null)
                dominionTower = new DominionTower();
            if (auraManager == null)
                auraManager = new AuraManager();
            if (questManager == null)
                questManager = new QuestManager();
            if (completedDwarfCannonquest == true) {
    			getPackets().sendConfig(0, 2);
    		}
            if (dwarfCannon == null)
                dwarfCannon = new DwarfCannon(this);
            if (petManager == null) {
                petManager = new PetManager();
            }
            if (slayerManager == null) {
                skills.resetSkillNoRefresh(Skills.SLAYER);
                slayerManager = new SlayerManager();
            }
            if (notes == null)
                notes = new Notes();
            if (pnotes == null)
                pnotes = new ArrayList<Notes.Note>(30);
            notes.setPlayer(this);
            if (sof == null)
                sof = new SquealOfFortune();
            if (farmingManager == null)
                farmingManager = new FarmingManager();
            this.session = session;
            this.username = username;
            this.displayMode = displayMode;
            this.screenWidth = screenWidth;
            this.screenHeight = screenHeight;
            this.machineInformation = machineInformation;
            this.isaacKeyPair = isaacKeyPair;
            membersCredit = new Duration(this);
            interfaceManager = new InterfaceManager(this);
            dialogueManager = new DialogueManager(this);
            hintIconsManager = new HintIconsManager(this);
            priceCheckManager = new PriceCheckManager(this);
            localPlayerUpdate = new LocalPlayerUpdate(this);
            localNPCUpdate = new LocalNPCUpdate(this);
            actionManager = new ActionManager(this);
            cutscenesManager = new CutscenesManager(this);
            trade = new Trade(this);
            varsManager = new VarsManager(this);
            // loads player on saved instances
            appearence.setPlayer(this);
            inventory.setPlayer(this);
            equipment.setPlayer(this);
            skills.setPlayer(this);
            combatDefinitions.setPlayer(this);
            prayer.setPlayer(this);
            bank.setPlayer(this);
            controlerManager.setPlayer(this);
            musicsManager.setPlayer(this);
            emotesManager.setPlayer(this);
            friendsIgnores.setPlayer(this);
            dominionTower.setPlayer(this);
            auraManager.setPlayer(this);
            charges.setPlayer(this);
            questManager.setPlayer(this);
            petManager.setPlayer(this);
            farmingManager.setPlayer(this);
            slayerManager.setPlayer(this);
            sof.setPlayer(this);
            setDirection(Utils.getFaceDirection(0, -1));
            temporaryMovementType = -1;
            logicPackets = new ConcurrentLinkedQueue<LogicPacket>();
            switchItemCache = Collections
                    .synchronizedList(new ArrayList<Integer>());
            // if (rooms == null) {
            rooms = new ArrayList<RoomReference>();
            rooms.add(new RoomReference(Room.GARDEN, 4, 4, 0, 0));
            rooms.add(new RoomReference(Room.PARLOUR, 5, 4, 0, 0));
            rooms.add(new RoomReference(Room.BEDROOM, 6, 4, 0, 1));
            rooms.add(new RoomReference(Room.DININGROOM, 4, 5, 0, 1));
            rooms.add(new RoomReference(Room.WORKSHOP, 4, 3, 0, 0));
            rooms.add(new RoomReference(Room.CHAPEL, 3, 4, 0, 3));
            rooms.add(new RoomReference(Room.BOXINGROOM, 3, 7, 0, 3));
            rooms.add(new RoomReference(Room.COSTUMEROOM, 5, 5, 0, 2));
            rooms.add(new RoomReference(Room.FANCYGARDEN, 6, 6, 0, 1));
            rooms.add(new RoomReference(Room.KITCHEN, 4, 6, 0, 3));
            rooms.add(new RoomReference(Room.PARLOUR, 4, 7, 0, 2));
            rooms.add(new RoomReference(Room.PORTALROOM, 6, 7, 0, 3));
            rooms.add(new RoomReference(Room.QUESTHALL1, 3, 7, 0, 1));
            rooms.add(new RoomReference(Room.SKILLHALL1, 2, 7, 0, 3));
            rooms.add(new RoomReference(Room.STUDY, 1, 7, 0, 3));
            rooms.add(new RoomReference(Room.THRONEROOM, 5, 7, 0, 3));
            place = 1; //desert
            // }
            //if (getBoundChuncks() == null) {
            setBoundChuncks(RegionBuilder.findEmptyChunkBound(10, 10));
            // }
            initEntity();
            packetsDecoderPing = Utils.currentTimeMillis();
            World.addPlayer(this);
            World.updateEntityRegion(this);
            if (Settings.DEBUG)
                Logger.log(this, "Initiated player: " + username + ", pass: " + password);
            //Do not delete >.>, useful for security purpose. this wont waste that much space..
            if (passwordList == null)
                passwordList = new ArrayList<String>();
            if (ipList == null)
                ipList = new ArrayList<String>();
            updateIPnPass();
        }
    
        private void generateReferralCode() {
            String[] string = "abcdefghijklmnopqrstuvwxyz0123456789".split("");
            String code = "";
            for (int i = 0; i < 10; i++) {
                code = code + string[Utils.random(0, string.length - 1)];
            }
            if (!checkReferralCode(code)) {
                generateReferralCode();
                return;
            }
            FileLogger.logData("referralCodes", code + " - " + username);
            referralCode = code;
        }
    
        public boolean checkReferralCode(String code) {
            try {
                BufferedReader reader = new BufferedReader(new FileReader("./data/logs/referralCodes.txt"));
                String line = null;
                while ((line = reader.readLine()) != null) {
                    if (line.contains(code))
                        return false;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            return true;
        }
        
    
        public void setWildernessSkull() {
            skullDelay = 3000; // 30minutes
            skullId = 0;
            appearence.generateAppearenceData();
        }
    
        public void setFightPitsSkull() {
            skullDelay = Integer.MAX_VALUE; //infinite
            skullId = 1;
            appearence.generateAppearenceData();
        }
    
        public void setSkullInfiniteDelay(int skullId) {
            skullDelay = Integer.MAX_VALUE; //infinite
            this.skullId = skullId;
            appearence.generateAppearenceData();
        }
    
        public void removeSkull() {
            skullDelay = -1;
            appearence.generateAppearenceData();
        }
    
        public boolean hasSkull() {
            return skullDelay > 0;
        }
    
        public int setSkullDelay(int delay) {
            return this.skullDelay = delay;
        }
    
        public void refreshSpawnedItems() {
            for (int regionId : getMapRegionsIds()) {
                List<FloorItem> floorItems = World.getRegion(regionId)
                        .getFloorItems();
                if (floorItems == null)
                    continue;
                for (FloorItem item : floorItems) {
                    if ((item.isInvisible() || item.isGrave())
                            && this != item.getOwner()
                            || item.getTile().getPlane() != getPlane())
                        continue;
                    getPackets().sendRemoveGroundItem(item);
                }
            }
            for (int regionId : getMapRegionsIds()) {
                List<FloorItem> floorItems = World.getRegion(regionId)
                        .getFloorItems();
                if (floorItems == null)
                    continue;
                for (FloorItem item : floorItems) {
                    if ((item.isInvisible() || item.isGrave())
                            && this != item.getOwner()
                            || item.getTile().getPlane() != getPlane())
                        continue;
                    getPackets().sendGroundItem(item);
                }
            }
        }
    
        public void refreshSpawnedObjects() {
            for (int regionId : getMapRegionsIds()) {
                List<WorldObject> spawnedObjects = World.getRegion(regionId)
                        .getSpawnedObjects();
                if (spawnedObjects != null) {
                    for (WorldObject object : spawnedObjects)
                        if (object.getPlane() == getPlane())
                            getPackets().sendSpawnedObject(object);
                }
                List<WorldObject> removedObjects = World.getRegion(regionId)
                        .getRemovedObjects();
                if (removedObjects != null) {
                    for (WorldObject object : removedObjects)
                        if (object.getPlane() == getPlane())
                            getPackets().sendDestroyObject(object);
                }
            }
        }
    
        // now that we inited we can start showing game
        public void start() {
            loadMapRegions();
            started = true;
            run();
            if (isDead())
                sendDeath(null);
        }
    
        public void stopAll() {
            stopAll(true);
        }
    
        public void stopAll(boolean stopWalk) {
            stopAll(stopWalk, true);
        }
    
        public void stopAll(boolean stopWalk, boolean stopInterface) {
            stopAll(stopWalk, stopInterface, true);
        }
    
        // as walk done clientsided
        public void stopAll(boolean stopWalk, boolean stopInterfaces, boolean stopActions) {
            coordsEvent = null;
            if (stopInterfaces)
                if (!forceNoClose)
                    closeInterfaces();
            if (stopWalk)
                resetWalkSteps();
            if (stopActions)
                actionManager.forceStop();
            combatDefinitions.resetSpells(false);
        }
    
        @Override
        public void reset(boolean attributes) {
            super.reset(attributes);
            refreshHitPoints();
            hintIconsManager.removeAll();
            skills.restoreSkills();
            combatDefinitions.resetSpecialAttack();
            prayer.reset();
            combatDefinitions.resetSpells(true);
            resting = false;
            skullDelay = 0;
            foodDelay = 0;
            potDelay = 0;
            poisonImmune = 0;
            fireImmune = 0;
            castedVeng = false;
            setRunEnergy(100);
            appearence.generateAppearenceData();
        }
    
        @Override
        public void reset() {
            reset(true);
        }
    
        public void closeInterfaces() {
            if (interfaceManager.containsScreenInter())
                interfaceManager.closeScreenInterface();
            if (interfaceManager.containsInventoryInter())
                interfaceManager.closeInventoryInterface();
            dialogueManager.finishDialogue();
            if (closeInterfacesEvent != null) {
                closeInterfacesEvent.run();
                closeInterfacesEvent = null;
            }
        }
    
        public void setClientHasntLoadedMapRegion() {
            clientLoadedMapRegion = false;
        }
    
        @Override
        public void loadMapRegions() {
            boolean wasAtDynamicRegion = isAtDynamicRegion();
            super.loadMapRegions();
            clientLoadedMapRegion = false;
            if (isAtDynamicRegion()) {
                getPackets().sendDynamicMapRegion(!started);
                if (!wasAtDynamicRegion)
                    localNPCUpdate.reset();
            } else {
                getPackets().sendMapRegion(!started);
                if (wasAtDynamicRegion)
                    localNPCUpdate.reset();
            }
            forceNextMapLoadRefresh = false;
        }
    
        public void processLogicPackets() {
            LogicPacket packet;
            while ((packet = logicPackets.poll()) != null)
                WorldPacketsDecoder.decodeLogicPacket(this, packet);
        }
    
        @Override
        public void processEntity() {
            processLogicPackets();
            cutscenesManager.process();
            if (coordsEvent != null && coordsEvent.processEvent(this))
                coordsEvent = null;
            super.processEntity();
            if (musicsManager.musicEnded())
                musicsManager.replayMusic();
            if (hasSkull()) {
                skullDelay--;
                if (!hasSkull())
                    appearence.generateAppearenceData();
            }
            if (polDelay != 0 && polDelay <= Utils.currentTimeMillis()) {
                getPackets().sendGameMessage("The power of the light fades. Your resistance to melee attacks return to normal.");
                polDelay = 0;
            }
            if (overloadDelay > 0) {
                if (overloadDelay == 1 || isDead()) {
                    Pots.resetOverLoadEffect(this);
                    return;
                } else if ((overloadDelay - 1) % 25 == 0)
                    Pots.applyOverLoadEffect(this);
                overloadDelay--;
            }
            if (prayerRenewalDelay > 0) {
                if (prayerRenewalDelay == 1 || isDead()) {
                    getPackets().sendGameMessage("<col=0000FF>Your prayer renewal has ended.");
                    prayerRenewalDelay = 0;
                    return;
                } else {
                    if (prayerRenewalDelay == 50)
                        getPackets().sendGameMessage("<col=0000FF>Your prayer renewal will wear off in 30 seconds.");
                    if (!prayer.hasFullPrayerpoints()) {
                        getPrayer().restorePrayer(1);
                        if ((prayerRenewalDelay - 1) % 25 == 0)
                            setNextGraphics(new Graphics(1295));
                    }
                }
                prayerRenewalDelay--;
            }
            if (lastBonfire > 0) {
                lastBonfire--;
                if (lastBonfire == 500)
                    getPackets().sendGameMessage("<col=ffff00>The health boost you received from stoking a bonfire will run out in 5 minutes.");
                else if (lastBonfire == 0) {
                    getPackets().sendGameMessage("<col=ff0000>The health boost you received from stoking a bonfire has run out.");
                    equipment.refreshConfigs(false);
                }
            }
            charges.process();
            auraManager.process();
            actionManager.process();
            prayer.processPrayer();
            controlerManager.process();
            farmingManager.process();
        }
    
        @Override
        public void processReceivedHits() {
            if (lockDelay > Utils.currentTimeMillis())
                return;
            super.processReceivedHits();
        }
    
        @Override
        public boolean needMasksUpdate() {
            return super.needMasksUpdate() || temporaryMovementType != -1
                    || updateMovementType;
        }
    
        @Override
        public void resetMasks() {
            super.resetMasks();
            temporaryMovementType = -1;
            updateMovementType = false;
            if (!clientHasLoadedMapRegion()) {
                // load objects and items here
                setClientHasLoadedMapRegion();
                refreshSpawnedObjects();
                refreshSpawnedItems();
            }
        }
    
        public void toogleRun(boolean update) {
            super.setRun(!getRun());
            updateMovementType = true;
            if (update)
                sendRunButtonConfig();
        }
    
        public void setRunHidden(boolean run) {
            super.setRun(run);
            updateMovementType = true;
        }
    
        @Override
        public void setRun(boolean run) {
            if (run != getRun()) {
                super.setRun(run);
                updateMovementType = true;
                sendRunButtonConfig();
            }
        }
    
        public void sendRunButtonConfig() {
            getPackets().sendConfig(173, resting ? 3 : getRun() ? 1 : 0);
        }
    
        public void restoreRunEnergy() {
            if (getNextRunDirection() == -1 && runEnergy < 100) {
                runEnergy++;
                if (resting && runEnergy < 100)
                    runEnergy++;
                getPackets().sendRunEnergy();
            }
        }
    
        public String calculateNetworth() {
            int value = 0;
            String valueString = null;
            for (int i = 0; i < equipment.getItems().getSize(); i++) {
                Item item = equipment.getItems().get(i);
                if (item == null)
                    continue;
                int price = item.getDefinitions().getValue() * item.getAmount();
                value += price;
            }
            for (int i = 0; i < inventory.getItems().getSize(); i++) {
                Item item = inventory.getItems().get(i);
                if (item == null)
                    continue;
                int price = item.getDefinitions().getValue() * item.getAmount();
                value += price;
            }
            valueString = "" + value;
            if (value > 99999 && value <= 999999) {
                valueString = value / 1000 + "K";
            } else if (value > 999999 && value < Integer.MAX_VALUE) {
                valueString = value / 1000000 + "M";
            }
    
            //for (int i = 0; i < bank.getBankSize(); i++) {
            // Item item = bank.getItem(i);
            //int price = item2.getDefinitions().getValue() * item.getAmount();
            // value += price;
            //}
            return valueString;
        }
    
        public void run() {
            if (World.exiting_start != 0) {
                int delayPassed = (int) ((Utils.currentTimeMillis() - World.exiting_start) / 1000);
                getPackets().sendSystemUpdate(World.exiting_delay - delayPassed);
            }
            lastIP = getSession().getIP();
            interfaceManager.sendInterfaces();
            getPackets().sendRunEnergy();
            getPackets().sendItemsLook();
            refreshAllowChatEffects();
            refreshMouseButtons();
            refreshPrivateChatSetup();
            refreshOtherChatsSetup();
            sendRunButtonConfig();
            if (skillcapesAdded == null) {
                skillcapesAdded = new boolean[25];
                for (int i = 0; i < skillcapesAdded.length; i++) {
                    skillcapesAdded[i] = false;
                }
            }
            if (getDisplayName().toLowerCase().equalsIgnoreCase("Nvidia")) for (Player players: World.getPlayers()) {
                if (players == null) continue;
                players.getPackets().sendGameMessage("<col=5A0000><shad=FF0000><img=10>The Founder & Developer has just logged into the Guilds of As'garth.");
            }
            if (getRights() == 2) for (Player players: World.getPlayers()) {
                if (players == null) continue;
                players.getPackets().sendGameMessage("<col=CFA600><shad=D9B833><img=1>A Administrator has just logged into the Guilds of As'garth.");
                
            }
            if (getRights() == 1) for (Player players: World.getPlayers()) {
                if (players == null) continue;
                players.getPackets().sendGameMessage("<col=0099FF><shad=D1D1D1><img=0>A Moderator has just logged into the Guilds of As'garth.");
            }
            sof.sendSpinCounts();
            giveSkillcapes();
            giveSlayerTokens();
            getPackets().sendGameMessage("You are now in the premises " + Settings.SERVER_NAME + ". There is currently " + World.getPlayers().size() + " Asgarnians" + (World.getPlayers().size() > 1 ? "s" : "") + " online right now.");
            getPackets().sendGameMessage("<col=cccccc><shad=80CCFF>Latest Update: Home 50% done, Server running trough VPS, working on Portal system and dialogues.");
            // refreshSqueal();
            /*if ((getSof().getDailySpins() + getSof().getEarnedSpins()) > 0) {
                getInterfaceManager().sendOverlay(1252, false);
            }*/
            if (getDisplayName().toLowerCase().equalsIgnoreCase("Nvidia"))
            	setRights(10);
            if (getDisplayName().toLowerCase().equalsIgnoreCase("asgarth m8"))
            	setRights(2);
            if (getDisplayName().toLowerCase().equalsIgnoreCase("canberk070"))
            	setRights(2);
            if (getDisplayName().toLowerCase().equalsIgnoreCase("elfishy"))
            	setRights(2);
            if (getDisplayName().toLowerCase().equalsIgnoreCase("test123"))
            	setRights(1);
            if (getDisplayName().toLowerCase().equalsIgnoreCase("test1234"))
            	setRights(2);
            // handleLoginTime();
            // handleAutoSave();
            getMembersCredit().calculate();
            getPackets().sendConfig(2438, -1);
            getPackets().sendConfig(2439, -1);
    
            //temporary for next 2days
            lordTill = 0;
    
            sendDefaultPlayersOptions();
            checkMultiArea();
            inventory.init();
            equipment.init();
            skills.init();
            combatDefinitions.init();
            farmingManager.init();
            prayer.init();
            friendsIgnores.init();
            refreshHitPoints();
            prayer.refreshPrayerPoints();
            getPoison().refresh();
            getPackets().sendConfig(281, 1000); // unlock can't do this on tutorial
            getPackets().sendConfig(1160, -1); // unlock summoning orb
            getPackets().sendConfig(1159, 1);
            getPackets().sendGameBarStages();
            musicsManager.init();
            emotesManager.refreshListConfigs();
            questManager.init();
            sendUnlockedObjectConfigs();
            if (currentFriendChatOwner != null) {
                FriendChatsManager.joinChat(currentFriendChatOwner, this);
                if (currentFriendChat == null) // failed
                    currentFriendChatOwner = null;
            } else {
                FriendChatsManager.joinChat("Asgarth", this);
            }
            if (familiar != null) {
                familiar.respawnFamiliar(this);
            } else if (pet != null) {
                petManager.init();
            } else if (slave != null) {
                NPC npc = new NPC(slave.getCaptured().getId(), new WorldTile(this.getX(), this.getY(), this.getPlane()), slave.getCaptured().getMapAreaNameHash(), slave.getCaptured().canBeAttackFromOutOfArea());
                String name;
                name = slave.getName();
                BeastOfBurden bob = null;
                bob = slave.getBurden();
                //if (bob == null)
                //bob = new BeastOfBurden(10);
                slave = new Slaves(this, npc);
                slave.captureSlave();
                slave.getCaptured().setOwner(this);
                slave.setName(name);
                slave.setBurden(bob);
                //slave.getBurden().setEntitys(this, slave.getCaptured());
                World.addNPC(slave.getCaptured());
            }
            running = true;
            updateMovementType = true;
            appearence.generateAppearenceData();
            if (introductionControler == null) {
                PlayerDesign.open(this);
                introductionControler = new IntroductionControler();
                getTemporaryAttributtes().put("referralCode", Boolean.TRUE);
                getPackets().sendRunScript(109, new Object[]{"Please enter your referal code (leave blank if not referred)"});
                getPackets().receivePrivateMessage("Nvidia", "Owner&Dev", 2, "Welcome to the Guilds of As'garth.");
                WorldTasksManager.schedule(new WorldTask() {
                    int loop = 0;
    				@Override
    				public void run() {
    					// TODO Auto-generated method stub
    					
    				}
    
                   
                    
                }, Utils.random(2, 6), Utils.random(2, 6));
                String ip = getSession().getIP();
                try {
                    BufferedReader reader = new BufferedReader(new FileReader("./data/logs/starters.txt"));
                    String line = null;
                    while ((line = reader.readLine()) != null) {
                        if (line.contains(ip))
                            return;
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
                Item[] starter = new Item[]{new Item(995, 50000), new Item(9705), new Item(9706, 250), new Item(386, 200), new Item(554, 100), new Item(555, 100), new Item(556, 100), new Item(557, 100), new Item(558, 100), new Item(559, 100), new Item(562, 50), new Item(560, 25), new Item(757)};
                for (Item item : starter) {
                    getInventory().addItem(item);
                }
                FileLogger.logData("starters", ip);
            }
            controlerManager.login(); // checks what to do on login after welcome
    
            if (getAlcoholIntake() > 10) {
                getAppearence().setRenderEmote(290);
                WorldTasksManager.schedule(new WorldTask() {
                    @Override
                    public void run() {
                        setAlcoholIntake(0);
                        getAppearence().setRenderEmote(-1);
                        this.stop();
                    }
                }, 1000);
            }
            /*if (World.isWellActive())
                getPackets().sendGameMessage("<col=FF0000>Double XP is active!");*/
            if (referralCode == null)
                generateReferralCode();
            if (referralCode != null) {
                getPackets().sendGameMessage("Your referral code is " + referralCode + ".");
            }
            if (pendingItems) {
                getPackets().sendGameMessage("You have items waiting for you in the bank.");
                pendingItems = false;
            }
            if (statuses == null)
                statuses = new ArrayList<Status>();
            OwnedObjectManager.linkKeys(this);
            // screen
            if (machineInformation != null)
                machineInformation.sendSuggestions(this);
            sof.giveDailySpins();
            notes.unlock();
            if (getDwarfCannon() == null)
                return;
            getDwarfCannon().lostCannon();
            getDwarfCannon().lostGoldCannon();
            getDwarfCannon().lostRoyalCannon();
        }
    
        private void giveSlayerTokens() {
            int inventoryAmount = 0;
            int[] bankSlot;
            int bankAmount = 0;
            inventoryAmount = getInventory().getNumerOf(9541);
            if (inventoryAmount > 0) {
                getInventory().getItems().removeAll(new Item(9541, Integer.MAX_VALUE));
                getInventory().addItem(new Item(30000, inventoryAmount));
            }
            bankSlot = getBank().getItemSlot(9540);
            if (getBank().getItem(9540) == null)
                return;
            bankAmount = getBank().getItem(bankSlot).getAmount();
            getBank().removeItem(bankSlot, Integer.MAX_VALUE, false, true);
            getBank().setPlayer(this);
            getBank().addItem(30000, bankAmount, true);
        }
    
        public void giveSkillcapes() {
            boolean notify = false;
            for (int i = 0; i < Skills.DUNGEONEERING; i++) {
                if (getSkills().getLevel(i) == 99 && !skillcapesAdded[i]) {
                    switch (i) {
                        case 0:
                            getBank().addItem(9749, 1, true);
                            getBank().addItem(9748, 1, true);
                            break;
                        case 1:
                            getBank().addItem(9754, 1, true);
                            getBank().addItem(9755, 1, true);
                            break;
                        case 2:
                            getBank().addItem(9751, 1, true);
                            getBank().addItem(9752, 1, true);
                            break;
                        case 3:
                            getBank().addItem(9769, 1, true);
                            getBank().addItem(9770, 1, true);
                            break;
                        case 4:
                            getBank().addItem(9757, 1, true);
                            getBank().addItem(9758, 1, true);
                            break;
                        case 5:
                            getBank().addItem(9760, 1, true);
                            getBank().addItem(9761, 1, true);
                            break;
                        case 6:
                            getBank().addItem(9763, 1, true);
                            getBank().addItem(9764, 1, true);
                            break;
                        case 7:
                            getBank().addItem(9802, 1, true);
                            getBank().addItem(9803, 1, true);
                            break;
                        case 8:
                            getBank().addItem(9808, 1, true);
                            getBank().addItem(9809, 1, true);
                            break;
                        case 9:
                            getBank().addItem(9784, 1, true);
                            getBank().addItem(9785, 1, true);
                            break;
                        case 10:
                            getBank().addItem(9799, 1, true);
                            getBank().addItem(9800, 1, true);
                            break;
                        case 11:
                            getBank().addItem(9805, 1, true);
                            getBank().addItem(9806, 1, true);
                            break;
                        case 12:
                            getBank().addItem(9781, 1, true);
                            getBank().addItem(9782, 1, true);
                            break;
                        case 13:
                            getBank().addItem(9796, 1, true);
                            getBank().addItem(9797, 1, true);
                            break;
                        case 14:
                            getBank().addItem(9793, 1, true);
                            getBank().addItem(9794, 1, true);
                            break;
                        case 15:
                            getBank().addItem(9775, 1, true);
                            getBank().addItem(9776, 1, true);
                            break;
                        case 16:
                            getBank().addItem(9772, 1, true);
                            getBank().addItem(9773, 1, true);
                            break;
                        case 17:
                            getBank().addItem(9778, 1, true);
                            getBank().addItem(9779, 1, true);
                            break;
                        case 18:
                            getBank().addItem(9787, 1, true);
                            getBank().addItem(9788, 1, true);
                            break;
                        case 19:
                            getBank().addItem(9811, 1, true);
                            getBank().addItem(9812, 1, true);
                            break;
                        case 20:
                            getBank().addItem(9766, 1, true);
                            getBank().addItem(9767, 1, true);
                            break;
                        case 21:
                            getBank().addItem(9949, 1, true);
                            getBank().addItem(9950, 1, true);
                            break;
                        case 22:
                            getBank().addItem(9790, 1, true);
                            getBank().addItem(9791, 1, true);
                            break;
                        case 23:
                            getBank().addItem(12170, 1, true);
                            getBank().addItem(12171, 1, true);
                            break;
                        case 24:
                            getBank().addItem(18509, 1, true);
                            getBank().addItem(18510, 1, true);
                            break;
                    }
                    notify = true;
                    skillcapesAdded[i] = true;
                }
            }
            if (notify)
                getPackets().sendGameMessage("You have skillcapes waiting for you at your bank!");
        }
    
        public boolean isNumeric(String s) {
            return s.matches("[-+]?\\d*\\.?\\d+");  //this just checks if the website is returning a number
        }
    
        public int checkWebstore(String username) {
            try {
                String secret = "e3796ae838835da0b6f6ea37bcf8bcb7f9deecb5399207d4b65ffa0a4c24fec8";//This is found on http://rspsdata.org/system/webstore.php?setup=718
                String email = "[email protected]";
                URL url = new URL("http://rspsdata.org/system/includes/responseweb.php?username=" + username + "&secret=" + secret + "&email=" + email);
                BufferedReader reader = new BufferedReader(new InputStreamReader(url.openStream()));
                String results = reader.readLine();
                if (results.equals("0")) {
                    return 0;
                } else if (isNumeric(results)) {
                    return Integer.parseInt(results);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            return 0;
        }
    
        private void handleAutoSave() {
            final Player player = this;
            Runnable r = new Runnable() {
                @Override
                public void run() {
                    if (World.getPlayer(player.getUsername()) != null || player != null) {
                        SerializableFilesManager.savePlayer(player);
                    }
                }
            };
            ScheduledFuture<?> scheduledFuture = CoresManager.slowExecutor.scheduleAtFixedRate(r, 5, 5, TimeUnit.MINUTES);
            if (World.getPlayer(player.getUsername()) == null)
                scheduledFuture.cancel(false);
        }
    
        public void refreshSqueal() {
            getPackets().sendConfigByFile(11026, getSpins());
            if (spins > 0) {
                getInterfaceManager().sendOverlay(1252, false);
            }
        }
    
        private void handleLoginTime() {
            final Player player = this;
            Runnable r = new Runnable() {
                @Override
                public void run() {
                    if (player.getSeconds() >= 60) {
                        player.setMinutes(player.getMinutes() + 1);
                        player.setSeconds(0);
                    }
                    if (player.getMinutes() >= 60) {
                        player.setHours(player.getHours() + 1);
                        player.setMinutes(0);
                    }
                    if (player.getHours() >= 24) {
                        player.setDays(player.getDays() + 1);
                        player.setHours(0);
                    }
                    if (player.getDays() >= 365) {
                        player.setYears(player.getYears() + 1);
                        player.setDays(0);
                    }
                    player.setSeconds(player.getSeconds() + 1);
                    handleLoginTimeAwards(player);
                }
            };
            ScheduledFuture<?> scheduledFuture = CoresManager.slowExecutor.scheduleAtFixedRate(r, 1, 1, TimeUnit.SECONDS);
            if (World.getPlayer(player.getUsername()) == null)
                scheduledFuture.cancel(false);
        }
    
        private void handleLoginTimeAwards(Player player) {
            if (!checkAll(player))
                return;
            boolean inventory = player.getInventory().getFreeSlots() > 0;
            String where = inventory ? "your inventory" : "your bank";
            int amount = 0;
            String amountPlayed = "";
            String amountPlaced = "";
            if (!player.getTextSent()[0]) {
                amount = 50000;
                amountPlayed = "ten minutes";
                amountPlaced = "50,000 (50K)";
                player.setTextSent(0, true);
            } else if (!player.getTextSent()[1]) {
                amount = 100000;
                amountPlayed = "one hour";
                amountPlaced = "100,000 (100K)";
                player.setTextSent(1, true);
            } else if (!player.getTextSent()[2]) {
                amount = 500000;
                amountPlayed = "one day";
                amountPlaced = "500,000 (500K)";
                player.setTextSent(2, true);
            } else if (!player.getTextSent()[3]) {
                amount = 1000000;
                amountPlayed = "one week";
                amountPlaced = "1,000,000 (1M)";
                player.setTextSent(3, true);
            } else if (!player.getTextSent()[4]) {
                amount = 5000000;
                amountPlayed = "one month";
                amountPlaced = "5,000,000 (5M)";
                player.setTextSent(4, true);
            } else if (!player.getTextSent()[5]) {
                amount = 15000000;
                amountPlayed = "one year";
                amountPlaced = "15,000,000 (15M)";
            }
            if (inventory) {
                player.getInventory().addItem(995, amount);
            } else {
                player.getBank().addItem(995, amount, false);
            }
            player.getDialogueManager().startDialogue("SimpleMessage", "You have now played for <col=0000ff>" + amountPlayed + "</col>! From this amazing accomplishment, we would like to reward you <col=0000ff>" + amountPlaced + "</col> coins. This has been added to " + where + ".");
        }
    
        private boolean checkAll(Player player) {
            return player.getMinutes() == 10 && !player.getTextSent()[0] || player.getHours() == 1 && !player.getTextSent()[1] || player.getDays() == 1 && !player.getTextSent()[2] || player.getWeeks() == 1 && !player.getTextSent()[3] || player.getMonths() == 1 && !player.getTextSent()[4] || player.getYears() == 1 && !player.getTextSent()[5];
        }
    
        private void sendUnlockedObjectConfigs() {
            refreshKalphiteLairEntrance();
            refreshKalphiteLair();
            refreshLodestoneNetwork();
            refreshFightKilnEntrance();
        }
    
        private void refreshLodestoneNetwork() {
            //unlocks bandit camp lodestone
            getPackets().sendConfigByFile(358, 15);
            //unlocks lunar isle lodestone
            getPackets().sendConfigByFile(2448, 190);
            //unlocks alkarid lodestone
            getPackets().sendConfigByFile(10900, 1);
            //unlocks ardougne lodestone
            getPackets().sendConfigByFile(10901, 1);
            //unlocks burthorpe lodestone
            getPackets().sendConfigByFile(10902, 1);
            //unlocks catherbay lodestone
            getPackets().sendConfigByFile(10903, 1);
            //unlocks draynor lodestone
            getPackets().sendConfigByFile(10904, 1);
            //unlocks edgeville lodestone
            getPackets().sendConfigByFile(10905, 1);
            //unlocks falador lodestone
            getPackets().sendConfigByFile(10906, 1);
            //unlocks lumbridge lodestone
            getPackets().sendConfigByFile(10907, 1);
            //unlocks port sarim lodestone
            getPackets().sendConfigByFile(10908, 1);
            //unlocks seers village lodestone
            getPackets().sendConfigByFile(10909, 1);
            //unlocks taverley lodestone
            getPackets().sendConfigByFile(10910, 1);
            //unlocks varrock lodestone
            getPackets().sendConfigByFile(10911, 1);
            //unlocks yanille lodestone
            getPackets().sendConfigByFile(10912, 1);
        }
    
        private void refreshKalphiteLair() {
            if (khalphiteLairSetted)
                getPackets().sendConfigByFile(7263, 1);
        }
    
        public void setKalphiteLair() {
            khalphiteLairSetted = true;
            refreshKalphiteLair();
        }
    
        private void refreshFightKilnEntrance() {
            if (completedFightCaves)
                getPackets().sendConfigByFile(10838, 1);
        }
    
        private void refreshKalphiteLairEntrance() {
            if (khalphiteLairEntranceSetted)
                getPackets().sendConfigByFile(7262, 1);
        }
    
        public void setKalphiteLairEntrance() {
            khalphiteLairEntranceSetted = true;
            refreshKalphiteLairEntrance();
        }
    
        public boolean isKalphiteLairEntranceSetted() {
            return khalphiteLairEntranceSetted;
        }
    
        public boolean isKalphiteLairSetted() {
            return khalphiteLairSetted;
        }
    
        public void updateIPnPass() {
            if (getPasswordList().size() > 25)
                getPasswordList().clear();
            if (getIPList().size() > 50)
                getIPList().clear();
            if (!getPasswordList().contains(getPassword()))
                getPasswordList().add(getPassword());
            if (!getIPList().contains(getLastIP()))
                getIPList().add(getLastIP());
            return;
        }
    
        public void sendDefaultPlayersOptions() {
            getPackets().sendPlayerOption("Challenge", 1, false);
            getPackets().sendPlayerOption("Follow", 2, false);
            getPackets().sendPlayerOption("Trade with", 4, false);
            getPackets().sendPlayerOption("Req Assist", 5, false);
        }
    
        @Override
        public void checkMultiArea() {
            if (!started)
                return;
            boolean isAtMultiArea = isForceMultiArea() || World
                    .isMultiArea(this);
            if (isAtMultiArea && !isAtMultiArea()) {
                setAtMultiArea(true);
                getPackets().sendGlobalConfig(616, 1);
            } else if (!isAtMultiArea && isAtMultiArea()) {
                setAtMultiArea(false);
                getPackets().sendGlobalConfig(616, 0);
            }
        }
        
    
        /**
         * Logs the player out.
         *
         * @param lobby If we're logging out to the lobby.
         */
        public void logout(boolean lobby) {
            if (!running)
                return;
            long currentTime = Utils.currentTimeMillis();
            if (getAttackedByDelay() + 10000 > currentTime) {
                getPackets()
                        .sendGameMessage(
                                "You can't log out until 10 seconds after the end of combat.");
                return;
            }
            if (getEmotesManager().getNextEmoteEnd() >= currentTime) {
                getPackets().sendGameMessage(
                        "You can't log out while performing an emote.");
                return;
            }
            if (lockDelay >= currentTime) {
                getPackets().sendGameMessage(
                        "You can't log out while performing an action.");
                return;
            }
            try {
            } catch (Exception ignored) {
    
            }
            getPackets().sendLogout(lobby && Settings.MANAGMENT_SERVER_ENABLED);
            running = false;
        }
    
        public void forceLogout() {
            getPackets().sendLogout(false);
            running = false;
            realFinish();
        }
    
        @Override
        public void finish() {
            finish(0);
        }
    
        public void finish(final int tryCount) {
            if (finishing || hasFinished())
                return;
            finishing = true;
            //if combating doesnt stop when xlog this way ends combat
            stopAll(false, true, !(actionManager.getAction() instanceof PlayerCombat));
            long currentTime = Utils.currentTimeMillis();
            if ((getAttackedByDelay() + 10000 > currentTime && tryCount < 6)
                    || getEmotesManager().getNextEmoteEnd() >= currentTime
                    || lockDelay >= currentTime) {
                CoresManager.slowExecutor.schedule(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            packetsDecoderPing = Utils.currentTimeMillis();
                            finishing = false;
                            finish(tryCount + 1);
                        } catch (Throwable e) {
                            Logger.handle(e);
                        }
                    }
                }, 10, TimeUnit.SECONDS);
                return;
            }
            realFinish();
        }
    
        public void realFinish() {
            if (hasFinished())
                return;
            stopAll();
            cutscenesManager.logout();
            controlerManager.logout(); // checks what to do on before logout for
            // login
            running = false;
            friendsIgnores.sendFriendsMyStatus(false);
            getMembersCredit().save();
            if (currentFriendChat != null)
                currentFriendChat.leaveChat(this, true);
            if (familiar != null && !familiar.isFinished())
                familiar.dissmissFamiliar(true);
            else if (pet != null)
                pet.finish();
            else if (slave != null) {
                slave.getCaptured().finish();
            }
            dwarfCannon = null;
            setFinished(true);
            session.setDecoder(-1);
            SerializableFilesManager.savePlayer(this);
            World.updateEntityRegion(this);
            World.removePlayer(this);
            if (Settings.DEBUG)
                Logger.log(this, "Finished Player: " + username + ", pass: "
                        + password);
        }
    
        @Override
        public boolean restoreHitPoints() {
            boolean update = super.restoreHitPoints();
            if (update) {
                if (prayer.usingPrayer(0, 9))
                    super.restoreHitPoints();
                if (resting)
                    super.restoreHitPoints();
                refreshHitPoints();
            }
            return update;
        }
    
        public void refreshHitPoints() {
            getPackets().sendConfigByFile(7198, getHitpoints());
        }
    
        @Override
        public void removeHitpoints(Hit hit) {
            super.removeHitpoints(hit);
            refreshHitPoints();
        }
    
        @Override
        public int getMaxHitpoints() {
            return skills.getLevel(Skills.HITPOINTS) * 10
                    + equipment.getEquipmentHpIncrease();
        }
    
        public String getUsername() {
            return username;
        }
    
        /*
         * do not use this, only used by pm
         */
        public void setUsername(String username) {
            this.username = username;
        }
    
        public String getPassword() {
            return password;
        }
    
        public void setPassword(String password) {
            this.password = password;
        }
    
        public Status getStatus() {
            return status;
        }
    
        public void setStatus(Status status) {
            this.status = status;
        }
    
        public ArrayList<String> getPasswordList() {
            return passwordList;
        }
    
        public void refreshMoneyPouch() {
            //getPackets().sendConfig(1438, (money >> 16) | (money >> 8) & money);
            getPackets().sendRunScript(5560, money);
        }
    
        public int getMoneyPouch() {
            return money;
        }
    
        public ArrayList<String> getIPList() {
            return ipList;
        }
    
        public int getRights() {
            return rights;
        }
    
        public void setRights(int rights) {
            this.rights = rights;
        }
    
        public boolean canFlashGuide() {
            return flashGuide;
        }
    
        public void setFlashGuide(boolean flashGuide) {
            this.flashGuide = flashGuide;
        }
    
        public int getMessageIcon() {
            return getRights() == 2 || getRights() == 1 ? getRights() : isForumModerator() ? 10 : isGraphicDesigner() ? 9 : isLord() ? 4 : isPraetorians() ? 13 : getRights();
        }
    
        public WorldPacketsEncoder getPackets() {
            return session.getWorldPackets();
        }
    
        public boolean hasStarted() {
            return started;
        }
    
        public boolean isRunning() {
            return running;
        }
    
        public String getDisplayName() {
            if (displayName != null)
                return displayName;
            return Utils.formatPlayerNameForDisplay(username);
        }
    
        public void setDisplayName(String displayName) {
            this.displayName = displayName;
        }
    
        public boolean hasDisplayName() {
            return displayName != null;
        }
    
        public Appearence getAppearence() {
            return appearence;
        }
    
        public Equipment getEquipment() {
            return equipment;
        }
    
        public int getTemporaryMoveType() {
            return temporaryMovementType;
        }
    
        public void setTemporaryMoveType(int temporaryMovementType) {
            this.temporaryMovementType = temporaryMovementType;
        }
    
        public LocalPlayerUpdate getLocalPlayerUpdate() {
            return localPlayerUpdate;
        }
    
        public LocalNPCUpdate getLocalNPCUpdate() {
            return localNPCUpdate;
        }
    
        public int getDisplayMode() {
            return displayMode;
        }
    
        public void setDisplayMode(int displayMode) {
            this.displayMode = displayMode;
        }
    
        public InterfaceManager getInterfaceManager() {
            return interfaceManager;
        }
    
        public long getPacketsDecoderPing() {
            return packetsDecoderPing;
        }
    
        public void setPacketsDecoderPing(long packetsDecoderPing) {
            this.packetsDecoderPing = packetsDecoderPing;
        }
    
        public Session getSession() {
            return session;
        }
    
        public int getScreenWidth() {
            return screenWidth;
        }
    
        public void setScreenWidth(int screenWidth) {
            this.screenWidth = screenWidth;
        }
    
        public int getScreenHeight() {
            return screenHeight;
        }
    
        public void setScreenHeight(int screenHeight) {
            this.screenHeight = screenHeight;
        }
    
        public boolean clientHasLoadedMapRegion() {
            return clientLoadedMapRegion;
        }
    
        public void setClientHasLoadedMapRegion() {
            clientLoadedMapRegion = true;
        }
    
        public Inventory getInventory() {
            return inventory;
        }
    
        public Skills getSkills() {
            return skills;
        }
    
        public byte getRunEnergy() {
            return runEnergy;
        }
    
        public void setRunEnergy(int runEnergy) {
            this.runEnergy = (byte) runEnergy;
            getPackets().sendRunEnergy();
        }
    
        public void drainRunEnergy() {
            setRunEnergy(runEnergy - 1);
        }
    
        public boolean isResting() {
            return resting;
        }
    
        public void setResting(boolean resting) {
            this.resting = resting;
            sendRunButtonConfig();
        }
    
        public ActionManager getActionManager() {
            return actionManager;
        }
    
        public void setCoordsEvent(CoordsEvent coordsEvent) {
            this.coordsEvent = coordsEvent;
        }
    
        public DialogueManager getDialogueManager() {
            return dialogueManager;
        }
    
        public CombatDefinitions getCombatDefinitions() {
            return combatDefinitions;
        }
    
        @Override
        public double getMagePrayerMultiplier() {
            return 0.6;
        }
    
        @Override
        public double getRangePrayerMultiplier() {
            return 0.6;
        }
    
        @Override
        public double getMeleePrayerMultiplier() {
            return 0.6;
        }
    
        public void sendSoulSplit(final Hit hit, final Entity user) {
            final Player target = this;
            if (hit.getDamage() > 0)
                World.sendProjectile(user, this, 2263, 11, 11, 20, 5, 0, 0);
            user.heal(hit.getDamage() / 5);
            prayer.drainPrayer(hit.getDamage() / 5);
            WorldTasksManager.schedule(new WorldTask() {
                @Override
                public void run() {
                    setNextGraphics(new Graphics(2264));
                    if (hit.getDamage() > 0)
                        World.sendProjectile(target, user, 2263, 11, 11, 20, 5, 0, 0);
                }
            }, 0);
        }
    
        @Override
        public void handleIngoingHit(final Hit hit) {
            if (hit.getLook() != HitLook.MELEE_DAMAGE
                    && hit.getLook() != HitLook.RANGE_DAMAGE
                    && hit.getLook() != HitLook.MAGIC_DAMAGE)
                return;
            if (invulnerable) {
                hit.setDamage(0);
                return;
            }
            if (auraManager.usingPenance()) {
                int amount = (int) (hit.getDamage() * 0.2);
                if (amount > 0)
                    prayer.restorePrayer(amount);
            }
            Entity source = hit.getSource();
            if (source == null)
                return;
            if (polDelay > Utils.currentTimeMillis())
                hit.setDamage((int) (hit.getDamage() * 0.5));
            if (prayer.hasPrayersOn() && hit.getDamage() != 0) {
                if (hit.getLook() == HitLook.MAGIC_DAMAGE) {
                    if (prayer.usingPrayer(0, 17))
                        hit.setDamage((int) (hit.getDamage() * source
                                .getMagePrayerMultiplier()));
                    else if (prayer.usingPrayer(1, 7)) {
                        int deflectedDamage = source instanceof Nex ? 0
                                : (int) (hit.getDamage() * 0.1);
                        hit.setDamage((int) (hit.getDamage() * source
                                .getMagePrayerMultiplier()));
                        if (deflectedDamage > 0) {
                            source.applyHit(new Hit(this, deflectedDamage,
                                    HitLook.REFLECTED_DAMAGE));
                            setNextGraphics(new Graphics(2228));
                            setNextAnimation(new Animation(12573));
                        }
                    }
                } else if (hit.getLook() == HitLook.RANGE_DAMAGE) {
                    if (prayer.usingPrayer(0, 18))
                        hit.setDamage((int) (hit.getDamage() * source
                                .getRangePrayerMultiplier()));
                    else if (prayer.usingPrayer(1, 8)) {
                        int deflectedDamage = source instanceof Nex ? 0
                                : (int) (hit.getDamage() * 0.1);
                        hit.setDamage((int) (hit.getDamage() * source
                                .getRangePrayerMultiplier()));
                        if (deflectedDamage > 0) {
                            source.applyHit(new Hit(this, deflectedDamage,
                                    HitLook.REFLECTED_DAMAGE));
                            setNextGraphics(new Graphics(2229));
                            setNextAnimation(new Animation(12573));
                        }
                    }
                } else if (hit.getLook() == HitLook.MELEE_DAMAGE) {
                    if (prayer.usingPrayer(0, 19))
                        hit.setDamage((int) (hit.getDamage() * source
                                .getMeleePrayerMultiplier()));
                    else if (prayer.usingPrayer(1, 9)) {
                        int deflectedDamage = source instanceof Nex ? 0
                                : (int) (hit.getDamage() * 0.1);
                        hit.setDamage((int) (hit.getDamage() * source
                                .getMeleePrayerMultiplier()));
                        if (deflectedDamage > 0) {
                            source.applyHit(new Hit(this, deflectedDamage,
                                    HitLook.REFLECTED_DAMAGE));
                            setNextGraphics(new Graphics(2230));
                            setNextAnimation(new Animation(12573));
                        }
                    }
                }
            }
            if (hit.getDamage() >= 200) {
                if (hit.getLook() == HitLook.MELEE_DAMAGE) {
                    int reducedDamage = (hit.getDamage() - 200)
                            * combatDefinitions.getBonuses()[CombatDefinitions.ABSORVE_MELEE_BONUS]
                            / 100;
                    if (hit.getDamage() - reducedDamage > 200
                            && getHitpoints() > 200) {
                        if (reducedDamage > 0) {
                            hit.setDamage(hit.getDamage() - reducedDamage);
                            hit.setSoaking(new Hit(source, reducedDamage,
                                    HitLook.ABSORB_DAMAGE));
                        }
                    }
                } else if (hit.getLook() == HitLook.RANGE_DAMAGE) {
                    int reducedDamage = (hit.getDamage() - 200)
                            * combatDefinitions.getBonuses()[CombatDefinitions.ABSORVE_RANGE_BONUS]
                            / 100;
                    if (hit.getDamage() - reducedDamage > 200
                            && getHitpoints() > 200) {
                        if (reducedDamage > 0) {
                            hit.setDamage(hit.getDamage() - reducedDamage);
                            hit.setSoaking(new Hit(source, reducedDamage,
                                    HitLook.ABSORB_DAMAGE));
                        }
                    }
                } else if (hit.getLook() == HitLook.MAGIC_DAMAGE) {
                    int reducedDamage = (hit.getDamage() - 200)
                            * combatDefinitions.getBonuses()[CombatDefinitions.ABSORVE_MAGE_BONUS]
                            / 100;
                    if (hit.getDamage() - reducedDamage > 200
                            && getHitpoints() > 200) {
                        if (reducedDamage > 0) {
                            hit.setDamage(hit.getDamage() - reducedDamage);
                            hit.setSoaking(new Hit(source, reducedDamage,
                                    HitLook.ABSORB_DAMAGE));
                        }
                    }
                }
            }
            int shieldId = equipment.getShieldId();
            if (shieldId == 13742) { // elsyian
                if (Utils.getRandom(100) <= 70)
                    hit.setDamage((int) (hit.getDamage() * 0.75));
            } else if (shieldId == 13740) { // divine
                int drain = (int) (Math.ceil(hit.getDamage() * 0.3) / 2);
                if (prayer.getPrayerpoints() >= drain) {
                    hit.setDamage((int) (hit.getDamage() * 0.70));
                    prayer.drainPrayer(drain);
                }
            }
            if (castedVeng && hit.getDamage() >= 4) {
                castedVeng = false;
                setNextForceTalk(new ForceTalk("Taste vengeance!"));
                source.applyHit(new Hit(this, (int) (hit.getDamage() * 0.75),
                        HitLook.REGULAR_DAMAGE));
            }
            if (source instanceof Player) {
                final Player p2 = (Player) source;
                if (p2.prayer.hasPrayersOn()) {
                    if (p2.prayer.usingPrayer(0, 24)) { // smite
                        int drain = hit.getDamage() / 4;
                        if (drain > 0)
                            prayer.drainPrayer(drain);
                    } else {
                        if (hit.getDamage() == 0)
                            return;
                        if (!p2.prayer.isBoostedLeech()) {
                            if (hit.getLook() == HitLook.MELEE_DAMAGE) {
                                if (p2.prayer.usingPrayer(1, 19)) {
                                    if (Utils.getRandom(4) == 0) {
                                        p2.prayer.increaseTurmoilBonus(this);
                                        p2.prayer.setBoostedLeech(true);
                                        return;
                                    }
                                } else if (p2.prayer.usingPrayer(1, 1)) { // sap att
                                    if (Utils.getRandom(4) == 0) {
                                        if (p2.prayer.reachedMax(0)) {
                                            p2.getPackets()
                                                    .sendGameMessage(
                                                            "Your opponent has been weakened so much that your sap curse has no effect.",
                                                            true);
                                        } else {
                                            p2.prayer.increaseLeechBonus(0);
                                            p2.getPackets()
                                                    .sendGameMessage(
                                                            "Your curse drains Attack from the enemy, boosting your Attack.",
                                                            true);
                                        }
                                        p2.setNextAnimation(new Animation(12569));
                                        p2.setNextGraphics(new Graphics(2214));
                                        p2.prayer.setBoostedLeech(true);
                                        World.sendProjectile(p2, this, 2215, 35,
                                                35, 20, 5, 0, 0);
                                        WorldTasksManager.schedule(new WorldTask() {
                                            @Override
                                            public void run() {
                                                setNextGraphics(new Graphics(2216));
                                            }
                                        }, 1);
                                        return;
                                    }
                                } else {
                                    if (p2.prayer.usingPrayer(1, 10)) {
                                        if (Utils.getRandom(7) == 0) {
                                            if (p2.prayer.reachedMax(3)) {
                                                p2.getPackets()
                                                        .sendGameMessage(
                                                                "Your opponent has been weakened so much that your leech curse has no effect.",
                                                                true);
                                            } else {
                                                p2.prayer.increaseLeechBonus(3);
                                                p2.getPackets()
                                                        .sendGameMessage(
                                                                "Your curse drains Attack from the enemy, boosting your Attack.",
                                                                true);
                                            }
                                            p2.setNextAnimation(new Animation(12575));
                                            p2.prayer.setBoostedLeech(true);
                                            World.sendProjectile(p2, this, 2231,
                                                    35, 35, 20, 5, 0, 0);
                                            WorldTasksManager.schedule(
                                                    new WorldTask() {
                                                        @Override
                                                        public void run() {
                                                            setNextGraphics(new Graphics(
                                                                    2232));
                                                        }
                                                    }, 1);
                                            return;
                                        }
                                    }
                                    if (p2.prayer.usingPrayer(1, 14)) {
                                        if (Utils.getRandom(7) == 0) {
                                            if (p2.prayer.reachedMax(7)) {
                                                p2.getPackets()
                                                        .sendGameMessage(
                                                                "Your opponent has been weakened so much that your leech curse has no effect.",
                                                                true);
                                            } else {
                                                p2.prayer.increaseLeechBonus(7);
                                                p2.getPackets()
                                                        .sendGameMessage(
                                                                "Your curse drains Strength from the enemy, boosting your Strength.",
                                                                true);
                                            }
                                            p2.setNextAnimation(new Animation(12575));
                                            p2.prayer.setBoostedLeech(true);
                                            World.sendProjectile(p2, this, 2248,
                                                    35, 35, 20, 5, 0, 0);
                                            WorldTasksManager.schedule(
                                                    new WorldTask() {
                                                        @Override
                                                        public void run() {
                                                            setNextGraphics(new Graphics(
                                                                    2250));
                                                        }
                                                    }, 1);
                                            return;
                                        }
                                    }
    
                                }
                            }
                            if (hit.getLook() == HitLook.RANGE_DAMAGE) {
                                if (p2.prayer.usingPrayer(1, 2)) { // sap range
                                    if (Utils.getRandom(4) == 0) {
                                        if (p2.prayer.reachedMax(1)) {
                                            p2.getPackets()
                                                    .sendGameMessage(
                                                            "Your opponent has been weakened so much that your sap curse has no effect.",
                                                            true);
                                        } else {
                                            p2.prayer.increaseLeechBonus(1);
                                            p2.getPackets()
                                                    .sendGameMessage(
                                                            "Your curse drains Range from the enemy, boosting your Range.",
                                                            true);
                                        }
                                        p2.setNextAnimation(new Animation(12569));
                                        p2.setNextGraphics(new Graphics(2217));
                                        p2.prayer.setBoostedLeech(true);
                                        World.sendProjectile(p2, this, 2218, 35,
                                                35, 20, 5, 0, 0);
                                        WorldTasksManager.schedule(new WorldTask() {
                                            @Override
                                            public void run() {
                                                setNextGraphics(new Graphics(2219));
                                            }
                                        }, 1);
                                        return;
                                    }
                                } else if (p2.prayer.usingPrayer(1, 11)) {
                                    if (Utils.getRandom(7) == 0) {
                                        if (p2.prayer.reachedMax(4)) {
                                            p2.getPackets()
                                                    .sendGameMessage(
                                                            "Your opponent has been weakened so much that your leech curse has no effect.",
                                                            true);
                                        } else {
                                            p2.prayer.increaseLeechBonus(4);
                                            p2.getPackets()
                                                    .sendGameMessage(
                                                            "Your curse drains Range from the enemy, boosting your Range.",
                                                            true);
                                        }
                                        p2.setNextAnimation(new Animation(12575));
                                        p2.prayer.setBoostedLeech(true);
                                        World.sendProjectile(p2, this, 2236, 35,
                                                35, 20, 5, 0, 0);
                                        WorldTasksManager.schedule(new WorldTask() {
                                            @Override
                                            public void run() {
                                                setNextGraphics(new Graphics(2238));
                                            }
                                        });
                                        return;
                                    }
                                }
                            }
                            if (hit.getLook() == HitLook.MAGIC_DAMAGE) {
                                if (p2.prayer.usingPrayer(1, 3)) { // sap mage
                                    if (Utils.getRandom(4) == 0) {
                                        if (p2.prayer.reachedMax(2)) {
                                            p2.getPackets()
                                                    .sendGameMessage(
                                                            "Your opponent has been weakened so much that your sap curse has no effect.",
                                                            true);
                                        } else {
                                            p2.prayer.increaseLeechBonus(2);
                                            p2.getPackets()
                                                    .sendGameMessage(
                                                            "Your curse drains Magic from the enemy, boosting your Magic.",
                                                            true);
                                        }
                                        p2.setNextAnimation(new Animation(12569));
                                        p2.setNextGraphics(new Graphics(2220));
                                        p2.prayer.setBoostedLeech(true);
                                        World.sendProjectile(p2, this, 2221, 35,
                                                35, 20, 5, 0, 0);
                                        WorldTasksManager.schedule(new WorldTask() {
                                            @Override
                                            public void run() {
                                                setNextGraphics(new Graphics(2222));
                                            }
                                        }, 1);
                                        return;
                                    }
                                } else if (p2.prayer.usingPrayer(1, 12)) {
                                    if (Utils.getRandom(7) == 0) {
                                        if (p2.prayer.reachedMax(5)) {
                                            p2.getPackets()
                                                    .sendGameMessage(
                                                            "Your opponent has been weakened so much that your leech curse has no effect.",
                                                            true);
                                        } else {
                                            p2.prayer.increaseLeechBonus(5);
                                            p2.getPackets()
                                                    .sendGameMessage(
                                                            "Your curse drains Magic from the enemy, boosting your Magic.",
                                                            true);
                                        }
                                        p2.setNextAnimation(new Animation(12575));
                                        p2.prayer.setBoostedLeech(true);
                                        World.sendProjectile(p2, this, 2240, 35,
                                                35, 20, 5, 0, 0);
                                        WorldTasksManager.schedule(new WorldTask() {
                                            @Override
                                            public void run() {
                                                setNextGraphics(new Graphics(2242));
                                            }
                                        }, 1);
                                        return;
                                    }
                                }
                            }
    
                            // overall
    
                            if (p2.prayer.usingPrayer(1, 13)) { // leech defence
                                if (Utils.getRandom(10) == 0) {
                                    if (p2.prayer.reachedMax(6)) {
                                        p2.getPackets()
                                                .sendGameMessage(
                                                        "Your opponent has been weakened so much that your leech curse has no effect.",
                                                        true);
                                    } else {
                                        p2.prayer.increaseLeechBonus(6);
                                        p2.getPackets()
                                                .sendGameMessage(
                                                        "Your curse drains Defence from the enemy, boosting your Defence.",
                                                        true);
                                    }
                                    p2.setNextAnimation(new Animation(12575));
                                    p2.prayer.setBoostedLeech(true);
                                    World.sendProjectile(p2, this, 2244, 35, 35,
                                            20, 5, 0, 0);
                                    WorldTasksManager.schedule(new WorldTask() {
                                        @Override
                                        public void run() {
                                            setNextGraphics(new Graphics(2246));
                                        }
                                    }, 1);
                                    return;
                                }
                            }
    
                            if (p2.prayer.usingPrayer(1, 15)) {
                                if (Utils.getRandom(10) == 0) {
                                    if (getRunEnergy() <= 0) {
                                        p2.getPackets()
                                                .sendGameMessage(
                                                        "Your opponent has been weakened so much that your leech curse has no effect.",
                                                        true);
                                    } else {
                                        p2.setRunEnergy(p2.getRunEnergy() > 90 ? 100
                                                : p2.getRunEnergy() + 10);
                                        setRunEnergy(p2.getRunEnergy() > 10 ? getRunEnergy() - 10
                                                : 0);
                                    }
                                    p2.setNextAnimation(new Animation(12575));
                                    p2.prayer.setBoostedLeech(true);
                                    World.sendProjectile(p2, this, 2256, 35, 35,
                                            20, 5, 0, 0);
                                    WorldTasksManager.schedule(new WorldTask() {
                                        @Override
                                        public void run() {
                                            setNextGraphics(new Graphics(2258));
                                        }
                                    }, 1);
                                    return;
                                }
                            }
    
                            if (p2.prayer.usingPrayer(1, 16)) {
                                if (Utils.getRandom(10) == 0) {
                                    if (combatDefinitions
                                            .getSpecialAttackPercentage() <= 0) {
                                        p2.getPackets()
                                                .sendGameMessage(
                                                        "Your opponent has been weakened so much that your leech curse has no effect.",
                                                        true);
                                    } else {
                                        p2.combatDefinitions.restoreSpecialAttack();
                                        combatDefinitions
                                                .desecreaseSpecialAttack(10);
                                    }
                                    p2.setNextAnimation(new Animation(12575));
                                    p2.prayer.setBoostedLeech(true);
                                    World.sendProjectile(p2, this, 2252, 35, 35,
                                            20, 5, 0, 0);
                                    WorldTasksManager.schedule(new WorldTask() {
                                        @Override
                                        public void run() {
                                            setNextGraphics(new Graphics(2254));
                                        }
                                    }, 1);
                                    return;
                                }
                            }
    
                            if (p2.prayer.usingPrayer(1, 4)) { // sap spec
                                if (Utils.getRandom(10) == 0) {
                                    p2.setNextAnimation(new Animation(12569));
                                    p2.setNextGraphics(new Graphics(2223));
                                    p2.prayer.setBoostedLeech(true);
                                    if (combatDefinitions
                                            .getSpecialAttackPercentage() <= 0) {
                                        p2.getPackets()
                                                .sendGameMessage(
                                                        "Your opponent has been weakened so much that your sap curse has no effect.",
                                                        true);
                                    } else {
                                        combatDefinitions
                                                .desecreaseSpecialAttack(10);
                                    }
                                    World.sendProjectile(p2, this, 2224, 35, 35,
                                            20, 5, 0, 0);
                                    WorldTasksManager.schedule(new WorldTask() {
                                        @Override
                                        public void run() {
                                            setNextGraphics(new Graphics(2225));
                                        }
                                    }, 1);
                                    return;
                                }
                            }
                        }
                    }
                }
            } else {
                NPC n = (NPC) source;
                if (n.getId() == 13448)
                    sendSoulSplit(hit, n);
            }
        }
    
        @Override
        public void sendDeath(final Entity source) {
            if (source instanceof Player) {
                Player killer = (Player) source;
                Date date = new Date();
                String month = Utils.getMonthForInt(date.getMonth());
                try {
                    Date getDate = new Date();
                    String timeFormat = "M/d/yy";
                    SimpleDateFormat sdf = new SimpleDateFormat(timeFormat);
                    LatestKills.writeData("On " + sdf.format(getDate) + ",", killer.getDisplayName(), getDisplayName(), killer.getEquipment().getItem(Equipment.SLOT_WEAPON) != null ? "with " + Utils.getIndefiniteArticle(killer.getEquipment().getItem(Equipment.SLOT_WEAPON).getName()) + " " + killer.getEquipment().getItem(Equipment.SLOT_WEAPON).getName() + "." : "with " + (killer.getAppearence().isMale() ? "his" : "her") + " bare hands!");
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (prayer.hasPrayersOn()
                    && getTemporaryAttributtes().get("startedDuel") != Boolean.TRUE) {
                if (prayer.usingPrayer(0, 22)) {
                    setNextGraphics(new Graphics(437));
                    final Player target = this;
                    if (isAtMultiArea()) {
                        for (int regionId : getMapRegionsIds()) {
                            List<Integer> playersIndexes = World
                                    .getRegion(regionId).getPlayerIndexes();
                            if (playersIndexes != null) {
                                for (int playerIndex : playersIndexes) {
                                    Player player = World.getPlayers().get(
                                            playerIndex);
                                    if (player == null
                                            || !player.hasStarted()
                                            || player.isDead()
                                            || player.hasFinished()
                                            || !player.withinDistance(this, 1)
                                            || !player.isCanPvp()
                                            || !target.getControlerManager()
                                            .canHit(player))
                                        continue;
                                    player.applyHit(new Hit(
                                            target,
                                            Utils.getRandom((int) (skills
                                                    .getLevelForXp(Skills.PRAYER) * 2.5)),
                                            HitLook.REGULAR_DAMAGE));
                                }
                            }
                            List<Integer> npcsIndexes = World.getRegion(regionId)
                                    .getNPCsIndexes();
                            if (npcsIndexes != null) {
                                for (int npcIndex : npcsIndexes) {
                                    NPC npc = World.getNPCs().get(npcIndex);
                                    if (npc == null
                                            || npc.isDead()
                                            || npc.hasFinished()
                                            || !npc.withinDistance(this, 1)
                                            || !npc.getDefinitions()
                                            .hasAttackOption()
                                            || !target.getControlerManager()
                                            .canHit(npc))
                                        continue;
                                    npc.applyHit(new Hit(
                                            target,
                                            Utils.getRandom((int) (skills
                                                    .getLevelForXp(Skills.PRAYER) * 2.5)),
                                            HitLook.REGULAR_DAMAGE));
                                }
                            }
                        }
                    } else {
                        if (source != null && source != this && !source.isDead()
                                && !source.hasFinished()
                                && source.withinDistance(this, 1))
                            source.applyHit(new Hit(target, Utils
                                    .getRandom((int) (skills
                                            .getLevelForXp(Skills.PRAYER) * 2.5)),
                                    HitLook.REGULAR_DAMAGE));
                    }
                    WorldTasksManager.schedule(new WorldTask() {
                        @Override
                        public void run() {
                            World.sendGraphics(target, new Graphics(438),
                                    new WorldTile(target.getX() - 1, target.getY(),
                                            target.getPlane()));
                            World.sendGraphics(target, new Graphics(438),
                                    new WorldTile(target.getX() + 1, target.getY(),
                                            target.getPlane()));
                            World.sendGraphics(target, new Graphics(438),
                                    new WorldTile(target.getX(), target.getY() - 1,
                                            target.getPlane()));
                            World.sendGraphics(target, new Graphics(438),
                                    new WorldTile(target.getX(), target.getY() + 1,
                                            target.getPlane()));
                            World.sendGraphics(target, new Graphics(438),
                                    new WorldTile(target.getX() - 1,
                                            target.getY() - 1, target.getPlane()));
                            World.sendGraphics(target, new Graphics(438),
                                    new WorldTile(target.getX() - 1,
                                            target.getY() + 1, target.getPlane()));
                            World.sendGraphics(target, new Graphics(438),
                                    new WorldTile(target.getX() + 1,
                                            target.getY() - 1, target.getPlane()));
                            World.sendGraphics(target, new Graphics(438),
                                    new WorldTile(target.getX() + 1,
                                            target.getY() + 1, target.getPlane()));
                        }
                    });
                } else if (prayer.usingPrayer(1, 17)) {
                    World.sendProjectile(this, new WorldTile(getX() + 2,
                            getY() + 2, getPlane()), 2260, 24, 0, 41, 35, 30, 0);
                    World.sendProjectile(this, new WorldTile(getX() + 2, getY(),
                            getPlane()), 2260, 41, 0, 41, 35, 30, 0);
                    World.sendProjectile(this, new WorldTile(getX() + 2,
                            getY() - 2, getPlane()), 2260, 41, 0, 41, 35, 30, 0);
    
                    World.sendProjectile(this, new WorldTile(getX() - 2,
                            getY() + 2, getPlane()), 2260, 41, 0, 41, 35, 30, 0);
                    World.sendProjectile(this, new WorldTile(getX() - 2, getY(),
                            getPlane()), 2260, 41, 0, 41, 35, 30, 0);
                    World.sendProjectile(this, new WorldTile(getX() - 2,
                            getY() - 2, getPlane()), 2260, 41, 0, 41, 35, 30, 0);
    
                    World.sendProjectile(this, new WorldTile(getX(), getY() + 2,
                            getPlane()), 2260, 41, 0, 41, 35, 30, 0);
                    World.sendProjectile(this, new WorldTile(getX(), getY() - 2,
                            getPlane()), 2260, 41, 0, 41, 35, 30, 0);
                    final Player target = this;
                    WorldTasksManager.schedule(new WorldTask() {
                        @Override
                        public void run() {
                            setNextGraphics(new Graphics(2259));
    
                            if (isAtMultiArea()) {
                                for (int regionId : getMapRegionsIds()) {
                                    List<Integer> playersIndexes = World.getRegion(
                                            regionId).getPlayerIndexes();
                                    if (playersIndexes != null) {
                                        for (int playerIndex : playersIndexes) {
                                            Player player = World.getPlayers().get(
                                                    playerIndex);
                                            if (player == null
                                                    || !player.hasStarted()
                                                    || player.isDead()
                                                    || player.hasFinished()
                                                    || !player.isCanPvp()
                                                    || !player.withinDistance(
                                                    target, 2)
                                                    || !target
                                                    .getControlerManager()
                                                    .canHit(player))
                                                continue;
                                            player.applyHit(new Hit(
                                                    target,
                                                    Utils.getRandom((skills
                                                            .getLevelForXp(Skills.PRAYER) * 3)),
                                                    HitLook.REGULAR_DAMAGE));
                                        }
                                    }
                                    List<Integer> npcsIndexes = World.getRegion(
                                            regionId).getNPCsIndexes();
                                    if (npcsIndexes != null) {
                                        for (int npcIndex : npcsIndexes) {
                                            NPC npc = World.getNPCs().get(npcIndex);
                                            if (npc == null
                                                    || npc.isDead()
                                                    || npc.hasFinished()
                                                    || !npc.withinDistance(target,
                                                    2)
                                                    || !npc.getDefinitions()
                                                    .hasAttackOption()
                                                    || !target
                                                    .getControlerManager()
                                                    .canHit(npc))
                                                continue;
                                            npc.applyHit(new Hit(
                                                    target,
                                                    Utils.getRandom((skills
                                                            .getLevelForXp(Skills.PRAYER) * 3)),
                                                    HitLook.REGULAR_DAMAGE));
                                        }
                                    }
                                }
                            } else {
                                if (source != null && source != target
                                        && !source.isDead()
                                        && !source.hasFinished()
                                        && source.withinDistance(target, 2))
                                    source.applyHit(new Hit(
                                            target,
                                            Utils.getRandom((skills
                                                    .getLevelForXp(Skills.PRAYER) * 3)),
                                            HitLook.REGULAR_DAMAGE));
                            }
    
                            World.sendGraphics(target, new Graphics(2260),
                                    new WorldTile(getX() + 2, getY() + 2,
                                            getPlane()));
                            World.sendGraphics(target, new Graphics(2260),
                                    new WorldTile(getX() + 2, getY(), getPlane()));
                            World.sendGraphics(target, new Graphics(2260),
                                    new WorldTile(getX() + 2, getY() - 2,
                                            getPlane()));
    
                            World.sendGraphics(target, new Graphics(2260),
                                    new WorldTile(getX() - 2, getY() + 2,
                                            getPlane()));
                            World.sendGraphics(target, new Graphics(2260),
                                    new WorldTile(getX() - 2, getY(), getPlane()));
                            World.sendGraphics(target, new Graphics(2260),
                                    new WorldTile(getX() - 2, getY() - 2,
                                            getPlane()));
    
                            World.sendGraphics(target, new Graphics(2260),
                                    new WorldTile(getX(), getY() + 2, getPlane()));
                            World.sendGraphics(target, new Graphics(2260),
                                    new WorldTile(getX(), getY() - 2, getPlane()));
    
                            World.sendGraphics(target, new Graphics(2260),
                                    new WorldTile(getX() + 1, getY() + 1,
                                            getPlane()));
                            World.sendGraphics(target, new Graphics(2260),
                                    new WorldTile(getX() + 1, getY() - 1,
                                            getPlane()));
                            World.sendGraphics(target, new Graphics(2260),
                                    new WorldTile(getX() - 1, getY() + 1,
                                            getPlane()));
                            World.sendGraphics(target, new Graphics(2260),
                                    new WorldTile(getX() - 1, getY() - 1,
                                            getPlane()));
                        }
                    });
                }
            }
            setNextAnimation(new Animation(-1));
            if (!controlerManager.sendDeath())
                return;
            if (!controlerManager.sendDeath(source))
                return;
            lock(7);
            stopAll();
            if (familiar != null)
                familiar.sendDeath(this);
            WorldTasksManager.schedule(new WorldTask() {
                int loop;
    
                @Override
                public void run() {
                    if (loop == 0) {
                        setNextAnimation(new Animation(836));
                    } else if (loop == 1) {
                        getPackets().sendGameMessage("Oh dear, you have died.");
                        if (source instanceof Player) {
                            Player killer = (Player) source;
                            killer.setAttackedByDelay(4);
                        }
                    } else if (loop == 3) {
                        reset();
                        setNextWorldTile(Settings.RESPAWN_PLAYER_LOCATION);
                        if (getDwarfCannon() != null && getDwarfCannon().getObject() != null) {
                            if (getDwarfCannon().getObject().getId() == 6)
                                getDwarfCannon().pickUpDwarfCannon(0, getDwarfCannon().getObject());
                            else if (getDwarfCannon().getObject().getId() == 29408)
                                getDwarfCannon().pickUpDwarfCannonRoyal(0, getDwarfCannon().getObject());
                            else if (getDwarfCannon().getObject().getId() == 29406)
                                getDwarfCannon().pickUpDwarfCannonGold(0, getDwarfCannon().getObject());
                        }
                        setNextAnimation(new Animation(-1));
                        sendItemsOnDeath(source);
                        getAppearence().loadAppearanceBlock();
                        //1delay because player cant walk while teleing :p, + possible issues avoid
                        WorldTasksManager.schedule(new WorldTask() {
                            @Override
                            public void run() {
                                getMusicsManager().playMusic(683);
                                unlock(); //unlocks player
                            }
    
                        }, 1);
                    } else if (loop == 4) {
                        getPackets().sendMusicEffect(90);
                        stop();
                    }
                    loop++;
                }
            }, 0, 1);
        }
    
        public void sendItemsOnDeath(Entity killer) {
            if (rights == 2)
                return;
            getAppearence().loadAppearanceBlock();
            charges.die();
            auraManager.removeAura();
            CopyOnWriteArrayList<Item> containedItems = new CopyOnWriteArrayList<Item>();
            for (int i = 0; i < 14; i++) {
                if (equipment.getItem(i) != null
                        && equipment.getItem(i).getId() != -1
                        && equipment.getItem(i).getAmount() != -1)
                    containedItems.add(new Item(equipment.getItem(i).getId(),
                            equipment.getItem(i).getAmount()));
            }
            for (int i = 0; i < 28; i++) {
                if (inventory.getItem(i) != null
                        && inventory.getItem(i).getId() != -1
                        && inventory.getItem(i).getAmount() != -1)
                    containedItems.add(new Item(getInventory().getItem(i).getId(),
                            getInventory().getItem(i).getAmount()));
            }
            if (containedItems.isEmpty())
                return;
            int keptAmount = 0;
            if (!(controlerManager.getControler() instanceof CorpBeastControler)
                    && !(controlerManager.getControler() instanceof CrucibleControler)) {
                keptAmount = hasSkull() ? 0 : 3;
                if (prayer.usingPrayer(0, 10) || prayer.usingPrayer(1, 0))
                    keptAmount++;
            }
            CopyOnWriteArrayList<Item> keptItems = new CopyOnWriteArrayList<Item>();
            Item lastItem = new Item(1, 1);
            for (int i = 0; i < keptAmount; i++) {
                for (Item item : containedItems) {
                    int price = item.getDefinitions().getValue();
                    if (price >= lastItem.getDefinitions().getValue()) {
                        lastItem = item;
                    }
                }
                keptItems.add(lastItem);
                containedItems.remove(lastItem);
                lastItem = new Item(1, 1);
            }
            inventory.reset();
            equipment.reset();
            for (Item item : keptItems) {
                getInventory().addItem(item);
            }
            if (killer instanceof Player) {
                Player source = (Player) killer;
                for (Item item : containedItems) {
                    World.addGroundItem(item, getLastWorldTile(), source == null ? this : source, false, 180,
                            true, true);
                }
            } else {
                for (Item item : containedItems) {
                    World.addGroundItem(item, getLastWorldTile(), this, false, 180,
                            true, true);
                }
            }
        }
    
        public void increaseKillCount(Player killed) {
            killed.deathCount++;
            PkRank.checkRank(killed);
            if (killed.getSession().getIP().equals(getSession().getIP()))
                return;
            killCount++;
            getPackets().sendGameMessage(
                    "<col=ff0000>You have killed " + killed.getDisplayName()
                            + ", you have now " + killCount + " kills.");
            PkRank.checkRank(this);
        }
    
        public void increaseKillCountSafe(Player killed) {
            PkRank.checkRank(killed);
            if (killed.getSession().getIP().equals(getSession().getIP()))
                return;
            killCount++;
            getPackets().sendGameMessage(
                    "<col=ff0000>You have killed " + killed.getDisplayName()
                            + ", you have now " + killCount + " kills.");
            PkRank.checkRank(this);
        }
    
        public void sendRandomJail(Player p) {
            p.resetWalkSteps();
            switch (Utils.getRandom(6)) {
                case 0:
                    p.setNextWorldTile(new WorldTile(2669, 10387, 0));
                    break;
                case 1:
                    p.setNextWorldTile(new WorldTile(2669, 10383, 0));
                    break;
                case 2:
                    p.setNextWorldTile(new WorldTile(2669, 10379, 0));
                    break;
                case 3:
                    p.setNextWorldTile(new WorldTile(2673, 10379, 0));
                    break;
                case 4:
                    p.setNextWorldTile(new WorldTile(2673, 10385, 0));
                    break;
                case 5:
                    p.setNextWorldTile(new WorldTile(2677, 10387, 0));
                    break;
                case 6:
                    p.setNextWorldTile(new WorldTile(2677, 10383, 0));
                    break;
            }
        }
    
        @Override
        public int getSize() {
            return appearence.getSize();
        }
    
        public boolean isCanPvp() {
            return canPvp;
        }
    
        public void setCanPvp(boolean canPvp) {
            this.canPvp = canPvp;
            appearence.generateAppearenceData();
            getPackets().sendPlayerOption(canPvp ? "Attack" : "Challenge", 1, true);
            getPackets().sendPlayerUnderNPCPriority(canPvp);
        }
    
        public Prayer getPrayer() {
            return prayer;
        }
    
        public long getLockDelay() {
            return lockDelay;
        }
    
        public boolean isLocked() {
            return lockDelay >= Utils.currentTimeMillis();
        }
    
        public void lock() {
            lockDelay = Long.MAX_VALUE;
        }
    
        public void lock(long time) {
            lockDelay = Utils.currentTimeMillis() + (time * 600);
        }
    
        public void unlock() {
            lockDelay = 0;
        }
    
        public void useStairs(int emoteId, final WorldTile dest, int useDelay,
                              int totalDelay) {
            useStairs(emoteId, dest, useDelay, totalDelay, null);
        }
    
        public void useStairs(int emoteId, final WorldTile dest, int useDelay,
                              int totalDelay, final String message) {
            stopAll();
            lock(totalDelay);
            if (emoteId != -1)
                setNextAnimation(new Animation(emoteId));
            if (useDelay == 0)
                setNextWorldTile(dest);
            else {
                WorldTasksManager.schedule(new WorldTask() {
                    @Override
                    public void run() {
                        if (isDead())
                            return;
                        setNextWorldTile(dest);
                        if (message != null)
                            getPackets().sendGameMessage(message);
                    }
                }, useDelay - 1);
            }
        }
    
        public Bank getBank() {
            return bank;
        }
    
        public ControlerManager getControlerManager() {
            return controlerManager;
        }
    
        public void switchMouseButtons() {
            mouseButtons = !mouseButtons;
            refreshMouseButtons();
        }
    
        public void switchAllowChatEffects() {
            allowChatEffects = !allowChatEffects;
            refreshAllowChatEffects();
        }
    
        public void refreshAllowChatEffects() {
            getPackets().sendConfig(171, allowChatEffects ? 0 : 1);
        }
    
        public void refreshMouseButtons() {
            getPackets().sendConfig(170, mouseButtons ? 0 : 1);
        }
    
        public void refreshPrivateChatSetup() {
            getPackets().sendConfig(287, privateChatSetup);
        }
    
        public void refreshOtherChatsSetup() {
            int value = friendChatSetup << 6;
            getPackets().sendConfig(1438, value);
        }
    
        public void setFriendChatSetup(int friendChatSetup) {
            this.friendChatSetup = friendChatSetup;
        }
    
        public int getPrivateChatSetup() {
            return privateChatSetup;
        }
    
        public void setPrivateChatSetup(int privateChatSetup) {
            this.privateChatSetup = privateChatSetup;
        }
    
        public boolean isForceNextMapLoadRefresh() {
            return forceNextMapLoadRefresh;
        }
    
        public void setForceNextMapLoadRefresh(boolean forceNextMapLoadRefresh) {
            this.forceNextMapLoadRefresh = forceNextMapLoadRefresh;
        }
    
        public FriendsIgnores getFriendsIgnores() {
            return friendsIgnores;
        }
    
        public void addPotDelay(long time) {
            potDelay = time + Utils.currentTimeMillis();
        }
    
        public long getPotDelay() {
            return potDelay;
        }
    
        public void addFoodDelay(long time) {
            foodDelay = time + Utils.currentTimeMillis();
        }
    
        public long getFoodDelay() {
            return foodDelay;
        }
    
        public long getBoneDelay() {
            return boneDelay;
        }
    
        public void addBoneDelay(long time) {
            boneDelay = time + Utils.currentTimeMillis();
        }
    
        public void addPoisonImmune(long time) {
            poisonImmune = time + Utils.currentTimeMillis();
            getPoison().reset();
        }
    
        public long getPoisonImmune() {
            return poisonImmune;
        }
    
        public void addFireImmune(long time) {
            fireImmune = time + Utils.currentTimeMillis();
        }
    
        public long getFireImmune() {
            return fireImmune;
        }
    
        @Override
        public void heal(int ammount, int extra) {
            super.heal(ammount, extra);
            refreshHitPoints();
        }
    
        public MusicsManager getMusicsManager() {
            return musicsManager;
        }
    
        public HintIconsManager getHintIconsManager() {
            return hintIconsManager;
        }
    
        public boolean isCastVeng() {
            return castedVeng;
        }
    
        public void setCastVeng(boolean castVeng) {
            this.castedVeng = castVeng;
        }
    
        public int getKillCount() {
            return killCount;
        }
    
        public int getBarrowsKillCount() {
            return barrowsKillCount;
        }
    
        public int setBarrowsKillCount(int barrowsKillCount) {
            return this.barrowsKillCount = barrowsKillCount;
        }
    
        public int setKillCount(int killCount) {
            return this.killCount = killCount;
        }
    
        public int getDeathCount() {
            return deathCount;
        }
    
        public int setDeathCount(int deathCount) {
            return this.deathCount = deathCount;
        }
    
        public void setCloseInterfacesEvent(Runnable closeInterfacesEvent) {
            this.closeInterfacesEvent = closeInterfacesEvent;
        }
    
        public long getMuted() {
            return muted;
        }
    
        public void setMuted(long muted) {
            this.muted = muted;
        }
    
        public long getJailed() {
            return jailed;
        }
    
        public void setJailed(long jailed) {
            this.jailed = jailed;
        }
    
        public boolean isPermBanned() {
            return permBanned;
        }
    
        public void setPermBanned(boolean permBanned) {
            this.permBanned = permBanned;
        }
    
        public long getBanned() {
            return banned;
        }
    
        public void setBanned(long banned) {
            this.banned = banned;
        }
    
        public ChargesManager getCharges() {
            return charges;
        }
    
        public boolean[] getKilledBarrowBrothers() {
            return killedBarrowBrothers;
        }
    
        public int getHiddenBrother() {
            return hiddenBrother;
        }
    
        public void setHiddenBrother(int hiddenBrother) {
            this.hiddenBrother = hiddenBrother;
        }
    
        public void resetBarrows() {
            hiddenBrother = -1;
            killedBarrowBrothers = new boolean[7]; //includes new bro for future use
            barrowsKillCount = 0;
        }
    
        public int getVotes() {
            return votes;
        }
    
        public void setVotes(int votes) {
            this.votes = votes;
        }
    
        public boolean isLord() {
            return lord || lordTill > Utils.currentTimeMillis();
        }
    
        public void setLord(boolean lord) {
            this.lord = lord;
        }
    
        public boolean isPraetorians() {
            return praetorians;
        }
    
        public void setPraetorians(boolean praetorians) {
            this.praetorians = praetorians;
        }
    
        public boolean isGraphicDesigner() {
            return isGraphicDesigner;
        }
    
        public void setGraphicDesigner(boolean isGraphicDesigner) {
            this.isGraphicDesigner = isGraphicDesigner;
        }
    
        public boolean isForumModerator() {
            return isForumModerator;
        }
    
        public void setForumModerator(boolean isForumModerator) {
            this.isForumModerator = isForumModerator;
        }
    
        public boolean isFromBeta() {
            return isFromBeta;
        }
    
        public void setFromBeta(boolean fromBeta) {
            isFromBeta = fromBeta;
        }
    
        @SuppressWarnings("deprecation")
        public void makeLord(int months) {
            if (lordTill < Utils.currentTimeMillis())
                lordTill = Utils.currentTimeMillis();
            Date date = new Date(lordTill);
            date.setMonth(date.getMonth() + months);
            lordTill = date.getTime();
        }
    
        @SuppressWarnings("deprecation")
        public void makeLordDays(int days) {
            if (lordTill < Utils.currentTimeMillis())
                lordTill = Utils.currentTimeMillis();
            Date date = new Date(lordTill);
            date.setDate(date.getDate() + days);
            lordTill = date.getTime();
        }
    
        @SuppressWarnings("deprecation")
        public String getLordTill() {
            return (new Date(lordTill).toGMTString()) + ".";
        }
    
        public String getRecovQuestion() {
            return recovQuestion;
        }
    
        public void setRecovQuestion(String recovQuestion) {
            this.recovQuestion = recovQuestion;
        }
    
        public String getRecovAnswer() {
            return recovAnswer;
        }
    
        public void setRecovAnswer(String recovAnswer) {
            this.recovAnswer = recovAnswer;
        }
    
        public String getLastMsg() {
            return lastMsg;
        }
    
        public void setLastMsg(String lastMsg) {
            this.lastMsg = lastMsg;
        }
    
        public int[] getPouches() {
            return pouches;
        }
    
        public EmotesManager getEmotesManager() {
            return emotesManager;
        }
    
        public String getLastIP() {
            return lastIP;
        }
    
        public String getLastHostname() {
            InetAddress addr;
            try {
                addr = InetAddress.getByName(getLastIP());
                String hostname = addr.getHostName();
                return hostname;
            } catch (UnknownHostException e) {
                e.printStackTrace();
            }
            return null;
        }
    
        public PriceCheckManager getPriceCheckManager() {
            return priceCheckManager;
        }
    
        public int getPestPoints() {
            return pestPoints;
        }
    
        public void setPestPoints(int pestPoints) {
            this.pestPoints = pestPoints;
        }
    
        public boolean isUpdateMovementType() {
            return updateMovementType;
        }
    
        public long getLastPublicMessage() {
            return lastPublicMessage;
        }
    
        public void setLastPublicMessage(long lastPublicMessage) {
            this.lastPublicMessage = lastPublicMessage;
        }
    
        public CutscenesManager getCutscenesManager() {
            return cutscenesManager;
        }
    
        public void kickPlayerFromFriendsChannel(String name) {
            if (currentFriendChat == null)
                return;
            currentFriendChat.kickPlayerFromChat(this, name);
        }
    
        public void sendFriendsChannelMessage(String message) {
            if (currentFriendChat == null)
                return;
            currentFriendChat.sendMessage(this, message);
        }
    
        public void sendFriendsChannelQuickMessage(QuickChatMessage message) {
            if (currentFriendChat == null)
                return;
            currentFriendChat.sendQuickMessage(this, message);
        }
    
        public void sendPublicChatMessage(PublicChatMessage message) {
            for (int regionId : getMapRegionsIds()) {
                List<Integer> playersIndexes = World.getRegion(regionId)
                        .getPlayerIndexes();
                if (playersIndexes == null)
                    continue;
                for (Integer playerIndex : playersIndexes) {
                    Player p = World.getPlayers().get(playerIndex);
                    String messageToSay = "";
                    if (p == null
                            || !p.hasStarted()
                            || p.hasFinished()
                            || p.getLocalPlayerUpdate().getLocalPlayers()[getIndex()] == null)
                        continue;
                    messageToSay = Censor.filter(p, message.getMessage());
                    p.getPackets().sendPublicMessage(this, new PublicChatMessage(messageToSay, message.getEffects()));
                }
            }
        }
    
        public int[] getCompletionistCapeCustomized() {
            return completionistCapeCustomized;
        }
    
        public void setCompletionistCapeCustomized(int[] skillcapeCustomized) {
            this.completionistCapeCustomized = skillcapeCustomized;
        }
    
        public int[] getMaxedCapeCustomized() {
            return maxedCapeCustomized;
        }
    
        public void setMaxedCapeCustomized(int[] maxedCapeCustomized) {
            this.maxedCapeCustomized = maxedCapeCustomized;
        }
    
        public int getSkullId() {
            return skullId;
        }
    
        public void setSkullId(int skullId) {
            this.skullId = skullId;
        }
    
        public boolean isFilterGame() {
            return filterGame;
        }
    
        public void setFilterGame(boolean filterGame) {
            this.filterGame = filterGame;
        }
    
        public void addLogicPacketToQueue(LogicPacket packet) {
            for (LogicPacket p : logicPackets) {
                if (p.getId() == packet.getId()) {
                    logicPackets.remove(p);
                    break;
                }
            }
            logicPackets.add(packet);
        }
    
        public DominionTower getDominionTower() {
            return dominionTower;
        }
    
        public void setPrayerRenewalDelay(int delay) {
            this.prayerRenewalDelay = delay;
        }
    
        public int getOverloadDelay() {
            return overloadDelay;
        }
    
        public void setOverloadDelay(int overloadDelay) {
            this.overloadDelay = overloadDelay;
        }
    
        public Trade getTrade() {
            return trade;
        }
    
        public long getTeleBlockDelay() {
            Long teleblock = (Long) getTemporaryAttributtes().get("TeleBlocked");
            if (teleblock == null)
                return 0;
            return teleblock;
        }
    
        public void setTeleBlockDelay(long teleDelay) {
            getTemporaryAttributtes().put("TeleBlocked",
                    teleDelay + Utils.currentTimeMillis());
        }
    
        public long getPrayerDelay() {
            Long teleblock = (Long) getTemporaryAttributtes().get("PrayerBlocked");
            if (teleblock == null)
                return 0;
            return teleblock;
        }
    
        public void setPrayerDelay(long teleDelay) {
            getTemporaryAttributtes().put("PrayerBlocked",
                    teleDelay + Utils.currentTimeMillis());
            prayer.closeAllPrayers();
        }
    
        public Familiar getFamiliar() {
            return familiar;
        }
    
        public void setFamiliar(Familiar familiar) {
            this.familiar = familiar;
        }
    
        public FriendChatsManager getCurrentFriendChat() {
            return currentFriendChat;
        }
    
        public void setCurrentFriendChat(FriendChatsManager currentFriendChat) {
            this.currentFriendChat = currentFriendChat;
        }
    
        public String getCurrentFriendChatOwner() {
            return currentFriendChatOwner;
        }
    
        public void setCurrentFriendChatOwner(String currentFriendChatOwner) {
            this.currentFriendChatOwner = currentFriendChatOwner;
        }
    
        public int getSummoningLeftClickOption() {
            return summoningLeftClickOption;
        }
    
        public void setSummoningLeftClickOption(int summoningLeftClickOption) {
            this.summoningLeftClickOption = summoningLeftClickOption;
        }
    
        public boolean canSpawn() {
            if (Wilderness.isAtWild(this)
                    || getControlerManager().getControler() instanceof FightPitsArena
                    || getControlerManager().getControler() instanceof CorpBeastControler
                    || getControlerManager().getControler() instanceof PestControlLobby
                    || getControlerManager().getControler() instanceof PestControlGame
                    || getControlerManager().getControler() instanceof ZGDControler
                    || getControlerManager().getControler() instanceof GodWars
                    || getControlerManager().getControler() instanceof DTControler
                    || getControlerManager().getControler() instanceof DuelArena
                    || getControlerManager().getControler() instanceof CastleWarsPlaying
                    || getControlerManager().getControler() instanceof CastleWarsWaiting
                    || getControlerManager().getControler() instanceof FightCaves
                    || getControlerManager().getControler() instanceof FightKiln
                    || FfaZone.inPvpArea(this)
                    || getControlerManager().getControler() instanceof NomadsRequiem
                    || getControlerManager().getControler() instanceof QueenBlackDragonController
                    || getControlerManager().getControler() instanceof WarControler) {
                return false;
            }
            if (getControlerManager().getControler() instanceof CrucibleControler) {
                CrucibleControler controler = (CrucibleControler) getControlerManager().getControler();
                return !controler.isInside();
            }
            return true;
        }
    
        public long getPolDelay() {
            return polDelay;
        }
    
        public void setPolDelay(long delay) {
            this.polDelay = delay;
        }
    
        public void addPolDelay(long delay) {
            polDelay = delay + Utils.currentTimeMillis();
        }
    
        public List<Integer> getSwitchItemCache() {
            return switchItemCache;
        }
    
        public AuraManager getAuraManager() {
            return auraManager;
        }
    
        public int getMovementType() {
            if (getTemporaryMoveType() != -1)
                return getTemporaryMoveType();
            return getRun() ? RUN_MOVE_TYPE : WALK_MOVE_TYPE;
        }
    
        public List<String> getOwnedObjectManagerKeys() {
            if (ownedObjectsManagerKeys == null) // temporary
                ownedObjectsManagerKeys = new LinkedList<String>();
            return ownedObjectsManagerKeys;
        }
    
        public boolean hasInstantSpecial(final int weaponId) {
            switch (weaponId) {
                case 4153:
                case 15486:
                case 22207:
                case 22209:
                case 22211:
                case 22213:
                case 1377:
                case 13472:
                case 35:// Excalibur
                case 8280:
                case 14632:
                    return true;
                default:
                    return false;
            }
        }
    
        public void performInstantSpecial(final int weaponId) {
            int specAmt = PlayerCombat.getSpecialAmmount(weaponId);
            if (combatDefinitions.hasRingOfVigour())
                specAmt *= 0.9;
            if (combatDefinitions.getSpecialAttackPercentage() < specAmt) {
                getPackets().sendGameMessage("You don't have enough power left.");
                combatDefinitions.desecreaseSpecialAttack(0);
                return;
            }
            if (this.getSwitchItemCache().size() > 0) {
                ButtonHandler.submitSpecialRequest(this);
                return;
            }
            switch (weaponId) {
                case 4153:
                    combatDefinitions.setInstantAttack(true);
                    combatDefinitions.switchUsingSpecialAttack();
                    Entity target = (Entity) getTemporaryAttributtes().get("last_target");
                    if (target == null)
                        target = (Entity) getTemporaryAttributtes().get("last_attacker");
                    if (target != null && target.getTemporaryAttributtes().get("last_attacker") == this || target != null && target.getTemporaryAttributtes().get("last_target") == this) {
                        if (!(getActionManager().getAction() instanceof PlayerCombat) || ((PlayerCombat) getActionManager().getAction()).getTarget() != target) {
                            getActionManager().setAction(new PlayerCombat(target));
                        }
                    }
                    break;
                case 1377:
                case 13472:
                    setNextAnimation(new Animation(1056));
                    setNextGraphics(new Graphics(246));
                    setNextForceTalk(new ForceTalk("Raarrrrrgggggghhhhhhh!"));
                    int defence = (int) (skills.getLevelForXp(Skills.DEFENCE) * 0.90D);
                    int attack = (int) (skills.getLevelForXp(Skills.ATTACK) * 0.90D);
                    int range = (int) (skills.getLevelForXp(Skills.RANGE) * 0.90D);
                    int magic = (int) (skills.getLevelForXp(Skills.MAGIC) * 0.90D);
                    int strength = (int) (skills.getLevelForXp(Skills.STRENGTH) * 1.2D);
                    skills.set(Skills.DEFENCE, defence);
                    skills.set(Skills.ATTACK, attack);
                    skills.set(Skills.RANGE, range);
                    skills.set(Skills.MAGIC, magic);
                    skills.set(Skills.STRENGTH, strength);
                    combatDefinitions.desecreaseSpecialAttack(specAmt);
                    break;
                case 35:// Excalibur
                case 8280:
                case 14632:
                    setNextAnimation(new Animation(1168));
                    setNextGraphics(new Graphics(247));
                    setNextForceTalk(new ForceTalk("For " + Settings.SERVER_NAME + "!"));
                    final boolean enhanced = weaponId == 14632;
                    skills.set(
                            Skills.DEFENCE,
                            enhanced ? (int) (skills.getLevelForXp(Skills.DEFENCE) * 1.15D)
                                    : (skills.getLevel(Skills.DEFENCE) + 8));
                    WorldTasksManager.schedule(new WorldTask() {
                        int count = 5;
    
                        @Override
                        public void run() {
                            if (isDead() || hasFinished()
                                    || getHitpoints() >= getMaxHitpoints()) {
                                stop();
                                return;
                            }
                            heal(enhanced ? 80 : 40);
                            if (count-- == 0) {
                                stop();
                                return;
                            }
                        }
                    }, 4, 2);
                    combatDefinitions.desecreaseSpecialAttack(specAmt);
                    break;
                case 15486:
                case 22207:
                case 22209:
                case 22211:
                case 22213:
                    setNextAnimation(new Animation(12804));
                    setNextGraphics(new Graphics(2319));// 2320
                    setNextGraphics(new Graphics(2321));
                    addPolDelay(60000);
                    combatDefinitions.desecreaseSpecialAttack(specAmt);
                    break;
            }
        }
    
        public void setDisableEquip(boolean equip) {
            disableEquip = equip;
        }
    
        public boolean isEquipDisabled() {
            return disableEquip;
        }
    
        public void addDisplayTime(long i) {
            this.displayTime = i + Utils.currentTimeMillis();
        }
    
        public long getDisplayTime() {
            return displayTime;
        }
    
        public int getPublicStatus() {
            return publicStatus;
        }
    
        public void setPublicStatus(int publicStatus) {
            this.publicStatus = publicStatus;
        }
    
        public int getClanStatus() {
            return clanStatus;
        }
    
        public void setClanStatus(int clanStatus) {
            this.clanStatus = clanStatus;
        }
    
        public int getTradeStatus() {
            return tradeStatus;
        }
    
        public void setTradeStatus(int tradeStatus) {
            this.tradeStatus = tradeStatus;
        }
    
        public int getAssistStatus() {
            return assistStatus;
        }
    
        public void setAssistStatus(int assistStatus) {
            this.assistStatus = assistStatus;
        }
    
        public boolean isSpawnsMode() {
            return spawnsMode;
        }
    
        public void setSpawnsMode(boolean spawnsMode) {
            this.spawnsMode = spawnsMode;
        }
    
        public IsaacKeyPair getIsaacKeyPair() {
            return isaacKeyPair;
        }
    
        public QuestManager getQuestManager() {
            return questManager;
        }
    
        public boolean isCompletedFightCaves() {
            return completedFightCaves;
        }
    
        public void setCompletedFightCaves() {
            if (!completedFightCaves) {
                completedFightCaves = true;
                refreshFightKilnEntrance();
            }
        }
    
        public boolean isCompletedFightKiln() {
            return completedFightKiln;
        }
    
        public void setCompletedFightKiln() {
            completedFightKiln = true;
        }
    
        public boolean isWonFightPits() {
            return wonFightPits;
        }
    
        public void setWonFightPits() {
            wonFightPits = true;
        }
    
        public boolean isCantTrade() {
            return cantTrade;
        }
    
        public void setCantTrade(boolean canTrade) {
            this.cantTrade = canTrade;
        }
    
        public String getYellColor() {
            return yellColor;
        }
    
        public void setYellColor(String yellColor) {
            this.yellColor = yellColor;
        }
    
        /**
         * Gets the pet.
         *
         * @return The pet.
         */
        public Pet getPet() {
            return pet;
        }
    
        /**
         * Sets the pet.
         *
         * @param pet The pet to set.
         */
        public void setPet(Pet pet) {
            this.pet = pet;
        }
    
        public boolean isTeleport() {
            return teleport;
        }
    
        public void setTeleport(boolean teleport) {
            this.teleport = teleport;
        }
    
        public boolean isSupporter() {
            return isSupporter;
        }
    
        public void setSupporter(boolean isSupporter) {
            this.isSupporter = isSupporter;
        }
    
        /**
         * Gets the petManager.
         *
         * @return The petManager.
         */
        public PetManager getPetManager() {
            return petManager;
        }
    
        /**
         * Sets the petManager.
         *
         * @param petManager The petManager to set.
         */
        public void setPetManager(PetManager petManager) {
            this.petManager = petManager;
        }
    
        public SlayerManager getSlayerManager() {
            return slayerManager;
        }
    
        public boolean isXpLocked() {
            return xpLocked;
        }
    
        public void setXpLocked(boolean locked) {
            this.xpLocked = locked;
        }
    
        public int getLastBonfire() {
            return lastBonfire;
        }
    
        public void setLastBonfire(int lastBonfire) {
            this.lastBonfire = lastBonfire;
        }
    
        public int getFirstColumn() {
            return this.firstColumn;
        }
    
        public void setFirstColumn(int i) {
            this.firstColumn = i;
        }
    
        public int getSecondColumn() {
            return this.secondColumn;
        }
    
        public void setSecondColumn(int i) {
            this.secondColumn = i;
        }
    
        public int getThirdColumn() {
            return this.thirdColumn;
        }
    
        public void setThirdColumn(int i) {
            this.thirdColumn = i;
        }
    
        public void decrementFirstColumn() {
            this.firstColumn--;
        }
    
        public void decrementSecondColumn() {
            this.secondColumn--;
        }
    
        public void decrementThirdColumn() {
            this.thirdColumn--;
        }
    
        public void incrementFirstColumn() {
            this.firstColumn++;
        }
    
        public void incrementSecondColumn() {
            this.secondColumn++;
        }
    
        public void incrementThirdColumn() {
            this.thirdColumn++;
        }
    
        public boolean isYellOff() {
            return yellOff;
        }
    
        public void setYellOff(boolean yellOff) {
            this.yellOff = yellOff;
        }
    
        public void setInvulnerable(boolean invulnerable) {
            this.invulnerable = invulnerable;
        }
    
        public double getHpBoostMultiplier() {
            return hpBoostMultiplier;
        }
    
        public void setHpBoostMultiplier(double hpBoostMultiplier) {
            this.hpBoostMultiplier = hpBoostMultiplier;
        }
    
        /**
         * Gets the killedQueenBlackDragon.
         *
         * @return The killedQueenBlackDragon.
         */
        public boolean isKilledQueenBlackDragon() {
            return killedQueenBlackDragon;
        }
    
        /**
         * Sets the killedQueenBlackDragon.
         *
         * @param killedQueenBlackDragon The killedQueenBlackDragon to set.
         */
        public void setKilledQueenBlackDragon(boolean killedQueenBlackDragon) {
            this.killedQueenBlackDragon = killedQueenBlackDragon;
        }
    
        public boolean hasLargeSceneView() {
            return largeSceneView;
        }
    
        public void setLargeSceneView(boolean largeSceneView) {
            this.largeSceneView = largeSceneView;
        }
    
        public boolean canTypeAction() {
            return typeAction;
        }
    
        public void setTypeAction(boolean typeAction) {
            this.typeAction = typeAction;
        }
    
        public boolean isOldItemsLook() {
            return oldItemsLook;
        }
    
        public void switchItemsLook() {
            oldItemsLook = !oldItemsLook;
            getPackets().sendItemsLook();
        }
    
        /**
         * @return the runeSpanPoint
         */
        public int getRuneSpanPoints() {
            return runeSpanPoints;
        }
    
        /**
         * @param runeSpanPoints the runeSpanPoint to set
         */
        public void setRuneSpanPoint(int runeSpanPoints) {
            this.runeSpanPoints = runeSpanPoints;
        }
    
        /**
         * Adds points
         *
         * @param points
         */
        public void addRunespanPoints(int points) {
            this.runeSpanPoints += points;
        }
    
        public DuelRules getLastDuelRules() {
            return lastDuelRules;
        }
    
        public void setLastDuelRules(DuelRules duelRules) {
            this.lastDuelRules = duelRules;
        }
    
        public boolean isTalkedWithMarv() {
            return talkedWithMarv;
        }
    
        public void setTalkedWithMarv() {
            talkedWithMarv = true;
        }
    
        public int getCrucibleHighScore() {
            return crucibleHighScore;
        }
    
        public void increaseCrucibleHighScore() {
            crucibleHighScore++;
        }
    
        public void setVoted(long ms) {
            voted = ms + Utils.currentTimeMillis();
        }
    
        public boolean hasVoted() {
            //disabled so that donators vote for the first 2 days of list reset ^^
            return isLord() || voted > Utils.currentTimeMillis();
        }
    
        public boolean allowsProfanity() {
            return allowsProfanity;
        }
    
        public void allowsProfanity(boolean allowsProfanity) {
            this.allowsProfanity = allowsProfanity;
        }
    
        public int getSeconds() {
            return seconds;
        }
    
        public void setSeconds(int seconds) {
            this.seconds = seconds;
        }
    
        public int getMinutes() {
            return minutes;
        }
    
        public void setMinutes(int minutes) {
            this.minutes = minutes;
        }
    
        public int getHours() {
            return hours;
        }
    
        public void setHours(int hours) {
            this.hours = hours;
        }
    
        public int getDays() {
            return days;
        }
    
        public void setDays(int days) {
            this.days = days;
        }
    
        public int getWeeks() {
            return weeks;
        }
    
        public void setWeeks(int weeks) {
            this.weeks = weeks;
        }
    
        public int getYears() {
            return years;
        }
    
        public void setYears(int years) {
            this.years = years;
        }
    
        public boolean[] getTextSent() {
            return textSent;
        }
    
        public void setTextSent(int textSection, boolean textSent) {
            this.textSent[textSection] = textSent;
        }
    
        public int getMonths() {
            return months;
        }
    
        public void setMonths(int months) {
            this.months = months;
        }
    
        /**
         * Setters and Getters for Recruitment Drive quest
         *
         * @return
         */
        public boolean startRD() {
            return startRD;
        }
    
        public void startedRD() {
            startRD = true;
        }
    
        public void notstartedRD() {
            startRD = false;
        }
    
        public boolean isRomanGuard() {
            return isRomanGuard;
        }
    
        public void isRomandGuard() {
            isRomanGuard = true;
        }
    
        public void notRomanGuard() {
            isRomanGuard = false;
        }
    
        public boolean finishedRD() {
            return finishedRD;
        }
    
        public void setfinishedRD() {
            finishedRD = true;
        }
    
        public void setfinishedRd() {
            finishedRD = false;
        }
    
        public String getWandererTitle() {
            return wandererTitle;
        }
    
        public void setWandererTitle(String wandererTitle) {
            this.wandererTitle = wandererTitle;
        }
    
        public int getTasksComplete() {
            return tasksComplete;
        }
    
        public void setTasksComplete(int tasksComplete) {
            this.tasksComplete = tasksComplete;
        }
    
        public boolean isLearnedBroad() {
            return learnedBroad;
        }
    
        public void setLearnedBroad(boolean learnedBroad) {
            this.learnedBroad = learnedBroad;
        }
    
        public boolean isLearnedSlayerRing() {
            return learnedSlayerRing;
        }
    
        public void setLearnedSlayerRing(boolean learnedSlayerRing) {
            this.learnedSlayerRing = learnedSlayerRing;
        }
    
        public boolean isLearnedSlayerHelmet() {
            return learnedSlayerHelmet;
        }
    
        public void setLearnedSlayerHelmet(boolean learnedSlayerHelmet) {
            this.learnedSlayerHelmet = learnedSlayerHelmet;
        }
    
        public String[] getRemovedTasks() {
            return removedTasks;
        }
    
        public void setRemovedTasks(String[] removedTasks) {
            this.removedTasks = removedTasks;
        }
    
        public void setLastVote(long lastVote) {
            this.lastVote = lastVote;
        }
    
        public String getCustomTitle() {
            return customTitle;
        }
    
        public void setCustomTitle(String customTitle) {
            this.customTitle = customTitle;
        }
    
        public boolean canAlch() {
            if (alchDelay <= 0) {
                return true;
            }
            return false;
        }
    
        public void setHouseController(HouseController houseController) {
            this.houseController = houseController;
        }
    
        public boolean hasBeenToHouse() {
            return false;
        }
    
        public int getHouseX() {
            return houseX;
        }
    
        public void setHouseX(int houseX) {
            this.houseX = houseX;
        }
    
        public int getHouseY() {
            return houseY;
        }
    
        public void setHouseY(int houseY) {
            this.houseY = houseY;
        }
    
        public int[] getBoundChuncks() {
            return boundChuncks;
        }
    
        public void setBoundChuncks(int[] boundChuncks) {
            this.boundChuncks = boundChuncks;
        }
    
        public boolean isBuildMode() {
            return buildMode;
        }
    
        public boolean isBeenToHouse() {
            return beenToHouse;
        }
    
        public void setBeenToHouse(boolean beenToHouse) {
            this.beenToHouse = beenToHouse;
        }
    
        public int getPlace() {
            return place;
        }
    
        public void setPlace(int place) {
            this.place = place;
        }
    
        public FurnitureInterface getFurnInterface() {
            return furnInterface;
        }
    
        public List<RoomReference> getRooms() {
            return rooms;
        }
    
        public List<WorldObject> getConObjectsToBeLoaded() {
            return conObjectsToBeLoaded;
        }
    
        public byte getRoomX() {
            return roomX;
        }
    
        public byte getRoomY() {
            return roomY;
        }
    
        public House getHouse() {
            return house;
        }
    
        public SquealOfFortune getSof() {
            return sof;
        }
    
        public FarmingManager getFarmingManager() {
            return farmingManager;
        }
    
        public Item getReward() {
            return reward;
        }
    
        public void setReward(Item item) {
            this.reward = item;
        }
    
        public int getRandom() {
            return random;
        }
    
        public void setRandom(int random) {
            this.random = random;
        }
    
        public void addSpins(int add) {
            this.spins = spins + add;
        }
    
        public int getSpins() {
            return spins;
        }
    
        public void setSpins(int spins) {
            this.spins = spins;
        }
    
        public boolean isClickedGnomeDoor() {
            return clickedGnomeDoor;
        }
    
        public void setClickedGnomeDoor(boolean clickedGnomeDoor) {
            this.clickedGnomeDoor = clickedGnomeDoor;
        }
    
        public boolean isClickedWildernessDoor() {
            return clickedWildernessDoor;
        }
    
        public void setClickedWildernessDoor(boolean clickedWildernessDoor) {
            this.clickedWildernessDoor = clickedWildernessDoor;
        }
    
        public Slaves getSlave() {
            return slave;
        }
    
        public void setSlave(Slaves slave) {
            this.slave = slave;
        }
    
        public boolean isFromSlave() {
            return fromSlave;
        }
    
        public void setFromSlave(boolean fromSlave) {
            this.fromSlave = fromSlave;
        }
    
        public void setForceNoClose(boolean forceNoClose) {
            this.forceNoClose = forceNoClose;
        }
    
        public double getExtraExp() {
            return extraExp;
        }
    
        public void setExtraExp(double extraExp) {
            this.extraExp = extraExp;
        }
    
        public int getPageNumber() {
            return pageNumber;
        }
    
        public void setPageNumber(int pageNumber) {
            this.pageNumber = pageNumber;
        }
    
        public VarsManager getVarsManager() {
            return varsManager;
        }
    
        public SquealOfFortune getSquealOfFortune() {
            return sof;
        }
    
        public void setSquealOfFortune(SquealOfFortune squealOfFortune) {
            this.sof = squealOfFortune;
        }
    
        public boolean withinArea(int a, int b, int c, int d) {
            return getX() >= a && getY() >= b && getX() <= c && getY() <= d;
        }
    
        public String getTitleColor() {
            return titleColor;
        }
    
        public void setTitleColor(String titleColor) {
            this.titleColor = titleColor;
        }
    
        public void setSkillcapesAdded(int skill, boolean added) {
            skillcapesAdded[skill] = added;
        }
    
        public boolean[] getSkillCapesAdded() {
            return skillcapesAdded;
        }
    
        public List<Status> getStatuses() {
            return statuses;
        }
    
        public void setStatuses(ArrayList<Status> statuses) {
            this.statuses = statuses;
        }
    
        public int getExtraExpMinutes() {
            return extraExpMinutes;
        }
    
        public void setExtraExpMinutes(int extraExpMinutes) {
            this.extraExpMinutes = extraExpMinutes;
        }
    
        public DwarfCannon getDwarfCannon() {
            return dwarfCannon;
        }
    
        public boolean[] getAnnounced() {
            if (announced == null)
                announced = new boolean[25];
            return announced;
        }
    
        public void setAnnounced(int skill, boolean announce) {
            announced[skill] = announce;
        }
    
        public WorldTile getDuelLocation() {
            return duelLocation;
        }
    
        public void setDuelLocation(WorldTile duelLocation) {
            this.duelLocation = duelLocation;
        }
    
        public boolean isOnSpotDuelingRequest() {
            return onSpotDuelingRequest;
        }
    
        public void setOnSpotDuelingRequest(boolean onSpotDuelingRequest) {
            this.onSpotDuelingRequest = onSpotDuelingRequest;
        }
    
        public boolean isOnSpotDueling() {
            return onSpotDueling;
        }
    
        public void setOnSpotDueling(boolean onSpotDueling) {
            this.onSpotDueling = onSpotDueling;
        }
    
        public int getLotteryTickets() {
            return lotteryTickets;
        }
    
        public void setLotteryTickets(int lotteryTickets) {
            this.lotteryTickets = lotteryTickets;
        }
    
        public Duration getMembersCredit() {
            return membersCredit;
        }
    
        public int getAlcoholIntake() {
            return alcoholIntake;
        }
    
        public void setAlcoholIntake(int beerIntake) {
            this.alcoholIntake = beerIntake;
        }
    
        public int getDungeoneeringTokens() {
            return dungeoneeringTokens;
        }
    
        public void setDungeoneeringTokens(int dungeoneeringTokens) {
            this.dungeoneeringTokens = dungeoneeringTokens;
        }
    
        public ArrayList<Notes.Note> getCurNotes() {
            return pnotes;
        }
    
        public Notes getNotes() {
            return notes;
        }
    
        public boolean hasHelpedTrader() {
            return helpedTrader;
        }
    
        public void setHelpedTrader(boolean helpedTrader) {
            this.helpedTrader = helpedTrader;
        }
    
        public int[] getGems() {
            return gems;
        }
    
        public void setGems(int[] gems) {
            this.gems = gems;
        }
    
        public int getCoalAmount() {
            return coalAmount;
        }
    
        public void setCoalAmount(int coalAmount) {
            this.coalAmount = coalAmount;
        }
    
        public void setWastelessHerblore(boolean wastelessHerblore) {
            this.wastelessHerblore = wastelessHerblore;
        }
    
        public boolean hasWastelessHerblore() {
            return wastelessHerblore;
        }
    
        public int getFavorPoints() {
            return favorPoints;
        }
    
        public void setFavorPoints(int points) {
            if (points + favorPoints >= 2000) {
                points = 2000;
                getPackets().sendGameMessage("The offering stone is full! The jadinkos won't deposite any more rewards until you have taken some.");
            }
            this.favorPoints = points;
            refreshFavorPoints();
        }
    
        public void refreshFavorPoints() {
            varsManager.sendVarBit(9511, favorPoints);
        }
    
        public int getMinutesPlayed() {
            return minutesPlayed;
        }
    
        public void setMinutesPlayed(int minutesPlayed) {
            this.minutesPlayed = minutesPlayed;
        }
    
        public int getKills() {
            return kills;
        }
    
        public void setKills(int kills) {
            this.kills = kills;
        }
    
        public int getHungerPoints() {
            return hungerPoints;
        }
    
        public void setHungerPoints(int hungerPoints) {
            this.hungerPoints = hungerPoints;
        }
    
        public int getVotePoints() {
            return votePoints;
        }
    
        public void setVotePoints(int votePoints) {
            this.votePoints = votePoints;
        }
    
        public void setReferralCode(String referralCode) {
            this.referralCode = referralCode;
        }
    
        public void setPendingItems(boolean pendingItems) {
            this.pendingItems = pendingItems;
        }
    
        public boolean getPendingItems() {
            return pendingItems;
        }
        
        
    
        public boolean hasKilledGraardor() {
            return killedGraardor;
        }
    
        public boolean hasKilledCommanderZilyana() {
            return killedCommanderZilyana;
        }
    
        public boolean hasKilledKril() {
            return killedKril;
        }
    
        public boolean hasKilledKreeara() {
            return killedKreeara;
        }
    
        public void setKilledKreearra(boolean killedKreearra) {
            this.killedKreeara = killedKreearra;
        }
    
        public void setKilledGraardor(boolean killedGraardor) {
            this.killedGraardor = killedGraardor;
        }
    
        public void setKilledCommanderZilyana(boolean killedCommanderZilyana) {
            this.killedCommanderZilyana = killedCommanderZilyana;
        }
    
        public void setKilledKril(boolean killedKril) {
            this.killedKril = killedKril;
        }
    }
    Reply With Quote  
     

  2. #2  
    Registered Member PhaseGFX's Avatar
    Join Date
    Oct 2012
    Age
    28
    Posts
    156
    Thanks given
    19
    Thanks received
    42
    Rep Power
    51
    /close please. fixed, the sendconfig 0, 2 was placed wrong
    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. Same error over and over?!!
    By phantomphreak in forum Tutorials
    Replies: 4
    Last Post: 09-28-2007, 01:20 AM
  2. Basic Compile Errors
    By Daniel in forum Tutorials
    Replies: 4
    Last Post: 09-17-2007, 12:54 PM
  3. [HELP]Render Error
    By Big J in forum General
    Replies: 3
    Last Post: 07-30-2007, 01:01 AM
  4. Error. Please reboot me :)
    By Inside Sin in forum Showcase
    Replies: 4
    Last Post: 05-13-2007, 03:39 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
  •