AntiFeed

/*
 * This program is free software: you can redistribute it and/or modify it under
 * the terms of the GNU General Public License as published by the Free Software
 * Foundation, either version 3 of the License, or (at your option) any later
 * version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program. If not, see <http://www.gnu.org/licenses/>.
 */
package net.sf.l2j.gameserver.model.actor.instance;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Collection;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArraySet;
import java.util.concurrent.Future;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.ReentrantLock;
import java.util.logging.Level;

import net.sf.l2j.Config;
import net.sf.l2j.L2DatabaseFactory;
import net.sf.l2j.gameserver.GameTimeController;
import net.sf.l2j.gameserver.GeoData;
import net.sf.l2j.gameserver.ItemsAutoDestroy;
import net.sf.l2j.gameserver.RecipeController;
import net.sf.l2j.gameserver.SevenSigns;
import net.sf.l2j.gameserver.SevenSignsFestival;
import net.sf.l2j.gameserver.ThreadPoolManager;
import net.sf.l2j.gameserver.ai.CtrlIntention;
import net.sf.l2j.gameserver.ai.L2CharacterAI;
import net.sf.l2j.gameserver.ai.L2PlayerAI;
import net.sf.l2j.gameserver.ai.L2SummonAI;
import net.sf.l2j.gameserver.communitybbs.BB.Forum;
import net.sf.l2j.gameserver.communitybbs.Manager.ForumsBBSManager;
import net.sf.l2j.gameserver.datatables.AccessLevels;
import net.sf.l2j.gameserver.datatables.CharNameTable;
import net.sf.l2j.gameserver.datatables.CharTemplateTable;
import net.sf.l2j.gameserver.datatables.ClanTable;
import net.sf.l2j.gameserver.datatables.FishTable;
import net.sf.l2j.gameserver.datatables.GmListTable;
import net.sf.l2j.gameserver.datatables.HennaTable;
import net.sf.l2j.gameserver.datatables.ItemTable;
import net.sf.l2j.gameserver.datatables.MapRegionTable;
import net.sf.l2j.gameserver.datatables.PetDataTable;
import net.sf.l2j.gameserver.datatables.SkillTable;
import net.sf.l2j.gameserver.datatables.SkillTable.FrequentSkill;
import net.sf.l2j.gameserver.datatables.SkillTreeTable;
import net.sf.l2j.gameserver.handler.IItemHandler;
import net.sf.l2j.gameserver.handler.ItemHandler;
import net.sf.l2j.gameserver.instancemanager.AntiFeedManager;
import net.sf.l2j.gameserver.instancemanager.CastleManager;
import net.sf.l2j.gameserver.instancemanager.CoupleManager;
import net.sf.l2j.gameserver.instancemanager.CursedWeaponsManager;
import net.sf.l2j.gameserver.instancemanager.DimensionalRiftManager;
import net.sf.l2j.gameserver.instancemanager.DuelManager;
import net.sf.l2j.gameserver.instancemanager.GrandBossManager;
import net.sf.l2j.gameserver.instancemanager.ItemsOnGroundManager;
import net.sf.l2j.gameserver.instancemanager.QuestManager;
import net.sf.l2j.gameserver.instancemanager.SiegeManager;
import net.sf.l2j.gameserver.model.BlockList;
import net.sf.l2j.gameserver.model.FishData;
import net.sf.l2j.gameserver.model.L2AccessLevel;
import net.sf.l2j.gameserver.model.L2Clan;
import net.sf.l2j.gameserver.model.L2ClanMember;
import net.sf.l2j.gameserver.model.L2Effect;
import net.sf.l2j.gameserver.model.L2Fishing;
import net.sf.l2j.gameserver.model.L2ItemInstance;
import net.sf.l2j.gameserver.model.L2Macro;
import net.sf.l2j.gameserver.model.L2ManufactureList;
import net.sf.l2j.gameserver.model.L2Object;
import net.sf.l2j.gameserver.model.L2Party;
import net.sf.l2j.gameserver.model.L2PetData;
import net.sf.l2j.gameserver.model.L2PetData.L2PetLevelData;
import net.sf.l2j.gameserver.model.L2Radar;
import net.sf.l2j.gameserver.model.L2RecipeList;
import net.sf.l2j.gameserver.model.L2Request;
import net.sf.l2j.gameserver.model.L2ShortCut;
import net.sf.l2j.gameserver.model.L2Skill;
import net.sf.l2j.gameserver.model.L2Skill.SkillTargetType;
import net.sf.l2j.gameserver.model.L2SkillLearn;
import net.sf.l2j.gameserver.model.L2World;
import net.sf.l2j.gameserver.model.L2WorldRegion;
import net.sf.l2j.gameserver.model.Location;
import net.sf.l2j.gameserver.model.MacroList;
import net.sf.l2j.gameserver.model.PartyMatchRoom;
import net.sf.l2j.gameserver.model.PartyMatchRoomList;
import net.sf.l2j.gameserver.model.PartyMatchWaitingList;
import net.sf.l2j.gameserver.model.ShortCuts;
import net.sf.l2j.gameserver.model.ShotType;
import net.sf.l2j.gameserver.model.TradeList;
import net.sf.l2j.gameserver.model.actor.L2Attackable;
import net.sf.l2j.gameserver.model.actor.L2Character;
import net.sf.l2j.gameserver.model.actor.L2Npc;
import net.sf.l2j.gameserver.model.actor.L2Playable;
import net.sf.l2j.gameserver.model.actor.L2Summon;
import net.sf.l2j.gameserver.model.actor.L2Vehicle;
import net.sf.l2j.gameserver.model.actor.appearance.PcAppearance;
import net.sf.l2j.gameserver.model.actor.knownlist.PcKnownList;
import net.sf.l2j.gameserver.model.actor.position.PcPosition;
import net.sf.l2j.gameserver.model.actor.stat.PcStat;
import net.sf.l2j.gameserver.model.actor.status.PcStatus;
import net.sf.l2j.gameserver.model.base.ClassId;
import net.sf.l2j.gameserver.model.base.ClassLevel;
import net.sf.l2j.gameserver.model.base.Experience;
import net.sf.l2j.gameserver.model.base.PlayerClass;
import net.sf.l2j.gameserver.model.base.Race;
import net.sf.l2j.gameserver.model.base.SubClass;
import net.sf.l2j.gameserver.model.entity.Castle;
import net.sf.l2j.gameserver.model.entity.Duel;
import net.sf.l2j.gameserver.model.entity.Hero;
import net.sf.l2j.gameserver.model.entity.Siege;
import net.sf.l2j.gameserver.model.itemcontainer.Inventory;
import net.sf.l2j.gameserver.model.itemcontainer.ItemContainer;
import net.sf.l2j.gameserver.model.itemcontainer.PcFreight;
import net.sf.l2j.gameserver.model.itemcontainer.PcInventory;
import net.sf.l2j.gameserver.model.itemcontainer.PcWarehouse;
import net.sf.l2j.gameserver.model.itemcontainer.PetInventory;
import net.sf.l2j.gameserver.model.olympiad.OlympiadGameManager;
import net.sf.l2j.gameserver.model.olympiad.OlympiadGameTask;
import net.sf.l2j.gameserver.model.olympiad.OlympiadManager;
import net.sf.l2j.gameserver.model.quest.Quest;
import net.sf.l2j.gameserver.model.quest.QuestEventType;
import net.sf.l2j.gameserver.model.quest.QuestState;
import net.sf.l2j.gameserver.model.zone.ZoneId;
import net.sf.l2j.gameserver.model.zone.type.L2BossZone;
import net.sf.l2j.gameserver.network.L2GameClient;
import net.sf.l2j.gameserver.network.SystemMessageId;
import net.sf.l2j.gameserver.network.serverpackets.AbstractNpcInfo;
import net.sf.l2j.gameserver.network.serverpackets.ActionFailed;
import net.sf.l2j.gameserver.network.serverpackets.ChangeWaitType;
import net.sf.l2j.gameserver.network.serverpackets.CharInfo;
import net.sf.l2j.gameserver.network.serverpackets.ConfirmDlg;
import net.sf.l2j.gameserver.network.serverpackets.EtcStatusUpdate;
import net.sf.l2j.gameserver.network.serverpackets.ExAutoSoulShot;
import net.sf.l2j.gameserver.network.serverpackets.ExDuelUpdateUserInfo;
import net.sf.l2j.gameserver.network.serverpackets.ExFishingEnd;
import net.sf.l2j.gameserver.network.serverpackets.ExFishingStart;
import net.sf.l2j.gameserver.network.serverpackets.ExOlympiadMode;
import net.sf.l2j.gameserver.network.serverpackets.ExSetCompassZoneCode;
import net.sf.l2j.gameserver.network.serverpackets.ExStorageMaxCount;
import net.sf.l2j.gameserver.network.serverpackets.FriendList;
import net.sf.l2j.gameserver.network.serverpackets.GetOnVehicle;
import net.sf.l2j.gameserver.network.serverpackets.HennaInfo;
import net.sf.l2j.gameserver.network.serverpackets.InventoryUpdate;
import net.sf.l2j.gameserver.network.serverpackets.ItemList;
import net.sf.l2j.gameserver.network.serverpackets.L2GameServerPacket;
import net.sf.l2j.gameserver.network.serverpackets.LeaveWorld;
import net.sf.l2j.gameserver.network.serverpackets.MagicSkillUse;
import net.sf.l2j.gameserver.network.serverpackets.MoveToPawn;
import net.sf.l2j.gameserver.network.serverpackets.MyTargetSelected;
import net.sf.l2j.gameserver.network.serverpackets.NpcHtmlMessage;
import net.sf.l2j.gameserver.network.serverpackets.ObservationMode;
import net.sf.l2j.gameserver.network.serverpackets.ObservationReturn;
import net.sf.l2j.gameserver.network.serverpackets.PartySmallWindowUpdate;
import net.sf.l2j.gameserver.network.serverpackets.PetInventoryUpdate;
import net.sf.l2j.gameserver.network.serverpackets.PlaySound;
import net.sf.l2j.gameserver.network.serverpackets.PledgeShowMemberListDelete;
import net.sf.l2j.gameserver.network.serverpackets.PledgeShowMemberListUpdate;
import net.sf.l2j.gameserver.network.serverpackets.PrivateStoreListBuy;
import net.sf.l2j.gameserver.network.serverpackets.PrivateStoreListSell;
import net.sf.l2j.gameserver.network.serverpackets.PrivateStoreManageListBuy;
import net.sf.l2j.gameserver.network.serverpackets.PrivateStoreManageListSell;
import net.sf.l2j.gameserver.network.serverpackets.PrivateStoreMsgBuy;
import net.sf.l2j.gameserver.network.serverpackets.PrivateStoreMsgSell;
import net.sf.l2j.gameserver.network.serverpackets.RecipeShopManageList;
import net.sf.l2j.gameserver.network.serverpackets.RecipeShopMsg;
import net.sf.l2j.gameserver.network.serverpackets.RecipeShopSellList;
import net.sf.l2j.gameserver.network.serverpackets.RelationChanged;
import net.sf.l2j.gameserver.network.serverpackets.Ride;
import net.sf.l2j.gameserver.network.serverpackets.SendTradeDone;
import net.sf.l2j.gameserver.network.serverpackets.ServerClose;
import net.sf.l2j.gameserver.network.serverpackets.SetupGauge;
import net.sf.l2j.gameserver.network.serverpackets.ShortBuffStatusUpdate;
import net.sf.l2j.gameserver.network.serverpackets.ShortCutInit;
import net.sf.l2j.gameserver.network.serverpackets.SkillCoolTime;
import net.sf.l2j.gameserver.network.serverpackets.SkillList;
import net.sf.l2j.gameserver.network.serverpackets.Snoop;
import net.sf.l2j.gameserver.network.serverpackets.SocialAction;
import net.sf.l2j.gameserver.network.serverpackets.StatusUpdate;
import net.sf.l2j.gameserver.network.serverpackets.StopMove;
import net.sf.l2j.gameserver.network.serverpackets.SystemMessage;
import net.sf.l2j.gameserver.network.serverpackets.TargetSelected;
import net.sf.l2j.gameserver.network.serverpackets.TargetUnselected;
import net.sf.l2j.gameserver.network.serverpackets.TradePressOtherOk;
import net.sf.l2j.gameserver.network.serverpackets.TradePressOwnOk;
import net.sf.l2j.gameserver.network.serverpackets.TradeStart;
import net.sf.l2j.gameserver.network.serverpackets.UserInfo;
import net.sf.l2j.gameserver.skills.Env;
import net.sf.l2j.gameserver.skills.Formulas;
import net.sf.l2j.gameserver.skills.Stats;
import net.sf.l2j.gameserver.skills.effects.EffectTemplate;
import net.sf.l2j.gameserver.skills.funcs.FuncBowAtkRange;
import net.sf.l2j.gameserver.skills.funcs.FuncHennaCON;
import net.sf.l2j.gameserver.skills.funcs.FuncHennaDEX;
import net.sf.l2j.gameserver.skills.funcs.FuncHennaINT;
import net.sf.l2j.gameserver.skills.funcs.FuncHennaMEN;
import net.sf.l2j.gameserver.skills.funcs.FuncHennaSTR;
import net.sf.l2j.gameserver.skills.funcs.FuncHennaWIT;
import net.sf.l2j.gameserver.skills.funcs.FuncMaxCpAdd;
import net.sf.l2j.gameserver.skills.funcs.FuncMaxCpMul;
import net.sf.l2j.gameserver.skills.funcs.FuncMaxHpAdd;
import net.sf.l2j.gameserver.skills.funcs.FuncMaxMpAdd;
import net.sf.l2j.gameserver.skills.l2skills.L2SkillSiegeFlag;
import net.sf.l2j.gameserver.skills.l2skills.L2SkillSummon;
import net.sf.l2j.gameserver.taskmanager.AttackStanceTaskManager;
import net.sf.l2j.gameserver.taskmanager.PvpFlagTaskManager;
import net.sf.l2j.gameserver.taskmanager.TakeBreakTaskManager;
import net.sf.l2j.gameserver.taskmanager.WaterTaskManager;
import net.sf.l2j.gameserver.templates.chars.L2PcTemplate;
import net.sf.l2j.gameserver.templates.item.L2ActionType;
import net.sf.l2j.gameserver.templates.item.L2Armor;
import net.sf.l2j.gameserver.templates.item.L2ArmorType;
import net.sf.l2j.gameserver.templates.item.L2EtcItemType;
import net.sf.l2j.gameserver.templates.item.L2Henna;
import net.sf.l2j.gameserver.templates.item.L2Item;
import net.sf.l2j.gameserver.templates.item.L2Weapon;
import net.sf.l2j.gameserver.templates.item.L2WeaponType;
import net.sf.l2j.gameserver.templates.skills.L2EffectFlag;
import net.sf.l2j.gameserver.templates.skills.L2EffectType;
import net.sf.l2j.gameserver.templates.skills.L2SkillType;
import net.sf.l2j.gameserver.util.Broadcast;
import net.sf.l2j.gameserver.util.FloodProtectors;
import net.sf.l2j.gameserver.util.Util;
import net.sf.l2j.util.Point3D;
import net.sf.l2j.util.Rnd;

/**
 * This class represents all player characters in the world. There is always a client-thread connected to this (except if a player-store is activated upon logout).
 */
public final class L2PcInstance extends L2Playable
{
    // Character Skill SQL String Definitions:
    private static final String RESTORE_SKILLS_FOR_CHAR = "SELECT skill_id,skill_level FROM character_skills WHERE char_obj_id=? AND class_index=?";
    private static final String ADD_NEW_SKILL = "INSERT INTO character_skills (char_obj_id,skill_id,skill_level,class_index) VALUES (?,?,?,?)";
    private static final String UPDATE_CHARACTER_SKILL_LEVEL = "UPDATE character_skills SET skill_level=? WHERE skill_id=? AND char_obj_id=? AND class_index=?";
    private static final String DELETE_SKILL_FROM_CHAR = "DELETE FROM character_skills WHERE skill_id=? AND char_obj_id=? AND class_index=?";
    private static final String DELETE_CHAR_SKILLS = "DELETE FROM character_skills WHERE char_obj_id=? AND class_index=?";

    // Character Skill Save SQL String Definitions:
    private static final String ADD_SKILL_SAVE = "INSERT INTO character_skills_save (char_obj_id,skill_id,skill_level,effect_count,effect_cur_time,reuse_delay,systime,restore_type,class_index,buff_index) VALUES (?,?,?,?,?,?,?,?,?,?)";
    private static final String RESTORE_SKILL_SAVE = "SELECT skill_id,skill_level,effect_count,effect_cur_time, reuse_delay, systime, restore_type FROM character_skills_save WHERE char_obj_id=? AND class_index=? ORDER BY buff_index ASC";
    private static final String DELETE_SKILL_SAVE = "DELETE FROM character_skills_save WHERE char_obj_id=? AND class_index=?";

    // Character SQL String Definitions:
    private static final String INSERT_CHARACTER = "INSERT INTO characters (account_name,obj_Id,char_name,level,maxHp,curHp,maxCp,curCp,maxMp,curMp,face,hairStyle,hairColor,sex,exp,sp,karma,pvpkills,pkkills,clanid,race,classid,deletetime,cancraft,title,accesslevel,online,isin7sdungeon,clan_privs,wantspeace,base_class,nobless,power_grade,last_recom_date) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)";
    private static final String UPDATE_CHARACTER = "UPDATE characters SET level=?,maxHp=?,curHp=?,maxCp=?,curCp=?,maxMp=?,curMp=?,face=?,hairStyle=?,hairColor=?,sex=?,heading=?,x=?,y=?,z=?,exp=?,expBeforeDeath=?,sp=?,karma=?,pvpkills=?,pkkills=?,rec_have=?,rec_left=?,clanid=?,race=?,classid=?,deletetime=?,title=?,accesslevel=?,online=?,isin7sdungeon=?,clan_privs=?,wantspeace=?,base_class=?,onlinetime=?,punish_level=?,punish_timer=?,nobless=?,power_grade=?,subpledge=?,last_recom_date=?,lvl_joined_academy=?,apprentice=?,sponsor=?,varka_ketra_ally=?,clan_join_expiry_time=?,clan_create_expiry_time=?,char_name=?,death_penalty_level=?,votebuff=?,vote_end_buff=? WHERE obj_id=?";
    private static final String RESTORE_CHARACTER = "SELECT account_name, obj_Id, char_name, level, maxHp, curHp, maxCp, curCp, maxMp, curMp, face, hairStyle, hairColor, sex, heading, x, y, z, exp, expBeforeDeath, sp, karma, pvpkills, pkkills, clanid, race, classid, deletetime, cancraft, title, rec_have, rec_left, accesslevel, online, char_slot, lastAccess, clan_privs, wantspeace, base_class, onlinetime, isin7sdungeon, punish_level, punish_timer, nobless, power_grade, subpledge, last_recom_date, lvl_joined_academy, apprentice, sponsor, varka_ketra_ally,clan_join_expiry_time,clan_create_expiry_time,death_penalty_level,lastVoteNetwork,lastVoteTopzone,hasVotedNet,hasVotedTop,totalVotes,tries,votebuff,vote_end_buff FROM characters WHERE obj_id=?";

    // Character Subclass SQL String Definitions:
    private static final String RESTORE_CHAR_SUBCLASSES = "SELECT class_id,exp,sp,level,class_index FROM character_subclasses WHERE char_obj_id=? ORDER BY class_index ASC";
    private static final String ADD_CHAR_SUBCLASS = "INSERT INTO character_subclasses (char_obj_id,class_id,exp,sp,level,class_index) VALUES (?,?,?,?,?,?)";
    private static final String UPDATE_CHAR_SUBCLASS = "UPDATE character_subclasses SET exp=?,sp=?,level=?,class_id=? WHERE char_obj_id=? AND class_index =?";
    private static final String DELETE_CHAR_SUBCLASS = "DELETE FROM character_subclasses WHERE char_obj_id=? AND class_index=?";

    private static final String RESTORE_CHAR_HENNAS = "SELECT slot,symbol_id FROM character_hennas WHERE char_obj_id=? AND class_index=?";
    private static final String ADD_CHAR_HENNA = "INSERT INTO character_hennas (char_obj_id,symbol_id,slot,class_index) VALUES (?,?,?,?)";
    private static final String DELETE_CHAR_HENNA = "DELETE FROM character_hennas WHERE char_obj_id=? AND slot=? AND class_index=?";
    private static final String DELETE_CHAR_HENNAS = "DELETE FROM character_hennas WHERE char_obj_id=? AND class_index=?";
    private static final String DELETE_CHAR_SHORTCUTS = "DELETE FROM character_shortcuts WHERE char_obj_id=? AND class_index=?";

    private static final String RESTORE_CHAR_RECOMS = "SELECT char_id,target_id FROM character_recommends WHERE char_id=?";
    private static final String ADD_CHAR_RECOM = "INSERT INTO character_recommends (char_id,target_id) VALUES (?,?)";
    private static final String DELETE_CHAR_RECOMS = "DELETE FROM character_recommends WHERE char_id=?";

    private static final String UPDATE_NOBLESS = "UPDATE characters SET nobless=? WHERE obj_Id=?";

    public static final int REQUEST_TIMEOUT = 15;
    public static final int STORE_PRIVATE_NONE = 0;
    public static final int STORE_PRIVATE_SELL = 1;
    public static final int STORE_PRIVATE_BUY = 3;
    public static final int STORE_PRIVATE_MANAGE = 4;
    public static final int STORE_PRIVATE_MANUFACTURE = 5;
    public static final int STORE_PRIVATE_PACKAGE_SELL = 8;

    /** The table containing all minimum level needed for each Expertise (None, D, C, B, A, S) */
    private static final int[] EXPERTISE_LEVELS =
    {
        SkillTreeTable.getInstance().getExpertiseLevel(0), // NONE
        SkillTreeTable.getInstance().getExpertiseLevel(1), // D
        SkillTreeTable.getInstance().getExpertiseLevel(2), // C
        SkillTreeTable.getInstance().getExpertiseLevel(3), // B
        SkillTreeTable.getInstance().getExpertiseLevel(4), // A
        SkillTreeTable.getInstance().getExpertiseLevel(5), // S
    };

    private static final int[] COMMON_CRAFT_LEVELS =
    {
        5,
        20,
        28,
        36,
        43,
        49,
        55,
        62
    };

    public class AIAccessor extends L2Character.AIAccessor
    {
        protected AIAccessor()
        {

        }

        public L2PcInstance getPlayer()
        {
            return L2PcInstance.this;
        }

        public void doPickupItem(L2Object object)
        {
            L2PcInstance.this.doPickupItem(object);

            // Schedule a paralyzed task to wait for the animation to finish
            ThreadPoolManager.getInstance().scheduleGeneral(new Runnable()
            {
                @Override
                public void run()
                {
                    setIsParalyzed(false);
                }
            }, 500);
            setIsParalyzed(true);
        }

        public void doInteract(L2Character target)
        {
            L2PcInstance.this.doInteract(target);
        }

        @Override
        public void doAttack(L2Character target)
        {
            super.doAttack(target);

            // cancel the recent fake-death protection instantly if the player attacks or casts spells
            getPlayer().setRecentFakeDeath(false);
        }

        @Override
        public void doCast(L2Skill skill)
        {
            super.doCast(skill);

            // cancel the recent fake-death protection instantly if the player attacks or casts spells
            getPlayer().setRecentFakeDeath(false);
        }
    }

    private L2GameClient _client;

    private String _accountName;
    private long _deleteTimer;

    private boolean _isOnline = false;
    private long _onlineTime;
    private long _onlineBeginTime;
    private long _lastAccess;
    private long _uptime;

    private final ReentrantLock _subclassLock = new ReentrantLock();
    protected int _baseClass;
    protected int _activeClass;
    protected int _classIndex = 0;
    private final Map<Integer, SubClass> _subClasses = new LinkedHashMap<>();

    private PcAppearance _appearance;
    private int _charId = 0x00030b7a;

    private long _expBeforeDeath;
    private int _karma;
    private int _pvpKills;
    private int _pkKills;
    private byte _pvpFlag;
    private byte _siegeState = 0;
    private int _curWeightPenalty = 0;

    private boolean _isVoteBuff = false;
    private long _votebuff_endTime = 0;

    private int _lastCompassZone; // the last compass zone update send to the client

    private boolean _isInWater;
    private boolean _isIn7sDungeon = false;

    private PunishLevel _punishLevel = PunishLevel.NONE;
    private long _punishTimer = 0;
    private ScheduledFuture<?> _punishTask;

    public enum PunishLevel
    {
        NONE(0, ""),
        CHAT(1, "chat banned"),
        JAIL(2, "jailed"),
        CHAR(3, "banned"),
        ACC(4, "banned");

        private final int punValue;
        private final String punString;

        PunishLevel(int value, String string)
        {
            punValue = value;
            punString = string;
        }

        public int value()
        {
            return punValue;
        }

        public String string()
        {
            return punString;
        }
    }

    /** Olympiad */
    private boolean _inOlympiadMode = false;
    private boolean _OlympiadStart = false;
    private int _olympiadGameId = -1;
    private int _olympiadSide = -1;

    /** Duel */
    private boolean _isInDuel = false;
    private int _duelState = Duel.DUELSTATE_NODUEL;
    private int _duelId = 0;
    private SystemMessageId _noDuelReason = SystemMessageId.THERE_IS_NO_OPPONENT_TO_RECEIVE_YOUR_CHALLENGE_FOR_A_DUEL;

    /** Boat */
    private L2Vehicle _vehicle = null;
    private Point3D _inVehiclePosition;

    public ScheduledFuture<?> _taskforfish;

    private int _mountType;
    private int _mountNpcId;
    private int _mountLevel;
    private int _mountObjectID = 0;

    public int _telemode = 0;
    private boolean _inCrystallize;
    private boolean _inCraftMode;

    private long _offlineShopStart = 0;
    private boolean _inOfflineShopMode = false;

    /** The table containing all L2RecipeList of the L2PcInstance */
    private final Map<Integer, L2RecipeList> _dwarvenRecipeBook = new HashMap<>();
    private final Map<Integer, L2RecipeList> _commonRecipeBook = new HashMap<>();

    /** True if the L2PcInstance is sitting */
    private boolean _waitTypeSitting;

    /** Location before entering Observer Mode */
    private int _lastX;
    private int _lastY;
    private int _lastZ;
    private boolean _observerMode = false;

    /** Stored from last ValidatePosition **/
    private final Point3D _lastServerPosition = new Point3D(0, 0, 0);

    private int _recomHave; // how much I was recommended by others
    private int _recomLeft; // how many recomendations I can give to others
    private long _lastRecomUpdate;
    private final List<Integer> _recomChars = new ArrayList<>();

    private final PcInventory _inventory = new PcInventory(this);
    private PcWarehouse _warehouse;
    private PcFreight _freight;
    private final List<PcFreight> _depositedFreight = new ArrayList<>();

    /** The Private Store type of the L2PcInstance (STORE_PRIVATE_NONE=0, STORE_PRIVATE_SELL=1, sellmanage=2, STORE_PRIVATE_BUY=3, buymanage=4, STORE_PRIVATE_MANUFACTURE=5) */
    private int _privateStore;

    private TradeList _activeTradeList;
    private ItemContainer _activeWarehouse;
    private L2ManufactureList _createList;
    private TradeList _sellList;
    private TradeList _buyList;

    private boolean _noble = false;
    private boolean _hero = false;

    /** The L2Npc corresponding to the current folk the player is talking with. */
    private L2Npc _currentFolkNpc = null;

    /** Last NPC Id talked on a quest */
    private int _questNpcObject = 0;

    /** The list containing all Quests began by the L2PcInstance */
    private final List<QuestState> _quests = new ArrayList<>();

    /** List of all QuestState instance that needs to be notified of this L2PcInstance's or its pet's death */
    private final List<QuestState> _notifyQuestOfDeathList = new ArrayList<>();

    /** The list containing all shortCuts of this L2PcInstance */
    private final ShortCuts _shortCuts = new ShortCuts(this);

    /** The list containing all macroses of this L2PcInstance */
    private final MacroList _macroses = new MacroList(this);

    private final List<L2PcInstance> _snoopListener = new ArrayList<>();
    private final List<L2PcInstance> _snoopedPlayer = new ArrayList<>();

    private ClassId _skillLearningClassId;

    // hennas
    private final L2Henna[] _henna = new L2Henna[3];
    private int _hennaSTR;
    private int _hennaINT;
    private int _hennaDEX;
    private int _hennaMEN;
    private int _hennaWIT;
    private int _hennaCON;

    // Summons
    private L2Summon _summon = null;
    private L2TamedBeastInstance _tamedBeast = null;

    // client radar
    // TODO: This needs to be better integrated and saved/loaded
    private L2Radar _radar;

    // these values are only stored temporarily
    private int _partyroom = 0;

    // Clan related attributes
    /** The Clan Identifier of the L2PcInstance */
    private int _clanId;

    /** The Clan object of the L2PcInstance */
    private L2Clan _clan;

    /** Apprentice and Sponsor IDs */
    private int _apprentice = 0;
    private int _sponsor = 0;

    private long _clanJoinExpiryTime;
    private long _clanCreateExpiryTime;

    private int _powerGrade = 0;
    private int _clanPrivileges = 0;

    /** L2PcInstance's pledge class (knight, Baron, etc.) */
    private int _pledgeClass = 0;
    private int _pledgeType = 0;

    /** Level at which the player joined the clan as an academy member */
    private int _lvlJoinedAcademy = 0;

    private boolean _wantsPeace;

    // Death Penalty Buff Level
    private int _deathPenaltyBuffLevel = 0;

    // charges
    private final AtomicInteger _charges = new AtomicInteger();
    private ScheduledFuture<?> _chargeTask = null;

    // WorldPosition used by TARGET_SIGNET_GROUND
    private Point3D _currentSkillWorldPosition;

    private L2AccessLevel _accessLevel;

    private boolean _messageRefusal = false; // message refusal mode
    private boolean _tradeRefusal = false; // Trade refusal
    private boolean _exchangeRefusal = false; // Exchange refusal

    private L2Party _party;

    // this is needed to find the inviting player for Party response
    // there can only be one active party request at once
    private L2PcInstance _activeRequester;
    private long _requestExpireTime = 0;
    private final L2Request _request = new L2Request(this);
    private L2ItemInstance _arrowItem;

    // Used for protection after teleport
    private long _protectEndTime = 0;

    // protects a char from agro mobs when getting up from fake death
    private long _recentFakeDeathEndTime = 0;
    private boolean _isFakeDeath;

    /** The fists L2Weapon of the L2PcInstance (used when no weapon is equipped) */
    private L2Weapon _fistsWeaponItem;

    private final Map<Integer, String> _chars = new HashMap<>();

    /** The current higher Expertise of the L2PcInstance (None=0, D=1, C=2, B=3, A=4, S=5) */
    private int _expertiseIndex; // index in EXPERTISE_LEVELS
    private int _expertiseArmorPenalty = 0;
    private boolean _expertiseWeaponPenalty = false;

    private L2ItemInstance _activeEnchantItem = null;

    protected boolean _inventoryDisable = false;

    protected Map<Integer, L2CubicInstance> _cubics = new ConcurrentHashMap<>();

    /** Active shots. A FastSet variable would actually suffice but this was changed to fix threading stability... */
    protected Set<Integer> _activeSoulShots = new CopyOnWriteArraySet<>();

    private final int _loto[] = new int[5];
    private final int _race[] = new int[2];

    private final BlockList _blockList = new BlockList(this);

    private int _team = 0;

    /**
     * lvl of alliance with ketra orcs or varka silenos, used in quests and aggro checks [-5,-1] varka, 0 neutral, [1,5] ketra
     */
    private int _alliedVarkaKetra = 0;

    private Location _fishingLoc;
    private L2ItemInstance _lure = null;
    private L2Fishing _fishCombat;
    private FishData _fish;

    /** Bypass validations */
    private final List<String> _validBypass = new ArrayList<>();
    private final List<String> _validBypass2 = new ArrayList<>();

    private Forum _forumMail;
    private Forum _forumMemo;

    /** data for mounted pets */
    private boolean _canFeed;
    private L2PetData _data;
    private L2PetLevelData _leveldata;
    private int _controlItemId;
    private int _curFeed;
    protected Future<?> _mountFeedTask;
    private ScheduledFuture<?> _dismountTask;

    private boolean _isInSiege;

    private SkillDat _currentSkill;
    private SkillDat _currentPetSkill;
    private SkillDat _queuedSkill;

    private int _cursedWeaponEquippedId = 0;

    private int _reviveRequested = 0;
    private double _revivePower = 0;
    private boolean _revivePet = false;

    private double _cpUpdateIncCheck = .0;
    private double _cpUpdateDecCheck = .0;
    private double _cpUpdateInterval = .0;
    private double _mpUpdateIncCheck = .0;
    private double _mpUpdateDecCheck = .0;
    private double _mpUpdateInterval = .0;

    /** Char Coords from Client */
    private volatile int _clientX;
    private volatile int _clientY;
    private volatile int _clientZ;
    private volatile int _clientHeading;

    private int _mailPosition;

    // during fall, validation will be disabled for 10 s.
    private static final int FALLING_VALIDATION_DELAY = 10000;
    private volatile long _fallingTimestamp = 0;

    private int _herbstask = 0;

    /** ShortBuff clearing Task */
    ScheduledFuture<?> _shortBuffTask = null;
    private int _shortBuffTaskSkillId = 0;

    // L2JMOD Wedding
    private boolean _married = false;
    private int _coupleId = 0;
    private boolean _marryrequest = false;
    private int _requesterId = 0;

    // summon friend
    private final SummonRequest _summonRequest = new SummonRequest();

    // open/close gates
    private final GatesRequest _gatesRequest = new GatesRequest();

    /** Task for Herbs */
    private class HerbTask implements Runnable
    {
        private final String _process;
        private final int _itemId;
        private final int _count;
        private final L2Object _reference;
        private final boolean _sendMessage;

        HerbTask(String process, int itemId, int count, L2Object reference, boolean sendMessage)
        {
            _process = process;
            _itemId = itemId;
            _count = count;
            _reference = reference;
            _sendMessage = sendMessage;
        }

        @Override
        public void run()
        {
            addItem(_process, _itemId, _count, _reference, _sendMessage);
        }
    }

    protected class ShortBuffTask implements Runnable
    {
        @Override
        public void run()
        {
            sendPacket(new ShortBuffStatusUpdate(0, 0, 0));
            setShortBuffTaskSkillId(0);
        }
    }

    /** Skill casting information (used to queue when several skills are cast in a short time) **/
    public static class SkillDat
    {
        private final L2Skill _skill;
        private final boolean _ctrlPressed;
        private final boolean _shiftPressed;

        protected SkillDat(L2Skill skill, boolean ctrlPressed, boolean shiftPressed)
        {
            _skill = skill;
            _ctrlPressed = ctrlPressed;
            _shiftPressed = shiftPressed;
        }

        public boolean isCtrlPressed()
        {
            return _ctrlPressed;
        }

        public boolean isShiftPressed()
        {
            return _shiftPressed;
        }

        public L2Skill getSkill()
        {
            return _skill;
        }

        public int getSkillId()
        {
            return (getSkill() != null) ? getSkill().getId() : -1;
        }
    }

    protected static class SummonRequest
    {
        private L2PcInstance _target = null;
        private L2Skill _skill = null;

        public void setTarget(L2PcInstance destination, L2Skill skill)
        {
            _target = destination;
            _skill = skill;
        }

        public L2PcInstance getTarget()
        {
            return _target;
        }

        public L2Skill getSkill()
        {
            return _skill;
        }
    }

    protected static class GatesRequest
    {
        private L2DoorInstance _target = null;

        public void setTarget(L2DoorInstance door)
        {
            _target = door;
        }

        public L2DoorInstance getDoor()
        {
            return _target;
        }
    }

    public void gatesRequest(L2DoorInstance door)
    {
        _gatesRequest.setTarget(door);
    }

    public void gatesAnswer(int answer, int type)
    {
        if (_gatesRequest.getDoor() == null)
            return;

        if (answer == 1 && getTarget() == _gatesRequest.getDoor() && type == 1)
            _gatesRequest.getDoor().openMe();
        else if (answer == 1 && getTarget() == _gatesRequest.getDoor() && type == 0)
            _gatesRequest.getDoor().closeMe();

        _gatesRequest.setTarget(null);
    }

    /**
     * Create a new L2PcInstance and add it in the characters table of the database.<BR>
     * <BR>
     * <B><U> Actions</U> :</B><BR>
     * <BR>
     * <li>Create a new L2PcInstance with an account name</li> <li>Set the name, the Hair Style, the Hair Color and the Face type of the L2PcInstance</li> <li>Add the player in the characters table of the database</li><BR>
     * <BR>
     * @param objectId Identifier of the object to initialized
     * @param template The L2PcTemplate to apply to the L2PcInstance
     * @param accountName The name of the L2PcInstance
     * @param name The name of the L2PcInstance
     * @param hairStyle The hair style Identifier of the L2PcInstance
     * @param hairColor The hair color Identifier of the L2PcInstance
     * @param face The face type Identifier of the L2PcInstance
     * @param sex The sex type Identifier of the L2PcInstance
     * @return The L2PcInstance added to the database or null
     */
    public static L2PcInstance create(int objectId, L2PcTemplate template, String accountName, String name, byte hairStyle, byte hairColor, byte face, boolean sex)
    {
        // Create a new L2PcInstance with an account name
        PcAppearance app = new PcAppearance(face, hairColor, hairStyle, sex);
        L2PcInstance player = new L2PcInstance(objectId, template, accountName, app);

        // Set the name of the L2PcInstance
        player.setName(name);

        // Set the base class ID to that of the actual class ID.
        player.setBaseClass(player.getClassId());

        // Add the player in the characters table of the database
        boolean ok = player.createDb();

        if (!ok)
            return null;

        return player;
    }

    public static L2PcInstance createDummyPlayer(int objectId, String name)
    {
        // Create a new L2PcInstance with an account name
        L2PcInstance player = new L2PcInstance(objectId);
        player.setName(name);

        return player;
    }

    public String getAccountName()
    {
        if (getClient() == null)
            return getAccountNamePlayer();

        return getClient().getAccountName();
    }

    public String getAccountNamePlayer()
    {
        return _accountName;
    }

    public Map<Integer, String> getAccountChars()
    {
        return _chars;
    }

    public int getRelation(L2PcInstance target)
    {
        int result = 0;

        // karma and pvp may not be required
        if (getPvpFlag() != 0)
            result |= RelationChanged.RELATION_PVP_FLAG;
        if (getKarma() > 0)
            result |= RelationChanged.RELATION_HAS_KARMA;

        if (isClanLeader())
            result |= RelationChanged.RELATION_LEADER;

        if (getSiegeState() != 0)
        {
            result |= RelationChanged.RELATION_INSIEGE;
            if (getSiegeState() != target.getSiegeState())
                result |= RelationChanged.RELATION_ENEMY;
            else
                result |= RelationChanged.RELATION_ALLY;
            if (getSiegeState() == 1)
                result |= RelationChanged.RELATION_ATTACKER;
        }

        if (getClan() != null && target.getClan() != null)
        {
            if (target.getPledgeType() != L2Clan.SUBUNIT_ACADEMY && getPledgeType() != L2Clan.SUBUNIT_ACADEMY && target.getClan().isAtWarWith(getClan().getClanId()))
            {
                result |= RelationChanged.RELATION_1SIDED_WAR;
                if (getClan().isAtWarWith(target.getClan().getClanId()))
                    result |= RelationChanged.RELATION_MUTUAL_WAR;
            }
        }
        return result;
    }

    private void initPcStatusUpdateValues()
    {
        _cpUpdateInterval = getMaxCp() / 352.0;
        _cpUpdateIncCheck = getMaxCp();
        _cpUpdateDecCheck = getMaxCp() - _cpUpdateInterval;
        _mpUpdateInterval = getMaxMp() / 352.0;
        _mpUpdateIncCheck = getMaxMp();
        _mpUpdateDecCheck = getMaxMp() - _mpUpdateInterval;
    }

    /**
     * Constructor of L2PcInstance (use L2Character constructor).<BR>
     * <BR>
     * <B><U> Actions</U> :</B><BR>
     * <BR>
     * <li>Call the L2Character constructor to create an empty _skills slot and copy basic Calculator set to this L2PcInstance</li> <li>Set the name of the L2PcInstance</li><BR>
     * <BR>
     * <FONT COLOR=#FF0000><B> <U>Caution</U> : This method SET the level of the L2PcInstance to 1</B></FONT><BR>
     * <BR>
     * @param objectId Identifier of the object to initialized
     * @param template The L2PcTemplate to apply to the L2PcInstance
     * @param accountName The name of the account including this L2PcInstance
     * @param app The PcAppearance of the L2PcInstance
     */
    private L2PcInstance(int objectId, L2PcTemplate template, String accountName, PcAppearance app)
    {
        super(objectId, template);
        super.initCharStatusUpdateValues();
        initPcStatusUpdateValues();

        _accountName = accountName;
        _appearance = app;

        // Create an AI
        _ai = new L2PlayerAI(new AIAccessor());

        // Create a L2Radar object
        _radar = new L2Radar(this);

        // Retrieve from the database all items of this L2PcInstance and add them to _inventory
        getInventory().restore();
        getWarehouse();
        getFreight();
    }

    private L2PcInstance(int objectId)
    {
        super(objectId, null);
        super.initCharStatusUpdateValues();
        initPcStatusUpdateValues();
    }

    @Override
    public void addFuncsToNewCharacter()
    {
        // Add L2Character functionalities.
        super.addFuncsToNewCharacter();

        addStatFunc(FuncMaxCpAdd.getInstance());
        addStatFunc(FuncMaxCpMul.getInstance());
        addStatFunc(FuncMaxHpAdd.getInstance());
        addStatFunc(FuncMaxMpAdd.getInstance());

        addStatFunc(FuncBowAtkRange.getInstance());

        addStatFunc(FuncHennaSTR.getInstance());
        addStatFunc(FuncHennaDEX.getInstance());
        addStatFunc(FuncHennaINT.getInstance());
        addStatFunc(FuncHennaMEN.getInstance());
        addStatFunc(FuncHennaCON.getInstance());
        addStatFunc(FuncHennaWIT.getInstance());
    }

    @Override
    public void initKnownList()
    {
        setKnownList(new PcKnownList(this));
    }

    @Override
    public final PcKnownList getKnownList()
    {
        return (PcKnownList) super.getKnownList();
    }

    @Override
    public void initCharStat()
    {
        setStat(new PcStat(this));
    }

    @Override
    public final PcStat getStat()
    {
        return (PcStat) super.getStat();
    }

    @Override
    public void initCharStatus()
    {
        setStatus(new PcStatus(this));
    }

    @Override
    public final PcStatus getStatus()
    {
        return (PcStatus) super.getStatus();
    }

    @Override
    public void initPosition()
    {
        setObjectPosition(new PcPosition(this));
    }

    @Override
    public PcPosition getPosition()
    {
        return (PcPosition) super.getPosition();
    }

    public final PcAppearance getAppearance()
    {
        return _appearance;
    }

    /**
     * @return the base L2PcTemplate link to the L2PcInstance.
     */
    public final L2PcTemplate getBaseTemplate()
    {
        return CharTemplateTable.getInstance().getTemplate(_baseClass);
    }

    /** Return the L2PcTemplate link to the L2PcInstance. */
    @Override
    public final L2PcTemplate getTemplate()
    {
        return (L2PcTemplate) super.getTemplate();
    }

    public void setTemplate(ClassId newclass)
    {
        super.setTemplate(CharTemplateTable.getInstance().getTemplate(newclass));
    }

    /**
     * Return the AI of the L2PcInstance (create it if necessary).
     */
    @Override
    public L2CharacterAI getAI()
    {
        if (_ai == null)
        {
            synchronized (this)
            {
                if (_ai == null)
                    _ai = new L2PlayerAI(new AIAccessor());
            }
        }

        return _ai;
    }

    /** Return the Level of the L2PcInstance. */
    @Override
    public final int getLevel()
    {
        return getStat().getLevel();
    }

    /**
     * A newbie is a player reaching level 6. He isn't considered newbie at lvl 25.<br>
     * Since IL newbie isn't anymore the first character of an account reaching that state, but any.
     * @return True if newbie.
     */
    public boolean isNewbie()
    {
        return getClassId().level() <= 1 && getLevel() >= 6 && getLevel() <= 25;
    }

    public void setBaseClass(int baseClass)
    {
        _baseClass = baseClass;
    }

    public void setBaseClass(ClassId classId)
    {
        _baseClass = classId.ordinal();
    }

    public boolean isInStoreMode()
    {
        return _privateStore > STORE_PRIVATE_NONE;
    }

    public boolean isInCraftMode()
    {
        return _inCraftMode;
    }

    public void isInCraftMode(boolean b)
    {
        _inCraftMode = b;
    }

    /**
     * Manage Logout Task
     */
    public void logout()
    {
        logout(true);
    }

    /**
     * Manage Logout Task
     * @param closeClient
     */
    public void logout(boolean closeClient)
    {
        try
        {
            closeNetConnection(closeClient);
        }
        catch (Exception e)
        {
            _log.log(Level.WARNING, "Exception on logout(): " + e.getMessage(), e);
        }
    }

    /**
     * @return a table containing all Common L2RecipeList of the L2PcInstance.
     */
    public L2RecipeList[] getCommonRecipeBook()
    {
        return _commonRecipeBook.values().toArray(new L2RecipeList[_commonRecipeBook.values().size()]);
    }

    /**
     * @return a table containing all Dwarf L2RecipeList of the L2PcInstance.
     */
    public L2RecipeList[] getDwarvenRecipeBook()
    {
        return _dwarvenRecipeBook.values().toArray(new L2RecipeList[_dwarvenRecipeBook.values().size()]);
    }

    /**
     * Add a new L2RecipList to the table _commonrecipebook containing all L2RecipeList of the L2PcInstance.
     * @param recipe The L2RecipeList to add to the _recipebook
     */
    public void registerCommonRecipeList(L2RecipeList recipe)
    {
        _commonRecipeBook.put(recipe.getId(), recipe);
    }

    /**
     * Add a new L2RecipList to the table _recipebook containing all L2RecipeList of the L2PcInstance.
     * @param recipe The L2RecipeList to add to the _recipebook
     */
    public void registerDwarvenRecipeList(L2RecipeList recipe)
    {
        _dwarvenRecipeBook.put(recipe.getId(), recipe);
    }

    /**
     * @param recipeId The Identifier of the L2RecipeList to check in the player's recipe books
     * @return <b>TRUE</b> if player has the recipe on Common or Dwarven Recipe book else returns <b>FALSE</b>
     */
    public boolean hasRecipeList(int recipeId)
    {
        if (_dwarvenRecipeBook.containsKey(recipeId))
            return true;

        if (_commonRecipeBook.containsKey(recipeId))
            return true;

        return false;
    }

    /**
     * Tries to remove a L2RecipList from the table _DwarvenRecipeBook or from table _CommonRecipeBook, those table contain all L2RecipeList of the L2PcInstance.
     * @param recipeId The Identifier of the L2RecipeList to remove from the _recipebook.
     */
    public void unregisterRecipeList(int recipeId)
    {
        if (_dwarvenRecipeBook.containsKey(recipeId))
            _dwarvenRecipeBook.remove(recipeId);
        else if (_commonRecipeBook.containsKey(recipeId))
            _commonRecipeBook.remove(recipeId);
        else
            _log.warning("Attempted to remove unknown RecipeList: " + recipeId);

        for (L2ShortCut sc : getAllShortCuts())
        {
            if (sc != null && sc.getId() == recipeId && sc.getType() == L2ShortCut.TYPE_RECIPE)
                deleteShortCut(sc.getSlot(), sc.getPage());
        }
    }

    /**
     * @return the Id for the last talked quest NPC.
     */
    public int getLastQuestNpcObject()
    {
        return _questNpcObject;
    }

    public void setLastQuestNpcObject(int npcId)
    {
        _questNpcObject = npcId;
    }

    /**
     * @param name The name of the quest.
     * @return The QuestState object corresponding to the quest name.
     */
    public QuestState getQuestState(String name)
    {
        for (QuestState qs : _quests)
        {
            if (name.equals(qs.getQuest().getName()))
                return qs;
        }
        return null;
    }

    /**
     * Add a QuestState to the table _quest containing all quests began by the L2PcInstance.
     * @param qs The QuestState to add to _quest.
     */
    public void setQuestState(QuestState qs)
    {
        _quests.add(qs);
    }

    /**
     * Remove a QuestState from the table _quest containing all quests began by the L2PcInstance.
     * @param qs : The QuestState to be removed from _quest.
     */
    public void delQuestState(QuestState qs)
    {
        _quests.remove(qs);
    }

    /**
     * @param completed : If true, include completed quests to the list.
     * @return list of started and eventually completed quests of the player.
     */
    public List<Quest> getAllQuests(boolean completed)
    {
        List<Quest> quests = new ArrayList<>();

        for (QuestState qs : _quests)
        {
            if (qs == null || completed && qs.isCreated() || !completed && !qs.isStarted())
                continue;

            Quest quest = qs.getQuest();
            if (quest == null || !quest.isRealQuest())
                continue;

            quests.add(quest);
        }

        return quests;
    }

    public void processQuestEvent(String questName, String event)
    {
        Quest quest = QuestManager.getInstance().getQuest(questName);
        if (quest == null)
            return;

        QuestState qs = getQuestState(questName);
        if (qs == null)
            return;

        L2Object object = L2World.getInstance().findObject(getLastQuestNpcObject());
        if (!(object instanceof L2Npc) || !isInsideRadius(object, L2Npc.INTERACTION_DISTANCE, false, false))
            return;

        L2Npc npc = (L2Npc) object;
        List<Quest> quests = npc.getTemplate().getEventQuests(QuestEventType.ON_TALK);
        if (quests != null)
        {
            for (Quest onTalk : quests)
            {
                if (onTalk == null || !onTalk.equals(quest))
                    continue;

                quest.notifyEvent(event, npc, this);
                break;
            }
        }
    }

    /**
     * Add QuestState instance that is to be notified of L2PcInstance's death.
     * @param qs The QuestState that subscribe to this event
     */
    public void addNotifyQuestOfDeath(QuestState qs)
    {
        if (qs == null)
            return;

        if (!_notifyQuestOfDeathList.contains(qs))
            _notifyQuestOfDeathList.add(qs);
    }

    /**
     * Remove QuestState instance that is to be notified of L2PcInstance's death.
     * @param qs The QuestState that subscribe to this event
     */
    public void removeNotifyQuestOfDeath(QuestState qs)
    {
        if (qs == null)
            return;

        _notifyQuestOfDeathList.remove(qs);
    }

    /**
     * @return A list of QuestStates which registered for notify of death of this L2PcInstance.
     */
    public final List<QuestState> getNotifyQuestOfDeath()
    {
        return _notifyQuestOfDeathList;
    }

    /**
     * @return A table containing all L2ShortCut of the L2PcInstance.
     */
    public L2ShortCut[] getAllShortCuts()
    {
        return _shortCuts.getAllShortCuts();
    }

    /**
     * @param slot The slot in wich the shortCuts is equipped
     * @param page The page of shortCuts containing the slot
     * @return The L2ShortCut of the L2PcInstance corresponding to the position (page-slot).
     */
    public L2ShortCut getShortCut(int slot, int page)
    {
        return _shortCuts.getShortCut(slot, page);
    }

    /**
     * Add a L2shortCut to the L2PcInstance _shortCuts
     * @param shortcut The shortcut to add.
     */
    public void registerShortCut(L2ShortCut shortcut)
    {
        _shortCuts.registerShortCut(shortcut);
    }

    /**
     * Delete the L2ShortCut corresponding to the position (page-slot) from the L2PcInstance _shortCuts.
     * @param slot
     * @param page
     */
    public void deleteShortCut(int slot, int page)
    {
        _shortCuts.deleteShortCut(slot, page);
    }

    /**
     * Add a L2Macro to the L2PcInstance _macroses.
     * @param macro The Macro object to add.
     */
    public void registerMacro(L2Macro macro)
    {
        _macroses.registerMacro(macro);
    }

    /**
     * Delete the L2Macro corresponding to the Identifier from the L2PcInstance _macroses.
     * @param id
     */
    public void deleteMacro(int id)
    {
        _macroses.deleteMacro(id);
    }

    /**
     * @return all L2Macro of the L2PcInstance.
     */
    public MacroList getMacroses()
    {
        return _macroses;
    }

    /**
     * Set the siege state of the L2PcInstance.
     * @param siegeState 1 = attacker, 2 = defender, 0 = not involved
     */
    public void setSiegeState(byte siegeState)
    {
        _siegeState = siegeState;
    }

    /**
     * @return the siege state of the L2PcInstance.
     */
    public byte getSiegeState()
    {
        return _siegeState;
    }

    /**
     * Set the PvP Flag of the L2PcInstance.
     * @param pvpFlag 0 or 1.
     */
    public void setPvpFlag(int pvpFlag)
    {
        _pvpFlag = (byte) pvpFlag;
    }

    @Override
    public byte getPvpFlag()
    {
        return _pvpFlag;
    }

    public void updatePvPFlag(int value)
    {
        if (getPvpFlag() == value)
            return;

        setPvpFlag(value);
        sendPacket(new UserInfo(this));

        if (getPet() != null)
            sendPacket(new RelationChanged(getPet(), getRelation(this), false));

        broadcastRelationsChanges();
    }

    @Override
    public void revalidateZone(boolean force)
    {
        // Cannot validate if not in a world region (happens during teleport)
        if (getWorldRegion() == null)
            return;

        // This function is called very often from movement code
        if (force)
            _zoneValidateCounter = 4;
        else
        {
            _zoneValidateCounter--;
            if (_zoneValidateCounter >= 0)
                return;

            _zoneValidateCounter = 4;
        }

        getWorldRegion().revalidateZones(this);

        if (Config.ALLOW_WATER)
            checkWaterState();

        if (isInsideZone(ZoneId.SIEGE))
        {
            if (_lastCompassZone == ExSetCompassZoneCode.SIEGEWARZONE2)
                return;

            _lastCompassZone = ExSetCompassZoneCode.SIEGEWARZONE2;
            sendPacket(new ExSetCompassZoneCode(ExSetCompassZoneCode.SIEGEWARZONE2));
        }
        else if (isInsideZone(ZoneId.PVP))
        {
            if (_lastCompassZone == ExSetCompassZoneCode.PVPZONE)
                return;

            _lastCompassZone = ExSetCompassZoneCode.PVPZONE;
            sendPacket(new ExSetCompassZoneCode(ExSetCompassZoneCode.PVPZONE));
        }
        else if (isIn7sDungeon())
        {
            if (_lastCompassZone == ExSetCompassZoneCode.SEVENSIGNSZONE)
                return;

            _lastCompassZone = ExSetCompassZoneCode.SEVENSIGNSZONE;
            sendPacket(new ExSetCompassZoneCode(ExSetCompassZoneCode.SEVENSIGNSZONE));
        }
        else if (isInsideZone(ZoneId.PEACE))
        {
            if (_lastCompassZone == ExSetCompassZoneCode.PEACEZONE)
                return;

            _lastCompassZone = ExSetCompassZoneCode.PEACEZONE;
            sendPacket(new ExSetCompassZoneCode(ExSetCompassZoneCode.PEACEZONE));
        }
        else
        {
            if (_lastCompassZone == ExSetCompassZoneCode.GENERALZONE)
                return;

            if (_lastCompassZone == ExSetCompassZoneCode.SIEGEWARZONE2)
                updatePvPStatus();

            _lastCompassZone = ExSetCompassZoneCode.GENERALZONE;
            sendPacket(new ExSetCompassZoneCode(ExSetCompassZoneCode.GENERALZONE));
        }
    }

    /**
     * @return True if the L2PcInstance can Craft Dwarven Recipes.
     */
    public boolean hasDwarvenCraft()
    {
        return getSkillLevel(L2Skill.SKILL_CREATE_DWARVEN) >= 1;
    }

    public int getDwarvenCraft()
    {
        return getSkillLevel(L2Skill.SKILL_CREATE_DWARVEN);
    }

    /**
     * @return True if the L2PcInstance can Craft Dwarven Recipes.
     */
    public boolean hasCommonCraft()
    {
        return getSkillLevel(L2Skill.SKILL_CREATE_COMMON) >= 1;
    }

    public int getCommonCraft()
    {
        return getSkillLevel(L2Skill.SKILL_CREATE_COMMON);
    }

    /**
     * @return the PK counter of the L2PcInstance.
     */
    public int getPkKills()
    {
        return _pkKills;
    }

    /**
     * Set the PK counter of the L2PcInstance.
     * @param pkKills A number.
     */
    public void setPkKills(int pkKills)
    {
        _pkKills = pkKills;
    }

    /**
     * @return The _deleteTimer of the L2PcInstance.
     */
    public long getDeleteTimer()
    {
        return _deleteTimer;
    }

    /**
     * Set the _deleteTimer of the L2PcInstance.
     * @param deleteTimer Time in ms.
     */
    public void setDeleteTimer(long deleteTimer)
    {
        _deleteTimer = deleteTimer;
    }

    /**
     * @return The current weight of the L2PcInstance.
     */
    public int getCurrentLoad()
    {
        return _inventory.getTotalWeight();
    }

    /**
     * @return The date of last update of recomPoints.
     */
    public long getLastRecomUpdate()
    {
        return _lastRecomUpdate;
    }

    public void setLastRecomUpdate(long date)
    {
        _lastRecomUpdate = date;
    }

    /**
     * @return The number of recommandation obtained by the L2PcInstance.
     */
    public int getRecomHave()
    {
        return _recomHave;
    }

    /**
     * Increment the number of recommandation obtained by the L2PcInstance (Max : 255).
     */
    protected void incRecomHave()
    {
        if (_recomHave < 255)
            _recomHave++;
    }

    /**
     * Set the number of recommandations obtained by the L2PcInstance (Max : 255).
     * @param value Number of recommandations obtained.
     */
    public void setRecomHave(int value)
    {
        if (value > 255)
            _recomHave = 255;
        else if (value < 0)
            _recomHave = 0;
        else
            _recomHave = value;
    }

    /**
     * @return The number of recommandation that the L2PcInstance can give.
     */
    public int getRecomLeft()
    {
        return _recomLeft;
    }

    /**
     * Increment the number of recommandation that the L2PcInstance can give.
     */
    protected void decRecomLeft()
    {
        if (_recomLeft > 0)
            _recomLeft--;
    }

    public void giveRecom(L2PcInstance target)
    {
        try (Connection con = L2DatabaseFactory.getInstance().getConnection())
        {
            PreparedStatement statement = con.prepareStatement(ADD_CHAR_RECOM);
            statement.setInt(1, getObjectId());
            statement.setInt(2, target.getObjectId());
            statement.execute();
            statement.close();
        }
        catch (Exception e)
        {
            _log.warning("Could not update char recommendations: " + e);
        }

        target.incRecomHave();
        decRecomLeft();
        _recomChars.add(target.getObjectId());
    }

    public boolean canRecom(L2PcInstance target)
    {
        return !_recomChars.contains(target.getObjectId());
    }

    /**
     * Set the exp of the L2PcInstance before a death
     * @param exp
     */
    public void setExpBeforeDeath(long exp)
    {
        _expBeforeDeath = exp;
    }

    public long getExpBeforeDeath()
    {
        return _expBeforeDeath;
    }

    /**
     * Return the Karma of the L2PcInstance.
     */
    @Override
    public int getKarma()
    {
        return _karma;
    }

    /**
     * Set the Karma of the L2PcInstance and send StatusUpdate (broadcast).
     * @param karma A value.
     */
    public void setKarma(int karma)
    {
        if (karma < 0)
            karma = 0;

        if (_karma > 0 && karma == 0)
        {
            sendPacket(new UserInfo(this));
            broadcastRelationsChanges();
        }

        // send message with new karma value
        sendPacket(SystemMessage.getSystemMessage(SystemMessageId.YOUR_KARMA_HAS_BEEN_CHANGED_TO_S1).addNumber(karma));

        _karma = karma;
        broadcastKarma();
    }

    /**
     * Weight Limit = (CON Modifier*69000)*Skills
     * @return The max weight that the L2PcInstance can load.
     */
    public int getMaxLoad()
    {
        int con = getCON();
        if (con < 1)
            return 31000;

        if (con > 59)
            return 176000;

        double baseLoad = Math.pow(1.029993928, con) * 30495.627366;
        return (int) calcStat(Stats.MAX_LOAD, baseLoad * Config.ALT_WEIGHT_LIMIT, this, null);
    }

    public int getExpertiseArmorPenalty()
    {
        return _expertiseArmorPenalty;
    }

    public boolean getExpertiseWeaponPenalty()
    {
        return _expertiseWeaponPenalty;
    }

    public int getWeightPenalty()
    {
        return _curWeightPenalty;
    }

    /**
     * Update the overloaded status of the L2PcInstance.
     */
    public void refreshOverloaded()
    {
        int maxLoad = getMaxLoad();
        if (maxLoad > 0)
        {
            int weightproc = getCurrentLoad() * 1000 / maxLoad;
            int newWeightPenalty;

            if (weightproc < 500)
                newWeightPenalty = 0;
            else if (weightproc < 666)
                newWeightPenalty = 1;
            else if (weightproc < 800)
                newWeightPenalty = 2;
            else if (weightproc < 1000)
                newWeightPenalty = 3;
            else
                newWeightPenalty = 4;

            if (_curWeightPenalty != newWeightPenalty)
            {
                _curWeightPenalty = newWeightPenalty;

                if (newWeightPenalty > 0)
                {
                    super.addSkill(SkillTable.getInstance().getInfo(4270, newWeightPenalty));
                    setIsOverloaded(getCurrentLoad() > maxLoad);
                }
                else
                {
                    super.removeSkill(getKnownSkill(4270));
                    setIsOverloaded(false);
                }

                sendPacket(new UserInfo(this));
                sendPacket(new EtcStatusUpdate(this));
                broadcastCharInfo();
            }
        }
    }

    /**
     * Refresh expertise level ; weapon got one rank, when armor got 4 ranks.<br>
     */
    public void refreshExpertisePenalty()
    {
        int armorPenalty = 0;
        boolean weaponPenalty = false;

        for (L2ItemInstance item : getInventory().getItems())
        {
            if (item != null && item.isEquipped() && item.getItemType() != L2EtcItemType.ARROW && item.getItem().getCrystalType() > getExpertiseIndex())
            {
                if (item.isWeapon())
                    weaponPenalty = true;
                else
                    armorPenalty += (item.getItem().getBodyPart() == L2Item.SLOT_FULL_ARMOR) ? 2 : 1;
            }
        }

        armorPenalty = Math.min(armorPenalty, 4);

        // Found a different state than previous ; update it.
        if (_expertiseWeaponPenalty != weaponPenalty || _expertiseArmorPenalty != armorPenalty)
        {
            _expertiseWeaponPenalty = weaponPenalty;
            _expertiseArmorPenalty = armorPenalty;

            // Passive skill "Grade Penalty" is either granted or dropped.
            if (_expertiseWeaponPenalty || _expertiseArmorPenalty > 0)
                super.addSkill(SkillTable.getInstance().getInfo(4267, 1));
            else
                super.removeSkill(getKnownSkill(4267));

            sendSkillList();
            sendPacket(new EtcStatusUpdate(this));
        }
    }

    /**
     * Equip or unequip the item.
     * <UL>
     * <LI>If item is equipped, shots are applied if automation is on.</LI>
     * <LI>If item is unequipped, shots are discharged.</LI>
     * </UL>
     * @param item The item to charge/discharge.
     * @param abortAttack If true, the current attack will be aborted in order to equip the item.
     */
    public void useEquippableItem(L2ItemInstance item, boolean abortAttack)
    {
        L2ItemInstance[] items = null;
        final boolean isEquipped = item.isEquipped();
        final int oldInvLimit = getInventoryLimit();
        SystemMessage sm = null;

        if (item.getItem() instanceof L2Weapon)
            item.unChargeAllShots();

        if (isEquipped)
        {
            if (item.getEnchantLevel() > 0)
                sm = SystemMessage.getSystemMessage(SystemMessageId.EQUIPMENT_S1_S2_REMOVED).addNumber(item.getEnchantLevel()).addItemName(item);
            else
                sm = SystemMessage.getSystemMessage(SystemMessageId.S1_DISARMED).addItemName(item);

            sendPacket(sm);

            int slot = getInventory().getSlotFromItem(item);
            items = getInventory().unEquipItemInBodySlotAndRecord(slot);
        }
        else
        {
            items = getInventory().equipItemAndRecord(item);

            if (item.isEquipped())
            {
                if (item.getEnchantLevel() > 0)
                    sm = SystemMessage.getSystemMessage(SystemMessageId.S1_S2_EQUIPPED).addNumber(item.getEnchantLevel()).addItemName(item);
                else
                    sm = SystemMessage.getSystemMessage(SystemMessageId.S1_EQUIPPED).addItemName(item);

                sendPacket(sm);

                if ((item.getItem().getBodyPart() & L2Item.SLOT_ALLWEAPON) != 0)
                    rechargeShots(true, true);
            }
            else
                sendPacket(SystemMessageId.CANNOT_EQUIP_ITEM_DUE_TO_BAD_CONDITION);
        }
        refreshExpertisePenalty();
        broadcastUserInfo();

        InventoryUpdate iu = new InventoryUpdate();
        iu.addItems(Arrays.asList(items));
        sendPacket(iu);

        if (abortAttack)
            abortAttack();

        if (getInventoryLimit() != oldInvLimit)
            sendPacket(new ExStorageMaxCount(this));
    }

    /**
     * @return PvP Kills of the L2PcInstance (number of player killed during a PvP).
     */
    public int getPvpKills()
    {
        return _pvpKills;
    }

    /**
     * Set PvP Kills of the L2PcInstance (number of player killed during a PvP).
     * @param pvpKills A value.
     */
    public void setPvpKills(int pvpKills)
    {
        _pvpKills = pvpKills;
    }

    /**
     * @return The ClassId object of the L2PcInstance contained in L2PcTemplate.
     */
    public ClassId getClassId()
    {
        return getTemplate().classId;
    }

    /**
     * Set the template of the L2PcInstance.
     * @param Id The Identifier of the L2PcTemplate to set to the L2PcInstance
     */
    public void setClassId(int Id)
    {
        if (!_subclassLock.tryLock())
            return;

        try
        {
            if (getLvlJoinedAcademy() != 0 && _clan != null && PlayerClass.values()[Id].getLevel() == ClassLevel.Third)
            {
                if (getLvlJoinedAcademy() <= 16)
                    _clan.addReputationScore(400);
                else if (getLvlJoinedAcademy() >= 39)
                    _clan.addReputationScore(170);
                else
                    _clan.addReputationScore((400 - (getLvlJoinedAcademy() - 16) * 10));

                setLvlJoinedAcademy(0);

                // Oust pledge member from the academy, because he has finished his 2nd class transfer.
                _clan.broadcastToOnlineMembers(new PledgeShowMemberListDelete(getName()), SystemMessage.getSystemMessage(SystemMessageId.CLAN_MEMBER_S1_EXPELLED).addString(getName()));
                _clan.removeClanMember(getObjectId(), 0);
                sendPacket(SystemMessageId.ACADEMY_MEMBERSHIP_TERMINATED);

                // receive graduation gift : academy circlet
                addItem("Gift", 8181, 1, this, true);
            }

            if (isSubClassActive())
                getSubClasses().get(_classIndex).setClassId(Id);

            broadcastPacket(new MagicSkillUse(this, this, 5103, 1, 1000, 0));
            setClassTemplate(Id);

            // Update class icon in party and clan
            if (isInParty())
                getParty().broadcastToPartyMembers(new PartySmallWindowUpdate(this));

            if (getClan() != null)
                getClan().broadcastToOnlineMembers(new PledgeShowMemberListUpdate(this));

            if (Config.AUTO_LEARN_SKILLS)
                rewardSkills();
        }
        finally
        {
            _subclassLock.unlock();
        }
    }

    /**
     * @return the Experience of the L2PcInstance.
     */
    public long getExp()
    {
        return getStat().getExp();
    }

    public void setActiveEnchantItem(L2ItemInstance scroll)
    {
        _activeEnchantItem = scroll;
    }

    public L2ItemInstance getActiveEnchantItem()
    {
        return _activeEnchantItem;
    }

    /**
     * Set the fists weapon of the L2PcInstance (used when no weapon is equipped).
     * @param weaponItem The fists L2Weapon to set to the L2PcInstance
     */
    public void setFistsWeaponItem(L2Weapon weaponItem)
    {
        _fistsWeaponItem = weaponItem;
    }

    /**
     * @return The fists weapon of the L2PcInstance (used when no weapon is equipped).
     */
    public L2Weapon getFistsWeaponItem()
    {
        return _fistsWeaponItem;
    }

    /**
     * @param classId The classId to test.
     * @return The fists weapon of the L2PcInstance Class (used when no weapon is equipped).
     */
    public static L2Weapon findFistsWeaponItem(int classId)
    {
        L2Weapon weaponItem = null;
        if ((classId >= 0x00) && (classId <= 0x09))
        {
            // human fighter fists
            L2Item temp = ItemTable.getInstance().getTemplate(246);
            weaponItem = (L2Weapon) temp;
        }
        else if ((classId >= 0x0a) && (classId <= 0x11))
        {
            // human mage fists
            L2Item temp = ItemTable.getInstance().getTemplate(251);
            weaponItem = (L2Weapon) temp;
        }
        else if ((classId >= 0x12) && (classId <= 0x18))
        {
            // elven fighter fists
            L2Item temp = ItemTable.getInstance().getTemplate(244);
            weaponItem = (L2Weapon) temp;
        }
        else if ((classId >= 0x19) && (classId <= 0x1e))
        {
            // elven mage fists
            L2Item temp = ItemTable.getInstance().getTemplate(249);
            weaponItem = (L2Weapon) temp;
        }
        else if ((classId >= 0x1f) && (classId <= 0x25))
        {
            // dark elven fighter fists
            L2Item temp = ItemTable.getInstance().getTemplate(245);
            weaponItem = (L2Weapon) temp;
        }
        else if ((classId >= 0x26) && (classId <= 0x2b))
        {
            // dark elven mage fists
            L2Item temp = ItemTable.getInstance().getTemplate(250);
            weaponItem = (L2Weapon) temp;
        }
        else if ((classId >= 0x2c) && (classId <= 0x30))
        {
            // orc fighter fists
            L2Item temp = ItemTable.getInstance().getTemplate(248);
            weaponItem = (L2Weapon) temp;
        }
        else if ((classId >= 0x31) && (classId <= 0x34))
        {
            // orc mage fists
            L2Item temp = ItemTable.getInstance().getTemplate(252);
            weaponItem = (L2Weapon) temp;
        }
        else if ((classId >= 0x35) && (classId <= 0x39))
        {
            // dwarven fists
            L2Item temp = ItemTable.getInstance().getTemplate(247);
            weaponItem = (L2Weapon) temp;
        }

        return weaponItem;
    }

    /**
     * This method is kinda polymorph :<BR>
     * <BR>
     * <li>it gives proper Expertise, Dwarven && Common Craft skill level ;</li> <li>it controls the Lucky skill (remove at lvl 10) ;</li> <li>it finally sends the skill list.</li>
     */
    public void rewardSkills()
    {
        // Get the Level of the L2PcInstance
        int lvl = getLevel();

        // Remove the Lucky skill once reached lvl 10.
        if (getSkillLevel(L2Skill.SKILL_LUCKY) > 0 && lvl >= 10)
            removeSkill(FrequentSkill.LUCKY.getSkill());

        // Calculate the current higher Expertise of the L2PcInstance
        for (int i = 0; i < EXPERTISE_LEVELS.length; i++)
        {
            if (lvl >= EXPERTISE_LEVELS[i])
                setExpertiseIndex(i);
        }

        // Add the Expertise skill corresponding to its Expertise level
        if (getExpertiseIndex() > 0)
        {
            L2Skill skill = SkillTable.getInstance().getInfo(239, getExpertiseIndex());
            addSkill(skill, true);
        }

        // Active skill dwarven craft
        if (getSkillLevel(1321) < 1 && getClassId().equalsOrChildOf(ClassId.dwarvenFighter))
        {
            L2Skill skill = FrequentSkill.DWARVEN_CRAFT.getSkill();
            addSkill(skill, true);
        }

        // Active skill common craft
        if (getSkillLevel(1322) < 1)
        {
            L2Skill skill = FrequentSkill.COMMON_CRAFT.getSkill();
            addSkill(skill, true);
        }

        for (int i = 0; i < COMMON_CRAFT_LEVELS.length; i++)
        {
            if (lvl >= COMMON_CRAFT_LEVELS[i] && getSkillLevel(1320) < (i + 1))
            {
                L2Skill skill = SkillTable.getInstance().getInfo(1320, (i + 1));
                addSkill(skill, true);
            }
        }

        // Auto-Learn skills if activated
        if (Config.AUTO_LEARN_SKILLS)
            giveAvailableSkills();

        sendSkillList();
    }

    /**
     * Regive all skills which aren't saved to database, like Noble, Hero, Clan Skills.<br>
     * <b>Do not call this on enterworld or char load.</b>.
     */
    private void regiveTemporarySkills()
    {
        // Add noble skills if noble.
        if (isNoble())
            setNoble(true, false);

        // Add Hero skills if hero.
        if (isHero())
            setHero(true);

        // Add clan skills.
        if (getClan() != null && getClan().getReputationScore() >= 0)
        {
            for (L2Skill sk : getClan().getClanSkills())
            {
                if (sk.getMinPledgeClass() <= getPledgeClass())
                    addSkill(sk, false);
            }
        }

        // Reload passive skills from armors / jewels / weapons
        getInventory().reloadEquippedItems();

        // Add Death Penalty Buff Level
        restoreDeathPenaltyBuffLevel();
    }

    /**
     * Give all available skills to the player.
     * @return The number of given skills.
     */
    public int giveAvailableSkills()
    {
        int result = 0;
        for (L2SkillLearn sl : SkillTreeTable.getInstance().getAllAvailableSkills(this, getClassId()))
        {
            addSkill(SkillTable.getInstance().getInfo(sl.getId(), sl.getLevel()), true);
            result++;
        }
        return result;
    }

    /**
     * @return The Race object of the L2PcInstance.
     */
    public Race getRace()
    {
        if (!isSubClassActive())
            return getTemplate().race;

        L2PcTemplate charTemp = CharTemplateTable.getInstance().getTemplate(_baseClass);
        return charTemp.race;
    }

    public L2Radar getRadar()
    {
        return _radar;
    }

    /**
     * @return the SP amount of the L2PcInstance.
     */
    public int getSp()
    {
        return getStat().getSp();
    }

    /**
     * @param castleId The castle to check.
     * @return True if this L2PcInstance is a clan leader in ownership of the passed castle.
     */
    public boolean isCastleLord(int castleId)
    {
        L2Clan clan = getClan();

        // player has clan and is the clan leader, check the castle info
        if ((clan != null) && (clan.getLeader().getPlayerInstance() == this))
        {
            // if the clan has a castle and it is actually the queried castle, return true
            Castle castle = CastleManager.getInstance().getCastleByOwner(clan);
            if ((castle != null) && (castle == CastleManager.getInstance().getCastleById(castleId)))
                return true;
        }

        return false;
    }

    /**
     * @return The Clan Identifier of the L2PcInstance.
     */
    public int getClanId()
    {
        return _clanId;
    }

    /**
     * @return The Clan Crest Identifier of the L2PcInstance or 0.
     */
    public int getClanCrestId()
    {
        if (_clan != null)
            return _clan.getCrestId();

        return 0;
    }

    /**
     * @return The Clan CrestLarge Identifier or 0
     */
    public int getClanCrestLargeId()
    {
        if (_clan != null)
            return _clan.getCrestLargeId();

        return 0;
    }

    public long getClanJoinExpiryTime()
    {
        return _clanJoinExpiryTime;
    }

    public void setClanJoinExpiryTime(long time)
    {
        _clanJoinExpiryTime = time;
    }

    public long getClanCreateExpiryTime()
    {
        return _clanCreateExpiryTime;
    }

    public void setClanCreateExpiryTime(long time)
    {
        _clanCreateExpiryTime = time;
    }

    public void setOnlineTime(long time)
    {
        _onlineTime = time;
        _onlineBeginTime = System.currentTimeMillis();
    }

    /**
     * Return the PcInventory Inventory of the L2PcInstance contained in _inventory.
     */
    @Override
    public PcInventory getInventory()
    {
        return _inventory;
    }

    /**
     * Delete a ShortCut of the L2PcInstance _shortCuts.
     * @param objectId The shortcut id.
     */
    public void removeItemFromShortCut(int objectId)
    {
        _shortCuts.deleteShortCutByObjectId(objectId);
    }

    /**
     * @return True if the L2PcInstance is sitting.
     */
    public boolean isSitting()
    {
        return _waitTypeSitting;
    }

    /**
     * Set _waitTypeSitting to given value.
     * @param state A boolean.
     */
    public void setIsSitting(boolean state)
    {
        _waitTypeSitting = state;
    }

    /**
     * Sit down the L2PcInstance, set the AI Intention to REST and send a Server->Client ChangeWaitType packet (broadcast)
     */
    public void sitDown()
    {
        sitDown(true);
    }

    public void sitDown(boolean checkCast)
    {
        if (checkCast && isCastingNow())
            return;

        if (!_waitTypeSitting && !isAttackingDisabled() && !isOutOfControl() && !isImmobilized())
        {
            breakAttack();
            setIsSitting(true);
            broadcastPacket(new ChangeWaitType(this, ChangeWaitType.WT_SITTING));

            // Schedule a sit down task to wait for the animation to finish
            getAI().setIntention(CtrlIntention.REST);
            ThreadPoolManager.getInstance().scheduleGeneral(new SitDownTask(), 2500);
            setIsParalyzed(true);
        }
    }

    /**
     * Sit down Task
     */
    protected class SitDownTask implements Runnable
    {
        @Override
        public void run()
        {
            setIsParalyzed(false);
        }
    }

    /**
     * Stand up Task
     */
    protected class StandUpTask implements Runnable
    {
        @Override
        public void run()
        {
            setIsSitting(false);
            getAI().setIntention(CtrlIntention.IDLE);
        }
    }

    /**
     * Stand up the L2PcInstance, set the AI Intention to IDLE and send a Server->Client ChangeWaitType packet (broadcast)
     */
    public void standUp()
    {
        if (_waitTypeSitting && !isInStoreMode() && !isAlikeDead())
        {
            if (_effects.isAffected(L2EffectFlag.RELAXING))
                stopEffects(L2EffectType.RELAXING);

            broadcastPacket(new ChangeWaitType(this, ChangeWaitType.WT_STANDING));
            // Schedule a stand up task to wait for the animation to finish
            ThreadPoolManager.getInstance().scheduleGeneral(new StandUpTask(), 2500);
        }
    }

    /**
     * Stands up and close any opened shop window, if any.
     */
    public void forceStandUp()
    {
        // Cancels any shop types.
        if (isInStoreMode())
        {
            setPrivateStoreType(STORE_PRIVATE_NONE);
            broadcastUserInfo();
        }

        // Stand up.
        if (isSitting())
            standUp();
    }

    /**
     * @return The PcWarehouse object of the L2PcInstance.
     */
    public PcWarehouse getWarehouse()
    {
        if (_warehouse == null)
        {
            _warehouse = new PcWarehouse(this);
            _warehouse.restore();
        }
        return _warehouse;
    }

    /**
     * Free memory used by Warehouse
     */
    public void clearWarehouse()
    {
        if (_warehouse != null)
            _warehouse.deleteMe();

        _warehouse = null;
    }

    /**
     * @return The PcFreight object of the L2PcInstance.
     */
    public PcFreight getFreight()
    {
        if (_freight == null)
        {
            _freight = new PcFreight(this);
            _freight.restore();
        }
        return _freight;
    }

    /**
     * Free memory used by Freight
     */
    public void clearFreight()
    {
        if (_freight != null)
            _freight.deleteMe();

        _freight = null;
    }

    /**
     * @param objectId The id of the owner.
     * @return deposited PcFreight object for the objectId or create new if not existing.
     */
    public PcFreight getDepositedFreight(int objectId)
    {
        for (PcFreight freight : _depositedFreight)
        {
            if (freight != null && freight.getOwnerId() == objectId)
                return freight;
        }

        PcFreight freight = new PcFreight(null);
        freight.doQuickRestore(objectId);
        _depositedFreight.add(freight);
        return freight;
    }

    /**
     * Clear memory used by deposited freight
     */
    public void clearDepositedFreight()
    {
        for (PcFreight freight : _depositedFreight)
        {
            if (freight != null)
                freight.deleteMe();
        }
        _depositedFreight.clear();
    }

    /**
     * @return The Identifier of the L2PcInstance.
     */
    public int getCharId()
    {
        return _charId;
    }

    /**
     * Set the Identifier of the L2PcInstance.
     * @param charId The CharId.
     */
    public void setCharId(int charId)
    {
        _charId = charId;
    }

    /**
     * @return The Adena amount of the L2PcInstance.
     */
    public int getAdena()
    {
        return _inventory.getAdena();
    }

    /**
     * @return The Ancient Adena amount of the L2PcInstance.
     */
    public int getAncientAdena()
    {
        return _inventory.getAncientAdena();
    }

    /**
     * Add adena to Inventory of the L2PcInstance and send a Server->Client InventoryUpdate packet to the L2PcInstance.
     * @param process String Identifier of process triggering this action
     * @param count int Quantity of adena to be added
     * @param reference L2Object Object referencing current action like NPC selling item or previous item in transformation
     * @param sendMessage boolean Specifies whether to send message to Client about this action
     */
    public void addAdena(String process, int count, L2Object reference, boolean sendMessage)
    {
        if (sendMessage)
            sendPacket(SystemMessage.getSystemMessage(SystemMessageId.EARNED_S1_ADENA).addNumber(count));

        if (count > 0)
        {
            _inventory.addAdena(process, count, this, reference);

            InventoryUpdate iu = new InventoryUpdate();
            iu.addItem(_inventory.getAdenaInstance());
            sendPacket(iu);
        }
    }

    /**
     * Reduce adena in Inventory of the L2PcInstance and send a Server->Client InventoryUpdate packet to the L2PcInstance.
     * @param process String Identifier of process triggering this action
     * @param count int Quantity of adena to be reduced
     * @param reference L2Object Object referencing current action like NPC selling item or previous item in transformation
     * @param sendMessage boolean Specifies whether to send message to Client about this action
     * @return boolean informing if the action was successfull
     */
    public boolean reduceAdena(String process, int count, L2Object reference, boolean sendMessage)
    {
        if (count > getAdena())
        {
            if (sendMessage)
                sendPacket(SystemMessageId.YOU_NOT_ENOUGH_ADENA);

            return false;
        }

        if (count > 0)
        {
            L2ItemInstance adenaItem = _inventory.getAdenaInstance();
            if (!_inventory.reduceAdena(process, count, this, reference))
                return false;

            // Send update packet
            InventoryUpdate iu = new InventoryUpdate();
            iu.addItem(adenaItem);
            sendPacket(iu);

            if (sendMessage)
                sendPacket(SystemMessage.getSystemMessage(SystemMessageId.S1_DISAPPEARED_ADENA).addNumber(count));
        }
        return true;
    }

    /**
     * Add ancient adena to Inventory of the L2PcInstance and send a Server->Client InventoryUpdate packet to the L2PcInstance.
     * @param process String Identifier of process triggering this action
     * @param count int Quantity of ancient adena to be added
     * @param reference L2Object Object referencing current action like NPC selling item or previous item in transformation
     * @param sendMessage boolean Specifies whether to send message to Client about this action
     */
    public void addAncientAdena(String process, int count, L2Object reference, boolean sendMessage)
    {
        if (sendMessage)
            sendPacket(SystemMessage.getSystemMessage(SystemMessageId.EARNED_S2_S1_S).addItemName(PcInventory.ANCIENT_ADENA_ID).addNumber(count));

        if (count > 0)
        {
            _inventory.addAncientAdena(process, count, this, reference);

            InventoryUpdate iu = new InventoryUpdate();
            iu.addItem(_inventory.getAncientAdenaInstance());
            sendPacket(iu);
        }
    }

    /**
     * Reduce ancient adena in Inventory of the L2PcInstance and send a Server->Client InventoryUpdate packet to the L2PcInstance.
     * @param process String Identifier of process triggering this action
     * @param count int Quantity of ancient adena to be reduced
     * @param reference L2Object Object referencing current action like NPC selling item or previous item in transformation
     * @param sendMessage boolean Specifies whether to send message to Client about this action
     * @return boolean informing if the action was successfull
     */
    public boolean reduceAncientAdena(String process, int count, L2Object reference, boolean sendMessage)
    {
        if (count > getAncientAdena())
        {
            if (sendMessage)
                sendPacket(SystemMessageId.YOU_NOT_ENOUGH_ADENA);

            return false;
        }

        if (count > 0)
        {
            L2ItemInstance ancientAdenaItem = _inventory.getAncientAdenaInstance();
            if (!_inventory.reduceAncientAdena(process, count, this, reference))
                return false;

            InventoryUpdate iu = new InventoryUpdate();
            iu.addItem(ancientAdenaItem);
            sendPacket(iu);

            if (sendMessage)
            {
                if (count > 1)
                    sendPacket(SystemMessage.getSystemMessage(SystemMessageId.S2_S1_DISAPPEARED).addItemName(PcInventory.ANCIENT_ADENA_ID).addItemNumber(count));
                else
                    sendPacket(SystemMessage.getSystemMessage(SystemMessageId.S1_DISAPPEARED).addItemName(PcInventory.ANCIENT_ADENA_ID));
            }
        }
        return true;
    }

    /**
     * Adds item to inventory and send a Server->Client InventoryUpdate packet to the L2PcInstance.
     * @param process String Identifier of process triggering this action
     * @param item L2ItemInstance to be added
     * @param reference L2Object Object referencing current action like NPC selling item or previous item in transformation
     * @param sendMessage boolean Specifies whether to send message to Client about this action
     */
    public void addItem(String process, L2ItemInstance item, L2Object reference, boolean sendMessage)
    {
        if (item.getCount() > 0)
        {
            // Sends message to client if requested
            if (sendMessage)
            {
                if (item.getCount() > 1)
                    sendPacket(SystemMessage.getSystemMessage(SystemMessageId.YOU_PICKED_UP_S2_S1).addItemName(item).addNumber(item.getCount()));
                else if (item.getEnchantLevel() > 0)
                    sendPacket(SystemMessage.getSystemMessage(SystemMessageId.YOU_PICKED_UP_A_S1_S2).addNumber(item.getEnchantLevel()).addItemName(item));
                else
                    sendPacket(SystemMessage.getSystemMessage(SystemMessageId.YOU_PICKED_UP_S1).addItemName(item));
            }

            // Add the item to inventory
            L2ItemInstance newitem = _inventory.addItem(process, item, this, reference);

            // Send inventory update packet
            InventoryUpdate playerIU = new InventoryUpdate();
            playerIU.addItem(newitem);
            sendPacket(playerIU);

            // Update current load as well
            StatusUpdate su = new StatusUpdate(this);
            su.addAttribute(StatusUpdate.CUR_LOAD, getCurrentLoad());
            sendPacket(su);

            // If over capacity, drop the item
            if (!_inventory.validateCapacity(0, item.isQuestItem()) && newitem.isDropable() && (!newitem.isStackable() || newitem.getLastChange() != L2ItemInstance.MODIFIED))
                dropItem("InvDrop", newitem, null, true, true);
            // Cursed Weapon
            else if (CursedWeaponsManager.getInstance().isCursed(newitem.getItemId()))
                CursedWeaponsManager.getInstance().activate(this, newitem);
            // If you pickup arrows and a bow is equipped, try to equip them if no arrows is currently equipped.
            else if (item.getItem().getItemType() == L2EtcItemType.ARROW && getAttackType() == L2WeaponType.BOW && getInventory().getPaperdollItem(Inventory.PAPERDOLL_LHAND) == null)
                checkAndEquipArrows();
        }
    }

    /**
     * Adds item to Inventory and send a Server->Client InventoryUpdate packet to the L2PcInstance.
     * @param process String Identifier of process triggering this action
     * @param itemId int Item Identifier of the item to be added
     * @param count int Quantity of items to be added
     * @param reference L2Object Object referencing current action like NPC selling item or previous item in transformation
     * @param sendMessage boolean Specifies whether to send message to Client about this action
     * @return The created L2ItemInstance.
     */
    public L2ItemInstance addItem(String process, int itemId, int count, L2Object reference, boolean sendMessage)
    {
        if (count > 0)
        {
            // Retrieve the template of the item.
            final L2Item item = ItemTable.getInstance().getTemplate(itemId);
            if (item == null)
            {
                _log.log(Level.SEVERE, "Item id " + itemId + "doesn't exist, so it can't be added.");
                return null;
            }

            // Sends message to client if requested.
            if (sendMessage && ((!isCastingNow() && item.getItemType() == L2EtcItemType.HERB) || item.getItemType() != L2EtcItemType.HERB))
            {
                if (count > 1)
                {
                    if (process.equalsIgnoreCase("Sweep") || process.equalsIgnoreCase("Quest"))
                        sendPacket(SystemMessage.getSystemMessage(SystemMessageId.EARNED_S2_S1_S).addItemName(itemId).addItemNumber(count));
                    else
                        sendPacket(SystemMessage.getSystemMessage(SystemMessageId.YOU_PICKED_UP_S2_S1).addItemName(itemId).addItemNumber(count));
                }
                else
                {
                    if (process.equalsIgnoreCase("Sweep") || process.equalsIgnoreCase("Quest"))
                        sendPacket(SystemMessage.getSystemMessage(SystemMessageId.EARNED_ITEM_S1).addItemName(itemId));
                    else
                        sendPacket(SystemMessage.getSystemMessage(SystemMessageId.YOU_PICKED_UP_S1).addItemName(itemId));
                }
            }

            // If the item is herb type, dont add it to inventory.
            if (item.getItemType() == L2EtcItemType.HERB)
            {
                if (!isCastingNow())
                {
                    final L2ItemInstance herb = new L2ItemInstance(_charId, itemId);

                    final IItemHandler handler = ItemHandler.getInstance().getItemHandler(herb.getEtcItem());
                    if (handler != null)
                    {
                        handler.useItem(this, herb, false);
                        if (_herbstask >= 100)
                            _herbstask -= 100;
                    }
                }
                else
                {
                    _herbstask += 100;
                    ThreadPoolManager.getInstance().scheduleAi(new HerbTask(process, itemId, count, reference, sendMessage), _herbstask);
                }
            }
            else
            {
                // Add the item to inventory
                final L2ItemInstance createdItem = _inventory.addItem(process, itemId, count, this, reference);

                // If over capacity, drop the item
                if (!_inventory.validateCapacity(0, item.isQuestItem()) && createdItem.isDropable() && (!createdItem.isStackable() || createdItem.getLastChange() != L2ItemInstance.MODIFIED))
                    dropItem("InvDrop", createdItem, null, true);
                // Cursed Weapon
                else if (CursedWeaponsManager.getInstance().isCursed(createdItem.getItemId()))
                    CursedWeaponsManager.getInstance().activate(this, createdItem);
                // If you pickup arrows and a bow is equipped, try to equip them if no arrows is currently equipped.
                else if (item.getItemType() == L2EtcItemType.ARROW && getAttackType() == L2WeaponType.BOW && getInventory().getPaperdollItem(Inventory.PAPERDOLL_LHAND) == null)
                    checkAndEquipArrows();

                return createdItem;
            }
        }
        return null;
    }

    /**
     * Destroy item from inventory and send a Server->Client InventoryUpdate packet to the L2PcInstance.
     * @param process String Identifier of process triggering this action
     * @param item L2ItemInstance to be destroyed
     * @param reference L2Object Object referencing current action like NPC selling item or previous item in transformation
     * @param sendMessage boolean Specifies whether to send message to Client about this action
     * @return boolean informing if the action was successfull
     */
    public boolean destroyItem(String process, L2ItemInstance item, L2Object reference, boolean sendMessage)
    {
        return this.destroyItem(process, item, item.getCount(), reference, sendMessage);
    }

    /**
     * Destroy item from inventory and send a Server->Client InventoryUpdate packet to the L2PcInstance.
     * @param process String Identifier of process triggering this action
     * @param item L2ItemInstance to be destroyed
     * @param count int Quantity of ancient adena to be reduced
     * @param reference L2Object Object referencing current action like NPC selling item or previous item in transformation
     * @param sendMessage boolean Specifies whether to send message to Client about this action
     * @return boolean informing if the action was successfull
     */
    public boolean destroyItem(String process, L2ItemInstance item, int count, L2Object reference, boolean sendMessage)
    {
        item = _inventory.destroyItem(process, item, count, this, reference);

        if (item == null)
        {
            if (sendMessage)
                sendPacket(SystemMessageId.NOT_ENOUGH_ITEMS);

            return false;
        }

        // Send inventory update packet
        InventoryUpdate playerIU = new InventoryUpdate();
        playerIU.addItem(item);
        sendPacket(playerIU);

        // Update current load as well
        StatusUpdate su = new StatusUpdate(this);
        su.addAttribute(StatusUpdate.CUR_LOAD, getCurrentLoad());
        sendPacket(su);

        // Sends message to client if requested
        if (sendMessage)
        {
            if (count > 1)
                sendPacket(SystemMessage.getSystemMessage(SystemMessageId.S2_S1_DISAPPEARED).addItemName(item).addItemNumber(count));
            else
                sendPacket(SystemMessage.getSystemMessage(SystemMessageId.S1_DISAPPEARED).addItemName(item));
        }
        return true;
    }

    /**
     * Destroys item from inventory and send a Server->Client InventoryUpdate packet to the L2PcInstance.
     * @param process String Identifier of process triggering this action
     * @param objectId int Item Instance identifier of the item to be destroyed
     * @param count int Quantity of items to be destroyed
     * @param reference L2Object Object referencing current action like NPC selling item or previous item in transformation
     * @param sendMessage boolean Specifies whether to send message to Client about this action
     * @return boolean informing if the action was successfull
     */
    @Override
    public boolean destroyItem(String process, int objectId, int count, L2Object reference, boolean sendMessage)
    {
        L2ItemInstance item = _inventory.getItemByObjectId(objectId);

        if (item == null)
        {
            if (sendMessage)
                sendPacket(SystemMessageId.NOT_ENOUGH_ITEMS);

            return false;
        }
        return this.destroyItem(process, item, count, reference, sendMessage);
    }

    /**
     * Destroys shots from inventory without logging and only occasional saving to database. Sends a Server->Client InventoryUpdate packet to the L2PcInstance.
     * @param process String Identifier of process triggering this action
     * @param objectId int Item Instance identifier of the item to be destroyed
     * @param count int Quantity of items to be destroyed
     * @param reference L2Object Object referencing current action like NPC selling item or previous item in transformation
     * @param sendMessage boolean Specifies whether to send message to Client about this action
     * @return boolean informing if the action was successfull
     */
    public boolean destroyItemWithoutTrace(String process, int objectId, int count, L2Object reference, boolean sendMessage)
    {
        L2ItemInstance item = _inventory.getItemByObjectId(objectId);

        if (item == null || item.getCount() < count)
        {
            if (sendMessage)
                sendPacket(SystemMessageId.NOT_ENOUGH_ITEMS);

            return false;
        }

        return this.destroyItem(null, item, count, reference, sendMessage);
    }

    /**
     * Destroy item from inventory by using its <B>itemId</B> and send a Server->Client InventoryUpdate packet to the L2PcInstance.
     * @param process String Identifier of process triggering this action
     * @param itemId int Item identifier of the item to be destroyed
     * @param count int Quantity of items to be destroyed
     * @param reference L2Object Object referencing current action like NPC selling item or previous item in transformation
     * @param sendMessage boolean Specifies whether to send message to Client about this action
     * @return boolean informing if the action was successfull
     */
    @Override
    public boolean destroyItemByItemId(String process, int itemId, int count, L2Object reference, boolean sendMessage)
    {
        if (itemId == 57)
            return reduceAdena(process, count, reference, sendMessage);

        L2ItemInstance item = _inventory.getItemByItemId(itemId);

        if (item == null || item.getCount() < count || _inventory.destroyItemByItemId(process, itemId, count, this, reference) == null)
        {
            if (sendMessage)
                sendPacket(SystemMessageId.NOT_ENOUGH_ITEMS);

            return false;
        }

        // Send inventory update packet
        InventoryUpdate playerIU = new InventoryUpdate();
        playerIU.addItem(item);
        sendPacket(playerIU);

        // Update current load as well
        StatusUpdate su = new StatusUpdate(this);
        su.addAttribute(StatusUpdate.CUR_LOAD, getCurrentLoad());
        sendPacket(su);

        // Sends message to client if requested
        if (sendMessage)
        {
            if (count > 1)
                sendPacket(SystemMessage.getSystemMessage(SystemMessageId.S2_S1_DISAPPEARED).addItemName(itemId).addItemNumber(count));
            else
                sendPacket(SystemMessage.getSystemMessage(SystemMessageId.S1_DISAPPEARED).addItemName(itemId));
        }
        return true;
    }

    /**
     * Transfers item to another ItemContainer and send a Server->Client InventoryUpdate packet to the L2PcInstance.
     * @param process String Identifier of process triggering this action
     * @param objectId int Item Identifier of the item to be transfered
     * @param count int Quantity of items to be transfered
     * @param target Inventory the Inventory target.
     * @param reference L2Object Object referencing current action like NPC selling item or previous item in transformation
     * @return L2ItemInstance corresponding to the new item or the updated item in inventory
     */
    public L2ItemInstance transferItem(String process, int objectId, int count, Inventory target, L2Object reference)
    {
        final L2ItemInstance oldItem = checkItemManipulation(objectId, count);
        if (oldItem == null)
            return null;

        final L2ItemInstance newItem = getInventory().transferItem(process, objectId, count, target, this, reference);
        if (newItem == null)
            return null;

        // Send inventory update packet
        InventoryUpdate playerIU = new InventoryUpdate();

        if (oldItem.getCount() > 0 && oldItem != newItem)
            playerIU.addModifiedItem(oldItem);
        else
            playerIU.addRemovedItem(oldItem);

        sendPacket(playerIU);

        // Update current load as well
        StatusUpdate playerSU = new StatusUpdate(this);
        playerSU.addAttribute(StatusUpdate.CUR_LOAD, getCurrentLoad());
        sendPacket(playerSU);

        // Send target update packet
        if (target instanceof PcInventory)
        {
            final L2PcInstance targetPlayer = ((PcInventory) target).getOwner();

            InventoryUpdate playerIU2 = new InventoryUpdate();
            if (newItem.getCount() > count)
                playerIU2.addModifiedItem(newItem);
            else
                playerIU2.addNewItem(newItem);
            targetPlayer.sendPacket(playerIU2);

            // Update current load as well
            playerSU = new StatusUpdate(targetPlayer);
            playerSU.addAttribute(StatusUpdate.CUR_LOAD, targetPlayer.getCurrentLoad());
            targetPlayer.sendPacket(playerSU);
        }
        else if (target instanceof PetInventory)
        {
            PetInventoryUpdate petIU = new PetInventoryUpdate();
            if (newItem.getCount() > count)
                petIU.addModifiedItem(newItem);
            else
                petIU.addNewItem(newItem);
            ((PetInventory) target).getOwner().getOwner().sendPacket(petIU);
        }
        return newItem;
    }

    /**
     * Drop item from inventory and send a Server->Client InventoryUpdate packet to the L2PcInstance.
     * @param process String Identifier of process triggering this action
     * @param item L2ItemInstance to be dropped
     * @param reference L2Object Object referencing current action like NPC selling item or previous item in transformation
     * @param sendMessage boolean Specifies whether to send message to Client about this action
     * @param protectItem whether or not dropped item must be protected temporary against other players
     * @return boolean informing if the action was successfull
     */
    public boolean dropItem(String process, L2ItemInstance item, L2Object reference, boolean sendMessage, boolean protectItem)
    {
        item = _inventory.dropItem(process, item, this, reference);

        if (item == null)
        {
            if (sendMessage)
                sendPacket(SystemMessageId.NOT_ENOUGH_ITEMS);

            return false;
        }

        item.dropMe(this, getX() + Rnd.get(50) - 25, getY() + Rnd.get(50) - 25, getZ() + 20);

        if (Config.AUTODESTROY_ITEM_AFTER > 0 && Config.DESTROY_DROPPED_PLAYER_ITEM && !Config.LIST_PROTECTED_ITEMS.contains(item.getItemId()))
        {
            if ((item.isEquipable() && Config.DESTROY_EQUIPABLE_PLAYER_ITEM) || !item.isEquipable())
                ItemsAutoDestroy.getInstance().addItem(item);
        }

        if (Config.DESTROY_DROPPED_PLAYER_ITEM)
        {
            if (!item.isEquipable() || (item.isEquipable() && Config.DESTROY_EQUIPABLE_PLAYER_ITEM))
                item.setProtected(false);
            else
                item.setProtected(true);
        }
        else
            item.setProtected(true);

        // retail drop protection
        if (protectItem)
            item.getDropProtection().protect(this);

        // Send inventory update packet
        InventoryUpdate playerIU = new InventoryUpdate();
        playerIU.addItem(item);
        sendPacket(playerIU);

        // Update current load as well
        StatusUpdate su = new StatusUpdate(this);
        su.addAttribute(StatusUpdate.CUR_LOAD, getCurrentLoad());
        sendPacket(su);

        // Sends message to client if requested
        if (sendMessage)
            sendPacket(SystemMessage.getSystemMessage(SystemMessageId.YOU_DROPPED_S1).addItemName(item));

        return true;
    }

    public boolean dropItem(String process, L2ItemInstance item, L2Object reference, boolean sendMessage)
    {
        return dropItem(process, item, reference, sendMessage, false);
    }

    /**
     * Drop item from inventory by using its <B>objectID</B> and send a Server->Client InventoryUpdate packet to the L2PcInstance.
     * @param process String Identifier of process triggering this action
     * @param objectId int Item Instance identifier of the item to be dropped
     * @param count int Quantity of items to be dropped
     * @param x int coordinate for drop X
     * @param y int coordinate for drop Y
     * @param z int coordinate for drop Z
     * @param reference L2Object Object referencing current action like NPC selling item or previous item in transformation
     * @param sendMessage boolean Specifies whether to send message to Client about this action
     * @param protectItem boolean Activates drop protection on that item if true
     * @return L2ItemInstance corresponding to the new item or the updated item in inventory
     */
    public L2ItemInstance dropItem(String process, int objectId, int count, int x, int y, int z, L2Object reference, boolean sendMessage, boolean protectItem)
    {
        L2ItemInstance invitem = _inventory.getItemByObjectId(objectId);
        L2ItemInstance item = _inventory.dropItem(process, objectId, count, this, reference);

        if (item == null)
        {
            if (sendMessage)
                sendPacket(SystemMessageId.NOT_ENOUGH_ITEMS);

            return null;
        }

        item.dropMe(this, x, y, z);

        if (Config.AUTODESTROY_ITEM_AFTER > 0 && Config.DESTROY_DROPPED_PLAYER_ITEM && !Config.LIST_PROTECTED_ITEMS.contains(item.getItemId()))
        {
            if ((item.isEquipable() && Config.DESTROY_EQUIPABLE_PLAYER_ITEM) || !item.isEquipable())
                ItemsAutoDestroy.getInstance().addItem(item);
        }

        if (Config.DESTROY_DROPPED_PLAYER_ITEM)
        {
            if (!item.isEquipable() || (item.isEquipable() && Config.DESTROY_EQUIPABLE_PLAYER_ITEM))
                item.setProtected(false);
            else
                item.setProtected(true);
        }
        else
            item.setProtected(true);

        // retail drop protection
        if (protectItem)
            item.getDropProtection().protect(this);

        // Send inventory update packet
        InventoryUpdate playerIU = new InventoryUpdate();
        playerIU.addItem(invitem);
        sendPacket(playerIU);

        // Update current load as well
        StatusUpdate su = new StatusUpdate(this);
        su.addAttribute(StatusUpdate.CUR_LOAD, getCurrentLoad());
        sendPacket(su);

        // Sends message to client if requested
        if (sendMessage)
            sendPacket(SystemMessage.getSystemMessage(SystemMessageId.YOU_DROPPED_S1).addItemName(item));

        return item;
    }

    public L2ItemInstance checkItemManipulation(int objectId, int count)
    {
        if (L2World.getInstance().findObject(objectId) == null)
            return null;

        final L2ItemInstance item = getInventory().getItemByObjectId(objectId);

        if (item == null || item.getOwnerId() != getObjectId())
            return null;

        if (count < 1 || (count > 1 && !item.isStackable()))
            return null;

        if (count > item.getCount())
            return null;

        // Pet is summoned and not the item that summoned the pet AND not the buggle from strider you're mounting
        if (getPet() != null && getPet().getControlItemId() == objectId || getMountObjectID() == objectId)
            return null;

        if (getActiveEnchantItem() != null && getActiveEnchantItem().getObjectId() == objectId)
            return null;

        // We cannot put a Weapon with Augmention in WH while casting (Possible Exploit)
        if (item.isAugmented() && (isCastingNow() || isCastingSimultaneouslyNow()))
            return null;

        return item;
    }

    /**
     * Set _protectEndTime according settings.
     * @param protect boolean Drop timer or activate it.
     */
    public void setProtection(boolean protect)
    {
        if (Config.DEVELOPER && (protect || _protectEndTime > 0))
            _log.warning(getName() + ": Protection " + (protect ? "ON " + (GameTimeController.getGameTicks() + Config.PLAYER_SPAWN_PROTECTION * GameTimeController.TICKS_PER_SECOND) : "OFF") + " (currently " + GameTimeController.getGameTicks() + ")");

        _protectEndTime = protect ? GameTimeController.getGameTicks() + Config.PLAYER_SPAWN_PROTECTION * GameTimeController.TICKS_PER_SECOND : 0;
    }

    public boolean isSpawnProtected()
    {
        return _protectEndTime > GameTimeController.getGameTicks();
    }

    /**
     * Set protection from agro mobs when getting up from fake death, according settings.
     * @param protect boolean Drop timer or activate it.
     */
    public void setRecentFakeDeath(boolean protect)
    {
        _recentFakeDeathEndTime = protect ? GameTimeController.getGameTicks() + Config.PLAYER_FAKEDEATH_UP_PROTECTION * GameTimeController.TICKS_PER_SECOND : 0;
    }

    public boolean isRecentFakeDeath()
    {
        return _recentFakeDeathEndTime > GameTimeController.getGameTicks();
    }

    public final boolean isFakeDeath()
    {
        return _isFakeDeath;
    }

    public final void setIsFakeDeath(boolean value)
    {
        _isFakeDeath = value;
    }

    @Override
    public final boolean isAlikeDead()
    {
        if (super.isAlikeDead())
            return true;

        return isFakeDeath();
    }

    /**
     * @return The client owner of this char.
     */
    public L2GameClient getClient()
    {
        return _client;
    }

    public void setClient(L2GameClient client)
    {
        _client = client;
    }

    /**
     * Close the active connection with the client.
     * @param closeClient
     */
    private void closeNetConnection(boolean closeClient)
    {
        L2GameClient client = _client;
        if (client != null)
        {
            if (client.isDetached())
                client.cleanMe(true);
            else
            {
                if (!client.getConnection().isClosed())
                {
                    if (closeClient)
                        client.close(LeaveWorld.STATIC_PACKET);
                    else
                        client.close(ServerClose.STATIC_PACKET);
                }
            }
        }
    }

    public Point3D getCurrentSkillWorldPosition()
    {
        return _currentSkillWorldPosition;
    }

    public void setCurrentSkillWorldPosition(Point3D worldPosition)
    {
        _currentSkillWorldPosition = worldPosition;
    }

    /**
     * @see net.sf.l2j.gameserver.model.actor.L2Character#enableSkill(net.sf.l2j.gameserver.model.L2Skill)
     */
    @Override
    public void enableSkill(L2Skill skill)
    {
        super.enableSkill(skill);
        _reuseTimeStamps.remove(skill.getReuseHashCode());
    }

    /**
     * @see net.sf.l2j.gameserver.model.actor.L2Character#checkDoCastConditions(net.sf.l2j.gameserver.model.L2Skill)
     */
    @Override
    protected boolean checkDoCastConditions(L2Skill skill)
    {
        if (!super.checkDoCastConditions(skill))
            return false;

        if (skill.getSkillType() == L2SkillType.SUMMON)
        {
            if (!((L2SkillSummon) skill).isCubic() && (getPet() != null || isMounted()))
            {
                sendPacket(SystemMessageId.SUMMON_ONLY_ONE);
                return false;
            }
        }

        // Can't use Hero and resurrect skills during Olympiad
        if (isInOlympiadMode() && (skill.isHeroSkill() || skill.getSkillType() == L2SkillType.RESURRECT))
        {
            sendPacket(SystemMessage.getSystemMessage(SystemMessageId.THIS_SKILL_IS_NOT_AVAILABLE_FOR_THE_OLYMPIAD_EVENT));
            return false;
        }

        // Check if the spell uses charges
        final int charges = getCharges();
        if (skill.getMaxCharges() == 0 && charges < skill.getNumCharges())
        {
            sendPacket(SystemMessage.getSystemMessage(SystemMessageId.S1_CANNOT_BE_USED).addSkillName(skill));
            return false;
        }

        return true;
    }

    /**
     * Manage actions when a player click on this L2PcInstance.<BR>
     * <BR>
     * <B><U> Actions on first click on the L2PcInstance (Select it)</U> :</B><BR>
     * <BR>
     * <li>Set the target of the player</li> <li>Send MyTargetSelected to the player (display the select window)</li><BR>
     * <BR>
     * <B><U> Actions on second click on the L2PcInstance (Follow it/Attack it/Intercat with it)</U> :</B><BR>
     * <BR>
     * <li>Send MyTargetSelected to the player (display the select window)</li> <li>If this L2PcInstance has a Private Store, notify the player AI with INTERACT</li> <li>If this L2PcInstance is autoAttackable, notify the player AI with ATTACK</li><BR>
     * <BR>
     * <li>If this L2PcInstance is NOT autoAttackable, notify the player AI with FOLLOW</li><BR>
     * <BR>
     * <B><U> Example of use </U> :</B><BR>
     * <BR>
     * <li>Client packet : Action, AttackRequest</li><BR>
     * <BR>
     * @param player The player that start an action on this L2PcInstance
     */
    @Override
    public void onAction(L2PcInstance player)
    {
        // Set the target of the player
        if (player.getTarget() != this)
            player.setTarget(this);
        else
        {
            // Check if this L2PcInstance has a Private Store
            if (isInStoreMode())
            {
                player.getAI().setIntention(CtrlIntention.INTERACT, this);
                return;
            }

            // Check if this L2PcInstance is autoAttackable
            if (isAutoAttackable(player))
            {
                // Player with lvl < 21 can't attack a cursed weapon holder and a cursed weapon holder can't attack players with lvl < 21
                if ((isCursedWeaponEquipped() && player.getLevel() < 21) || (player.isCursedWeaponEquipped() && getLevel() < 21))
                {
                    player.sendPacket(ActionFailed.STATIC_PACKET);
                    return;
                }

                if (Config.GEODATA == 0 || GeoData.getInstance().canSeeTarget(player, this))
                {
                    player.getAI().setIntention(CtrlIntention.ATTACK, this);
                    player.onActionRequest();
                }
            }
            else
            {
                // avoids to stuck when clicking two or more times
                player.sendPacket(ActionFailed.STATIC_PACKET);

                if (player != this && (Config.GEODATA == 0 || GeoData.getInstance().canSeeTarget(player, this)))
                    player.getAI().setIntention(CtrlIntention.FOLLOW, this);
            }
        }
    }

    /**
     * @param barPixels
     * @return true if cp update should be done, false if not
     */
    private boolean needCpUpdate(int barPixels)
    {
        double currentCp = getCurrentCp();

        if (currentCp <= 1.0 || getMaxCp() < barPixels)
            return true;

        if (currentCp <= _cpUpdateDecCheck || currentCp >= _cpUpdateIncCheck)
        {
            if (currentCp == getMaxCp())
            {
                _cpUpdateIncCheck = currentCp + 1;
                _cpUpdateDecCheck = currentCp - _cpUpdateInterval;
            }
            else
            {
                double doubleMulti = currentCp / _cpUpdateInterval;
                int intMulti = (int) doubleMulti;

                _cpUpdateDecCheck = _cpUpdateInterval * (doubleMulti < intMulti ? intMulti-- : intMulti);
                _cpUpdateIncCheck = _cpUpdateDecCheck + _cpUpdateInterval;
            }

            return true;
        }

        return false;
    }

    /**
     * @param barPixels
     * @return true if mp update should be done, false if not
     */
    private boolean needMpUpdate(int barPixels)
    {
        double currentMp = getCurrentMp();

        if (currentMp <= 1.0 || getMaxMp() < barPixels)
            return true;

        if (currentMp <= _mpUpdateDecCheck || currentMp >= _mpUpdateIncCheck)
        {
            if (currentMp == getMaxMp())
            {
                _mpUpdateIncCheck = currentMp + 1;
                _mpUpdateDecCheck = currentMp - _mpUpdateInterval;
            }
            else
            {
                double doubleMulti = currentMp / _mpUpdateInterval;
                int intMulti = (int) doubleMulti;

                _mpUpdateDecCheck = _mpUpdateInterval * (doubleMulti < intMulti ? intMulti-- : intMulti);
                _mpUpdateIncCheck = _mpUpdateDecCheck + _mpUpdateInterval;
            }

            return true;
        }

        return false;
    }

    /**
     * Send packet StatusUpdate with current HP,MP and CP to the L2PcInstance and only current HP, MP and Level to all other L2PcInstance of the Party.<BR>
     * <BR>
     * <B><U> Actions</U> :</B><BR>
     * <BR>
     * <li>Send the Server->Client packet StatusUpdate with current HP, MP and CP to this L2PcInstance</li><BR>
     * <li>Send the Server->Client packet PartySmallWindowUpdate with current HP, MP and Level to all other L2PcInstance of the Party</li><BR>
     * <BR>
     * <FONT COLOR=#FF0000><B> <U>Caution</U> : This method DOESN'T SEND current HP and MP to all L2PcInstance of the _statusListener</B></FONT><BR>
     * <BR>
     */
    @Override
    public void broadcastStatusUpdate()
    {
        // Send the Server->Client packet StatusUpdate with current HP, MP and CP to this L2PcInstance
        StatusUpdate su = new StatusUpdate(this);
        su.addAttribute(StatusUpdate.CUR_HP, (int) getCurrentHp());
        su.addAttribute(StatusUpdate.CUR_MP, (int) getCurrentMp());
        su.addAttribute(StatusUpdate.CUR_CP, (int) getCurrentCp());
        su.addAttribute(StatusUpdate.MAX_CP, getMaxCp());
        sendPacket(su);

        final boolean needCpUpdate = needCpUpdate(352);
        final boolean needHpUpdate = needHpUpdate(352);
        // Check if a party is in progress and party window update is usefull
        L2Party party = _party;
        if (party != null && (needCpUpdate || needHpUpdate || needMpUpdate(352)))
        {
            if (Config.DEBUG)
                _log.fine("Send status for party window of " + getObjectId() + "(" + getName() + ") to his party. CP: " + getCurrentCp() + " HP: " + getCurrentHp() + " MP: " + getCurrentMp());
            // Send the Server->Client packet PartySmallWindowUpdate with current HP, MP and Level to all other L2PcInstance of the Party
            PartySmallWindowUpdate update = new PartySmallWindowUpdate(this);
            party.broadcastToPartyMembers(this, update);
        }

        if (isInOlympiadMode() && isOlympiadStart() && (needCpUpdate || needHpUpdate))
        {
            final OlympiadGameTask game = OlympiadGameManager.getInstance().getOlympiadTask(getOlympiadGameId());
            if (game != null && game.isBattleStarted())
                game.getZone().broadcastStatusUpdate(this);
        }

        // In duel, MP updated only with CP or HP
        if (isInDuel() && (needCpUpdate || needHpUpdate))
        {
            ExDuelUpdateUserInfo update = new ExDuelUpdateUserInfo(this);
            DuelManager.getInstance().broadcastToOppositeTeam(this, update);
        }
    }

    /**
     * Broadcast informations from a user to himself and his knownlist.<BR>
     * If player is morphed, it sends informations from the template the player is using.<BR>
     * <BR>
     * <B><U> Actions</U> :</B><BR>
     * <li>Send a UserInfo packet (public and private data) to this L2PcInstance.</li> <li>Send a CharInfo packet (public data only) to L2PcInstance's knownlist.</li>
     */
    public final void broadcastUserInfo()
    {
        sendPacket(new UserInfo(this));

        if (getPoly().isMorphed())
            Broadcast.toKnownPlayers(this, new AbstractNpcInfo.PcMorphInfo(this, getPoly().getNpcTemplate()));
        else
            broadcastCharInfo();
    }

    public final void broadcastCharInfo()
    {
        for (L2PcInstance player : getKnownList().getKnownType(L2PcInstance.class))
        {
            player.sendPacket(new CharInfo(this));

            final int relation = getRelation(player);
            player.sendPacket(new RelationChanged(this, relation, isAutoAttackable(player)));
            if (getPet() != null)
                player.sendPacket(new RelationChanged(getPet(), relation, isAutoAttackable(player)));
        }
    }

    /**
     * @return the Alliance Identifier of the L2PcInstance.
     */
    public int getAllyId()
    {
        if (_clan == null)
            return 0;

        return _clan.getAllyId();
    }

    public int getAllyCrestId()
    {
        if (getClanId() == 0)
            return 0;

        if (getClan().getAllyId() == 0)
            return 0;

        return getClan().getAllyCrestId();
    }

    /**
     * Send a packet to the L2PcInstance.
     */
    @Override
    public void sendPacket(L2GameServerPacket packet)
    {
        if (_client != null)
            _client.sendPacket(packet);
    }

    /**
     * Send SystemMessage packet.
     * @param id SystemMessageId
     */
    @Override
    public void sendPacket(SystemMessageId id)
    {
        sendPacket(SystemMessage.getSystemMessage(id));
    }

    /**
     * Manage Interact Task with another L2PcInstance.<BR>
     * <BR>
     * Turn the character in front of the target.<BR>
     * In case of private stores, send the related packet.
     * @param target The L2Character targeted
     */
    public void doInteract(L2Character target)
    {
        if (target instanceof L2PcInstance)
        {
            L2PcInstance temp = (L2PcInstance) target;
            sendPacket(new MoveToPawn(this, temp, L2Npc.INTERACTION_DISTANCE));

            switch (temp.getPrivateStoreType())
            {
                case STORE_PRIVATE_SELL:
                case STORE_PRIVATE_PACKAGE_SELL:
                    sendPacket(new PrivateStoreListSell(this, temp));
                    break;

                case STORE_PRIVATE_BUY:
                    sendPacket(new PrivateStoreListBuy(this, temp));
                    break;

                case STORE_PRIVATE_MANUFACTURE:
                    sendPacket(new RecipeShopSellList(this, temp));
                    break;
            }
        }
        else
        {
            // _interactTarget=null should never happen but one never knows ^^;
            if (target != null)
                target.onAction(this);
        }
    }

    /**
     * Manage AutoLoot Task.<BR>
     * <BR>
     * <B><U> Actions</U> :</B><BR>
     * <BR>
     * <li>Send a System Message to the L2PcInstance : YOU_PICKED_UP_S1_ADENA or YOU_PICKED_UP_S1_S2</li> <li>Add the Item to the L2PcInstance inventory</li> <li>Send InventoryUpdate to this L2PcInstance with NewItem (use a new slot) or ModifiedItem (increase amount)</li> <li>Send StatusUpdate to
     * this L2PcInstance with current weight</li><BR>
     * <BR>
     * <FONT COLOR=#FF0000><B> <U>Caution</U> : If a Party is in progress, distribute Items between party members</B></FONT><BR>
     * <BR>
     * @param target The reference Object.
     * @param item The dropped RewardItem.
     */
    public void doAutoLoot(L2Attackable target, L2Attackable.RewardItem item)
    {
        if (isInParty())
            getParty().distributeItem(this, item, false, target);
        else if (item.getItemId() == 57)
            addAdena("Loot", item.getCount(), target, true);
        else
            addItem("Loot", item.getItemId(), item.getCount(), target, true);
    }

    /**
     * Manage Pickup Task.<BR>
     * <BR>
     * <B><U> Actions</U> :</B><BR>
     * <BR>
     * <li>Send StopMove to this L2PcInstance</li> <li>Remove the L2ItemInstance from the world and send server->client GetItem packets</li> <li>Send a System Message to the L2PcInstance : YOU_PICKED_UP_S1_ADENA or YOU_PICKED_UP_S1_S2</li> <li>Add the Item to the L2PcInstance inventory</li> <li>Send
     * InventoryUpdate to this L2PcInstance with NewItem (use a new slot) or ModifiedItem (increase amount)</li> <li>Send StatusUpdate to this L2PcInstance with current weight</li><BR>
     * <BR>
     * <FONT COLOR=#FF0000><B> <U>Caution</U> : If a Party is in progress, distribute Items between party members</B></FONT><BR>
     * <BR>
     * @param object The L2ItemInstance to pick up
     */
    protected void doPickupItem(L2Object object)
    {
        if (isAlikeDead() || isFakeDeath())
            return;

        // Set the AI Intention to IDLE
        getAI().setIntention(CtrlIntention.IDLE);

        // Check if the L2Object to pick up is a L2ItemInstance
        if (!(object instanceof L2ItemInstance))
        {
            // dont try to pickup anything that is not an item :)
            _log.warning(getName() + " tried to pickup a wrong target: " + object);
            return;
        }

        L2ItemInstance target = (L2ItemInstance) object;

        // Send ActionFailed to this L2PcInstance
        sendPacket(ActionFailed.STATIC_PACKET);
        sendPacket(new StopMove(this));

        synchronized (target)
        {
            // Check if the target to pick up is visible
            if (!target.isVisible())
                return;

            if (!target.getDropProtection().tryPickUp(this))
            {
                sendPacket(SystemMessage.getSystemMessage(SystemMessageId.FAILED_TO_PICKUP_S1).addItemName(target.getItemId()));
                return;
            }

            if (((isInParty() && getParty().getLootDistribution() == L2Party.ITEM_LOOTER) || !isInParty()) && !_inventory.validateCapacity(target))
            {
                sendPacket(SystemMessageId.SLOTS_FULL);
                return;
            }

            if (getActiveTradeList() != null)
            {
                sendPacket(SystemMessageId.CANNOT_PICKUP_OR_USE_ITEM_WHILE_TRADING);
                return;
            }

            if (target.getOwnerId() != 0 && target.getOwnerId() != getObjectId() && !isInLooterParty(target.getOwnerId()))
            {
                if (target.getItemId() == 57)
                    sendPacket(SystemMessage.getSystemMessage(SystemMessageId.FAILED_TO_PICKUP_S1_ADENA).addNumber(target.getCount()));
                else if (target.getCount() > 1)
                    sendPacket(SystemMessage.getSystemMessage(SystemMessageId.FAILED_TO_PICKUP_S2_S1_S).addItemName(target).addNumber(target.getCount()));
                else
                    sendPacket(SystemMessage.getSystemMessage(SystemMessageId.FAILED_TO_PICKUP_S1).addItemName(target));

                return;
            }

            if (target.getItemLootShedule() != null && (target.getOwnerId() == getObjectId() || isInLooterParty(target.getOwnerId())))
                target.resetOwnerTimer();

            // Remove the L2ItemInstance from the world and send server->client GetItem packets
            target.pickupMe(this);

            if (Config.SAVE_DROPPED_ITEM) // item must be removed from ItemsOnGroundManager if is active
                ItemsOnGroundManager.getInstance().removeObject(target);
        }

        // Auto use herbs - pick up
        if (target.getItemType() == L2EtcItemType.HERB)
        {
            IItemHandler handler = ItemHandler.getInstance().getItemHandler(target.getEtcItem());
            if (handler != null)
                handler.useItem(this, target, false);

            ItemTable.getInstance().destroyItem("Consume", target, this, null);
        }
        // Cursed Weapons are not distributed
        else if (CursedWeaponsManager.getInstance().isCursed(target.getItemId()))
        {
            addItem("Pickup", target, null, true);
        }
        else
        {
            // if item is instance of L2ArmorType or L2WeaponType broadcast an "Attention" system message
            if (target.getItemType() instanceof L2ArmorType || target.getItemType() instanceof L2WeaponType)
            {
                if (target.getEnchantLevel() > 0)
                {
                    SystemMessage msg = SystemMessage.getSystemMessage(SystemMessageId.ATTENTION_S1_PICKED_UP_S2_S3);
                    msg.addString(getName());
                    msg.addNumber(target.getEnchantLevel());
                    msg.addItemName(target.getItemId());
                    broadcastPacket(msg, 1400);
                }
                else
                {
                    SystemMessage msg = SystemMessage.getSystemMessage(SystemMessageId.ATTENTION_S1_PICKED_UP_S2);
                    msg.addString(getName());
                    msg.addItemName(target.getItemId());
                    broadcastPacket(msg, 1400);
                }
            }

            // Check if a Party is in progress
            if (isInParty())
                getParty().distributeItem(this, target);
            // Target is adena
            else if (target.getItemId() == 57 && getInventory().getAdenaInstance() != null)
            {
                addAdena("Pickup", target.getCount(), null, true);
                ItemTable.getInstance().destroyItem("Pickup", target, this, null);
            }
            // Target is regular item
            else
                addItem("Pickup", target, null, true);
        }
    }

    public boolean canOpenPrivateStore()
    {
        return !isAlikeDead() && !isInOlympiadMode() && !isMounted() && isInsideZone(ZoneId.PRIVATESTORE) && !isCastingNow();
    }

    public void tryOpenPrivateBuyStore()
    {
        if (canOpenPrivateStore())
        {
            if (getPrivateStoreType() == STORE_PRIVATE_BUY || getPrivateStoreType() == STORE_PRIVATE_MANAGE)
                setPrivateStoreType(STORE_PRIVATE_NONE);

            if (getPrivateStoreType() == STORE_PRIVATE_NONE)
            {
                if (isSitting())
                    standUp();

                setPrivateStoreType(STORE_PRIVATE_MANAGE);
                sendPacket(new PrivateStoreManageListBuy(this));
            }
        }
        else
        {
            if (!isInsideZone(ZoneId.PRIVATESTORE))
                sendPacket(SystemMessageId.NO_PRIVATE_STORE_HERE);

            sendPacket(ActionFailed.STATIC_PACKET);
        }
    }

    public void tryOpenPrivateSellStore(boolean isPackageSale)
    {
        if (canOpenPrivateStore())
        {
            if (getPrivateStoreType() == STORE_PRIVATE_SELL || getPrivateStoreType() == STORE_PRIVATE_SELL + 1 || getPrivateStoreType() == STORE_PRIVATE_PACKAGE_SELL)
                setPrivateStoreType(STORE_PRIVATE_NONE);

            if (getPrivateStoreType() == STORE_PRIVATE_NONE)
            {
                if (isSitting())
                    standUp();

                setPrivateStoreType(STORE_PRIVATE_SELL + 1);
                sendPacket(new PrivateStoreManageListSell(this, isPackageSale));
            }
        }
        else
        {
            if (!isInsideZone(ZoneId.PRIVATESTORE))
                sendPacket(SystemMessageId.NO_PRIVATE_STORE_HERE);

            sendPacket(ActionFailed.STATIC_PACKET);
        }
    }

    public void tryOpenWorkshop(boolean isDwarven)
    {
        if (canOpenPrivateStore())
        {
            if (isInStoreMode())
                setPrivateStoreType(STORE_PRIVATE_NONE);

            if (getPrivateStoreType() == STORE_PRIVATE_NONE)
            {
                if (isSitting())
                    standUp();

                if (getCreateList() == null)
                    setCreateList(new L2ManufactureList());

                sendPacket(new RecipeShopManageList(this, isDwarven));
            }
        }
        else
        {
            if (!isInsideZone(ZoneId.PRIVATESTORE))
                sendPacket(SystemMessageId.NO_PRIVATE_WORKSHOP_HERE);

            sendPacket(ActionFailed.STATIC_PACKET);
        }
    }

    /**
     * Set a target.
     * <ul>
     * <li>Remove the L2PcInstance from the _statusListener of the old target if it was a L2Character</li>
     * <li>Add the L2PcInstance to the _statusListener of the new target if it's a L2Character</li>
     * <li>Target the new L2Object (add the target to the L2PcInstance _target, _knownObject and L2PcInstance to _KnownObject of the L2Object)</li>
     * </ul>
     * @param newTarget The L2Object to target
     */
    @Override
    public void setTarget(L2Object newTarget)
    {
        if (newTarget != null)
        {
            boolean isParty = (((newTarget instanceof L2PcInstance) && isInParty() && getParty().getPartyMembers().contains(newTarget)));

            // Check if the new target is visible
            if (!isParty && (!newTarget.isVisible() || Math.abs(newTarget.getZ() - getZ()) > 1000))
                newTarget = null;
        }

        // Can't target and attack festival monsters if not participant
        if ((newTarget instanceof L2FestivalMonsterInstance) && !isFestivalParticipant())
            newTarget = null;
        // Can't target and attack rift invaders if not in the same room
        else if (isInParty() && getParty().isInDimensionalRift())
        {
            byte riftType = getParty().getDimensionalRift().getType();
            byte riftRoom = getParty().getDimensionalRift().getCurrentRoom();

            if (newTarget != null && !DimensionalRiftManager.getInstance().getRoom(riftType, riftRoom).checkIfInZone(newTarget.getX(), newTarget.getY(), newTarget.getZ()))
                newTarget = null;
        }

        // Get the current target
        L2Object oldTarget = getTarget();

        if (oldTarget != null)
        {
            if (oldTarget.equals(newTarget))
                return; // no target change

            // Remove the L2PcInstance from the _statusListener of the old target if it was a L2Character
            if (oldTarget instanceof L2Character)
                ((L2Character) oldTarget).removeStatusListener(this);
        }

        // Add the L2PcInstance to the _statusListener of the new target if it's a L2Character
        if (newTarget instanceof L2Character)
        {
            final L2Character target = (L2Character) newTarget;

            target.addStatusListener(this);

            // Show the client his new target.
            if (target.isAutoAttackable(this))
            {
                // Show the client his new target.
                sendPacket(new MyTargetSelected(target.getObjectId(), getLevel() - target.getLevel()));

                // Send max/current hp.
                final StatusUpdate su = new StatusUpdate(target);
                su.addAttribute(StatusUpdate.MAX_HP, target.getMaxHp());
                su.addAttribute(StatusUpdate.CUR_HP, (int) target.getCurrentHp());
                sendPacket(su);
            }
            else
                sendPacket(new MyTargetSelected(target.getObjectId(), 0));

            Broadcast.toKnownPlayers(this, new TargetSelected(getObjectId(), newTarget.getObjectId(), getX(), getY(), getZ()));
        }

        if (newTarget == null && getTarget() != null)
        {
            broadcastPacket(new TargetUnselected(this));
            setCurrentFolkNPC(null);
        }
        else
        {
            // Rehabilitates that useful check.
            if (newTarget instanceof L2NpcInstance)
                setCurrentFolkNPC((L2Npc) newTarget);
        }

        // Target the new L2Object (add the target to the L2PcInstance _target, _knownObject and L2PcInstance to _KnownObject of the L2Object)
        super.setTarget(newTarget);
    }

    /**
     * Return the active weapon instance (always equipped in the right hand).<BR>
     * <BR>
     */
    @Override
    public L2ItemInstance getActiveWeaponInstance()
    {
        return getInventory().getPaperdollItem(Inventory.PAPERDOLL_RHAND);
    }

    /**
     * Return the active weapon item (always equipped in the right hand).<BR>
     * <BR>
     */
    @Override
    public L2Weapon getActiveWeaponItem()
    {
        L2ItemInstance weapon = getActiveWeaponInstance();

        if (weapon == null)
            return getFistsWeaponItem();

        return (L2Weapon) weapon.getItem();
    }

    public L2ItemInstance getChestArmorInstance()
    {
        return getInventory().getPaperdollItem(Inventory.PAPERDOLL_CHEST);
    }

    public L2Armor getActiveChestArmorItem()
    {
        L2ItemInstance armor = getChestArmorInstance();

        if (armor == null)
            return null;

        return (L2Armor) armor.getItem();
    }

    public boolean isWearingHeavyArmor()
    {
        L2ItemInstance armor = getChestArmorInstance();

        if ((L2ArmorType) armor.getItemType() == L2ArmorType.HEAVY)
            return true;

        return false;
    }

    public boolean isWearingLightArmor()
    {
        L2ItemInstance armor = getChestArmorInstance();

        if ((L2ArmorType) armor.getItemType() == L2ArmorType.LIGHT)
            return true;

        return false;
    }

    public boolean isWearingMagicArmor()
    {
        L2ItemInstance armor = getChestArmorInstance();

        if ((L2ArmorType) armor.getItemType() == L2ArmorType.MAGIC)
            return true;

        return false;
    }

    public boolean isMarried()
    {
        return _married;
    }

    public void setMarried(boolean state)
    {
        _married = state;
    }

    public void setUnderMarryRequest(boolean state)
    {
        _marryrequest = state;
    }

    public boolean isUnderMarryRequest()
    {
        return _marryrequest;
    }

    public int getCoupleId()
    {
        return _coupleId;
    }

    public void setCoupleId(int coupleId)
    {
        _coupleId = coupleId;
    }

    public void setRequesterId(int requesterId)
    {
        _requesterId = requesterId;
    }

    public void EngageAnswer(int answer)
    {
        if (!_marryrequest || _requesterId == 0)
            return;

        L2PcInstance ptarget = L2World.getInstance().getPlayer(_requesterId);
        if (ptarget != null)
        {
            if (answer == 1)
            {
                // Create the couple
                CoupleManager.getInstance().createCouple(ptarget, this);

                // Then "finish the job"
                L2WeddingManagerInstance.justMarried(ptarget, this);
            }
            else
            {
                setUnderMarryRequest(false);
                sendMessage("You declined your partner's marriage request.");

                ptarget.setUnderMarryRequest(false);
                ptarget.sendMessage("Your partner declined your marriage request.");
            }
        }
    }

    /**
     * Return the secondary weapon instance (always equipped in the left hand).<BR>
     * <BR>
     */
    @Override
    public L2ItemInstance getSecondaryWeaponInstance()
    {
        return getInventory().getPaperdollItem(Inventory.PAPERDOLL_LHAND);
    }

    /**
     * Return the secondary L2Item item (always equiped in the left hand).<BR>
     * Arrows, shield,...<BR>
     */
    @Override
    public L2Item getSecondaryWeaponItem()
    {
        L2ItemInstance item = getInventory().getPaperdollItem(Inventory.PAPERDOLL_LHAND);
        if (item != null)
            return item.getItem();

        return null;
    }

    /**
     * Kill the L2Character, Apply Death Penalty, Manage gain/loss Karma and Item Drop.<BR>
     * <BR>
     * <B><U> Actions</U> :</B><BR>
     * <BR>
     * <li>Reduce the Experience of the L2PcInstance in function of the calculated Death Penalty</li> <li>If necessary, unsummon the Pet of the killed L2PcInstance</li> <li>Manage Karma gain for attacker and Karam loss for the killed L2PcInstance</li> <li>If the killed L2PcInstance has Karma, manage
     * Drop Item</li> <li>Kill the L2PcInstance</li><BR>
     * <BR>
     * @param killer The L2Character who attacks
     */
    @Override
    public boolean doDie(L2Character killer)
    {
        // Kill the L2PcInstance
        if (!super.doDie(killer))
            return false;

        if (isMounted())
            stopFeed();

        synchronized (this)
        {
            if (isFakeDeath())
                stopFakeDeath(true);
        }

        if (killer != null)
        {
            L2PcInstance pk = killer.getActingPlayer();

            // Clear resurrect xp calculation
            setExpBeforeDeath(0);

            if (isCursedWeaponEquipped())
                CursedWeaponsManager.getInstance().drop(_cursedWeaponEquippedId, killer);
            else
            {
                if (pk == null || !pk.isCursedWeaponEquipped())
                {
                    onDieDropItem(killer); // Check if any item should be dropped

                    // if the area isn't an arena
                    if (!isInArena())
                    {
                        // if both victim and attacker got clans & aren't academicians
                        if (pk != null && pk.getClan() != null && getClan() != null && !isAcademyMember() && !pk.isAcademyMember())
                        {
                            // if clans got mutual war, then use the reputation calcul
                            if (_clan.isAtWarWith(pk.getClanId()) && pk.getClan().isAtWarWith(_clan.getClanId()))
                            {
                                if (AntiFeedManager.getInstance().check(killer, this))
                                {
                                    // when your reputation score is 0 or below, the other clan cannot acquire any reputation points
                                    if (getClan().getReputationScore() > 0)
                                        pk.getClan().addReputationScore(1);
                                    // when the opposing sides reputation score is 0 or below, your clans reputation score doesn't decrease
                                    if (pk.getClan().getReputationScore() > 0)
                                        _clan.takeReputationScore(1);
                                }
                            }
                        }
                    }

                    // Reduce player's xp and karma.
                    if (Config.ALT_GAME_DELEVEL && (getSkillLevel(L2Skill.SKILL_LUCKY) < 0 || getStat().getLevel() > 9))
                        deathPenalty(pk != null && getClan() != null && (getClan().isAtWarWith(pk.getClanId()) || pk.getClan().isAtWarWith(getClanId())), pk != null, killer instanceof L2SiegeGuardInstance);
                }
            }
        }

        // Unsummon Cubics
        if (!_cubics.isEmpty())
        {
            for (L2CubicInstance cubic : _cubics.values())
            {
                cubic.stopAction();
                cubic.cancelDisappear();
            }

            _cubics.clear();
        }

        if (_fusionSkill != null)
            abortCast();

        for (L2Character character : getKnownList().getKnownType(L2Character.class))
            if (character.getFusionSkill() != null && character.getFusionSkill().getTarget() == this)
                character.abortCast();

        if (isInParty() && getParty().isInDimensionalRift())
            getParty().getDimensionalRift().getDeadMemberList().add(this);

        // calculate death penalty buff
        calculateDeathPenaltyBuffLevel(killer);

        stopWaterTask();

        AntiFeedManager.getInstance().setLastDeathTime(getObjectId());

        if (isPhoenixBlessed() || (isAffected(L2EffectFlag.CHARM_OF_COURAGE) && isInSiege()))
            reviveRequest(this, null, false);

        // Icons update in order to get retained buffs list
        updateEffectIcons();

        return true;
    }

    private void onDieDropItem(L2Character killer)
    {
        if (killer == null)
            return;

        L2PcInstance pk = killer.getActingPlayer();
        if (getKarma() <= 0 && pk != null && pk.getClan() != null && getClan() != null && pk.getClan().isAtWarWith(getClanId()))
            return;

        if ((!isInsideZone(ZoneId.PVP) || pk == null) && (!isGM() || Config.KARMA_DROP_GM))
        {
            boolean isKillerNpc = (killer instanceof L2Npc);
            int pkLimit = Config.KARMA_PK_LIMIT;

            int dropEquip = 0;
            int dropEquipWeapon = 0;
            int dropItem = 0;
            int dropLimit = 0;
            int dropPercent = 0;

            if (getKarma() > 0 && getPkKills() >= pkLimit)
            {
                dropPercent = Config.KARMA_RATE_DROP;
                dropEquip = Config.KARMA_RATE_DROP_EQUIP;
                dropEquipWeapon = Config.KARMA_RATE_DROP_EQUIP_WEAPON;
                dropItem = Config.KARMA_RATE_DROP_ITEM;
                dropLimit = Config.KARMA_DROP_LIMIT;
            }
            else if (isKillerNpc && getLevel() > 4 && !isFestivalParticipant())
            {
                dropPercent = Config.PLAYER_RATE_DROP;
                dropEquip = Config.PLAYER_RATE_DROP_EQUIP;
                dropEquipWeapon = Config.PLAYER_RATE_DROP_EQUIP_WEAPON;
                dropItem = Config.PLAYER_RATE_DROP_ITEM;
                dropLimit = Config.PLAYER_DROP_LIMIT;
            }

            if (dropPercent > 0 && Rnd.get(100) < dropPercent)
            {
                int dropCount = 0;
                int itemDropPercent = 0;

                for (L2ItemInstance itemDrop : getInventory().getItems())
                {
                    // Don't drop those following things
                    if (!itemDrop.isDropable() || itemDrop.isShadowItem() || itemDrop.getItemId() == 57 || itemDrop.getItem().getType2() == L2Item.TYPE2_QUEST || getPet() != null && getPet().getControlItemId() == itemDrop.getItemId() || Arrays.binarySearch(Config.KARMA_LIST_NONDROPPABLE_ITEMS, itemDrop.getItemId()) >= 0 || Arrays.binarySearch(Config.KARMA_LIST_NONDROPPABLE_PET_ITEMS, itemDrop.getItemId()) >= 0)
                        continue;

                    if (itemDrop.isEquipped())
                    {
                        // Set proper chance according to Item type of equipped Item
                        itemDropPercent = itemDrop.getItem().getType2() == L2Item.TYPE2_WEAPON ? dropEquipWeapon : dropEquip;
                        getInventory().unEquipItemInSlot(itemDrop.getLocationSlot());
                    }
                    else
                        itemDropPercent = dropItem; // Item in inventory

                    // NOTE: Each time an item is dropped, the chance of another item being dropped gets lesser (dropCount * 2)
                    if (Rnd.get(100) < itemDropPercent)
                    {
                        dropItem("DieDrop", itemDrop, killer, true);

                        if (++dropCount >= dropLimit)
                            break;
                    }
                }
            }
        }
    }

    public void updateKarmaLoss(long exp)
    {
        if (!isCursedWeaponEquipped() && getKarma() > 0)
        {
            int karmaLost = Formulas.calculateKarmaLost(getLevel(), Math.round(exp));
            if (karmaLost > 0)
                setKarma(getKarma() - karmaLost);
        }
    }

    /**
     * This method is used to update PvP counter, or PK counter / add Karma if necessary.<br>
     * It also updates clan kills/deaths counters on siege.
     * @param target The L2Playable victim.
     */
    public void onKillUpdatePvPKarma(L2Playable target)
    {
        if (target == null)
            return;

        final L2PcInstance targetPlayer = target.getActingPlayer();
        if (targetPlayer == null || targetPlayer == this)
            return;

        // Don't rank up the CW if it was a summon.
        if (isCursedWeaponEquipped() && target instanceof L2PcInstance)
        {
            CursedWeaponsManager.getInstance().increaseKills(_cursedWeaponEquippedId);
            return;
        }

        // If in duel and you kill (only can kill l2summon), do nothing
        if (isInDuel() && targetPlayer.isInDuel())
            return;

        // If in pvp zone, do nothing.
        if (isInsideZone(ZoneId.PVP) && targetPlayer.isInsideZone(ZoneId.PVP))
        {
            // Until the zone was a siege zone. Check also if victim was a player. Randomers aren't counted.
            if (target instanceof L2PcInstance && getSiegeState() > 0 && targetPlayer.getSiegeState() > 0 && getSiegeState() != targetPlayer.getSiegeState())
            {
                // Now check clan relations.
                final L2Clan killerClan = getClan();
                if (killerClan != null)
                    killerClan.setSiegeKills(killerClan.getSiegeKills() + 1);

                final L2Clan targetClan = targetPlayer.getClan();
                if (targetClan != null)
                    targetClan.setSiegeDeaths(targetClan.getSiegeDeaths() + 1);
            }
            return;
        }

        // Check if it's pvp (cases : regular, wars, victim is PKer)
        if (checkIfPvP(target) || (targetPlayer.getClan() != null && getClan() != null && getClan().isAtWarWith(targetPlayer.getClanId()) && targetPlayer.getClan().isAtWarWith(getClanId()) && targetPlayer.getPledgeType() != L2Clan.SUBUNIT_ACADEMY && getPledgeType() != L2Clan.SUBUNIT_ACADEMY) || (targetPlayer.getKarma() > 0 && Config.KARMA_AWARD_PK_KILL))
        {
            if (target instanceof L2PcInstance && AntiFeedManager.getInstance().check(this, target))
            {
                // Add PvP point to attacker.
                setPvpKills(getPvpKills() + 1);

                if (Config.ALLOW_PVP_REWARD)
                {
                   for (int[] item : Config.PVP_REWARD_ITEM)
                    addItem("", item[0], item[1], this, true);
                    sendMessage("You will be rewarded for pvp kill!");
                }

                // Send a Server->Client UserInfo packet to attacker with its Karma and PK Counter
                sendPacket(new UserInfo(this));
            }
        }

        // Otherwise, killer is considered as a PKer.
        else if (targetPlayer.getKarma() == 0 && targetPlayer.getPvpFlag() == 0)
        {
            // PK Points are increased only if you kill a player.
            if (target instanceof L2PcInstance)
                setPkKills(getPkKills() + 1);

            if (Config.ALLOW_PK_REWARD)
            {
                       for (int[] item : Config.PK_REWARD_ITEM)
                       addItem("", item[0], item[1], this, true);
                       sendMessage("You will be rewarded for pk kill!");
            }
            // Calculate new karma.
            setKarma(getKarma() + Formulas.calculateKarmaGain(getPkKills(), target instanceof L2Summon));

            // Send a Server->Client UserInfo packet to attacker with its Karma and PK Counter
            sendPacket(new UserInfo(this));
        }
    }

    public void updatePvPStatus()
    {
        if (isInsideZone(ZoneId.PVP))
            return;

        PvpFlagTaskManager.getInstance().addPvpFlagTask(this, System.currentTimeMillis() + Config.PVP_NORMAL_TIME);

        if (getPvpFlag() == 0)
            updatePvPFlag(1);
    }

    public void updatePvPStatus(L2Character target)
    {
        final L2PcInstance player = target.getActingPlayer();
        if (player == null)
            return;

        if (isInDuel() && player.getDuelId() == getDuelId())
            return;

        if ((!isInsideZone(ZoneId.PVP) || !target.isInsideZone(ZoneId.PVP)) && player.getKarma() == 0)
        {
            PvpFlagTaskManager.getInstance().addPvpFlagTask(this, System.currentTimeMillis() + ((checkIfPvP(player)) ? Config.PVP_PVP_TIME : Config.PVP_NORMAL_TIME));

            if (getPvpFlag() == 0)
                updatePvPFlag(1);
        }
    }

    /**
     * Restore the experience this L2PcInstance has lost and sends a Server->Client StatusUpdate packet.
     * @param restorePercent The specified % of restored experience.
     */
    public void restoreExp(double restorePercent)
    {
        if (getExpBeforeDeath() > 0)
        {
            getStat().addExp((int) Math.round((getExpBeforeDeath() - getExp()) * restorePercent / 100));
            setExpBeforeDeath(0);
        }
    }

    /**
     * Reduce the Experience (and level if necessary) of the L2PcInstance in function of the calculated Death Penalty.
     * <ul>
     * <li>Calculate the Experience loss</li>
     * <li>Set the value of _expBeforeDeath</li>
     * <li>Set the new Experience value of the L2PcInstance and Decrease its level if necessary</li>
     * <li>Send a Server->Client StatusUpdate packet with its new Experience</li>
     * </ul>
     * @param atWar If true, use clan war penalty system instead of regular system.
     * @param killedByPlayable Used to see if victim loses XP or not.
     * @param killedBySiegeNpc Used to see if victim loses XP or not.
     */
    public void deathPenalty(boolean atWar, boolean killedByPlayable, boolean killedBySiegeNpc)
    {
        // No xp loss inside pvp zone unless
        // - it's a siege zone and you're NOT participating
        // - you're killed by a non-pc whose not belong to the siege
        if (isInsideZone(ZoneId.PVP))
        {
            // No xp loss for siege participants inside siege zone.
            if (isInsideZone(ZoneId.SIEGE))
            {
                if (isInSiege() && (killedByPlayable || killedBySiegeNpc))
                    return;
            }
            // No xp loss for arenas participants killed by playable.
            else if (killedByPlayable)
                return;
        }

        // Get the level of the L2PcInstance
        final int lvl = getLevel();

        // The death steal you some Exp
        double percentLost = 7.0;
        if (getLevel() >= 76)
            percentLost = 2.0;
        else if (getLevel() >= 40)
            percentLost = 4.0;

        if (getKarma() > 0)
            percentLost *= Config.RATE_KARMA_EXP_LOST;

        if (isFestivalParticipant() || atWar || isInsideZone(ZoneId.SIEGE))
            percentLost /= 4.0;

        // Calculate the Experience loss
        long lostExp = 0;

        if (lvl < Experience.MAX_LEVEL)
            lostExp = Math.round((getStat().getExpForLevel(lvl + 1) - getStat().getExpForLevel(lvl)) * percentLost / 100);
        else
            lostExp = Math.round((getStat().getExpForLevel(Experience.MAX_LEVEL) - getStat().getExpForLevel(Experience.MAX_LEVEL - 1)) * percentLost / 100);

        // Get the Experience before applying penalty
        setExpBeforeDeath(getExp());

        if (Config.DEBUG)
            _log.fine(getName() + " died and lost " + lostExp + " experience.");

        // Set new karma
        updateKarmaLoss(lostExp);

        // Set the new Experience value of the L2PcInstance
        getStat().addExp(-lostExp);
    }

    public boolean isPartyWaiting()
    {
        return PartyMatchWaitingList.getInstance().getPlayers().contains(this);
    }

    public void setPartyRoom(int id)
    {
        _partyroom = id;
    }

    public int getPartyRoom()
    {
        return _partyroom;
    }

    public boolean isInPartyMatchRoom()
    {
        return _partyroom > 0;
    }

    /**
     * Manage the increase level task of a L2PcInstance (Max MP, Max MP, Recommandation, Expertise and beginner skills...).<BR>
     * <BR>
     * <B><U> Actions</U> :</B><BR>
     * <BR>
     * <li>Send a Server->Client System Message to the L2PcInstance : YOU_INCREASED_YOUR_LEVEL</li> <li>Send StatusUpdate to the L2PcInstance with new LEVEL, MAX_HP and MAX_MP</li> <li>Set the current HP and MP of the L2PcInstance, Launch/Stop a HP/MP/CP Regeneration Task and send StatusUpdate
     * packet to all other L2PcInstance to inform (exclusive broadcast)</li> <li>Recalculate the party level</li> <li>Recalculate the number of Recommandation that the L2PcInstance can give</li> <li>Give Expertise skill of this level and remove beginner Lucky skill</li><BR>
     * <BR>
     */
    public void increaseLevel()
    {
        // Set the current HP and MP of the L2Character, Launch/Stop a HP/MP/CP Regeneration Task and send StatusUpdate packet to all other L2PcInstance to inform (exclusive broadcast)
        setCurrentHpMp(getMaxHp(), getMaxMp());
        setCurrentCp(getMaxCp());
    }

    /**
     * Stop all timers related to that L2PcInstance.
     */
    public void stopAllTimers()
    {
        stopHpMpRegeneration();
        stopWaterTask();
        stopFeed();
        clearPetData();
        storePetFood(_mountNpcId);
        stopPunishTask(true);
        stopChargeTask();
        getInventory().stopShadowTimers();

        AttackStanceTaskManager.getInstance().removeAttackStanceTask(this);
        PvpFlagTaskManager.getInstance().removePvpFlagTask(this);
        TakeBreakTaskManager.getInstance().removeTakeBreakTask(this);
    }

    /**
     * Return the L2Summon of the L2PcInstance or null.
     */
    @Override
    public L2Summon getPet()
    {
        return _summon;
    }

    /**
     * @return {@code true} if the player has a pet, {@code false} otherwise
     */
    public boolean hasPet()
    {
        return _summon instanceof L2PetInstance;
    }

    /**
     * @return {@code true} if the player has a summon, {@code false} otherwise
     */
    public boolean hasServitor()
    {
        return _summon instanceof L2SummonInstance;
    }

    /**
     * Set the L2Summon of the L2PcInstance.
     * @param summon The Object.
     */
    public void setPet(L2Summon summon)
    {
        _summon = summon;
    }

    /**
     * @return the L2TamedBeast of the L2PcInstance or null.
     */
    public L2TamedBeastInstance getTrainedBeast()
    {
        return _tamedBeast;
    }

    /**
     * Set the L2TamedBeast of the L2PcInstance.
     * @param tamedBeast The Object.
     */
    public void setTrainedBeast(L2TamedBeastInstance tamedBeast)
    {
        _tamedBeast = tamedBeast;
    }

    /**
     * @return the L2PcInstance requester of a transaction (ex : FriendInvite, JoinAlly, JoinParty...).
     */
    public L2Request getRequest()
    {
        return _request;
    }

    /**
     * Set the L2PcInstance requester of a transaction (ex : FriendInvite, JoinAlly, JoinParty...).
     * @param requester
     */
    public void setActiveRequester(L2PcInstance requester)
    {
        _activeRequester = requester;
    }

    /**
     * @return the L2PcInstance requester of a transaction (ex : FriendInvite, JoinAlly, JoinParty...).
     */
    public L2PcInstance getActiveRequester()
    {
        L2PcInstance requester = _activeRequester;
        if (requester != null)
        {
            if (requester.isRequestExpired() && _activeTradeList == null)
                _activeRequester = null;
        }
        return _activeRequester;
    }

    /**
     * @return True if a request is in progress.
     */
    public boolean isProcessingRequest()
    {
        return getActiveRequester() != null || _requestExpireTime > GameTimeController.getGameTicks();
    }

    /**
     * @return True if a transaction <B>(trade OR request)</B> is in progress.
     */
    public boolean isProcessingTransaction()
    {
        return getActiveRequester() != null || _activeTradeList != null || _requestExpireTime > GameTimeController.getGameTicks();
    }

    /**
     * Set the _requestExpireTime of that L2PcInstance, and set his partner as the active requester.
     * @param partner The partner to make checks on.
     */
    public void onTransactionRequest(L2PcInstance partner)
    {
        _requestExpireTime = GameTimeController.getGameTicks() + REQUEST_TIMEOUT * GameTimeController.TICKS_PER_SECOND;
        partner.setActiveRequester(this);
    }

    /**
     * @return true if last request is expired.
     */
    public boolean isRequestExpired()
    {
        return !(_requestExpireTime > GameTimeController.getGameTicks());
    }

    /**
     * Select the Warehouse to be used in next activity.
     */
    public void onTransactionResponse()
    {
        _requestExpireTime = 0;
    }

    /**
     * Select the Warehouse to be used in next activity.
     * @param warehouse An active warehouse.
     */
    public void setActiveWarehouse(ItemContainer warehouse)
    {
        _activeWarehouse = warehouse;
    }

    /**
     * @return The active Warehouse.
     */
    public ItemContainer getActiveWarehouse()
    {
        return _activeWarehouse;
    }

    /**
     * Set the TradeList to be used in next activity.
     * @param tradeList The TradeList to be used.
     */
    public void setActiveTradeList(TradeList tradeList)
    {
        _activeTradeList = tradeList;
    }

    /**
     * @return The active TradeList.
     */
    public TradeList getActiveTradeList()
    {
        return _activeTradeList;
    }

    public void onTradeStart(L2PcInstance partner)
    {
        _activeTradeList = new TradeList(this);
        _activeTradeList.setPartner(partner);

        sendPacket(SystemMessage.getSystemMessage(SystemMessageId.BEGIN_TRADE_WITH_S1).addString(partner.getName()));
        sendPacket(new TradeStart(this));
    }

    public void onTradeConfirm(L2PcInstance partner)
    {
        sendPacket(SystemMessage.getSystemMessage(SystemMessageId.S1_CONFIRMED_TRADE).addString(partner.getName()));

        partner.sendPacket(TradePressOwnOk.STATIC_PACKET);
        sendPacket(TradePressOtherOk.STATIC_PACKET);
    }

    public void onTradeCancel(L2PcInstance partner)
    {
        if (_activeTradeList == null)
            return;

        _activeTradeList.lock();
        _activeTradeList = null;

        sendPacket(new SendTradeDone(0));
        SystemMessage msg = SystemMessage.getSystemMessage(SystemMessageId.S1_CANCELED_TRADE);
        msg.addString(partner.getName());
        sendPacket(msg);
    }

    public void onTradeFinish(boolean successfull)
    {
        _activeTradeList = null;
        sendPacket(new SendTradeDone(1));
        if (successfull)
            sendPacket(SystemMessageId.TRADE_SUCCESSFUL);
    }

    public void startTrade(L2PcInstance partner)
    {
        onTradeStart(partner);
        partner.onTradeStart(this);
    }

    public void cancelActiveTrade()
    {
        if (_activeTradeList == null)
            return;

        L2PcInstance partner = _activeTradeList.getPartner();
        if (partner != null)
            partner.onTradeCancel(this);

        onTradeCancel(this);
    }

    /**
     * @return The _createList object of the L2PcInstance.
     */
    public L2ManufactureList getCreateList()
    {
        return _createList;
    }

    /**
     * Set the _createList object of the L2PcInstance.
     * @param list
     */
    public void setCreateList(L2ManufactureList list)
    {
        _createList = list;
    }

    /**
     * @return The _sellList object of the L2PcInstance.
     */
    public TradeList getSellList()
    {
        if (_sellList == null)
            _sellList = new TradeList(this);

        return _sellList;
    }

    /**
     * @return the _buyList object of the L2PcInstance.
     */
    public TradeList getBuyList()
    {
        if (_buyList == null)
            _buyList = new TradeList(this);

        return _buyList;
    }

    /**
     * Set the Private Store type of the L2PcInstance.
     * @param type The value : 0 = none, 1 = sell, 2 = sellmanage, 3 = buy, 4 = buymanage, 5 = manufacture.
     */
    public void setPrivateStoreType(int type)
    {
        _privateStore = type;

        if (Config.OFFLINE_DISCONNECT_FINISHED && _privateStore == STORE_PRIVATE_NONE && inOfflineShopMode() && (getClient() == null || getClient().isDetached()))
        {
            deleteMe();
        }
    }

    /**
     * @return The Private Store type of the L2PcInstance.
     */
    public int getPrivateStoreType()
    {
        return _privateStore;
    }

    /**
     * Set the _skillLearningClassId object of the L2PcInstance.
     * @param classId The parameter.
     */
    public void setSkillLearningClassId(ClassId classId)
    {
        _skillLearningClassId = classId;
    }

    /**
     * @return The _skillLearningClassId object of the L2PcInstance.
     */
    public ClassId getSkillLearningClassId()
    {
        return _skillLearningClassId;
    }

    /**
     * Set the _clan object, _clanId, _clanLeader Flag and title of the L2PcInstance.
     * @param clan The Clan object which is used to feed L2PcInstance values.
     */
    public void setClan(L2Clan clan)
    {
        _clan = clan;
        setTitle("");

        if (clan == null)
        {
            _clanId = 0;
            _clanPrivileges = 0;
            _pledgeType = 0;
            _powerGrade = 0;
            _lvlJoinedAcademy = 0;
            _apprentice = 0;
            _sponsor = 0;
            return;
        }

        if (!clan.isMember(getObjectId()))
        {
            // char has been kicked from clan
            setClan(null);
            return;
        }

        _clanId = clan.getClanId();
    }

    /**
     * @return The _clan object of the L2PcInstance.
     */
    public L2Clan getClan()
    {
        return _clan;
    }

    /**
     * @return True if the L2PcInstance is the leader of its clan.
     */
    public boolean isClanLeader()
    {
        if (getClan() == null)
            return false;

        return getObjectId() == getClan().getLeaderId();
    }

    /**
     * Reduce the number of arrows owned by the L2PcInstance and send it Server->Client Packet InventoryUpdate or ItemList (to unequip if the last arrow was consummed).<BR>
     * <BR>
     */
    @Override
    protected void reduceArrowCount()
    {
        L2ItemInstance arrows = getInventory().getPaperdollItem(Inventory.PAPERDOLL_LHAND);

        if (arrows == null)
        {
            getInventory().unEquipItemInSlot(Inventory.PAPERDOLL_LHAND);
            _arrowItem = null;
            sendPacket(new ItemList(this, false));
            return;
        }

        // Adjust item quantity
        if (arrows.getCount() > 1)
        {
            synchronized (arrows)
            {
                arrows.changeCountWithoutTrace(-1, this, null);
                arrows.setLastChange(L2ItemInstance.MODIFIED);

                // could do also without saving, but let's save approx 1 of 10
                if (GameTimeController.getGameTicks() % 10 == 0)
                    arrows.updateDatabase();
                _inventory.refreshWeight();
            }
        }
        else
        {
            // Destroy entire item and save to database
            _inventory.destroyItem("Consume", arrows, this, null);

            getInventory().unEquipItemInSlot(Inventory.PAPERDOLL_LHAND);
            _arrowItem = null;

            if (Config.DEBUG)
                _log.fine("removed arrows count");

            sendPacket(new ItemList(this, false));
            return;
        }

        InventoryUpdate iu = new InventoryUpdate();
        iu.addModifiedItem(arrows);
        sendPacket(iu);
    }

    /**
     * Equip arrows needed in left hand and send ItemList to the L2PcINstance then return True.<BR>
     * <BR>
     */
    @Override
    protected boolean checkAndEquipArrows()
    {
        // Check if nothing is equipped in left hand
        if (getInventory().getPaperdollItem(Inventory.PAPERDOLL_LHAND) == null)
        {
            // Get the L2ItemInstance of the arrows needed for this bow
            _arrowItem = getInventory().findArrowForBow(getActiveWeaponItem());

            if (_arrowItem != null)
            {
                // Equip arrows needed in left hand
                getInventory().setPaperdollItem(Inventory.PAPERDOLL_LHAND, _arrowItem);

                // Send ItemList to this L2PcINstance to update left hand equipement
                ItemList il = new ItemList(this, false);
                sendPacket(il);
            }
        }
        else
        {
            // Get the L2ItemInstance of arrows equipped in left hand
            _arrowItem = getInventory().getPaperdollItem(Inventory.PAPERDOLL_LHAND);
        }

        return _arrowItem != null;
    }

    /**
     * Disarm the player's weapon and shield.
     * @return true if successful, false otherwise.
     */
    public boolean disarmWeapons()
    {
        // Don't allow disarming a cursed weapon
        if (isCursedWeaponEquipped())
            return false;

        // Unequip the weapon
        L2ItemInstance wpn = getInventory().getPaperdollItem(Inventory.PAPERDOLL_RHAND);
        if (wpn != null)
        {
            L2ItemInstance[] unequipped = getInventory().unEquipItemInBodySlotAndRecord(wpn.getItem().getBodyPart());
            InventoryUpdate iu = new InventoryUpdate();
            for (L2ItemInstance itm : unequipped)
                iu.addModifiedItem(itm);
            sendPacket(iu);

            abortAttack();
            broadcastUserInfo();

            // this can be 0 if the user pressed the right mousebutton twice very fast
            if (unequipped.length > 0)
            {
                SystemMessage sm;
                if (unequipped[0].getEnchantLevel() > 0)
                    sm = SystemMessage.getSystemMessage(SystemMessageId.EQUIPMENT_S1_S2_REMOVED).addNumber(unequipped[0].getEnchantLevel()).addItemName(unequipped[0]);
                else
                    sm = SystemMessage.getSystemMessage(SystemMessageId.S1_DISARMED).addItemName(unequipped[0]);

                sendPacket(sm);
            }
        }

        // Unequip the shield
        L2ItemInstance sld = getInventory().getPaperdollItem(Inventory.PAPERDOLL_LHAND);
        if (sld != null)
        {
            L2ItemInstance[] unequipped = getInventory().unEquipItemInBodySlotAndRecord(sld.getItem().getBodyPart());
            InventoryUpdate iu = new InventoryUpdate();
            for (L2ItemInstance itm : unequipped)
                iu.addModifiedItem(itm);
            sendPacket(iu);

            abortAttack();
            broadcastUserInfo();

            // this can be 0 if the user pressed the right mousebutton twice very fast
            if (unequipped.length > 0)
            {
                SystemMessage sm;
                if (unequipped[0].getEnchantLevel() > 0)
                    sm = SystemMessage.getSystemMessage(SystemMessageId.EQUIPMENT_S1_S2_REMOVED).addNumber(unequipped[0].getEnchantLevel()).addItemName(unequipped[0]);
                else
                    sm = SystemMessage.getSystemMessage(SystemMessageId.S1_DISARMED).addItemName(unequipped[0]);

                sendPacket(sm);
            }
        }
        return true;
    }

    public boolean mount(L2Summon pet)
    {
        if (!disarmWeapons())
            return false;

        stopAllToggles();
        Ride mount = new Ride(getObjectId(), Ride.ACTION_MOUNT, pet.getTemplate().getNpcId());
        setMount(pet.getNpcId(), pet.getLevel(), mount.getMountType());
        setMountObjectID(pet.getControlItemId());
        clearPetData();
        startFeed(pet.getNpcId());
        broadcastPacket(mount);

        // Notify self and others about speed change
        broadcastUserInfo();

        pet.unSummon(this);
        return true;
    }

    public boolean mount(int npcId, int controlItemId, boolean useFood)
    {
        if (!disarmWeapons())
            return false;

        stopAllToggles();
        Ride mount = new Ride(getObjectId(), Ride.ACTION_MOUNT, npcId);
        if (setMount(npcId, getLevel(), mount.getMountType()))
        {
            clearPetData();
            setMountObjectID(controlItemId);
            broadcastPacket(mount);

            // Notify self and others about speed change
            broadcastUserInfo();

            if (useFood)
                startFeed(npcId);

            return true;
        }
        return false;
    }

    public boolean mountPlayer(L2Summon summon)
    {
        if (summon != null && summon.isMountable() && !isMounted() && !isBetrayed())
        {
            if (isDead()) // A strider cannot be ridden when dead.
            {
                sendPacket(SystemMessageId.STRIDER_CANT_BE_RIDDEN_WHILE_DEAD);
                return false;
            }

            if (summon.isDead()) // A dead strider cannot be ridden.
            {
                sendPacket(SystemMessageId.DEAD_STRIDER_CANT_BE_RIDDEN);
                return false;
            }

            if (summon.isInCombat() || summon.isRooted()) // A strider in battle cannot be ridden.
            {
                sendPacket(SystemMessageId.STRIDER_IN_BATLLE_CANT_BE_RIDDEN);
                return false;
            }

            if (isInCombat()) // A strider cannot be ridden while in battle
            {
                sendPacket(SystemMessageId.STRIDER_CANT_BE_RIDDEN_WHILE_IN_BATTLE);
                return false;
            }

            if (isSitting()) // A strider can be ridden only when standing
            {
                sendPacket(SystemMessageId.STRIDER_CAN_BE_RIDDEN_ONLY_WHILE_STANDING);
                return false;
            }

            if (isFishing()) // You can't mount, dismount, break and drop items while fishing
            {
                sendPacket(SystemMessageId.CANNOT_DO_WHILE_FISHING_2);
                return false;
            }

            if (isCursedWeaponEquipped()) // You can't mount, dismount, break and drop items while weilding a cursed weapon
            {
                sendPacket(SystemMessageId.STRIDER_CANT_BE_RIDDEN_WHILE_IN_BATTLE);
                return false;
            }

            if (!Util.checkIfInRange(200, this, summon, true))
            {
                sendPacket(SystemMessageId.TOO_FAR_AWAY_FROM_STRIDER_TO_MOUNT);
                return false;
            }

            if (summon.isHungry())
            {
                sendPacket(SystemMessageId.HUNGRY_STRIDER_NOT_MOUNT);
                return false;
            }

            if (!summon.isDead() && !isMounted())
                mount(summon);
        }
        else if (isMounted())
        {
            if (getMountType() == 2 && isInsideZone(ZoneId.NO_LANDING))
            {
                sendPacket(SystemMessageId.NO_DISMOUNT_HERE);
                return false;
            }

            if (isHungry())
            {
                sendPacket(SystemMessageId.HUNGRY_STRIDER_NOT_MOUNT);
                return false;
            }

            dismount();
        }
        return true;
    }

    public boolean dismount()
    {
        sendPacket(new SetupGauge(3, 0, 0));
        int petId = _mountNpcId;
        if (setMount(0, 0, 0))
        {
            stopFeed();
            clearPetData();

            broadcastPacket(new Ride(getObjectId(), Ride.ACTION_DISMOUNT, 0));

            setMountObjectID(0);
            storePetFood(petId);

            // Notify self and others about speed change
            broadcastUserInfo();
            return true;
        }
        return false;
    }

    public void storePetFood(int petId)
    {
        if (_controlItemId != 0 && petId != 0)
        {
            try (Connection con = L2DatabaseFactory.getInstance().getConnection())
            {
                PreparedStatement statement = con.prepareStatement("UPDATE pets SET fed=? WHERE item_obj_id = ?");
                statement.setInt(1, getCurrentFeed());
                statement.setInt(2, _controlItemId);
                statement.executeUpdate();
                statement.close();
                _controlItemId = 0;
            }
            catch (Exception e)
            {
                _log.log(Level.SEVERE, "Failed to store Pet [NpcId: " + petId + "] data", e);
            }
        }
    }

    protected class FeedTask implements Runnable
    {
        @Override
        public void run()
        {
            try
            {
                if (!isMounted())
                {
                    stopFeed();
                    return;
                }

                if (getCurrentFeed() > getFeedConsume())
                {
                    // eat
                    setCurrentFeed(getCurrentFeed() - getFeedConsume());
                }
                else
                {
                    // go back to pet control item, or simply said, unsummon it
                    setCurrentFeed(0);
                    stopFeed();
                    dismount();
                    sendPacket(SystemMessageId.OUT_OF_FEED_MOUNT_CANCELED);
                }

                int[] foodIds = getPetData(getMountNpcId()).getFood();
                if (foodIds.length == 0)
                    return;

                L2ItemInstance food = null;
                for (int id : foodIds)
                {
                    food = getInventory().getItemByItemId(id);
                    if (food != null)
                        break;
                }

                if (food != null && isHungry())
                {
                    IItemHandler handler = ItemHandler.getInstance().getItemHandler(food.getEtcItem());
                    if (handler != null)
                    {
                        handler.useItem(L2PcInstance.this, food, false);
                        sendPacket(SystemMessage.getSystemMessage(SystemMessageId.PET_TOOK_S1_BECAUSE_HE_WAS_HUNGRY).addItemName(food));
                    }
                }
            }
            catch (Exception e)
            {
                _log.log(Level.SEVERE, "Mounted Pet [NpcId: " + getMountNpcId() + "] a feed task error has occurred", e);
            }
        }
    }

    protected synchronized void startFeed(int npcId)
    {
        _canFeed = npcId > 0;
        if (!isMounted())
            return;

        if (getPet() != null)
        {
            setCurrentFeed(((L2PetInstance) getPet()).getCurrentFed());
            _controlItemId = getPet().getControlItemId();
            sendPacket(new SetupGauge(3, getCurrentFeed() * 10000 / getFeedConsume(), getMaxFeed() * 10000 / getFeedConsume()));
            if (!isDead())
                _mountFeedTask = ThreadPoolManager.getInstance().scheduleGeneralAtFixedRate(new FeedTask(), 10000, 10000);
        }
        else if (_canFeed)
        {
            setCurrentFeed(getMaxFeed());
            sendPacket(new SetupGauge(3, getCurrentFeed() * 10000 / getFeedConsume(), getMaxFeed() * 10000 / getFeedConsume()));
            if (!isDead())
                _mountFeedTask = ThreadPoolManager.getInstance().scheduleGeneralAtFixedRate(new FeedTask(), 10000, 10000);
        }
    }

    protected synchronized void stopFeed()
    {
        if (_mountFeedTask != null)
        {
            _mountFeedTask.cancel(false);
            _mountFeedTask = null;

            if (Config.DEBUG)
                _log.fine("Pet [#" + _mountNpcId + "] feed task stop");
        }
    }

    private final void clearPetData()
    {
        _data = null;
    }

    protected final L2PetData getPetData(int npcId)
    {
        if (_data == null)
            _data = PetDataTable.getInstance().getPetData(npcId);
        return _data;
    }

    private final L2PetLevelData getPetLevelData(int npcId)
    {
        if (_leveldata == null)
            _leveldata = PetDataTable.getInstance().getPetData(npcId).getPetLevelData(getMountLevel());
        return _leveldata;
    }

    public int getCurrentFeed()
    {
        return _curFeed;
    }

    protected int getFeedConsume()
    {
        return (isAttackingNow()) ? getPetLevelData(_mountNpcId).getPetFeedBattle() : getPetLevelData(_mountNpcId).getPetFeedNormal();
    }

    public void setCurrentFeed(int num)
    {
        _curFeed = (num > getMaxFeed()) ? getMaxFeed() : num;
        sendPacket(new SetupGauge(3, getCurrentFeed() * 10000 / getFeedConsume(), getMaxFeed() * 10000 / getFeedConsume()));
    }

    private int getMaxFeed()
    {
        return getPetLevelData(_mountNpcId).getPetMaxFeed();
    }

    protected boolean isHungry()
    {
        return _canFeed ? (getCurrentFeed() < (getPetLevelData(getMountNpcId()).getPetMaxFeed() * 0.55)) : false;
    }

    /**
     * @return the type of attack, depending of the worn weapon.
     */
    @Override
    public L2WeaponType getAttackType()
    {
        final L2Weapon weapon = getActiveWeaponItem();
        if (weapon != null)
            return weapon.getItemType();

        return L2WeaponType.FIST;
    }

    public void setUptime(long time)
    {
        _uptime = time;
    }

    public long getUptime()
    {
        return System.currentTimeMillis() - _uptime;
    }

    /**
     * Return True if the L2PcInstance is invulnerable.
     */
    @Override
    public boolean isInvul()
    {
        return super.isInvul() || _protectEndTime > GameTimeController.getGameTicks();
    }

    /**
     * Return True if the L2PcInstance has a Party in progress.
     */
    @Override
    public boolean isInParty()
    {
        return _party != null;
    }

    /**
     * Set the _party object of the L2PcInstance (without joining it).
     * @param party The object.
     */
    public void setParty(L2Party party)
    {
        _party = party;
    }

    /**
     * Set the _party object of the L2PcInstance AND join it.
     * @param party
     */
    public void joinParty(L2Party party)
    {
        if (party != null)
        {
            _party = party;
            party.addPartyMember(this);
        }
    }

    /**
     * Manage the Leave Party task of the L2PcInstance.
     */
    public void leaveParty()
    {
        if (isInParty())
        {
            _party.removePartyMember(this);
            _party = null;
        }
    }

    /**
     * Return the _party object of the L2PcInstance.
     */
    @Override
    public L2Party getParty()
    {
        return _party;
    }

    /**
     * Return True if the L2PcInstance is a GM.
     */
    @Override
    public boolean isGM()
    {
        return getAccessLevel().isGm();
    }

    /**
     * Set the _accessLevel of the L2PcInstance.
     * @param level
     */
    public void setAccessLevel(int level)
    {
        if (level == AccessLevels._masterAccessLevelNum)
        {
            _log.warning(getName() + " has logged in with Master access level.");
            _accessLevel = AccessLevels._masterAccessLevel;
        }
        else if (level == AccessLevels._userAccessLevelNum)
            _accessLevel = AccessLevels._userAccessLevel;
        else
        {
            L2AccessLevel accessLevel = AccessLevels.getInstance().getAccessLevel(level);

            if (accessLevel == null)
            {
                if (level < 0)
                {
                    AccessLevels.getInstance().addBanAccessLevel(level);
                    _accessLevel = AccessLevels.getInstance().getAccessLevel(level);
                }
                else
                {
                    _log.warning("Server tried to set unregistered access level " + level + " to " + getName() + ". His access level have been reseted to user level.");
                    _accessLevel = AccessLevels._userAccessLevel;
                }
            }
            else
            {
                _accessLevel = accessLevel;
                setTitle(_accessLevel.getName());
            }
        }

        getAppearance().setNameColor(_accessLevel.getNameColor());
        getAppearance().setTitleColor(_accessLevel.getTitleColor());
        broadcastUserInfo();

        CharNameTable.getInstance().addName(this);
    }

    public void setAccountAccesslevel(int level)
    {
    //  LoginServerThread.getInstance().sendAccessLevel(getAccountName(), level);
    }

    /**
     * @return the _accessLevel of the L2PcInstance.
     */
    public L2AccessLevel getAccessLevel()
    {
        if (Config.EVERYBODY_HAS_ADMIN_RIGHTS)
            return AccessLevels._masterAccessLevel;
        else if (_accessLevel == null) /* This is here because inventory etc. is loaded before access level on login, so it is not null */
            setAccessLevel(AccessLevels._userAccessLevelNum);

        return _accessLevel;
    }

    /**
     * Update Stats of the L2PcInstance client side by sending Server->Client packet UserInfo/StatusUpdate to this L2PcInstance and CharInfo/StatusUpdate to all L2PcInstance in its _KnownPlayers (broadcast).
     * @param broadcastType
     */
    public void updateAndBroadcastStatus(int broadcastType)
    {
        refreshOverloaded();
        refreshExpertisePenalty();

        if (broadcastType == 1)
            sendPacket(new UserInfo(this));
        else if (broadcastType == 2)
            broadcastUserInfo();
    }

    /**
     * Send a Server->Client StatusUpdate packet with Karma to the L2PcInstance and all L2PcInstance to inform (broadcast).
     */
    public void broadcastKarma()
    {
        StatusUpdate su = new StatusUpdate(this);
        su.addAttribute(StatusUpdate.KARMA, getKarma());
        sendPacket(su);

        if (getPet() != null)
            sendPacket(new RelationChanged(getPet(), getRelation(this), false));

        broadcastRelationsChanges();
    }

    /**
     * Set the online Flag to True or False and update the characters table of the database with online status and lastAccess (called when login and logout).
     * @param isOnline
     * @param updateInDb
     */
    public void setOnlineStatus(boolean isOnline, boolean updateInDb)
    {
        if (_isOnline != isOnline)
            _isOnline = isOnline;

        // Update the characters table of the database with online status and lastAccess (called when login and logout)
        if (updateInDb)
            updateOnlineStatus();
    }

    public void setIsIn7sDungeon(boolean isIn7sDungeon)
    {
        _isIn7sDungeon = isIn7sDungeon;
    }

    /**
     * Update the characters table of the database with online status and lastAccess of this L2PcInstance (called when login and logout).
     */
    public void updateOnlineStatus()
    {
        try (Connection con = L2DatabaseFactory.getInstance().getConnection())
        {
            PreparedStatement statement = con.prepareStatement("UPDATE characters SET online=?, lastAccess=? WHERE obj_id=?");
            statement.setInt(1, isOnlineInt());
            statement.setLong(2, System.currentTimeMillis());
            statement.setInt(3, getObjectId());
            statement.execute();
            statement.close();
        }
        catch (Exception e)
        {
            _log.warning("could not set char online status:" + e);
        }
    }

    /**
     * Create a new player in the characters table of the database.
     * @return true if successful.
     */
    private boolean createDb()
    {
        try (Connection con = L2DatabaseFactory.getInstance().getConnection())
        {
            PreparedStatement statement = con.prepareStatement(INSERT_CHARACTER);
            statement.setString(1, _accountName);
            statement.setInt(2, getObjectId());
            statement.setString(3, getName());
            statement.setInt(4, getLevel());
            statement.setInt(5, getMaxHp());
            statement.setDouble(6, getCurrentHp());
            statement.setInt(7, getMaxCp());
            statement.setDouble(8, getCurrentCp());
            statement.setInt(9, getMaxMp());
            statement.setDouble(10, getCurrentMp());
            statement.setInt(11, getAppearance().getFace());
            statement.setInt(12, getAppearance().getHairStyle());
            statement.setInt(13, getAppearance().getHairColor());
            statement.setInt(14, getAppearance().getSex() ? 1 : 0);
            statement.setLong(15, getExp());
            statement.setInt(16, getSp());
            statement.setInt(17, getKarma());
            statement.setInt(18, getPvpKills());
            statement.setInt(19, getPkKills());
            statement.setInt(20, getClanId());
            statement.setInt(21, getRace().ordinal());
            statement.setInt(22, getClassId().getId());
            statement.setLong(23, getDeleteTimer());
            statement.setInt(24, hasDwarvenCraft() ? 1 : 0);
            statement.setString(25, getTitle());
            statement.setInt(26, getAccessLevel().getLevel());
            statement.setInt(27, isOnlineInt());
            statement.setInt(28, isIn7sDungeon() ? 1 : 0);
            statement.setInt(29, getClanPrivileges());
            statement.setInt(30, wantsPeace() ? 1 : 0);
            statement.setInt(31, getBaseClass());
            statement.setInt(32, isNoble() ? 1 : 0);
            statement.setLong(33, 0);
            statement.setLong(34, System.currentTimeMillis());
            statement.executeUpdate();
            statement.close();
        }
        catch (Exception e)
        {
            _log.severe("Could not insert char data: " + e);
            return false;
        }
        return true;
    }

    /**
     * Retrieve a L2PcInstance from the characters table of the database and add it in _allObjects of the L2world.<BR>
     * <BR>
     * <B><U> Actions</U> :</B><BR>
     * <BR>
     * <li>Retrieve the L2PcInstance from the characters table of the database</li> <li>Add the L2PcInstance object in _allObjects</li> <li>Set the x,y,z position of the L2PcInstance and make it invisible</li> <li>Update the overloaded status of the L2PcInstance</li><BR>
     * <BR>
     * @param objectId Identifier of the object to initialized
     * @return The L2PcInstance loaded from the database
     */
    public static L2PcInstance restore(int objectId)
    {
        L2PcInstance player = null;
        try (Connection con = L2DatabaseFactory.getInstance().getConnection())
        {
            PreparedStatement statement = con.prepareStatement(RESTORE_CHARACTER);
            statement.setInt(1, objectId);
            ResultSet rset = statement.executeQuery();

            while (rset.next())
            {
                final int activeClassId = rset.getInt("classid");
                final L2PcTemplate template = CharTemplateTable.getInstance().getTemplate(activeClassId);
                final PcAppearance app = new PcAppearance(rset.getByte("face"), rset.getByte("hairColor"), rset.getByte("hairStyle"), rset.getInt("sex") != 0);

                player = new L2PcInstance(objectId, template, rset.getString("account_name"), app);
                player.setName(rset.getString("char_name"));
                player._lastAccess = rset.getLong("lastAccess");

                player.getStat().setExp(rset.getLong("exp"));
                player.setExpBeforeDeath(rset.getLong("expBeforeDeath"));
                player.getStat().setLevel(rset.getByte("level"));
                player.getStat().setSp(rset.getInt("sp"));

                player.setWantsPeace(rset.getInt("wantspeace") == 1);

                player.setHeading(rset.getInt("heading"));

                player.setKarma(rset.getInt("karma"));
                player.setPvpKills(rset.getInt("pvpkills"));
                player.setPkKills(rset.getInt("pkkills"));
                player.setOnlineTime(rset.getLong("onlinetime"));
                player.setNoble(rset.getInt("nobless") == 1, false);

                player.setClanJoinExpiryTime(rset.getLong("clan_join_expiry_time"));
                if (player.getClanJoinExpiryTime() < System.currentTimeMillis())
                    player.setClanJoinExpiryTime(0);

                player.setClanCreateExpiryTime(rset.getLong("clan_create_expiry_time"));
                if (player.getClanCreateExpiryTime() < System.currentTimeMillis())
                    player.setClanCreateExpiryTime(0);

                player.setPowerGrade((int) rset.getLong("power_grade"));
                player.setPledgeType(rset.getInt("subpledge"));
                player.setLastRecomUpdate(rset.getLong("last_recom_date"));

                int clanId = rset.getInt("clanid");
                if (clanId > 0)
                    player.setClan(ClanTable.getInstance().getClan(clanId));

                if (player.getClan() != null)
                {
                    if (player.getClan().getLeaderId() != player.getObjectId())
                    {
                        if (player.getPowerGrade() == 0)
                            player.setPowerGrade(5);

                        player.setClanPrivileges(player.getClan().getRankPrivs(player.getPowerGrade()));
                    }
                    else
                    {
                        player.setClanPrivileges(L2Clan.CP_ALL);
                        player.setPowerGrade(1);
                    }
                }
                else
                    player.setClanPrivileges(L2Clan.CP_NOTHING);

                player.setPledgeClass(L2ClanMember.calculatePledgeClass(player));
                player.setDeleteTimer(rset.getLong("deletetime"));

                player.setTitle(rset.getString("title"));
                player.setAccessLevel(rset.getInt("accesslevel"));
                player.setFistsWeaponItem(findFistsWeaponItem(activeClassId));
                player.setUptime(System.currentTimeMillis());

                // Check recs
                player.checkRecom(rset.getInt("rec_have"), rset.getInt("rec_left"));

                player._classIndex = 0;
                try
                {
                    player.setBaseClass(rset.getInt("base_class"));
                }
                catch (Exception e)
                {
                    player.setBaseClass(activeClassId);
                }

                // Restore Subclass Data (cannot be done earlier in function)
                if (restoreSubClassData(player))
                {
                    if (activeClassId != player.getBaseClass())
                    {
                        for (SubClass subClass : player.getSubClasses().values())
                            if (subClass.getClassId() == activeClassId)
                                player._classIndex = subClass.getClassIndex();
                    }
                }

                player.setApprentice(rset.getInt("apprentice"));
                player.setSponsor(rset.getInt("sponsor"));
                player.setLvlJoinedAcademy(rset.getInt("lvl_joined_academy"));
                player.setIsIn7sDungeon(rset.getInt("isin7sdungeon") == 1);
                player.setPunishLevel(rset.getInt("punish_level"));
                if (player.getPunishLevel() != PunishLevel.NONE)
                    player.setPunishTimer(rset.getLong("punish_timer"));
                else
                    player.setPunishTimer(0);

                CursedWeaponsManager.getInstance().checkPlayer(player);

                player.setAllianceWithVarkaKetra(rset.getInt("varka_ketra_ally"));

                player.setVoteBuff(rset.getInt("votebuff") == 1 ? true : false);
                player.setVoteBuffEndTime(rset.getLong("vote_end_buff"));

                player.setDeathPenaltyBuffLevel(rset.getInt("death_penalty_level"));

                // Set the x,y,z position of the L2PcInstance and make it invisible
                player.setXYZInvisible(rset.getInt("x"), rset.getInt("y"), rset.getInt("z"));

                // Set Hero status if it applies
                if (Hero.getInstance().isActiveHero(objectId))
                    player.setHero(true);

                // Retrieve from the database all secondary data of this L2PcInstance and reward expertise/lucky skills if necessary.
                // Note that Clan, Noblesse and Hero skills are given separately and not here.
                player.restoreCharData();
                player.rewardSkills();

                // buff and status icons
                if (Config.STORE_SKILL_COOLTIME)
                    player.restoreEffects();

                // Restore current CP, HP and MP values
                final double currentHp = rset.getDouble("curHp");

                player.setCurrentCp(rset.getDouble("curCp"));
                player.setCurrentHp(currentHp);
                player.setCurrentMp(rset.getDouble("curMp"));

                if (currentHp < 0.5)
                {
                    player.setIsDead(true);
                    player.stopHpMpRegeneration();
                }

                // Restore pet if exists in the world
                player.setPet(L2World.getInstance().getPet(player.getObjectId()));
                if (player.getPet() != null)
                    player.getPet().setOwner(player);

                player.refreshOverloaded();
                player.refreshExpertisePenalty();

                player.restoreFriendList();

                // Retrieve the name and ID of the other characters assigned to this account.
                PreparedStatement stmt = con.prepareStatement("SELECT obj_Id, char_name FROM characters WHERE account_name=? AND obj_Id<>?");
                stmt.setString(1, player._accountName);
                stmt.setInt(2, objectId);
                ResultSet chars = stmt.executeQuery();

                while (chars.next())
                    player._chars.put(chars.getInt("obj_Id"), chars.getString("char_name"));

                chars.close();
                stmt.close();
                break;
            }

            rset.close();
            statement.close();
        }
        catch (Exception e)
        {
            _log.severe("Could not restore char data: " + e);
        }

        return player;
    }

    /**
     * @return
     */
    public Forum getMail()
    {
        if (_forumMail == null)
        {
            setMail(ForumsBBSManager.getInstance().getForumByName("MailRoot").getChildByName(getName()));

            if (_forumMail == null)
            {
                ForumsBBSManager.getInstance().createNewForum(getName(), ForumsBBSManager.getInstance().getForumByName("MailRoot"), Forum.MAIL, Forum.OWNERONLY, getObjectId());
                setMail(ForumsBBSManager.getInstance().getForumByName("MailRoot").getChildByName(getName()));
            }
        }

        return _forumMail;
    }

    /**
     * @param forum
     */
    public void setMail(Forum forum)
    {
        _forumMail = forum;
    }

    /**
     * @return
     */
    public Forum getMemo()
    {
        if (_forumMemo == null)
        {
            setMemo(ForumsBBSManager.getInstance().getForumByName("MemoRoot").getChildByName(_accountName));

            if (_forumMemo == null)
            {
                ForumsBBSManager.getInstance().createNewForum(_accountName, ForumsBBSManager.getInstance().getForumByName("MemoRoot"), Forum.MEMO, Forum.OWNERONLY, getObjectId());
                setMemo(ForumsBBSManager.getInstance().getForumByName("MemoRoot").getChildByName(_accountName));
            }
        }

        return _forumMemo;
    }

    /**
     * @param forum
     */
    public void setMemo(Forum forum)
    {
        _forumMemo = forum;
    }

    /**
     * Restores sub-class data for the L2PcInstance, used to check the current class index for the character.
     * @param player The player to make checks on.
     * @return true if successful.
     */
    private static boolean restoreSubClassData(L2PcInstance player)
    {
        try (Connection con = L2DatabaseFactory.getInstance().getConnection())
        {
            PreparedStatement statement = con.prepareStatement(RESTORE_CHAR_SUBCLASSES);
            statement.setInt(1, player.getObjectId());

            ResultSet rset = statement.executeQuery();

            while (rset.next())
            {
                SubClass subClass = new SubClass();
                subClass.setClassId(rset.getInt("class_id"));
                subClass.setLevel(rset.getByte("level"));
                subClass.setExp(rset.getLong("exp"));
                subClass.setSp(rset.getInt("sp"));
                subClass.setClassIndex(rset.getInt("class_index"));

                // Enforce the correct indexing of _subClasses against their class indexes.
                player.getSubClasses().put(subClass.getClassIndex(), subClass);
            }

            statement.close();
        }
        catch (Exception e)
        {
            _log.warning("Could not restore classes for " + player.getName() + ": " + e);
            e.printStackTrace();
        }

        return true;
    }

    /**
     * Restores secondary data for the L2PcInstance, based on the current class index.
     */
    private void restoreCharData()
    {
        // Retrieve from the database all skills of this L2PcInstance and add them to _skills.
        restoreSkills();

        // Retrieve from the database all macroses of this L2PcInstance and add them to _macroses.
        _macroses.restore();

        // Retrieve from the database all shortCuts of this L2PcInstance and add them to _shortCuts.
        _shortCuts.restore();

        // Retrieve from the database all henna of this L2PcInstance and add them to _henna.
        restoreHenna();

        // Retrieve from the database all recom data of this L2PcInstance and add to _recomChars.
        restoreRecom();

        // Retrieve from the database the recipe book of this L2PcInstance.
        if (!isSubClassActive())
            restoreRecipeBook();
    }

    /**
     * Store recipe book data for this L2PcInstance, if not on an active sub-class.
     */
    private void storeRecipeBook()
    {
        // If the player is on a sub-class don't even attempt to store a recipe book.
        if (isSubClassActive())
            return;
        if (getCommonRecipeBook().length == 0 && getDwarvenRecipeBook().length == 0)
            return;

        try (Connection con = L2DatabaseFactory.getInstance().getConnection())
        {
            PreparedStatement statement = con.prepareStatement("DELETE FROM character_recipebook WHERE char_id=?");
            statement.setInt(1, getObjectId());
            statement.execute();
            statement.close();

            L2RecipeList[] recipes = getCommonRecipeBook();

            for (L2RecipeList recipe : recipes)
            {
                statement = con.prepareStatement("INSERT INTO character_recipebook (char_id, id, type) values(?,?,0)");
                statement.setInt(1, getObjectId());
                statement.setInt(2, recipe.getId());
                statement.execute();
                statement.close();
            }

            recipes = getDwarvenRecipeBook();
            for (L2RecipeList recipe : recipes)
            {
                statement = con.prepareStatement("INSERT INTO character_recipebook (char_id, id, type) values(?,?,1)");
                statement.setInt(1, getObjectId());
                statement.setInt(2, recipe.getId());
                statement.execute();
                statement.close();
            }
        }
        catch (Exception e)
        {
            _log.warning("Could not store recipe book data: " + e);
        }
    }

    /**
     * Restore recipe book data for this L2PcInstance.
     */
    private void restoreRecipeBook()
    {
        try (Connection con = L2DatabaseFactory.getInstance().getConnection())
        {
            PreparedStatement statement = con.prepareStatement("SELECT id, type FROM character_recipebook WHERE char_id=?");
            statement.setInt(1, getObjectId());
            ResultSet rset = statement.executeQuery();

            L2RecipeList recipe;
            while (rset.next())
            {
                recipe = RecipeController.getInstance().getRecipeList(rset.getInt("id"));

                if (rset.getInt("type") == 1)
                    registerDwarvenRecipeList(recipe);
                else
                    registerCommonRecipeList(recipe);
            }

            rset.close();
            statement.close();
        }
        catch (Exception e)
        {
            _log.warning("Could not restore recipe book data:" + e);
        }
    }

    /**
     * Update L2PcInstance stats in the characters table of the database.
     * @param storeActiveEffects
     */
    public synchronized void store(boolean storeActiveEffects)
    {
        // update client coords, if these look like true
        if (isInsideRadius(getClientX(), getClientY(), 1000, true))
            setXYZ(getClientX(), getClientY(), getClientZ());

        storeCharBase();
        storeCharSub();
        storeEffect(storeActiveEffects);
        storeRecipeBook();
        SevenSigns.getInstance().saveSevenSignsData(getObjectId());
    }

    public void store()
    {
        store(true);
    }

    private void storeCharBase()
    {
        try (Connection con = L2DatabaseFactory.getInstance().getConnection())
        {
            // Get the exp, level, and sp of base class to store in base table
            int currentClassIndex = getClassIndex();
            _classIndex = 0;
            long exp = getStat().getExp();
            int level = getStat().getLevel();
            int sp = getStat().getSp();
            _classIndex = currentClassIndex;

            PreparedStatement statement = con.prepareStatement(UPDATE_CHARACTER);

            statement.setInt(1, level);
            statement.setInt(2, getMaxHp());
            statement.setDouble(3, getCurrentHp());
            statement.setInt(4, getMaxCp());
            statement.setDouble(5, getCurrentCp());
            statement.setInt(6, getMaxMp());
            statement.setDouble(7, getCurrentMp());
            statement.setInt(8, getAppearance().getFace());
            statement.setInt(9, getAppearance().getHairStyle());
            statement.setInt(10, getAppearance().getHairColor());
            statement.setInt(11, getAppearance().getSex() ? 1 : 0);
            statement.setInt(12, getHeading());
            statement.setInt(13, _observerMode ? _lastX : getX());
            statement.setInt(14, _observerMode ? _lastY : getY());
            statement.setInt(15, _observerMode ? _lastZ : getZ());
            statement.setLong(16, exp);
            statement.setLong(17, getExpBeforeDeath());
            statement.setInt(18, sp);
            statement.setInt(19, getKarma());
            statement.setInt(20, getPvpKills());
            statement.setInt(21, getPkKills());
            statement.setInt(22, getRecomHave());
            statement.setInt(23, getRecomLeft());
            statement.setInt(24, getClanId());
            statement.setInt(25, getRace().ordinal());
            statement.setInt(26, getClassId().getId());
            statement.setLong(27, getDeleteTimer());
            statement.setString(28, getTitle());
            statement.setInt(29, getAccessLevel().getLevel());
            statement.setInt(30, isOnlineInt());
            statement.setInt(31, isIn7sDungeon() ? 1 : 0);
            statement.setInt(32, getClanPrivileges());
            statement.setInt(33, wantsPeace() ? 1 : 0);
            statement.setInt(34, getBaseClass());

            long totalOnlineTime = _onlineTime;
            if (_onlineBeginTime > 0)
                totalOnlineTime += (System.currentTimeMillis() - _onlineBeginTime) / 1000;

            statement.setLong(35, totalOnlineTime);
            statement.setInt(36, getPunishLevel().value());
            statement.setLong(37, getPunishTimer());
            statement.setInt(38, isNoble() ? 1 : 0);
            statement.setLong(39, getPowerGrade());
            statement.setInt(40, getPledgeType());
            statement.setLong(41, getLastRecomUpdate());
            statement.setInt(42, getLvlJoinedAcademy());
            statement.setLong(43, getApprentice());
            statement.setLong(44, getSponsor());
            statement.setInt(45, getAllianceWithVarkaKetra());
            statement.setLong(46, getClanJoinExpiryTime());
            statement.setLong(47, getClanCreateExpiryTime());
            statement.setString(48, getName());
            statement.setLong(49, getDeathPenaltyBuffLevel());
            statement.setInt(50, isVoteBuff() ? 1 : 0);
            statement.setLong(51, getVoteBuffEndTime());
            statement.setInt(52, getObjectId());

            statement.execute();
            statement.close();
        }
        catch (Exception e)
        {
            _log.warning("Could not store char base data: " + e);
        }
    }

    private void storeCharSub()
    {
        try (Connection con = L2DatabaseFactory.getInstance().getConnection())
        {
            PreparedStatement statement = con.prepareStatement(UPDATE_CHAR_SUBCLASS);

            if (getTotalSubClasses() > 0)
            {
                for (SubClass subClass : getSubClasses().values())
                {
                    statement.setLong(1, subClass.getExp());
                    statement.setInt(2, subClass.getSp());
                    statement.setInt(3, subClass.getLevel());
                    statement.setInt(4, subClass.getClassId());
                    statement.setInt(5, getObjectId());
                    statement.setInt(6, subClass.getClassIndex());

                    statement.execute();
                }
            }
            statement.close();
        }
        catch (Exception e)
        {
            _log.warning("Could not store sub class data for " + getName() + ": " + e);
        }
    }

    private void storeEffect(boolean storeEffects)
    {
        if (!Config.STORE_SKILL_COOLTIME)
            return;

        try (Connection con = L2DatabaseFactory.getInstance().getConnection())
        {
            // Delete all current stored effects for char to avoid dupe
            PreparedStatement statement = con.prepareStatement(DELETE_SKILL_SAVE);

            statement.setInt(1, getObjectId());
            statement.setInt(2, getClassIndex());
            statement.execute();
            statement.close();

            int buff_index = 0;

            final List<Integer> storedSkills = new ArrayList<>();

            // Store all effect data along with calulated remaining
            // reuse delays for matching skills. 'restore_type'= 0.
            statement = con.prepareStatement(ADD_SKILL_SAVE);

            if (storeEffects)
            {
                for (L2Effect effect : getAllEffects())
                {
                    if (effect == null)
                        continue;

                    switch (effect.getEffectType())
                    {
                        case HEAL_OVER_TIME:
                        case COMBAT_POINT_HEAL_OVER_TIME:
                            continue;
                    }

                    L2Skill skill = effect.getSkill();
                    if (storedSkills.contains(skill.getReuseHashCode()))
                        continue;

                    storedSkills.add(skill.getReuseHashCode());

                    if (!effect.isHerbEffect() && effect.getInUse() && !skill.isToggle())
                    {
                        statement.setInt(1, getObjectId());
                        statement.setInt(2, skill.getId());
                        statement.setInt(3, skill.getLevel());
                        statement.setInt(4, effect.getCount());
                        statement.setInt(5, effect.getTime());

                        if (_reuseTimeStamps.containsKey(skill.getReuseHashCode()))
                        {
                            TimeStamp t = _reuseTimeStamps.get(skill.getReuseHashCode());
                            statement.setLong(6, t.hasNotPassed() ? t.getReuse() : 0);
                            statement.setDouble(7, t.hasNotPassed() ? t.getStamp() : 0);
                        }
                        else
                        {
                            statement.setLong(6, 0);
                            statement.setDouble(7, 0);
                        }

                        statement.setInt(8, 0);
                        statement.setInt(9, getClassIndex());
                        statement.setInt(10, ++buff_index);
                        statement.execute();
                    }
                }
            }

            // Store the reuse delays of remaining skills which
            // lost effect but still under reuse delay. 'restore_type' 1.
            for (int hash : _reuseTimeStamps.keySet())
            {
                if (storedSkills.contains(hash))
                    continue;

                TimeStamp t = _reuseTimeStamps.get(hash);
                if (t != null && t.hasNotPassed())
                {
                    storedSkills.add(hash);

                    statement.setInt(1, getObjectId());
                    statement.setInt(2, t.getSkillId());
                    statement.setInt(3, t.getSkillLvl());
                    statement.setInt(4, -1);
                    statement.setInt(5, -1);
                    statement.setLong(6, t.getReuse());
                    statement.setDouble(7, t.getStamp());
                    statement.setInt(8, 1);
                    statement.setInt(9, getClassIndex());
                    statement.setInt(10, ++buff_index);
                    statement.execute();
                }
            }
            statement.close();
        }
        catch (Exception e)
        {
            _log.log(Level.WARNING, "Could not store char effect data: ", e);
        }
    }

    /**
     * @return True if the L2PcInstance is online.
     */
    public boolean isOnline()
    {
        return _isOnline;
    }

    /**
     * @return an int interpretation of online status.
     */
    public int isOnlineInt()
    {
        if (_isOnline && getClient() != null)
            return getClient().isDetached() ? 2 : 1;

        return 0;
    }

    public boolean isIn7sDungeon()
    {
        return _isIn7sDungeon;
    }

    /**
     * Add a skill to the L2PcInstance _skills and its Func objects to the calculator set of the L2PcInstance and save update in the character_skills table of the database.<BR>
     * <BR>
     * <B><U> Concept</U> :</B><BR>
     * <BR>
     * All skills own by a L2PcInstance are identified in <B>_skills</B><BR>
     * <BR>
     * <B><U> Actions</U> :</B><BR>
     * <BR>
     * <li>Replace oldSkill by newSkill or Add the newSkill</li> <li>If an old skill has been replaced, remove all its Func objects of L2Character calculator set</li> <li>Add Func objects of newSkill to the calculator set of the L2Character</li><BR>
     * <BR>
     * @param newSkill The L2Skill to add to the L2Character
     * @param store
     * @return The L2Skill replaced or null if just added a new L2Skill
     */
    public L2Skill addSkill(L2Skill newSkill, boolean store)
    {
        // Add a skill to the L2PcInstance _skills and its Func objects to the calculator set of the L2PcInstance
        L2Skill oldSkill = super.addSkill(newSkill);

        // Add or update a L2PcInstance skill in the character_skills table of the database
        if (store)
            storeSkill(newSkill, oldSkill, -1);

        return oldSkill;
    }

    @Override
    public L2Skill removeSkill(L2Skill skill, boolean store)
    {
        if (store)
            return removeSkill(skill);

        return super.removeSkill(skill, true);
    }

    public L2Skill removeSkill(L2Skill skill, boolean store, boolean cancelEffect)
    {
        if (store)
            return removeSkill(skill);

        return super.removeSkill(skill, cancelEffect);
    }

    /**
     * Remove a skill from the L2Character and its Func objects from calculator set of the L2Character and save update in the character_skills table of the database.<BR>
     * <BR>
     * <B><U> Concept</U> :</B><BR>
     * <BR>
     * All skills own by a L2Character are identified in <B>_skills</B><BR>
     * <BR>
     * <B><U> Actions</U> :</B><BR>
     * <BR>
     * <li>Remove the skill from the L2Character _skills</li> <li>Remove all its Func objects from the L2Character calculator set</li><BR>
     * <BR>
     * <B><U> Overriden in </U> :</B><BR>
     * <BR>
     * <li>L2PcInstance : Save update in the character_skills table of the database</li><BR>
     * <BR>
     * @param skill The L2Skill to remove from the L2Character
     * @return The L2Skill removed
     */
    @Override
    public L2Skill removeSkill(L2Skill skill)
    {
        // Remove a skill from the L2Character and its Func objects from calculator set of the L2Character
        L2Skill oldSkill = super.removeSkill(skill);

        try (Connection con = L2DatabaseFactory.getInstance().getConnection())
        {
            PreparedStatement statement = con.prepareStatement(DELETE_SKILL_FROM_CHAR);

            if (oldSkill != null)
            {
                statement.setInt(1, oldSkill.getId());
                statement.setInt(2, getObjectId());
                statement.setInt(3, getClassIndex());
                statement.execute();
            }
            statement.close();
        }
        catch (Exception e)
        {
            _log.warning("Error could not delete skill: " + e);
        }

        // Don't busy with shortcuts if skill was a passive skill.
        if (skill != null && !skill.isPassive())
        {
            L2ShortCut[] allShortCuts = getAllShortCuts();

            for (L2ShortCut sc : allShortCuts)
            {
                if (sc != null && sc.getId() == skill.getId() && sc.getType() == L2ShortCut.TYPE_SKILL)
                    deleteShortCut(sc.getSlot(), sc.getPage());
            }
        }

        return oldSkill;
    }

    /**
     * Add or update a L2PcInstance skill in the character_skills table of the database. <BR>
     * <BR>
     * If newClassIndex > -1, the skill will be stored with that class index, not the current one.
     * @param newSkill
     * @param oldSkill
     * @param newClassIndex
     */
    private void storeSkill(L2Skill newSkill, L2Skill oldSkill, int newClassIndex)
    {
        int classIndex = _classIndex;

        if (newClassIndex > -1)
            classIndex = newClassIndex;

        try (Connection con = L2DatabaseFactory.getInstance().getConnection())
        {
            PreparedStatement statement;

            if (oldSkill != null && newSkill != null)
            {
                statement = con.prepareStatement(UPDATE_CHARACTER_SKILL_LEVEL);
                statement.setInt(1, newSkill.getLevel());
                statement.setInt(2, oldSkill.getId());
                statement.setInt(3, getObjectId());
                statement.setInt(4, classIndex);
                statement.execute();
                statement.close();
            }
            else if (newSkill != null)
            {
                statement = con.prepareStatement(ADD_NEW_SKILL);
                statement.setInt(1, getObjectId());
                statement.setInt(2, newSkill.getId());
                statement.setInt(3, newSkill.getLevel());
                statement.setInt(4, classIndex);
                statement.execute();
                statement.close();
            }
            else
            {
                _log.warning("storeSkill() couldn't store new skill. It's null type.");
            }
        }
        catch (Exception e)
        {
            _log.warning("Error could not store char skills: " + e);
        }
    }

    /**
     * Retrieve from the database all skills of this L2PcInstance and add them to _skills.
     */
    private void restoreSkills()
    {
        try (Connection con = L2DatabaseFactory.getInstance().getConnection())
        {
            PreparedStatement statement = con.prepareStatement(RESTORE_SKILLS_FOR_CHAR);
            statement.setInt(1, getObjectId());
            statement.setInt(2, getClassIndex());
            ResultSet rset = statement.executeQuery();

            // Go though the recordset of this SQL query
            while (rset.next())
            {
                int id = rset.getInt("skill_id");
                int level = rset.getInt("skill_level");

                if (id > 9000)
                    continue; // fake skills for base stats

                // Create a L2Skill object for each record
                L2Skill skill = SkillTable.getInstance().getInfo(id, level);

                // Add the L2Skill object to the L2Character _skills and its Func objects to the calculator set of the L2Character
                super.addSkill(skill);
            }

            rset.close();
            statement.close();
        }
        catch (Exception e)
        {
            _log.warning("Could not restore character skills: " + e);
        }
    }

    /**
     * Retrieve from the database all skill effects of this L2PcInstance and add them to the player.
     */
    public void restoreEffects()
    {
        try (Connection con = L2DatabaseFactory.getInstance().getConnection())
        {
            PreparedStatement statement = con.prepareStatement(RESTORE_SKILL_SAVE);
            statement.setInt(1, getObjectId());
            statement.setInt(2, getClassIndex());
            ResultSet rset = statement.executeQuery();

            while (rset.next())
            {
                int effectCount = rset.getInt("effect_count");
                int effectCurTime = rset.getInt("effect_cur_time");
                long reuseDelay = rset.getLong("reuse_delay");
                long systime = rset.getLong("systime");
                int restoreType = rset.getInt("restore_type");

                final L2Skill skill = SkillTable.getInstance().getInfo(rset.getInt("skill_id"), rset.getInt("skill_level"));
                if (skill == null)
                    continue;

                final long remainingTime = systime - System.currentTimeMillis();
                if (remainingTime > 10)
                {
                    disableSkill(skill, remainingTime);
                    addTimeStamp(skill, reuseDelay, systime);
                }

                /**
                 * Restore Type 1 The remaning skills lost effect upon logout but were still under a high reuse delay.
                 */
                if (restoreType > 0)
                    continue;

                /**
                 * Restore Type 0 These skills were still in effect on the character upon logout. Some of which were self casted and might still have a long reuse delay which also is restored.
                 */
                if (skill.hasEffects())
                {
                    Env env = new Env();
                    env.player = this;
                    env.target = this;
                    env.skill = skill;
                    L2Effect ef;
                    for (EffectTemplate et : skill.getEffectTemplates())
                    {
                        ef = et.getEffect(env);
                        if (ef != null)
                        {
                            ef.setCount(effectCount);
                            ef.setFirstTime(effectCurTime);
                            ef.scheduleEffect();
                        }
                    }
                }
            }

            rset.close();
            statement.close();

            statement = con.prepareStatement(DELETE_SKILL_SAVE);
            statement.setInt(1, getObjectId());
            statement.setInt(2, getClassIndex());
            statement.executeUpdate();
            statement.close();
        }
        catch (Exception e)
        {
            _log.log(Level.WARNING, "Could not restore " + this + " active effect data: " + e.getMessage(), e);
        }
    }

    /**
     * Retrieve from the database all Henna of this L2PcInstance, add them to _henna and calculate stats of the L2PcInstance.
     */
    private void restoreHenna()
    {
        try (Connection con = L2DatabaseFactory.getInstance().getConnection())
        {
            PreparedStatement statement = con.prepareStatement(RESTORE_CHAR_HENNAS);
            statement.setInt(1, getObjectId());
            statement.setInt(2, getClassIndex());
            ResultSet rset = statement.executeQuery();

            for (int i = 0; i < 3; i++)
                _henna[i] = null;

            while (rset.next())
            {
                int slot = rset.getInt("slot");

                if (slot < 1 || slot > 3)
                    continue;

                int symbolId = rset.getInt("symbol_id");
                if (symbolId != 0)
                {
                    L2Henna tpl = HennaTable.getInstance().getTemplate(symbolId);
                    if (tpl != null)
                        _henna[slot - 1] = tpl;
                }
            }

            rset.close();
            statement.close();
        }
        catch (Exception e)
        {
            _log.warning("could not restore henna: " + e);
        }

        // Calculate Henna modifiers of this L2PcInstance
        recalcHennaStats();
    }

    /**
     * Retrieve from the database all Recommendation data of this L2PcInstance, add to _recomChars and calculate stats of the L2PcInstance.
     */
    private void restoreRecom()
    {
        try (Connection con = L2DatabaseFactory.getInstance().getConnection())
        {
            PreparedStatement statement = con.prepareStatement(RESTORE_CHAR_RECOMS);
            statement.setInt(1, getObjectId());
            ResultSet rset = statement.executeQuery();
            while (rset.next())
                _recomChars.add(rset.getInt("target_id"));

            rset.close();
            statement.close();
        }
        catch (Exception e)
        {
            _log.warning("could not restore recommendations: " + e);
        }
    }

    /**
     * @return the number of Henna empty slot of the L2PcInstance.
     */
    public int getHennaEmptySlots()
    {
        int totalSlots = 0;
        if (getClassId().level() == 1)
            totalSlots = 2;
        else
            totalSlots = 3;

        for (int i = 0; i < 3; i++)
        {
            if (_henna[i] != null)
                totalSlots--;
        }

        if (totalSlots <= 0)
            return 0;

        return totalSlots;
    }

    /**
     * Remove a Henna of the L2PcInstance, save update in the character_hennas table of the database and send Server->Client HennaInfo/UserInfo packet to this L2PcInstance.
     * @param slot The slot number to make checks on.
     * @return true if successful.
     */
    public boolean removeHenna(int slot)
    {
        if (slot < 1 || slot > 3)
            return false;

        slot--;

        if (_henna[slot] == null)
            return false;

        L2Henna henna = _henna[slot];
        _henna[slot] = null;

        try (Connection con = L2DatabaseFactory.getInstance().getConnection())
        {
            PreparedStatement statement = con.prepareStatement(DELETE_CHAR_HENNA);

            statement.setInt(1, getObjectId());
            statement.setInt(2, slot + 1);
            statement.setInt(3, getClassIndex());

            statement.execute();
            statement.close();
        }
        catch (Exception e)
        {
            _log.warning("could not remove char henna: " + e);
        }

        // Calculate Henna modifiers of this L2PcInstance
        recalcHennaStats();

        // Send Server->Client HennaInfo packet to this L2PcInstance
        sendPacket(new HennaInfo(this));

        // Send Server->Client UserInfo packet to this L2PcInstance
        sendPacket(new UserInfo(this));

        reduceAdena("Henna", henna.getPrice() / 5, this, false);

        // Add the recovered dyes to the player's inventory and notify them.
        addItem("Henna", henna.getDyeId(), L2Henna.getAmountDyeRequire() / 2, this, true);
        sendPacket(SystemMessageId.SYMBOL_DELETED);
        return true;
    }

    /**
     * Add a Henna to the L2PcInstance, save update in the character_hennas table of the database and send Server->Client HennaInfo/UserInfo packet to this L2PcInstance.
     * @param henna The Henna template to add.
     */
    public void addHenna(L2Henna henna)
    {
        for (int i = 0; i < 3; i++)
        {
            if (_henna[i] == null)
            {
                _henna[i] = henna;

                // Calculate Henna modifiers of this L2PcInstance
                recalcHennaStats();

                try (Connection con = L2DatabaseFactory.getInstance().getConnection())
                {
                    PreparedStatement statement = con.prepareStatement(ADD_CHAR_HENNA);

                    statement.setInt(1, getObjectId());
                    statement.setInt(2, henna.getSymbolId());
                    statement.setInt(3, i + 1);
                    statement.setInt(4, getClassIndex());

                    statement.execute();
                    statement.close();
                }
                catch (Exception e)
                {
                    _log.warning("could not save char henna: " + e);
                }

                sendPacket(new HennaInfo(this));
                sendPacket(new UserInfo(this));
                sendPacket(SystemMessageId.SYMBOL_ADDED);
                return;
            }
        }
    }

    /**
     * Calculate Henna modifiers of this L2PcInstance.<BR>
     * <BR>
     */
    private void recalcHennaStats()
    {
        _hennaINT = 0;
        _hennaSTR = 0;
        _hennaCON = 0;
        _hennaMEN = 0;
        _hennaWIT = 0;
        _hennaDEX = 0;

        for (int i = 0; i < 3; i++)
        {
            if (_henna[i] == null)
                continue;

            _hennaINT += _henna[i].getStatINT();
            _hennaSTR += _henna[i].getStatSTR();
            _hennaMEN += _henna[i].getStatMEN();
            _hennaCON += _henna[i].getStatCON();
            _hennaWIT += _henna[i].getStatWIT();
            _hennaDEX += _henna[i].getStatDEX();
        }

        if (_hennaINT > 5)
            _hennaINT = 5;

        if (_hennaSTR > 5)
            _hennaSTR = 5;

        if (_hennaMEN > 5)
            _hennaMEN = 5;

        if (_hennaCON > 5)
            _hennaCON = 5;

        if (_hennaWIT > 5)
            _hennaWIT = 5;

        if (_hennaDEX > 5)
            _hennaDEX = 5;
    }

    /**
     * @param slot A slot to check.
     * @return the Henna of this L2PcInstance corresponding to the selected slot.
     */
    public L2Henna getHenna(int slot)
    {
        if (slot < 1 || slot > 3)
            return null;

        return _henna[slot - 1];
    }

    public int getHennaStatINT()
    {
        return _hennaINT;
    }

    public int getHennaStatSTR()
    {
        return _hennaSTR;
    }

    public int getHennaStatCON()
    {
        return _hennaCON;
    }

    public int getHennaStatMEN()
    {
        return _hennaMEN;
    }

    public int getHennaStatWIT()
    {
        return _hennaWIT;
    }

    public int getHennaStatDEX()
    {
        return _hennaDEX;
    }

    /**
     * Return True if the L2PcInstance is autoAttackable.
     * <ul>
     * <li>Check if the attacker isn't the L2PcInstance Pet</li>
     * <li>Check if the attacker is L2MonsterInstance</li>
     * <li>If the attacker is a L2PcInstance, check if it is not in the same party</li>
     * <li>Check if the L2PcInstance has Karma</li>
     * <li>If the attacker is a L2PcInstance, check if it is not in the same siege clan (Attacker, Defender)</li>
     * </ul>
     */
    @Override
    public boolean isAutoAttackable(L2Character attacker)
    {
        // Check if the attacker isn't the L2PcInstance Pet
        if (attacker == this || attacker == getPet())
            return false;

        // Check if the attacker is a L2MonsterInstance
        if (attacker instanceof L2MonsterInstance)
            return true;

        // Check if the attacker is not in the same party
        if (getParty() != null && getParty().getPartyMembers().contains(attacker))
            return false;

        // Check if the attacker is a L2Playable
        if (attacker instanceof L2Playable)
        {
            if (isInsideZone(ZoneId.PEACE))
                return false;

            // Get L2PcInstance
            final L2PcInstance cha = attacker.getActingPlayer();

            // Check if the attacker is in olympiad and olympiad start
            if (attacker instanceof L2PcInstance && cha.isInOlympiadMode())
            {
                if (isInOlympiadMode() && isOlympiadStart() && cha.getOlympiadGameId() == getOlympiadGameId())
                    return true;

                return false;
            }

            // is AutoAttackable if both players are in the same duel and the duel is still going on
            if (getDuelState() == Duel.DUELSTATE_DUELLING && getDuelId() == cha.getDuelId())
                return true;

            if (getClan() != null)
            {
                final Siege siege = SiegeManager.getSiege(getX(), getY(), getZ());
                if (siege != null)
                {
                    // Check if a siege is in progress and if attacker and the L2PcInstance aren't in the Defender clan
                    if (siege.checkIsDefender(cha.getClan()) && siege.checkIsDefender(getClan()))
                        return false;

                    // Check if a siege is in progress and if attacker and the L2PcInstance aren't in the Attacker clan
                    if (siege.checkIsAttacker(cha.getClan()) && siege.checkIsAttacker(getClan()))
                        return false;
                }

                // Check if clan is at war
                if (getClan().isAtWarWith(cha.getClanId()) && !wantsPeace() && !cha.wantsPeace() && !isAcademyMember())
                    return true;
            }

            // Check if the L2PcInstance is in an arena.
            if (isInArena() && attacker.isInArena())
                return true;

            // Check if the attacker is not in the same ally.
            if (getAllyId() != 0 && getAllyId() == cha.getAllyId())
                return false;

            // Check if the attacker is not in the same clan.
            if (getClan() != null && getClan().isMember(cha.getObjectId()))
                return false;

            // Now check again if the L2PcInstance is in pvp zone (as arenas check was made before, it ends with sieges).
            if (isInsideZone(ZoneId.PVP) && attacker.isInsideZone(ZoneId.PVP))
                return true;
        }
        else if (attacker instanceof L2SiegeGuardInstance)
        {
            if (getClan() != null)
            {
                final Siege siege = SiegeManager.getSiege(this);
                return (siege != null && siege.checkIsAttacker(getClan()));
            }
        }

        // Check if the L2PcInstance has Karma
        if (getKarma() > 0 || getPvpFlag() > 0)
            return true;

        return false;
    }

    /**
     * Check if the active L2Skill can be casted.<BR>
     * <BR>
     * <B><U> Actions</U> :</B><BR>
     * <BR>
     * <li>Check if the skill isn't toggle and is offensive</li> <li>Check if the target is in the skill cast range</li> <li>Check if the skill is Spoil type and if the target isn't already spoiled</li> <li>Check if the caster owns enought consummed Item, enough HP and MP to cast the skill</li> <li>
     * Check if the caster isn't sitting</li> <li>Check if all skills are enabled and this skill is enabled</li><BR>
     * <BR>
     * <li>Check if the caster own the weapon needed</li><BR>
     * <BR>
     * <li>Check if the skill is active</li><BR>
     * <BR>
     * <li>Check if all casting conditions are completed</li><BR>
     * <BR>
     * <li>Notify the AI with CAST and target</li><BR>
     * <BR>
     * @param skill The L2Skill to use
     * @param forceUse used to force ATTACK on players
     * @param dontMove used to prevent movement, if not in range
     */
    @Override
    public boolean useMagic(L2Skill skill, boolean forceUse, boolean dontMove)
    {
        // Check if the skill is active
        if (skill.isPassive())
        {
            sendPacket(ActionFailed.STATIC_PACKET);
            return false;
        }

        // Cancels the use of skills when player uses a cursed weapon or is flying.
        if ((isCursedWeaponEquipped() && !skill.isDemonicSkill()) // If CW, allow ONLY demonic skills.
            || (getMountType() == 1 && !skill.isStriderSkill()) // If mounted, allow ONLY Strider skills.
            || (getMountType() == 2 && !skill.isFlyingSkill())) // If flying, allow ONLY Wyvern skills.
        {
            sendPacket(ActionFailed.STATIC_PACKET);
            return false;
        }

        // Players wearing Formal Wear cannot use skills.
        final L2ItemInstance formal = getInventory().getPaperdollItem(Inventory.PAPERDOLL_CHEST);
        if (formal != null && formal.getItem().getBodyPart() == L2Item.SLOT_ALLDRESS)
        {
            sendPacket(SystemMessageId.CANNOT_USE_ITEMS_SKILLS_WITH_FORMALWEAR);
            sendPacket(ActionFailed.STATIC_PACKET);
            return false;
        }

        // ************************************* Check Casting in Progress *******************************************

        // If a skill is currently being used, queue this one if this is not the same
        if (isCastingNow())
        {
            SkillDat currentSkill = getCurrentSkill();
            // Check if new skill different from current skill in progress
            if (currentSkill != null && skill.getId() == currentSkill.getSkillId())
            {
                sendPacket(ActionFailed.STATIC_PACKET);
                return false;
            }

            if (Config.DEBUG && getQueuedSkill() != null)
                _log.info(getQueuedSkill().getSkill().getName() + " is already queued for " + getName() + ".");

            // Create a new SkillDat object and queue it in the player _queuedSkill
            setQueuedSkill(skill, forceUse, dontMove);
            sendPacket(ActionFailed.STATIC_PACKET);
            return false;
        }
        setIsCastingNow(true);

        // Create a new SkillDat object and set the player _currentSkill
        setCurrentSkill(skill, forceUse, dontMove);

        if (getQueuedSkill() != null) // wiping out previous values, after casting has been aborted
            setQueuedSkill(null, false, false);

        if (!checkUseMagicConditions(skill, forceUse, dontMove))
        {
            setIsCastingNow(false);
            return false;
        }

        // Check if the target is correct and Notify the AI with CAST and target
        L2Object target = null;

        switch (skill.getTargetType())
        {
            case TARGET_AURA: // AURA, SELF should be cast even if no target has been found
            case TARGET_FRONT_AURA:
            case TARGET_BEHIND_AURA:
            case TARGET_GROUND:
            case TARGET_SELF:
            case TARGET_AURA_UNDEAD:
                target = this;
                break;
            default:

                // Get the first target of the list
                target = skill.getFirstOfTargetList(this);
                break;
        }

        // Notify the AI with CAST and target
        getAI().setIntention(CtrlIntention.CAST, skill, target);
        return true;
    }

    private boolean checkUseMagicConditions(L2Skill skill, boolean forceUse, boolean dontMove)
    {
        L2SkillType sklType = skill.getSkillType();

        // ************************************* Check Player State *******************************************

        // Abnormal effects(ex : Stun, Sleep...) are checked in L2Character useMagic()

        if (isOutOfControl() || isParalyzed() || isStunned() || isSleeping())
        {
            sendPacket(ActionFailed.STATIC_PACKET);
            return false;
        }

        // Check if the player is dead
        if (isDead())
        {
            // Send ActionFailed to the L2PcInstance
            sendPacket(ActionFailed.STATIC_PACKET);
            return false;
        }

        if (isFishing() && (sklType != L2SkillType.PUMPING && sklType != L2SkillType.REELING && sklType != L2SkillType.FISHING))
        {
            // Only fishing skills are available
            sendPacket(SystemMessageId.ONLY_FISHING_SKILLS_NOW);
            return false;
        }

        if (inObserverMode())
        {
            sendPacket(SystemMessageId.OBSERVERS_CANNOT_PARTICIPATE);
            abortCast();
            sendPacket(ActionFailed.STATIC_PACKET);
            return false;
        }

        // Check if the caster is sitted. Toggle skills can be only removed, not activated.
        if (isSitting())
        {
            if (skill.isToggle())
            {
                // Get effects of the skill
                L2Effect effect = getFirstEffect(skill.getId());
                if (effect != null)
                {
                    effect.exit();

                    // Send ActionFailed to the L2PcInstance
                    sendPacket(ActionFailed.STATIC_PACKET);
                    return false;
                }
            }

            // Send a System Message to the caster
            sendPacket(SystemMessageId.CANT_MOVE_SITTING);

            // Send ActionFailed to the L2PcInstance
            sendPacket(ActionFailed.STATIC_PACKET);
            return false;
        }

        // Check if the skill type is TOGGLE
        if (skill.isToggle())
        {
            // Get effects of the skill
            L2Effect effect = getFirstEffect(skill.getId());

            if (effect != null)
            {
                // If the toggle is different of FakeDeath, you can de-activate it clicking on it.
                if (skill.getId() != 60)
                    effect.exit();

                // Send ActionFailed to the L2PcInstance
                sendPacket(ActionFailed.STATIC_PACKET);
                return false;
            }
        }

        // Check if the player uses "Fake Death" skill
        if (isFakeDeath())
        {
            // Send ActionFailed to the L2PcInstance
            sendPacket(ActionFailed.STATIC_PACKET);
            return false;
        }

        // ************************************* Check Target *******************************************
        // Create and set a L2Object containing the target of the skill
        L2Object target = null;
        SkillTargetType sklTargetType = skill.getTargetType();
        Point3D worldPosition = getCurrentSkillWorldPosition();

        if (sklTargetType == SkillTargetType.TARGET_GROUND && worldPosition == null)
        {
            _log.info("WorldPosition is null for skill: " + skill.getName() + ", player: " + getName() + ".");
            sendPacket(ActionFailed.STATIC_PACKET);
            return false;
        }

        switch (sklTargetType)
        {
        // Target the player if skill type is AURA, PARTY, CLAN or SELF
            case TARGET_AURA:
            case TARGET_FRONT_AURA:
            case TARGET_BEHIND_AURA:
            case TARGET_AURA_UNDEAD:
            case TARGET_PARTY:
            case TARGET_ALLY:
            case TARGET_CLAN:
            case TARGET_GROUND:
            case TARGET_SELF:
            case TARGET_AREA_SUMMON:
                target = this;
                break;
            case TARGET_PET:
            case TARGET_SUMMON:
                target = getPet();
                break;
            default:
                target = getTarget();
                break;
        }

        // Check the validity of the target
        if (target == null)
        {
            sendPacket(ActionFailed.STATIC_PACKET);
            return false;
        }

        if (target instanceof L2DoorInstance)
        {
            if (!((L2DoorInstance) target).isAttackable(this) // Siege doors only hittable during siege
                || (((L2DoorInstance) target).isUnlockable() && skill.getSkillType() != L2SkillType.UNLOCK)) // unlockable doors
            {
                sendPacket(SystemMessageId.INCORRECT_TARGET);
                sendPacket(ActionFailed.STATIC_PACKET);
                return false;
            }
        }

        // Are the target and the player in the same duel?
        if (isInDuel())
        {
            if (target instanceof L2Playable)
            {
                // Get L2PcInstance
                L2PcInstance cha = target.getActingPlayer();
                if (cha.getDuelId() != getDuelId())
                {
                    sendPacket(SystemMessageId.INCORRECT_TARGET);
                    sendPacket(ActionFailed.STATIC_PACKET);
                    return false;
                }
            }
        }

        // ************************************* Check skill availability *******************************************

        // Siege summon checks. Both checks send a message to the player if it return false.
        if (skill.isSiegeSummonSkill() && (!SiegeManager.checkIfOkToSummon(this) || !SevenSigns.getInstance().checkSummonConditions(this)))
            return false;

        // Check if this skill is enabled (ex : reuse time)
        if (isSkillDisabled(skill))
        {
            sendPacket(SystemMessage.getSystemMessage(SystemMessageId.S1_PREPARED_FOR_REUSE).addSkillName(skill));
            return false;
        }

        // ************************************* Check casting conditions *******************************************

        // Check if all casting conditions are completed
        if (!skill.checkCondition(this, target, false))
        {
            // Send ActionFailed to the L2PcInstance
            sendPacket(ActionFailed.STATIC_PACKET);
            return false;
        }

        // ************************************* Check Skill Type *******************************************

        // Check if this is offensive magic skill
        if (skill.isOffensive())
        {
            if (isInsidePeaceZone(this, target))
            {
                // If L2Character or target is in a peace zone, send a system message TARGET_IN_PEACEZONE ActionFailed
                sendPacket(SystemMessageId.TARGET_IN_PEACEZONE);
                sendPacket(ActionFailed.STATIC_PACKET);
                return false;
            }

            if (isInOlympiadMode() && !isOlympiadStart())
            {
                // if L2PcInstance is in Olympia and the match isn't already start, send ActionFailed
                sendPacket(ActionFailed.STATIC_PACKET);
                return false;
            }

            // Check if the target is attackable
            if (!target.isAttackable() && !getAccessLevel().allowPeaceAttack())
            {
                // If target is not attackable, send ActionFailed
                sendPacket(ActionFailed.STATIC_PACKET);
                return false;
            }

            // Check if a Forced ATTACK is in progress on non-attackable target
            if (!target.isAutoAttackable(this) && !forceUse)
            {
                switch (sklTargetType)
                {
                    case TARGET_AURA:
                    case TARGET_FRONT_AURA:
                    case TARGET_BEHIND_AURA:
                    case TARGET_AURA_UNDEAD:
                    case TARGET_CLAN:
                    case TARGET_ALLY:
                    case TARGET_PARTY:
                    case TARGET_SELF:
                    case TARGET_GROUND:
                    case TARGET_AREA_SUMMON:
                        break;
                    default: // Send ActionFailed to the L2PcInstance
                        sendPacket(ActionFailed.STATIC_PACKET);
                        return false;
                }
            }

            // Check if the target is in the skill cast range
            if (dontMove)
            {
                // Calculate the distance between the L2PcInstance and the target
                if (sklTargetType == SkillTargetType.TARGET_GROUND)
                {
                    if (!isInsideRadius(worldPosition.getX(), worldPosition.getY(), worldPosition.getZ(), skill.getCastRange() + getTemplate().getCollisionRadius(), false, false))
                    {
                        // Send a System Message to the caster
                        sendPacket(SystemMessageId.TARGET_TOO_FAR);

                        // Send ActionFailed to the L2PcInstance
                        sendPacket(ActionFailed.STATIC_PACKET);
                        return false;
                    }
                }
                else if (skill.getCastRange() > 0 && !isInsideRadius(target, skill.getCastRange() + getTemplate().getCollisionRadius(), false, false))
                {
                    // Send a System Message to the caster
                    sendPacket(SystemMessageId.TARGET_TOO_FAR);

                    // Send ActionFailed to the L2PcInstance
                    sendPacket(ActionFailed.STATIC_PACKET);
                    return false;
                }
            }
        }

        // Check if the skill is defensive
        if (!skill.isOffensive() && target instanceof L2MonsterInstance && !forceUse)
        {
            // check if the target is a monster and if force attack is set.. if not then we don't want to cast.
            switch (sklTargetType)
            {
                case TARGET_PET:
                case TARGET_SUMMON:
                case TARGET_AURA:
                case TARGET_FRONT_AURA:
                case TARGET_BEHIND_AURA:
                case TARGET_AURA_UNDEAD:
                case TARGET_CLAN:
                case TARGET_SELF:
                case TARGET_PARTY:
                case TARGET_ALLY:
                case TARGET_CORPSE_MOB:
                case TARGET_AREA_CORPSE_MOB:
                case TARGET_GROUND:
                    break;
                default:
                {
                    switch (sklType)
                    {
                        case BEAST_FEED:
                        case DELUXE_KEY_UNLOCK:
                        case UNLOCK:
                            break;
                        default:
                            sendPacket(ActionFailed.STATIC_PACKET);
                            return false;
                    }
                    break;
                }
            }
        }

        // Check if the skill is Spoil type and if the target isn't already spoiled
        if (sklType == L2SkillType.SPOIL)
        {
            if (!(target instanceof L2MonsterInstance))
            {
                // Send a System Message to the L2PcInstance
                sendPacket(SystemMessageId.INCORRECT_TARGET);

                // Send ActionFailed to the L2PcInstance
                sendPacket(ActionFailed.STATIC_PACKET);
                return false;
            }
        }

        // Check if the skill is Sweep type and if conditions not apply
        if (sklType == L2SkillType.SWEEP && target instanceof L2Attackable)
        {
            if (((L2Attackable) target).isDead())
            {
                final int spoilerId = ((L2Attackable) target).getIsSpoiledBy();
                if (spoilerId == 0)
                {
                    // Send a System Message to the L2PcInstance
                    sendPacket(SystemMessageId.SWEEPER_FAILED_TARGET_NOT_SPOILED);

                    // Send ActionFailed to the L2PcInstance
                    sendPacket(ActionFailed.STATIC_PACKET);
                    return false;
                }

                if (getObjectId() != spoilerId && !isInLooterParty(spoilerId))
                {
                    // Send a System Message to the L2PcInstance
                    sendPacket(SystemMessageId.SWEEP_NOT_ALLOWED);

                    // Send ActionFailed to the L2PcInstance
                    sendPacket(ActionFailed.STATIC_PACKET);
                    return false;
                }
            }
        }

        // Check if the skill is Drain Soul (Soul Crystals) and if the target is a MOB
        if (sklType == L2SkillType.DRAIN_SOUL)
        {
            if (!(target instanceof L2MonsterInstance))
            {
                // Send a System Message to the L2PcInstance
                sendPacket(SystemMessageId.INCORRECT_TARGET);

                // Send ActionFailed to the L2PcInstance
                sendPacket(ActionFailed.STATIC_PACKET);
                return false;
            }
        }

        // Check if this is a Pvp skill and target isn't a non-flagged/non-karma player
        switch (sklTargetType)
        {
            case TARGET_PARTY:
            case TARGET_ALLY: // For such skills, checkPvpSkill() is called from L2Skill.getTargetList()
            case TARGET_CLAN: // For such skills, checkPvpSkill() is called from L2Skill.getTargetList()
            case TARGET_AURA:
            case TARGET_FRONT_AURA:
            case TARGET_BEHIND_AURA:
            case TARGET_AURA_UNDEAD:
            case TARGET_GROUND:
            case TARGET_SELF:
                break;
            default:
                if (!checkPvpSkill(target, skill) && !getAccessLevel().allowPeaceAttack())
                {
                    // Send a System Message to the L2PcInstance
                    sendPacket(SystemMessageId.TARGET_IS_INCORRECT);

                    // Send ActionFailed to the L2PcInstance
                    sendPacket(ActionFailed.STATIC_PACKET);
                    return false;
                }
        }

        if ((sklTargetType == SkillTargetType.TARGET_HOLY && !checkIfOkToCastSealOfRule(CastleManager.getInstance().getCastle(this), false, skill, target)) || (sklType == L2SkillType.SIEGEFLAG && !L2SkillSiegeFlag.checkIfOkToPlaceFlag(this, false)) || (sklType == L2SkillType.STRSIEGEASSAULT && !checkIfOkToUseStriderSiegeAssault(skill)) || (sklType == L2SkillType.SUMMON_FRIEND && !(checkSummonerStatus(this) && checkSummonTargetStatus(target, this))))
        {
            sendPacket(ActionFailed.STATIC_PACKET);
            abortCast();
            return false;
        }

        // GeoData Los Check here
        if (skill.getCastRange() > 0)
        {
            if (sklTargetType == SkillTargetType.TARGET_GROUND)
            {
                if (!GeoData.getInstance().canSeeTarget(this, worldPosition))
                {
                    sendPacket(SystemMessageId.CANT_SEE_TARGET);
                    sendPacket(ActionFailed.STATIC_PACKET);
                    return false;
                }
            }
            else if (!GeoData.getInstance().canSeeTarget(this, target))
            {
                sendPacket(SystemMessageId.CANT_SEE_TARGET);
                sendPacket(ActionFailed.STATIC_PACKET);
                return false;
            }
        }
        // finally, after passing all conditions
        return true;
    }

    public boolean checkIfOkToUseStriderSiegeAssault(L2Skill skill)
    {
        SystemMessage sm;
        Castle castle = CastleManager.getInstance().getCastle(this);

        if (!isRiding())
            sm = SystemMessage.getSystemMessage(SystemMessageId.S1_CANNOT_BE_USED).addSkillName(skill);
        else if (!(getTarget() instanceof L2DoorInstance))
            sm = SystemMessage.getSystemMessage(SystemMessageId.INCORRECT_TARGET);
        else if (castle == null || castle.getCastleId() <= 0)
            sm = SystemMessage.getSystemMessage(SystemMessageId.S1_CANNOT_BE_USED).addSkillName(skill);
        else if (!castle.getSiege().isInProgress() || castle.getSiege().getAttackerClan(getClan()) == null)
            sm = SystemMessage.getSystemMessage(SystemMessageId.S1_CANNOT_BE_USED).addSkillName(skill);
        else
            return true;

        sendPacket(sm);
        return false;
    }

    public boolean checkIfOkToCastSealOfRule(Castle castle, boolean isCheckOnly, L2Skill skill, L2Object target)
    {
        SystemMessage sm;

        if (castle == null || castle.getCastleId() <= 0)
            sm = SystemMessage.getSystemMessage(SystemMessageId.S1_CANNOT_BE_USED).addSkillName(skill);
        else if (!castle.getArtefacts().contains(target))
            sm = SystemMessage.getSystemMessage(SystemMessageId.INCORRECT_TARGET);
        else if (!castle.getSiege().isInProgress())
            sm = SystemMessage.getSystemMessage(SystemMessageId.S1_CANNOT_BE_USED).addSkillName(skill);
        else if (!Util.checkIfInRange(200, this, target, true))
            sm = SystemMessage.getSystemMessage(SystemMessageId.DIST_TOO_FAR_CASTING_STOPPED);
        else if (!isInsideZone(ZoneId.CAST_ON_ARTIFACT))
            sm = SystemMessage.getSystemMessage(SystemMessageId.S1_CANNOT_BE_USED).addSkillName(skill);
        else if (castle.getSiege().getAttackerClan(getClan()) == null)
            sm = SystemMessage.getSystemMessage(SystemMessageId.S1_CANNOT_BE_USED).addSkillName(skill);
        else
        {
            if (!isCheckOnly)
            {
                sm = SystemMessage.getSystemMessage(SystemMessageId.OPPONENT_STARTED_ENGRAVING);
                castle.getSiege().announceToPlayer(sm, false);
            }
            return true;
        }
        sendPacket(sm);
        return false;
    }

    public boolean isInLooterParty(int LooterId)
    {
        L2PcInstance looter = L2World.getInstance().getPlayer(LooterId);

        // if L2PcInstance is in a CommandChannel
        if (isInParty() && getParty().isInCommandChannel() && looter != null)
            return getParty().getCommandChannel().getMembers().contains(looter);

        if (isInParty() && looter != null)
            return getParty().getPartyMembers().contains(looter);

        return false;
    }

    /**
     * Check if the requested casting is a Pc->Pc skill cast and if it's a valid pvp condition
     * @param target L2Object instance containing the target
     * @param skill L2Skill instance with the skill being casted
     * @return False if the skill is a pvpSkill and target is not a valid pvp target
     */
    public boolean checkPvpSkill(L2Object target, L2Skill skill)
    {
        return checkPvpSkill(target, skill, false);
    }

    /**
     * Check if the requested casting is a Pc->Pc skill cast and if it's a valid pvp condition
     * @param target L2Object instance containing the target
     * @param skill L2Skill instance with the skill being casted
     * @param srcIsSummon is L2Summon - caster?
     * @return False if the skill is a pvpSkill and target is not a valid pvp target
     */
    public boolean checkPvpSkill(L2Object target, L2Skill skill, boolean srcIsSummon)
    {
        // check for PC->PC Pvp status
        if (target instanceof L2Summon)
            target = target.getActingPlayer();

        if (target != null && target != this && target instanceof L2PcInstance && !(isInDuel() && ((L2PcInstance) target).getDuelId() == getDuelId()) && !isInsideZone(ZoneId.PVP) && !target.isInsideZone(ZoneId.PVP))
        {
            SkillDat skilldat = getCurrentSkill();
            SkillDat skilldatpet = getCurrentPetSkill();

            if (skill.isPvpSkill()) // pvp skill
            {
                // in clan war player can attack whites even with sleep etc.
                if (getClan() != null && ((L2PcInstance) target).getClan() != null)
                {
                    if (getClan().isAtWarWith(((L2PcInstance) target).getClan().getClanId()))
                        return true;
                }

                // target's pvp flag is not set and target has no karma
                if (((L2PcInstance) target).getPvpFlag() == 0 && ((L2PcInstance) target).getKarma() == 0)
                    return false;
            }
            else if ((skilldat != null && !skilldat.isCtrlPressed() && skill.isOffensive() && !srcIsSummon) || (skilldatpet != null && !skilldatpet.isCtrlPressed() && skill.isOffensive() && srcIsSummon))
            {
                // in clan war player can attack whites even with sleep etc.
                if (getClan() != null && ((L2PcInstance) target).getClan() != null)
                {
                    if (getClan().isAtWarWith(((L2PcInstance) target).getClan().getClanId()))
                        return true;
                }

                // target's pvp flag is not set and target has no karma
                if (((L2PcInstance) target).getPvpFlag() == 0 && ((L2PcInstance) target).getKarma() == 0)
                    return false;
            }
        }
        return true;
    }

    /**
     * @return True if the L2PcInstance is a Mage (based on class templates).
     */
    public boolean isMageClass()
    {
        return getClassId().isMage();
    }

    public boolean isMounted()
    {
        return _mountType > 0;
    }

    /**
     * This method allows to :<br>
     * - change isRiding/isFlying flags;<br>
     * - gift player with Wyvern Breath skill if mount is a wyvern;;<br>
     * - send the skillList (faded icons update)
     * @param npcId the npcId of the mount
     * @param npcLevel The level of the mount
     * @param mountType 0, 1 or 2 (dismount, strider or wyvern).
     * @return always true.
     */
    public boolean setMount(int npcId, int npcLevel, int mountType)
    {
        switch (mountType)
        {
            case 0: // Dismounted
                if (isFlying())
                    removeSkill(FrequentSkill.WYVERN_BREATH.getSkill());
                break;

            case 2: // Flying Wyvern
                addSkill(FrequentSkill.WYVERN_BREATH.getSkill(), false); // not saved to DB
                break;
        }

        _mountNpcId = npcId;
        _mountType = mountType;
        _mountLevel = npcLevel;

        sendSkillList(); // Update faded icons && eventual added skills.
        return true;
    }

    @Override
    public boolean isRiding()
    {
        return _mountType == 1;
    }

    @Override
    public boolean isFlying()
    {
        return _mountType == 2;
    }

    /**
     * @return the type of Pet mounted (0 : none, 1 : Strider, 2 : Wyvern).
     */
    public int getMountType()
    {
        return _mountType;
    }

    @Override
    public final void stopAllEffects()
    {
        super.stopAllEffects();
        updateAndBroadcastStatus(2);
    }

    @Override
    public final void stopAllEffectsExceptThoseThatLastThroughDeath()
    {
        super.stopAllEffectsExceptThoseThatLastThroughDeath();
        updateAndBroadcastStatus(2);
    }

    /**
     * Stop all toggle-type effects
     */
    public final void stopAllToggles()
    {
        _effects.stopAllToggles();
    }

    public final void stopCubics()
    {
        if (getCubics() != null)
        {
            boolean removed = false;
            for (L2CubicInstance cubic : getCubics().values())
            {
                cubic.stopAction();
                delCubic(cubic.getId());
                removed = true;
            }
            if (removed)
                broadcastUserInfo();
        }
    }

    public final void stopCubicsByOthers()
    {
        if (getCubics() != null)
        {
            boolean removed = false;
            for (L2CubicInstance cubic : getCubics().values())
            {
                if (cubic.givenByOther())
                {
                    cubic.stopAction();
                    delCubic(cubic.getId());
                    removed = true;
                }
            }
            if (removed)
                broadcastUserInfo();
        }
    }

    /**
     * Send UserInfo to this L2PcInstance and CharInfo to all L2PcInstance in its _KnownPlayers.<BR>
     * <BR>
     * <B><U> Concept</U> :</B><BR>
     * <BR>
     * Others L2PcInstance in the detection area of the L2PcInstance are identified in <B>_knownPlayers</B>. In order to inform other players of this L2PcInstance state modifications, server just need to go through _knownPlayers to send Server->Client Packet<BR>
     * <BR>
     * <B><U> Actions</U> :</B><BR>
     * <BR>
     * <li>Send UserInfo to this L2PcInstance (Public and Private Data)</li> <li>Send CharInfo to all L2PcInstance in _KnownPlayers of the L2PcInstance (Public data only)</li><BR>
     * <BR>
     * <FONT COLOR=#FF0000><B> <U>Caution</U> : DON'T SEND UserInfo packet to other players instead of CharInfo packet. Indeed, UserInfo packet contains PRIVATE DATA as MaxHP, STR, DEX...</B></FONT><BR>
     * <BR>
     */
    @Override
    public void updateAbnormalEffect()
    {
        broadcastUserInfo();
    }

    /**
     * Disable the Inventory and create a new task to enable it after 1.5s.
     */
    public void tempInventoryDisable()
    {
        _inventoryDisable = true;

        ThreadPoolManager.getInstance().scheduleGeneral(new InventoryEnable(), 1500);
    }

    /**
     * @return True if the Inventory is disabled.
     */
    public boolean isInventoryDisabled()
    {
        return _inventoryDisable;
    }

    protected class InventoryEnable implements Runnable
    {
        @Override
        public void run()
        {
            _inventoryDisable = false;
        }
    }

    public Map<Integer, L2CubicInstance> getCubics()
    {
        return _cubics;
    }

    /**
     * Add a L2CubicInstance to the L2PcInstance _cubics.
     * @param id
     * @param level
     * @param matk
     * @param activationtime
     * @param activationchance
     * @param totalLifetime
     * @param givenByOther
     */
    public void addCubic(int id, int level, double matk, int activationtime, int activationchance, int totalLifetime, boolean givenByOther)
    {
        if (Config.DEBUG)
            _log.info("L2PcInstance(" + getName() + "): addCubic(" + id + "|" + level + "|" + matk + ")");

        L2CubicInstance cubic = new L2CubicInstance(this, id, level, (int) matk, activationtime, activationchance, totalLifetime, givenByOther);
        _cubics.put(id, cubic);
    }

    /**
     * Remove a L2CubicInstance from the L2PcInstance _cubics.
     * @param id
     */
    public void delCubic(int id)
    {
        _cubics.remove(id);
    }

    /**
     * @param id
     * @return the L2CubicInstance corresponding to the Identifier of the L2PcInstance _cubics.
     */
    public L2CubicInstance getCubic(int id)
    {
        return _cubics.get(id);
    }

    @Override
    public String toString()
    {
        return "player " + getName();
    }

    /**
     * @return the modifier corresponding to the Enchant Effect of the Active Weapon (Min : 127).
     */
    public int getEnchantEffect()
    {
        L2ItemInstance wpn = getActiveWeaponInstance();

        if (wpn == null)
            return 0;

        return Math.min(127, wpn.getEnchantLevel());
    }

    /**
     * Set the _currentFolkNpc of the player.
     * @param npc
     */
    public void setCurrentFolkNPC(L2Npc npc)
    {
        _currentFolkNpc = npc;
    }

    /**
     * @return the _currentFolkNpc of the player.
     */
    public L2Npc getCurrentFolkNPC()
    {
        return _currentFolkNpc;
    }

    /**
     * @return True if L2PcInstance is a participant in the Festival of Darkness.
     */
    public boolean isFestivalParticipant()
    {
        return SevenSignsFestival.getInstance().isParticipant(this);
    }

    public void addAutoSoulShot(int itemId)
    {
        _activeSoulShots.add(itemId);
    }

    public boolean removeAutoSoulShot(int itemId)
    {
        return _activeSoulShots.remove(itemId);
    }

    public Set<Integer> getAutoSoulShot()
    {
        return _activeSoulShots;
    }

    @Override
    public boolean isChargedShot(ShotType type)
    {
        L2ItemInstance weapon = getActiveWeaponInstance();
        return weapon != null && weapon.isChargedShot(type);
    }

    @Override
    public void setChargedShot(ShotType type, boolean charged)
    {
        L2ItemInstance weapon = getActiveWeaponInstance();
        if (weapon != null)
            weapon.setChargedShot(type, charged);
    }

    @Override
    public void rechargeShots(boolean physical, boolean magic)
    {
        if (_activeSoulShots == null || _activeSoulShots.isEmpty())
            return;

        for (int itemId : _activeSoulShots)
        {
            L2ItemInstance item = getInventory().getItemByItemId(itemId);
            if (item != null)
            {
                if (magic && item.getItem().getDefaultAction() == L2ActionType.spiritshot)
                {
                    IItemHandler handler = ItemHandler.getInstance().getItemHandler(item.getEtcItem());
                    if (handler != null)
                        handler.useItem(this, item, false);
                }

                if (physical && item.getItem().getDefaultAction() == L2ActionType.soulshot)
                {
                    IItemHandler handler = ItemHandler.getInstance().getItemHandler(item.getEtcItem());
                    if (handler != null)
                        handler.useItem(this, item, false);
                }
            }
            else
                removeAutoSoulShot(itemId);
        }
    }

    /**
     * Cancel autoshot use for shot itemId
     * @param itemId int id to disable
     * @return true if canceled.
     */
    public boolean disableAutoShot(int itemId)
    {
        if (_activeSoulShots.contains(itemId))
        {
            removeAutoSoulShot(itemId);
            sendPacket(new ExAutoSoulShot(itemId, 0));
            sendPacket(SystemMessage.getSystemMessage(SystemMessageId.AUTO_USE_OF_S1_CANCELLED).addItemName(itemId));
            return true;
        }

        return false;
    }

    /**
     * Cancel all autoshots for player
     */
    public void disableAutoShotsAll()
    {
        for (int itemId : _activeSoulShots)
        {
            sendPacket(new ExAutoSoulShot(itemId, 0));
            sendPacket(SystemMessage.getSystemMessage(SystemMessageId.AUTO_USE_OF_S1_CANCELLED).addItemName(itemId));
        }
        _activeSoulShots.clear();
    }

    class LookingForFishTask implements Runnable
    {
        boolean _isNoob, _isUpperGrade;
        int _fishType, _fishGutsCheck;
        long _endTaskTime;

        protected LookingForFishTask(int fishWaitTime, int fishGutsCheck, int fishType, boolean isNoob, boolean isUpperGrade)
        {
            _fishGutsCheck = fishGutsCheck;
            _endTaskTime = System.currentTimeMillis() + fishWaitTime + 10000;
            _fishType = fishType;
            _isNoob = isNoob;
            _isUpperGrade = isUpperGrade;
        }

        @Override
        public void run()
        {
            if (System.currentTimeMillis() >= _endTaskTime)
            {
                endFishing(false);
                return;
            }

            if (_fishType == -1)
                return;

            int check = Rnd.get(1000);
            if (_fishGutsCheck > check)
            {
                stopLookingForFishTask();
                startFishCombat(_isNoob, _isUpperGrade);
            }
        }
    }

    public int getClanPrivileges()
    {
        return _clanPrivileges;
    }

    public void setClanPrivileges(int n)
    {
        _clanPrivileges = n;
    }

    // baron etc
    public void setPledgeClass(int classId)
    {
        _pledgeClass = classId;
    }

    public int getPledgeClass()
    {
        return _pledgeClass;
    }

    public void setPledgeType(int typeId)
    {
        _pledgeType = typeId;
    }

    public int getPledgeType()
    {
        return _pledgeType;
    }

    public int getApprentice()
    {
        return _apprentice;
    }

    public void setApprentice(int apprentice_id)
    {
        _apprentice = apprentice_id;
    }

    public int getSponsor()
    {
        return _sponsor;
    }

    public void setSponsor(int sponsor_id)
    {
        _sponsor = sponsor_id;
    }

    @Override
    public void sendMessage(String message)
    {
        sendPacket(SystemMessage.sendString(message));
    }

    /**
     * Unsummon all types of summons : pets, cubics, normal summons and trained beasts.
     */
    public void dropAllSummons()
    {
        // Delete summons and pets
        if (getPet() != null)
            getPet().unSummon(this);

        // Delete trained beasts
        if (getTrainedBeast() != null)
            getTrainedBeast().deleteMe();

        // Delete any form of cubics
        stopCubics();
    }

    public void enterObserverMode(int x, int y, int z)
    {
        _lastX = getX();
        _lastY = getY();
        _lastZ = getZ();

        _observerMode = true;

        if (isSitting())
            standUp();

        dropAllSummons();
        setTarget(null);
        setIsParalyzed(true);
        startParalyze();
        setIsInvul(true);
        getAppearance().setInvisible();

        sendPacket(new ObservationMode(x, y, z));
        getKnownList().removeAllKnownObjects(); // reinit knownlist
        setXYZ(x, y, z);

        broadcastUserInfo();
    }

    public void setLastCords(int x, int y, int z)
    {
        _lastX = getX();
        _lastY = getY();
        _lastZ = getZ();
    }

    public void enterOlympiadObserverMode(int id)
    {
        final OlympiadGameTask task = OlympiadGameManager.getInstance().getOlympiadTask(id);
        if (task == null)
            return;

        dropAllSummons();

        if (getParty() != null)
            getParty().removePartyMember(this, true);

        _olympiadGameId = id;

        if (isSitting())
            standUp();

        if (!_observerMode)
        {
            _lastX = getX();
            _lastY = getY();
            _lastZ = getZ();
        }

        _observerMode = true;
        setTarget(null);
        setIsInvul(true);
        getAppearance().setInvisible();
        teleToLocation(task.getZone().getSpawns().get(2), 0);
        sendPacket(new ExOlympiadMode(3));
        broadcastUserInfo();
    }

    public void leaveObserverMode()
    {
        setTarget(null);
        getKnownList().removeAllKnownObjects(); // reinit knownlist
        setXYZ(_lastX, _lastY, _lastZ);
        setIsParalyzed(false);
        stopParalyze(false);
        getAppearance().setVisible();
        setIsInvul(false);

        if (hasAI())
            getAI().setIntention(CtrlIntention.IDLE);

        // prevent receive falling damage
        setFalling();

        _observerMode = false;
        setLastCords(0, 0, 0);
        sendPacket(new ObservationReturn(this));
        broadcastUserInfo();
    }

    public void leaveOlympiadObserverMode()
    {
        if (_olympiadGameId == -1)
            return;

        _olympiadGameId = -1;
        _observerMode = false;

        setTarget(null);
        sendPacket(new ExOlympiadMode(0));
        teleToLocation(_lastX, _lastY, _lastZ, 20);
        getAppearance().setVisible();
        setIsInvul(false);

        if (hasAI())
            getAI().setIntention(CtrlIntention.IDLE);

        setLastCords(0, 0, 0);
        broadcastUserInfo();
    }

    public void setOlympiadSide(int i)
    {
        _olympiadSide = i;
    }

    public int getOlympiadSide()
    {
        return _olympiadSide;
    }

    public void setOlympiadGameId(int id)
    {
        _olympiadGameId = id;
    }

    public int getOlympiadGameId()
    {
        return _olympiadGameId;
    }

    public int getLastX()
    {
        return _lastX;
    }

    public int getLastY()
    {
        return _lastY;
    }

    public int getLastZ()
    {
        return _lastZ;
    }

    public boolean inObserverMode()
    {
        return _observerMode;
    }

    public int getTeleMode()
    {
        return _telemode;
    }

    public void setTeleMode(int mode)
    {
        _telemode = mode;
    }

    public void setLoto(int i, int val)
    {
        _loto[i] = val;
    }

    public int getLoto(int i)
    {
        return _loto[i];
    }

    public void setRace(int i, int val)
    {
        _race[i] = val;
    }

    public int getRace(int i)
    {
        return _race[i];
    }

    public boolean isInRefusalMode()
    {
        return _messageRefusal;
    }

    public void setInRefusalMode(boolean mode)
    {
        _messageRefusal = mode;
        sendPacket(new EtcStatusUpdate(this));
    }

    public void setTradeRefusal(boolean mode)
    {
        _tradeRefusal = mode;
    }

    public boolean getTradeRefusal()
    {
        return _tradeRefusal;
    }

    public void setExchangeRefusal(boolean mode)
    {
        _exchangeRefusal = mode;
    }

    public boolean getExchangeRefusal()
    {
        return _exchangeRefusal;
    }

    public BlockList getBlockList()
    {
        return _blockList;
    }

    public void setHero(boolean hero)
    {
        if (hero)
        {
            for (L2Skill s : SkillTable.getHeroSkills())
                addSkill(s, false); // Dont Save Hero skills to database
        }
        else
        {
            for (L2Skill s : SkillTable.getHeroSkills())
                super.removeSkill(s); // Just Remove skills from nonHero characters
        }
        _hero = hero;

        sendSkillList();
    }

    public void setIsInOlympiadMode(boolean b)
    {
        _inOlympiadMode = b;
    }

    public void setIsOlympiadStart(boolean b)
    {
        _OlympiadStart = b;
    }

    public boolean isOlympiadStart()
    {
        return _OlympiadStart;
    }

    public boolean isHero()
    {
        return _hero;
    }

    public boolean isInOlympiadMode()
    {
        return _inOlympiadMode;
    }

    public boolean isInDuel()
    {
        return _isInDuel;
    }

    public int getDuelId()
    {
        return _duelId;
    }

    public void setDuelState(int mode)
    {
        _duelState = mode;
    }

    public int getDuelState()
    {
        return _duelState;
    }

    /**
     * Sets up the duel state using a non 0 duelId.
     * @param duelId 0=not in a duel
     */
    public void setIsInDuel(int duelId)
    {
        if (duelId > 0)
        {
            _isInDuel = true;
            _duelState = Duel.DUELSTATE_DUELLING;
            _duelId = duelId;
        }
        else
        {
            if (_duelState == Duel.DUELSTATE_DEAD)
            {
                enableAllSkills();
                getStatus().startHpMpRegeneration();
            }
            _isInDuel = false;
            _duelState = Duel.DUELSTATE_NODUEL;
            _duelId = 0;
        }
    }

    /**
     * This returns a SystemMessage stating why the player is not available for duelling.
     * @return S1_CANNOT_DUEL... message
     */
    public SystemMessage getNoDuelReason()
    {
        SystemMessage sm = SystemMessage.getSystemMessage(_noDuelReason);
        sm.addPcName(this);
        _noDuelReason = SystemMessageId.THERE_IS_NO_OPPONENT_TO_RECEIVE_YOUR_CHALLENGE_FOR_A_DUEL;
        return sm;
    }

    /**
     * Checks if this player might join / start a duel. To get the reason use getNoDuelReason() after calling this function.
     * @return true if the player might join/start a duel.
     */
    public boolean canDuel()
    {
        if (isInCombat() || getPunishLevel() == PunishLevel.JAIL)
            _noDuelReason = SystemMessageId.S1_CANNOT_DUEL_BECAUSE_S1_IS_CURRENTLY_ENGAGED_IN_BATTLE;
        else if (isDead() || isAlikeDead() || (getCurrentHp() < getMaxHp() / 2 || getCurrentMp() < getMaxMp() / 2))
            _noDuelReason = SystemMessageId.S1_CANNOT_DUEL_BECAUSE_S1_HP_OR_MP_IS_BELOW_50_PERCENT;
        else if (isInDuel())
            _noDuelReason = SystemMessageId.S1_CANNOT_DUEL_BECAUSE_S1_IS_ALREADY_ENGAGED_IN_A_DUEL;
        else if (isInOlympiadMode())
            _noDuelReason = SystemMessageId.S1_CANNOT_DUEL_BECAUSE_S1_IS_PARTICIPATING_IN_THE_OLYMPIAD;
        else if (isCursedWeaponEquipped())
            _noDuelReason = SystemMessageId.S1_CANNOT_DUEL_BECAUSE_S1_IS_IN_A_CHAOTIC_STATE;
        else if (isInStoreMode())
            _noDuelReason = SystemMessageId.S1_CANNOT_DUEL_BECAUSE_S1_IS_CURRENTLY_ENGAGED_IN_A_PRIVATE_STORE_OR_MANUFACTURE;
        else if (isMounted() || isInBoat())
            _noDuelReason = SystemMessageId.S1_CANNOT_DUEL_BECAUSE_S1_IS_CURRENTLY_RIDING_A_BOAT_WYVERN_OR_STRIDER;
        else if (isFishing())
            _noDuelReason = SystemMessageId.S1_CANNOT_DUEL_BECAUSE_S1_IS_CURRENTLY_FISHING;
        else if (isInsideZone(ZoneId.PVP) || isInsideZone(ZoneId.PEACE) || isInsideZone(ZoneId.SIEGE))
            _noDuelReason = SystemMessageId.S1_CANNOT_MAKE_A_CHALLANGE_TO_A_DUEL_BECAUSE_S1_IS_CURRENTLY_IN_A_DUEL_PROHIBITED_AREA;
        else
            return true;

        return false;
    }

    public boolean isNoble()
    {
        return _noble;
    }

    /**
     * Set Noblesse Status, and reward with nobles' skills.
     * @param val Add skills if setted to true, else remove skills.
     * @param store Store the status directly in the db if setted to true.
     */
    public void setNoble(boolean val, boolean store)
    {
        if (val)
            for (L2Skill s : SkillTable.getNobleSkills())
                addSkill(s, false); // Dont Save Noble skills to Sql
        else
            for (L2Skill s : SkillTable.getNobleSkills())
                super.removeSkill(s); // Just Remove skills without deleting from Sql

        _noble = val;

        sendSkillList();

        if (store)
        {
            try (Connection con = L2DatabaseFactory.getInstance().getConnection())
            {
                PreparedStatement statement = con.prepareStatement(UPDATE_NOBLESS);
                statement.setBoolean(1, val);
                statement.setInt(2, getObjectId());
                statement.executeUpdate();
                statement.close();
            }
            catch (Exception e)
            {
                _log.log(Level.WARNING, "Could not update " + getName() + " nobless status: " + e.getMessage(), e);
            }
        }
    }

    public void setLvlJoinedAcademy(int lvl)
    {
        _lvlJoinedAcademy = lvl;
    }

    public int getLvlJoinedAcademy()
    {
        return _lvlJoinedAcademy;
    }

    public boolean isAcademyMember()
    {
        return _lvlJoinedAcademy > 0;
    }

    public void setTeam(int team)
    {
        _team = team;
    }

    public int getTeam()
    {
        return _team;
    }

    public void setWantsPeace(boolean wantsPeace)
    {
        _wantsPeace = wantsPeace;
    }

    public boolean wantsPeace()
    {
        return _wantsPeace;
    }

    public boolean isFishing()
    {
        return _fishingLoc != null;
    }

    public void setAllianceWithVarkaKetra(int sideAndLvlOfAlliance)
    {
        _alliedVarkaKetra = sideAndLvlOfAlliance;
    }

    /**
     * [-5,-1] varka, 0 neutral, [1,5] ketra
     * @return the side faction.
     */
    public int getAllianceWithVarkaKetra()
    {
        return _alliedVarkaKetra;
    }

    public boolean isAlliedWithVarka()
    {
        return (_alliedVarkaKetra < 0);
    }

    public boolean isAlliedWithKetra()
    {
        return (_alliedVarkaKetra > 0);
    }

    public void sendSkillList()
    {
        final L2ItemInstance formal = getInventory().getPaperdollItem(Inventory.PAPERDOLL_CHEST);
        final boolean isWearingFormalWear = formal != null && formal.getItem().getBodyPart() == L2Item.SLOT_ALLDRESS;

        boolean isDisabled = false;
        SkillList sl = new SkillList();
        for (L2Skill s : getAllSkills())
        {
            if (s == null)
                continue;

            if (s.getId() > 9000 && s.getId() < 9007)
                continue; // Fake skills to change base stats

            if (getClan() != null)
                isDisabled = s.isClanSkill() && getClan().getReputationScore() < 0;

            if (isCursedWeaponEquipped()) // Only Demonic skills are available
                isDisabled = !s.isDemonicSkill();
            else if (isMounted()) // else if, because only ONE state is possible
            {
                if (getMountType() == 1) // Only Strider skills are available
                    isDisabled = !s.isStriderSkill();
                else if (getMountType() == 2) // Only Wyvern skills are available
                    isDisabled = !s.isFlyingSkill();
            }

            if (isWearingFormalWear)
                isDisabled = true;

            sl.addSkill(s.getId(), s.getLevel(), s.isPassive(), isDisabled);
        }
        sendPacket(sl);
    }

    /**
     * 1. Add the specified class ID as a subclass (up to the maximum number of <b>three</b>) for this character.<BR>
     * 2. This method no longer changes the active _classIndex of the player. This is only done by the calling of setActiveClass() method as that should be the only way to do so.
     * @param classId
     * @param classIndex
     * @return boolean subclassAdded
     */
    public boolean addSubClass(int classId, int classIndex)
    {
        if (!_subclassLock.tryLock())
            return false;

        try
        {
            if (getTotalSubClasses() == 3 || classIndex == 0)
                return false;

            if (getSubClasses().containsKey(classIndex))
                return false;

            // Note: Never change _classIndex in any method other than setActiveClass().

            SubClass newClass = new SubClass();
            newClass.setClassId(classId);
            newClass.setClassIndex(classIndex);

            try (Connection con = L2DatabaseFactory.getInstance().getConnection())
            {
                PreparedStatement statement = con.prepareStatement(ADD_CHAR_SUBCLASS);
                statement.setInt(1, getObjectId());
                statement.setInt(2, newClass.getClassId());
                statement.setLong(3, newClass.getExp());
                statement.setInt(4, newClass.getSp());
                statement.setInt(5, newClass.getLevel());
                statement.setInt(6, newClass.getClassIndex()); // <-- Added

                statement.execute();
                statement.close();
            }
            catch (Exception e)
            {
                _log.warning("WARNING: Could not add character sub class for " + getName() + ": " + e);
                return false;
            }

            // Commit after database INSERT incase exception is thrown.
            getSubClasses().put(newClass.getClassIndex(), newClass);

            if (Config.DEBUG)
                _log.info(getName() + " added class ID " + classId + " as a sub class at index " + classIndex + ".");

            ClassId subTemplate = ClassId.values()[classId];
            Collection<L2SkillLearn> skillTree = SkillTreeTable.getInstance().getAllowedSkills(subTemplate);

            if (skillTree == null)
                return true;

            final Map<Integer, L2Skill> prevSkillList = new LinkedHashMap<>();

            for (L2SkillLearn skillInfo : skillTree)
            {
                if (skillInfo.getMinLevel() <= 40)
                {
                    L2Skill prevSkill = prevSkillList.get(skillInfo.getId());
                    L2Skill newSkill = SkillTable.getInstance().getInfo(skillInfo.getId(), skillInfo.getLevel());

                    if (prevSkill != null && (prevSkill.getLevel() > newSkill.getLevel()))
                        continue;

                    prevSkillList.put(newSkill.getId(), newSkill);
                    storeSkill(newSkill, prevSkill, classIndex);
                }
            }

            if (Config.DEBUG)
                _log.info(getName() + " was given " + getAllSkills().length + " skills for their new sub class.");

            return true;
        }
        finally
        {
            _subclassLock.unlock();
        }
    }

    /**
     * 1. Completely erase all existance of the subClass linked to the classIndex.<BR>
     * 2. Send over the newClassId to addSubClass()to create a new instance on this classIndex.<BR>
     * 3. Upon Exception, revert the player to their BaseClass to avoid further problems.<BR>
     * @param classIndex
     * @param newClassId
     * @return boolean subclassAdded
     */
    public boolean modifySubClass(int classIndex, int newClassId)
    {
        if (!_subclassLock.tryLock())
            return false;

        try
        {
            int oldClassId = getSubClasses().get(classIndex).getClassId();

            if (Config.DEBUG)
                _log.info(getName() + " has requested to modify sub class index " + classIndex + " from class ID " + oldClassId + " to " + newClassId + ".");

            try (Connection con = L2DatabaseFactory.getInstance().getConnection())
            {
                // Remove all henna info stored for this sub-class.
                PreparedStatement statement = con.prepareStatement(DELETE_CHAR_HENNAS);
                statement.setInt(1, getObjectId());
                statement.setInt(2, classIndex);
                statement.execute();
                statement.close();

                // Remove all shortcuts info stored for this sub-class.
                statement = con.prepareStatement(DELETE_CHAR_SHORTCUTS);
                statement.setInt(1, getObjectId());
                statement.setInt(2, classIndex);
                statement.execute();
                statement.close();

                // Remove all effects info stored for this sub-class.
                statement = con.prepareStatement(DELETE_SKILL_SAVE);
                statement.setInt(1, getObjectId());
                statement.setInt(2, classIndex);
                statement.execute();
                statement.close();

                // Remove all skill info stored for this sub-class.
                statement = con.prepareStatement(DELETE_CHAR_SKILLS);
                statement.setInt(1, getObjectId());
                statement.setInt(2, classIndex);
                statement.execute();
                statement.close();

                // Remove all basic info stored about this sub-class.
                statement = con.prepareStatement(DELETE_CHAR_SUBCLASS);
                statement.setInt(1, getObjectId());
                statement.setInt(2, classIndex);
                statement.execute();
                statement.close();
            }
            catch (Exception e)
            {
                _log.warning("Could not modify subclass for " + getName() + " to class index " + classIndex + ": " + e);

                // This must be done in order to maintain data consistency.
                getSubClasses().remove(classIndex);
                return false;
            }

            getSubClasses().remove(classIndex);
        }
        finally
        {
            _subclassLock.unlock();
        }

        return addSubClass(newClassId, classIndex);
    }

    public boolean isSubClassActive()
    {
        return _classIndex > 0;
    }

    public Map<Integer, SubClass> getSubClasses()
    {
        return _subClasses;
    }

    public int getTotalSubClasses()
    {
        return getSubClasses().size();
    }

    public int getBaseClass()
    {
        return _baseClass;
    }

    public int getActiveClass()
    {
        return _activeClass;
    }

    public int getClassIndex()
    {
        return _classIndex;
    }

    private void setClassTemplate(int classId)
    {
        _activeClass = classId;

        L2PcTemplate t = CharTemplateTable.getInstance().getTemplate(classId);

        if (t == null)
        {
            _log.severe("Missing template for classId: " + classId);
            throw new Error();
        }

        // Set the template of the L2PcInstance
        setTemplate(t);
    }

    /**
     * Changes the character's class based on the given class index. <BR>
     * <BR>
     * An index of zero specifies the character's original (base) class, while indexes 1-3 specifies the character's sub-classes respectively.
     * @param classIndex
     * @return true if successful.
     */
    public boolean setActiveClass(int classIndex)
    {
        if (!_subclassLock.tryLock())
            return false;

        try
        {
            // Remove active item skills before saving char to database because next time when choosing this class, worn items can be different
            for (L2ItemInstance item : getInventory().getAugmentedItems())
            {
                if (item != null && item.isEquipped())
                    item.getAugmentation().removeBonus(this);
            }

            // abort any kind of cast.
            abortCast();

            // Stop casting for any player that may be casting a force buff on this l2pcinstance.
            for (L2Character character : getKnownList().getKnownType(L2Character.class))
                if (character.getFusionSkill() != null && character.getFusionSkill().getTarget() == this)
                    character.abortCast();

            /*
             * 1. Call store() before modifying _classIndex to avoid skill effects rollover. 2. Register the correct _classId against applied 'classIndex'.
             */
            store();
            _reuseTimeStamps.clear();

            // clear charges
            _charges.set(0);
            stopChargeTask();

            if (classIndex == 0)
                setClassTemplate(getBaseClass());
            else
            {
                try
                {
                    setClassTemplate(getSubClasses().get(classIndex).getClassId());
                }
                catch (Exception e)
                {
                    _log.info("Could not switch " + getName() + "'s sub class to class index " + classIndex + ": " + e);
                    return false;
                }
            }
            _classIndex = classIndex;

            if (isInParty())
                getParty().recalculatePartyLevel();

            /*
             * Update the character's change in class status. 1. Remove any active cubics from the player. 2. Renovate the characters table in the database with the new class info, storing also buff/effect data. 3. Remove all existing skills. 4. Restore all the learned skills for the current class
             * from the database. 5. Restore effect/buff data for the new class. 6. Restore henna data for the class, applying the new stat modifiers while removing existing ones. 7. Reset HP/MP/CP stats and send Server->Client character status packet to reflect changes. 8. Restore shortcut data
             * related to this class. 9. Resend a class change animation effect to broadcast to all nearby players. 10.Unsummon any active servitor from the player.
             */

            if (getPet() instanceof L2SummonInstance)
                getPet().unSummon(this);

            for (L2Skill oldSkill : getAllSkills())
                super.removeSkill(oldSkill);

            stopAllEffectsExceptThoseThatLastThroughDeath();
            stopCubics();

            if (isSubClassActive())
            {
                _dwarvenRecipeBook.clear();
                _commonRecipeBook.clear();
            }
            else
            {
                restoreRecipeBook();
            }

            // Restore any Death Penalty Buff
            restoreDeathPenaltyBuffLevel();

            restoreSkills();
            rewardSkills();
            regiveTemporarySkills();

            // Prevents some issues when changing between subclases that shares skills
            if (_disabledSkills != null && !_disabledSkills.isEmpty())
                _disabledSkills.clear();

            restoreEffects();
            updateEffectIcons();
            sendPacket(new EtcStatusUpdate(this));

            // If player has quest "Repent Your Sins", remove it
            QuestState st = getQuestState("Q422_RepentYourSins");
            if (st != null)
                st.exitQuest(true);

            for (int i = 0; i < 3; i++)
                _henna[i] = null;

            restoreHenna();
            sendPacket(new HennaInfo(this));

            if (getCurrentHp() > getMaxHp())
                setCurrentHp(getMaxHp());
            if (getCurrentMp() > getMaxMp())
                setCurrentMp(getMaxMp());
            if (getCurrentCp() > getMaxCp())
                setCurrentCp(getMaxCp());

            refreshOverloaded();
            refreshExpertisePenalty();
            broadcastUserInfo();

            // Clear resurrect xp calculation
            setExpBeforeDeath(0);

            _shortCuts.restore();
            sendPacket(new ShortCutInit(this));

            broadcastPacket(new SocialAction(this, 15));
            sendPacket(new SkillCoolTime(this));

            if(isVoteBuff())
            {
                final L2Skill skill = SkillTable.getInstance().getInfo(7083, 1);
                if(skill != null)
                {
                  addSkill(skill,false);
                  sendSkillList();
                }
            }
            else
            {
                removeSkill(SkillTable.getInstance().getInfo(7083, 1),true);
            }

            return true;
        }
        finally
        {
            _subclassLock.unlock();
        }
    }

    public boolean isLocked()
    {
        return _subclassLock.isLocked();
    }

    public boolean isVoteBuff()
    {
        return _isVoteBuff;
    }

    public void setVoteBuff(boolean val)
    {
        _isVoteBuff = val;
    }
    public long getVoteBuffEndTime()
    {
        return _votebuff_endTime;
    }

    public long getvotetime()
    {
        try (Connection con = L2DatabaseFactory.getInstance().getConnection())
        {
            PreparedStatement statement = con.prepareStatement("SELECT vote_end_buff FROM characters WHERE obj_Id=?");
            statement.setInt(1, getObjectId());
            ResultSet rset = statement.executeQuery();
            while(rset.next())
            {
                _votebuff_endTime = rset.getLong("vote_end_buff");
            }
            rset.close();
            statement.close();
        }
        catch (Exception e)
        {
            _log.log(Level.WARNING, "Error found in " + getName() + "'s Vote Buff: " + e.getMessage(), e);
        }

        return _votebuff_endTime - System.currentTimeMillis();
    }

    public void setVoteBuffEndTime(long val)
    {
        _votebuff_endTime = val;
    }

    private boolean _isVoting = false;

    public final boolean isVoting()
    {
        return _isVoting;
    }

    public final void setIsVoting(boolean value)
    {
        _isVoting = value;
    }

    public void setEndVoteBuff(int val)
    {
         Calendar calendar = Calendar.getInstance();
          calendar.add(Calendar.HOUR, val);
         long end_hours = calendar.getTimeInMillis();
         _votebuff_endTime = end_hours;
   }

    public void stopWaterTask()
    {
        if (_isInWater)
        {
            _isInWater = false;
            sendPacket(new SetupGauge(2, 0));
            WaterTaskManager.getInstance().removeWaterTask(this);
        }
    }

    public void startWaterTask()
    {
        if (!isDead() && !_isInWater)
        {
            _isInWater = true;
            int time = (int) calcStat(Stats.BREATH, 60000, this, null);

            sendPacket(new SetupGauge(2, time));
            WaterTaskManager.getInstance().addWaterTask(this, System.currentTimeMillis() + time);
        }
    }

    public void checkWaterState()
    {
        if (isInsideZone(ZoneId.WATER))
            startWaterTask();
        else
            stopWaterTask();
    }

    public void onPlayerEnter()
    {
        if (isCursedWeaponEquipped())
            CursedWeaponsManager.getInstance().getCursedWeapon(getCursedWeaponEquippedId()).cursedOnLogin();

        // Add a task for the "Take Break" message.
        TakeBreakTaskManager.getInstance().addTakeBreakTask(this);

        // Teleport player if the Seven Signs period isn't the good one, or if the player isn't in a cabal.
        if (isIn7sDungeon() && !isGM())
        {
            if (SevenSigns.getInstance().isSealValidationPeriod() || SevenSigns.getInstance().isCompResultsPeriod())
            {
                if (SevenSigns.getInstance().getPlayerCabal(getObjectId()) != SevenSigns.getInstance().getCabalHighestScore())
                {
                    teleToLocation(MapRegionTable.TeleportWhereType.Town);
                    setIsIn7sDungeon(false);
                }
            }
            else if (SevenSigns.getInstance().getPlayerCabal(getObjectId()) == SevenSigns.CABAL_NULL)
            {
                teleToLocation(MapRegionTable.TeleportWhereType.Town);
                setIsIn7sDungeon(false);
            }
        }

        // Jail task
        updatePunishState();

        if (isGM())
        {
            if (isInvul())
                sendMessage("Entering world in Invulnerable mode.");
            if (getAppearance().getInvisible())
                sendMessage("Entering world in Invisible mode.");
            if (isInRefusalMode())
                sendMessage("Entering world in Message Refusal mode.");
        }

        revalidateZone(true);
        notifyFriends(true);
    }

    public long getLastAccess()
    {
        return _lastAccess;
    }

    private void checkRecom(int recsHave, int recsLeft)
    {
        Calendar check = Calendar.getInstance();
        check.setTimeInMillis(_lastRecomUpdate);
        check.add(Calendar.DAY_OF_MONTH, 1);

        Calendar min = Calendar.getInstance();

        _recomHave = recsHave;
        _recomLeft = recsLeft;

        if (getStat().getLevel() < 10 || check.after(min))
            return;

        restartRecom();
    }

    public void restartRecom()
    {
        try (Connection con = L2DatabaseFactory.getInstance().getConnection())
        {
            PreparedStatement statement = con.prepareStatement(DELETE_CHAR_RECOMS);
            statement.setInt(1, getObjectId());
            statement.execute();
            statement.close();

            _recomChars.clear();
        }
        catch (Exception e)
        {
            _log.warning("could not clear char recommendations: " + e);
        }

        if (getStat().getLevel() < 20)
        {
            _recomLeft = 3;
            _recomHave--;
        }
        else if (getStat().getLevel() < 40)
        {
            _recomLeft = 6;
            _recomHave -= 2;
        }
        else
        {
            _recomLeft = 9;
            _recomHave -= 3;
        }

        if (_recomHave < 0)
            _recomHave = 0;

        // If we have to update last update time, but it's now before 13, we should set it to yesterday
        Calendar update = Calendar.getInstance();
        if (update.get(Calendar.HOUR_OF_DAY) < 13)
            update.add(Calendar.DAY_OF_MONTH, -1);

        update.set(Calendar.HOUR_OF_DAY, 13);
        _lastRecomUpdate = update.getTimeInMillis();
    }

    @Override
    public void doRevive()
    {
        super.doRevive();
        stopEffects(L2EffectType.CHARMOFCOURAGE);
        sendPacket(new EtcStatusUpdate(this));
        _reviveRequested = 0;
        _revivePower = 0;

        if (isMounted())
            startFeed(_mountNpcId);

        if (isInParty() && getParty().isInDimensionalRift())
        {
            if (!DimensionalRiftManager.getInstance().checkIfInPeaceZone(getX(), getY(), getZ()))
                getParty().getDimensionalRift().memberRessurected(this);
        }
    }

    @Override
    public void doRevive(double revivePower)
    {
        // Restore the player's lost experience,
        // depending on the % return of the skill used (based on its power).
        restoreExp(revivePower);
        doRevive();
    }

    public void reviveRequest(L2PcInstance Reviver, L2Skill skill, boolean Pet)
    {
        if (_reviveRequested == 1)
        {
            // Resurrection has already been proposed.
            if (_revivePet == Pet)
                Reviver.sendPacket(SystemMessageId.RES_HAS_ALREADY_BEEN_PROPOSED);
            else
            {
                if (Pet)
                    // A pet cannot be resurrected while it's owner is in the process of resurrecting.
                    Reviver.sendPacket(SystemMessageId.CANNOT_RES_PET2);
                else
                    // While a pet is attempting to resurrect, it cannot help in resurrecting its master.
                    Reviver.sendPacket(SystemMessageId.MASTER_CANNOT_RES);
            }
            return;
        }

        if ((Pet && getPet() != null && getPet().isDead()) || (!Pet && isDead()))
        {
            _reviveRequested = 1;

            if (isPhoenixBlessed())
                _revivePower = 100;
            else if (isAffected(L2EffectFlag.CHARM_OF_COURAGE))
                _revivePower = 0;
            else
                _revivePower = Formulas.calculateSkillResurrectRestorePercent(skill.getPower(), Reviver);

            _revivePet = Pet;

            if (isAffected(L2EffectFlag.CHARM_OF_COURAGE))
            {
                sendPacket(new ConfirmDlg(SystemMessageId.DO_YOU_WANT_TO_BE_RESTORED).addTime(60000));
                return;
            }

            sendPacket(new ConfirmDlg(SystemMessageId.RESSURECTION_REQUEST_BY_S1).addPcName(Reviver));
        }
    }

    public void reviveAnswer(int answer)
    {
        if (_reviveRequested != 1 || (!isDead() && !_revivePet) || (_revivePet && getPet() != null && !getPet().isDead()))
            return;

        if (answer == 0 && isPhoenixBlessed())
            stopPhoenixBlessing(null);
        else if (answer == 1)
        {
            if (!_revivePet)
            {
                if (_revivePower != 0)
                    doRevive(_revivePower);
                else
                    doRevive();
            }
            else if (getPet() != null)
            {
                if (_revivePower != 0)
                    getPet().doRevive(_revivePower);
                else
                    getPet().doRevive();
            }
        }
        _reviveRequested = 0;
        _revivePower = 0;
    }

    public boolean isReviveRequested()
    {
        return (_reviveRequested == 1);
    }

    public boolean isRevivingPet()
    {
        return _revivePet;
    }

    public void removeReviving()
    {
        _reviveRequested = 0;
        _revivePower = 0;
    }

    public void onActionRequest()
    {
        setProtection(false);
    }

    /**
     * @param expertiseIndex The expertiseIndex to set.
     */
    public void setExpertiseIndex(int expertiseIndex)
    {
        _expertiseIndex = expertiseIndex;
    }

    /**
     * @return Returns the expertiseIndex.
     */
    public int getExpertiseIndex()
    {
        return _expertiseIndex;
    }

    @Override
    public final void onTeleported()
    {
        super.onTeleported();

        // Force a revalidation
        revalidateZone(true);

        if (Config.PLAYER_SPAWN_PROTECTION > 0)
            setProtection(true);

        // Stop toggles upon teleport.
        if (!isGM())
            stopAllToggles();

        // Modify the position of the tamed beast if necessary
        if (getTrainedBeast() != null)
        {
            getTrainedBeast().getAI().stopFollow();
            getTrainedBeast().teleToLocation(getPosition().getX(), getPosition().getY(), getPosition().getZ(), 0);
            getTrainedBeast().getAI().startFollow(this);
        }

        // Modify the position of the pet if necessary
        L2Summon pet = getPet();
        if (pet != null)
        {
            pet.setFollowStatus(false);
            pet.teleToLocation(getPosition().getX(), getPosition().getY(), getPosition().getZ(), 0);
            ((L2SummonAI) pet.getAI()).setStartFollowController(true);
            pet.setFollowStatus(true);
        }
    }

    public void setLastServerPosition(int x, int y, int z)
    {
        _lastServerPosition.setXYZ(x, y, z);
    }

    public boolean checkLastServerPosition(int x, int y, int z)
    {
        return _lastServerPosition.equals(x, y, z);
    }

    public int getLastServerDistance(int x, int y, int z)
    {
        double dx = (x - _lastServerPosition.getX());
        double dy = (y - _lastServerPosition.getY());
        double dz = (z - _lastServerPosition.getZ());

        return (int) Math.sqrt(dx * dx + dy * dy + dz * dz);
    }

    @Override
    public void addExpAndSp(long addToExp, int addToSp)
    {
        getStat().addExpAndSp(addToExp, addToSp);
    }

    public void removeExpAndSp(long removeExp, int removeSp)
    {
        getStat().removeExpAndSp(removeExp, removeSp);
    }

    @Override
    public void reduceCurrentHp(double value, L2Character attacker, boolean awake, boolean isDOT, L2Skill skill)
    {
        if (skill != null)
            getStatus().reduceHp(value, attacker, awake, isDOT, skill.isToggle(), skill.getDmgDirectlyToHP());
        else
            getStatus().reduceHp(value, attacker, awake, isDOT, false, false);

        // notify the tamed beast of attacks
        if (getTrainedBeast() != null)
            getTrainedBeast().onOwnerGotAttacked(attacker);
    }

    public void broadcastSnoop(int type, String name, String _text)
    {
        if (_snoopListener.size() > 0)
        {
            Snoop sn = new Snoop(getObjectId(), getName(), type, name, _text);

            for (L2PcInstance pci : _snoopListener)
                if (pci != null)
                    pci.sendPacket(sn);
        }
    }

    public void addSnooper(L2PcInstance pci)
    {
        if (!_snoopListener.contains(pci))
            _snoopListener.add(pci);
    }

    public void removeSnooper(L2PcInstance pci)
    {
        _snoopListener.remove(pci);
    }

    public void addSnooped(L2PcInstance pci)
    {
        if (!_snoopedPlayer.contains(pci))
            _snoopedPlayer.add(pci);
    }

    public void removeSnooped(L2PcInstance pci)
    {
        _snoopedPlayer.remove(pci);
    }

    public synchronized void addBypass(String bypass)
    {
        if (bypass == null)
            return;

        _validBypass.add(bypass);
    }

    public synchronized void addBypass2(String bypass)
    {
        if (bypass == null)
            return;

        _validBypass2.add(bypass);
    }

    public synchronized boolean validateBypass(String cmd)
    {
        for (String bp : _validBypass)
        {
            if (bp == null)
                continue;

            if (bp.equals(cmd))
                return true;
        }

        for (String bp : _validBypass2)
        {
            if (bp == null)
                continue;

            if (cmd.startsWith(bp))
                return true;
        }

        if (Config.DEBUG)
            _log.warning(getName() + " sent an invalid bypass: '" + cmd + "'.");

        return false;
    }

    public boolean validateItemManipulation(int objectId, String action)
    {
        L2ItemInstance item = getInventory().getItemByObjectId(objectId);

        if (item == null || item.getOwnerId() != getObjectId())
        {
            _log.finest(getObjectId() + ": player tried to " + action + " item he is not owner of");
            return false;
        }

        // Pet is summoned and not the item that summoned the pet AND not the buggle from strider you're mounting
        if (getPet() != null && getPet().getControlItemId() == objectId || getMountObjectID() == objectId)
        {
            if (Config.DEBUG)
                _log.finest(getObjectId() + ": player tried to " + action + " item controling pet");

            return false;
        }

        if (getActiveEnchantItem() != null && getActiveEnchantItem().getObjectId() == objectId)
        {
            if (Config.DEBUG)
                _log.finest(getObjectId() + ":player tried to " + action + " an enchant scroll he was using");

            return false;
        }

        if (CursedWeaponsManager.getInstance().isCursed(item.getItemId()))
        {
            // can not trade a cursed weapon
            return false;
        }

        return true;
    }

    public synchronized void clearBypass()
    {
        _validBypass.clear();
        _validBypass2.clear();
    }

    /**
     * @return Returns the inBoat.
     */
    public boolean isInBoat()
    {
        return _vehicle != null && _vehicle.isBoat();
    }

    /**
     * @return
     */
    public L2BoatInstance getBoat()
    {
        return (L2BoatInstance) _vehicle;
    }

    public L2Vehicle getVehicle()
    {
        return _vehicle;
    }

    public void setVehicle(L2Vehicle v)
    {
        if (v == null && _vehicle != null)
            _vehicle.removePassenger(this);

        _vehicle = v;
    }

    public void setInCrystallize(boolean inCrystallize)
    {
        _inCrystallize = inCrystallize;
    }

    public boolean isInCrystallize()
    {
        return _inCrystallize;
    }

    /**
     * @return
     */
    public Point3D getInVehiclePosition()
    {
        return _inVehiclePosition;
    }

    public void setInVehiclePosition(Point3D pt)
    {
        _inVehiclePosition = pt;
    }

    /**
     * Manage the delete task of a L2PcInstance (Leave Party, Unsummon pet, Save its inventory in the database, Remove it from the world...).<BR>
     * <BR>
     * <B><U> Actions</U> :</B><BR>
     * <BR>
     * <li>If the L2PcInstance is in observer mode, set its position to its position before entering in observer mode</li> <li>Set the online Flag to True or False and update the characters table of the database with online status and lastAccess</li> <li>Stop the HP/MP/CP Regeneration task</li> <li>
     * Cancel Crafting, Attak or Cast</li> <li>Remove the L2PcInstance from the world</li> <li>Stop Party and Unsummon Pet</li> <li>Update database with items in its inventory and remove them from the world</li> <li>Remove all L2Object from _knownObjects and _knownPlayer of the L2Character then
     * cancel Attak or Cast and notify AI</li> <li>Close the connection with the client</li><BR>
     * <BR>
     */
    @Override
    public void deleteMe()
    {
        cleanup();
        store();
        super.deleteMe();
    }

    private synchronized void cleanup()
    {
        try
        {
            if (!isOnline())
                _log.log(Level.SEVERE, "deleteMe() called on offline character " + this, new RuntimeException());

            // Put the online status to false
            setOnlineStatus(false, true);

            // abort cast & attack and remove the target. Cancels movement aswell.
            abortAttack();
            abortCast();
            stopMove(null);
            setTarget(null);

            PartyMatchWaitingList.getInstance().removePlayer(this);
            if (_partyroom != 0)
            {
                PartyMatchRoom room = PartyMatchRoomList.getInstance().getRoom(_partyroom);
                if (room != null)
                    room.deleteMember(this);
            }

            if (isFlying())
                removeSkill(SkillTable.getInstance().getInfo(4289, 1));

            // Stop all scheduled tasks
            stopAllTimers();

            // Cancel the cast of eventual fusion skill users on this target.
            for (L2Character character : getKnownList().getKnownType(L2Character.class))
                if (character.getFusionSkill() != null && character.getFusionSkill().getTarget() == this)
                    character.abortCast();

            // Stop signets & toggles effects.
            for (L2Effect effect : getAllEffects())
            {
                if (effect.getSkill().isToggle())
                {
                    effect.exit();
                    continue;
                }

                switch (effect.getEffectType())
                {
                    case SIGNET_GROUND:
                    case SIGNET_EFFECT:
                        effect.exit();
                        break;
                }
            }

            // Remove the L2PcInstance from the world
            decayMe();

            // Remove from world regions zones
            L2WorldRegion oldRegion = getWorldRegion();
            if (oldRegion != null)
                oldRegion.removeFromZones(this);

            // If a party is in progress, leave it
            if (isInParty())
                leaveParty();

            // If the L2PcInstance has Pet, unsummon it
            if (getPet() != null)
                getPet().unSummon(this);

            // Handle removal from olympiad game
            if (OlympiadManager.getInstance().isRegistered(this) || getOlympiadGameId() != -1)
                OlympiadManager.getInstance().removeDisconnectedCompetitor(this);

            // set the status for pledge member list to OFFLINE
            if (getClan() != null)
            {
                L2ClanMember clanMember = getClan().getClanMember(getObjectId());
                if (clanMember != null)
                    clanMember.setPlayerInstance(null);
            }

            // deals with sudden exit in the middle of transaction
            if (getActiveRequester() != null)
            {
                setActiveRequester(null);
                cancelActiveTrade();
            }

            // If the L2PcInstance is a GM, remove it from the GM List
            if (isGM())
                GmListTable.getInstance().deleteGm(this);

            // Check if the L2PcInstance is in observer mode to set its position to its position
            // before entering in observer mode
            if (inObserverMode())
                setXYZInvisible(_lastX, _lastY, _lastZ);

            // Oust player from boat
            if (getVehicle() != null)
                getVehicle().oustPlayer(this);

            // Update inventory and remove them from the world
            getInventory().deleteMe();

            // Update warehouse and remove them from the world
            clearWarehouse();

            // Update freight and remove them from the world
            clearFreight();
            clearDepositedFreight();

            if (isCursedWeaponEquipped())
                CursedWeaponsManager.getInstance().getCursedWeapon(_cursedWeaponEquippedId).setPlayer(null);

            // Remove all L2Object from _knownObjects and _knownPlayer of the L2Character then cancel Attak or Cast and notify AI
            getKnownList().removeAllKnownObjects();

            if (getClanId() > 0)
                getClan().broadcastToOtherOnlineMembers(new PledgeShowMemberListUpdate(this), this);

            for (L2PcInstance player : _snoopedPlayer)
                player.removeSnooper(this);

            for (L2PcInstance player : _snoopListener)
                player.removeSnooped(this);

            // Remove L2Object object from _allObjects of L2World
            L2World.getInstance().removeObject(this);
            L2World.getInstance().removeFromAllPlayers(this); // force remove in case of crash during teleport

            // friends & blocklist update
            notifyFriends(false);
            getBlockList().playerLogout();
        }
        catch (Exception e)
        {
            _log.log(Level.WARNING, "Exception on deleteMe()" + e.getMessage(), e);
        }
    }

    public void startFishing(Location loc)
    {
        stopMove(null);
        setIsImmobilized(true);

        _fishingLoc = loc;

        // Starts fishing
        int group = getRandomGroup();

        _fish = FishTable.getFish(getRandomFishLvl(), getRandomFishType(group), group);
        if (_fish == null)
        {
            endFishing(false);
            return;
        }

        sendPacket(SystemMessageId.CAST_LINE_AND_START_FISHING);

        broadcastPacket(new ExFishingStart(this, _fish.getType(_lure.isNightLure()), loc, _lure.isNightLure()));
        sendPacket(new PlaySound(1, "SF_P_01", 0, 0, 0, 0, 0));
        startLookingForFishTask();
    }

    public void stopLookingForFishTask()
    {
        if (_taskforfish != null)
        {
            _taskforfish.cancel(false);
            _taskforfish = null;
        }
    }

    public void startLookingForFishTask()
    {
        if (!isDead() && _taskforfish == null)
        {
            int checkDelay = 0;
            boolean isNoob = false;
            boolean isUpperGrade = false;

            if (_lure != null)
            {
                int lureid = _lure.getItemId();
                isNoob = _fish.getGroup() == 0;
                isUpperGrade = _fish.getGroup() == 2;
                if (lureid == 6519 || lureid == 6522 || lureid == 6525 || lureid == 8505 || lureid == 8508 || lureid == 8511) // low grade
                    checkDelay = Math.round((float) (_fish.getGutsCheckTime() * (1.33)));
                else if (lureid == 6520 || lureid == 6523 || lureid == 6526 || (lureid >= 8505 && lureid <= 8513) || (lureid >= 7610 && lureid <= 7613) || (lureid >= 7807 && lureid <= 7809) || (lureid >= 8484 && lureid <= 8486)) // medium grade, beginner, prize-winning & quest special bait
                    checkDelay = Math.round((float) (_fish.getGutsCheckTime() * (1.00)));
                else if (lureid == 6521 || lureid == 6524 || lureid == 6527 || lureid == 8507 || lureid == 8510 || lureid == 8513) // high grade
                    checkDelay = Math.round((float) (_fish.getGutsCheckTime() * (0.66)));
            }
            _taskforfish = ThreadPoolManager.getInstance().scheduleEffectAtFixedRate(new LookingForFishTask(_fish.getWaitTime(), _fish.getFishGuts(), _fish.getType(_lure.isNightLure()), isNoob, isUpperGrade), 10000, checkDelay);
        }
    }

    private int getRandomGroup()
    {
        switch (_lure.getItemId())
        {
            case 7807: // green for beginners
            case 7808: // purple for beginners
            case 7809: // yellow for beginners
            case 8486: // prize-winning for beginners
                return 0;

            case 8485: // prize-winning luminous
            case 8506: // green luminous
            case 8509: // purple luminous
            case 8512: // yellow luminous
                return 2;

            default:
                return 1;
        }
    }

    private int getRandomFishType(int group)
    {
        int check = Rnd.get(100);
        int type = 1;
        switch (group)
        {
            case 0: // fish for novices
                switch (_lure.getItemId())
                {
                    case 7807: // green lure, preferred by fast-moving (nimble) fish (type 5)
                        if (check <= 54)
                            type = 5;
                        else if (check <= 77)
                            type = 4;
                        else
                            type = 6;
                        break;

                    case 7808: // purple lure, preferred by fat fish (type 4)
                        if (check <= 54)
                            type = 4;
                        else if (check <= 77)
                            type = 6;
                        else
                            type = 5;
                        break;

                    case 7809: // yellow lure, preferred by ugly fish (type 6)
                        if (check <= 54)
                            type = 6;
                        else if (check <= 77)
                            type = 5;
                        else
                            type = 4;
                        break;

                    case 8486: // prize-winning fishing lure for beginners
                        if (check <= 33)
                            type = 4;
                        else if (check <= 66)
                            type = 5;
                        else
                            type = 6;
                        break;
                }
                break;

            case 1: // normal fish
                switch (_lure.getItemId())
                {
                    case 7610:
                    case 7611:
                    case 7612:
                    case 7613:
                        type = 3;
                        break;

                    case 6519: // all theese lures (green) are prefered by fast-moving (nimble) fish (type 1)
                    case 8505:
                    case 6520:
                    case 6521:
                    case 8507:
                        if (check <= 54)
                            type = 1;
                        else if (check <= 74)
                            type = 0;
                        else if (check <= 94)
                            type = 2;
                        else
                            type = 3;
                        break;

                    case 6522: // all theese lures (purple) are prefered by fat fish (type 0)
                    case 8508:
                    case 6523:
                    case 6524:
                    case 8510:
                        if (check <= 54)
                            type = 0;
                        else if (check <= 74)
                            type = 1;
                        else if (check <= 94)
                            type = 2;
                        else
                            type = 3;
                        break;

                    case 6525: // all theese lures (yellow) are prefered by ugly fish (type 2)
                    case 8511:
                    case 6526:
                    case 6527:
                    case 8513:
                        if (check <= 55)
                            type = 2;
                        else if (check <= 74)
                            type = 1;
                        else if (check <= 94)
                            type = 0;
                        else
                            type = 3;
                        break;
                    case 8484: // prize-winning fishing lure
                        if (check <= 33)
                            type = 0;
                        else if (check <= 66)
                            type = 1;
                        else
                            type = 2;
                        break;
                }
                break;

            case 2: // upper grade fish, luminous lure
                switch (_lure.getItemId())
                {
                    case 8506: // green lure, preferred by fast-moving (nimble) fish (type 8)
                        if (check <= 54)
                            type = 8;
                        else if (check <= 77)
                            type = 7;
                        else
                            type = 9;
                        break;

                    case 8509: // purple lure, preferred by fat fish (type 7)
                        if (check <= 54)
                            type = 7;
                        else if (check <= 77)
                            type = 9;
                        else
                            type = 8;
                        break;

                    case 8512: // yellow lure, preferred by ugly fish (type 9)
                        if (check <= 54)
                            type = 9;
                        else if (check <= 77)
                            type = 8;
                        else
                            type = 7;
                        break;

                    case 8485: // prize-winning fishing lure
                        if (check <= 33)
                            type = 7;
                        else if (check <= 66)
                            type = 8;
                        else
                            type = 9;
                        break;
                }
        }
        return type;
    }

    private int getRandomFishLvl()
    {
        int skilllvl = getSkillLevel(1315);

        final L2Effect e = getFirstEffect(2274);
        if (e != null)
            skilllvl = (int) e.getSkill().getPower();

        if (skilllvl <= 0)
            return 1;

        int randomlvl;

        final int check = Rnd.get(100);
        if (check <= 50)
            randomlvl = skilllvl;
        else if (check <= 85)
        {
            randomlvl = skilllvl - 1;
            if (randomlvl <= 0)
                randomlvl = 1;
        }
        else
        {
            randomlvl = skilllvl + 1;
            if (randomlvl > 27)
                randomlvl = 27;
        }
        return randomlvl;
    }

    public void startFishCombat(boolean isNoob, boolean isUpperGrade)
    {
        _fishCombat = new L2Fishing(this, _fish, isNoob, isUpperGrade, _lure.getItemId());
    }

    public void endFishing(boolean win)
    {
        if (_fishCombat == null)
            sendPacket(SystemMessageId.BAIT_LOST_FISH_GOT_AWAY);
        else
            _fishCombat = null;

        _lure = null;
        _fishingLoc = null;

        // Ends fishing
        broadcastPacket(new ExFishingEnd(win, this));
        sendPacket(SystemMessageId.REEL_LINE_AND_STOP_FISHING);
        setIsImmobilized(false);
        stopLookingForFishTask();
    }

    public L2Fishing getFishCombat()
    {
        return _fishCombat;
    }

    public Location getFishingLoc()
    {
        return _fishingLoc;
    }

    public void setLure(L2ItemInstance lure)
    {
        _lure = lure;
    }

    public L2ItemInstance getLure()
    {
        return _lure;
    }

    public int getInventoryLimit()
    {
        int ivlim;
        if (getRace() == Race.Dwarf)
            ivlim = Config.INVENTORY_MAXIMUM_DWARF;
        else
            ivlim = Config.INVENTORY_MAXIMUM_NO_DWARF;

        ivlim += (int) getStat().calcStat(Stats.INV_LIM, 0, null, null);

        return ivlim;
    }

    /**
     * @return
     */
    public static int getQuestInventoryLimit()
    {
        return Config.INVENTORY_MAXIMUM_QUEST_ITEMS;
    }

    public int getWareHouseLimit()
    {
        int whlim;
        if (getRace() == Race.Dwarf)
            whlim = Config.WAREHOUSE_SLOTS_DWARF;
        else
            whlim = Config.WAREHOUSE_SLOTS_NO_DWARF;
        whlim += (int) getStat().calcStat(Stats.WH_LIM, 0, null, null);

        return whlim;
    }

    public int getPrivateSellStoreLimit()
    {
        int pslim;
        if (getRace() == Race.Dwarf)
            pslim = Config.MAX_PVTSTORE_SLOTS_DWARF;
        else
            pslim = Config.MAX_PVTSTORE_SLOTS_OTHER;

        pslim += (int) getStat().calcStat(Stats.P_SELL_LIM, 0, null, null);

        return pslim;
    }

    public int getPrivateBuyStoreLimit()
    {
        int pblim;
        if (getRace() == Race.Dwarf)
            pblim = Config.MAX_PVTSTORE_SLOTS_DWARF;
        else
            pblim = Config.MAX_PVTSTORE_SLOTS_OTHER;

        pblim += (int) getStat().calcStat(Stats.P_BUY_LIM, 0, null, null);

        return pblim;
    }

    public int getFreightLimit()
    {
        return Config.FREIGHT_SLOTS + (int) getStat().calcStat(Stats.FREIGHT_LIM, 0, null, null);
    }

    public int getDwarfRecipeLimit()
    {
        int recdlim = Config.DWARF_RECIPE_LIMIT;
        recdlim += (int) getStat().calcStat(Stats.REC_D_LIM, 0, null, null);
        return recdlim;
    }

    public int getCommonRecipeLimit()
    {
        int recclim = Config.COMMON_RECIPE_LIMIT;
        recclim += (int) getStat().calcStat(Stats.REC_C_LIM, 0, null, null);
        return recclim;
    }

    public int getMountNpcId()
    {
        return _mountNpcId;
    }

    public int getMountLevel()
    {
        return _mountLevel;
    }

    public void setMountObjectID(int newID)
    {
        _mountObjectID = newID;
    }

    public int getMountObjectID()
    {
        return _mountObjectID;
    }

    /**
     * @return the current skill in use or return null.
     */
    public SkillDat getCurrentSkill()
    {
        return _currentSkill;
    }

    /**
     * Create a new SkillDat object and set the player _currentSkill.
     * @param currentSkill
     * @param ctrlPressed
     * @param shiftPressed
     */
    public void setCurrentSkill(L2Skill currentSkill, boolean ctrlPressed, boolean shiftPressed)
    {
        if (currentSkill == null)
        {
            if (Config.DEBUG)
                _log.info("Setting current skill: NULL for " + getName() + ".");

            _currentSkill = null;
            return;
        }

        if (Config.DEBUG)
            _log.info("Setting current skill: " + currentSkill.getName() + " (ID: " + currentSkill.getId() + ") for " + getName() + ".");

        _currentSkill = new SkillDat(currentSkill, ctrlPressed, shiftPressed);
    }

    /**
     * @return the current pet skill in use or return null.
     */
    public SkillDat getCurrentPetSkill()
    {
        return _currentPetSkill;
    }

    /**
     * Create a new SkillDat object and set the player _currentPetSkill.
     * @param currentSkill
     * @param ctrlPressed
     * @param shiftPressed
     */
    public void setCurrentPetSkill(L2Skill currentSkill, boolean ctrlPressed, boolean shiftPressed)
    {
        if (currentSkill == null)
        {
            if (Config.DEBUG)
                _log.info("Setting current pet skill: NULL for " + getName() + ".");

            _currentPetSkill = null;
            return;
        }

        if (Config.DEBUG)
            _log.info("Setting current Pet skill: " + currentSkill.getName() + " (ID: " + currentSkill.getId() + ") for " + getName() + ".");

        _currentPetSkill = new SkillDat(currentSkill, ctrlPressed, shiftPressed);
    }

    public SkillDat getQueuedSkill()
    {
        return _queuedSkill;
    }

    /**
     * Create a new SkillDat object and queue it in the player _queuedSkill.
     * @param queuedSkill
     * @param ctrlPressed
     * @param shiftPressed
     */
    public void setQueuedSkill(L2Skill queuedSkill, boolean ctrlPressed, boolean shiftPressed)
    {
        if (queuedSkill == null)
        {
            if (Config.DEBUG)
                _log.info("Setting queued skill: NULL for " + getName() + ".");

            _queuedSkill = null;
            return;
        }

        if (Config.DEBUG)
            _log.info("Setting queued skill: " + queuedSkill.getName() + " (ID: " + queuedSkill.getId() + ") for " + getName() + ".");

        _queuedSkill = new SkillDat(queuedSkill, ctrlPressed, shiftPressed);
    }

    /**
     * @return the timer to delay animation tasks, based on run speed.
     */
    public int getAnimationTimer()
    {
        int timer = 5000 - getRunSpeed() * 20;
        if (timer < 1000)
            timer = 1000;

        return timer;
    }

    /**
     * @return punishment level of player
     */
    public PunishLevel getPunishLevel()
    {
        return _punishLevel;
    }

    /**
     * @return True if player is jailed
     */
    public boolean isInJail()
    {
        return _punishLevel == PunishLevel.JAIL;
    }

    /**
     * @return True if player is chat banned
     */
    public boolean isChatBanned()
    {
        return _punishLevel == PunishLevel.CHAT;
    }

    public void setPunishLevel(int state)
    {
        switch (state)
        {
            case 0:
                _punishLevel = PunishLevel.NONE;
                break;
            case 1:
                _punishLevel = PunishLevel.CHAT;
                break;
            case 2:
                _punishLevel = PunishLevel.JAIL;
                break;
            case 3:
                _punishLevel = PunishLevel.CHAR;
                break;
            case 4:
                _punishLevel = PunishLevel.ACC;
                break;
        }
    }

    /**
     * Sets punish level for player based on delay
     * @param state
     * @param delayInMinutes -- 0 for infinite
     */
    public void setPunishLevel(PunishLevel state, int delayInMinutes)
    {
        long delayInMilliseconds = delayInMinutes * 60000L;
        switch (state)
        {
            case NONE: // Remove Punishments
            {
                switch (_punishLevel)
                {
                    case CHAT:
                    {
                        _punishLevel = state;
                        stopPunishTask(true);
                        sendPacket(new EtcStatusUpdate(this));
                        sendMessage("Chatting is now available.");
                        sendPacket(new PlaySound("systemmsg_e.345"));
                        break;
                    }
                    case JAIL:
                    {
                        _punishLevel = state;

                        // Open a Html message to inform the player
                        NpcHtmlMessage htmlMsg = new NpcHtmlMessage(0);
                        htmlMsg.setFile("data/html/jail_out.htm");
                        sendPacket(htmlMsg);
                        stopPunishTask(true);
                        teleToLocation(17836, 170178, -3507, 20); // Floran village
                        break;
                    }
                }
                break;
            }
            case CHAT: // Chat ban
            {
                // not allow player to escape jail using chat ban
                if (_punishLevel == PunishLevel.JAIL)
                    break;

                _punishLevel = state;
                _punishTimer = 0;
                sendPacket(new EtcStatusUpdate(this));

                // Remove the task if any
                stopPunishTask(false);

                if (delayInMinutes > 0)
                {
                    _punishTimer = delayInMilliseconds;

                    // start the countdown
                    _punishTask = ThreadPoolManager.getInstance().scheduleGeneral(new PunishTask(), _punishTimer);
                    sendMessage("Chatting has been suspended for " + delayInMinutes + " minute(s).");
                }
                else
                    sendMessage("Chatting has been suspended.");

                // Send same sound packet in both "delay" cases.
                sendPacket(new PlaySound("systemmsg_e.346"));
                break;

            }
            case JAIL: // Jail Player
            {
                _punishLevel = state;
                _punishTimer = 0;

                // Remove the task if any
                stopPunishTask(false);

                if (delayInMinutes > 0)
                {
                    _punishTimer = delayInMilliseconds;

                    // start the countdown
                    _punishTask = ThreadPoolManager.getInstance().scheduleGeneral(new PunishTask(), _punishTimer);
                    sendMessage("You are jailed for " + delayInMinutes + " minutes.");
                }

                if (OlympiadManager.getInstance().isRegisteredInComp(this))
                    OlympiadManager.getInstance().removeDisconnectedCompetitor(this);

                // Open a Html message to inform the player
                NpcHtmlMessage htmlMsg = new NpcHtmlMessage(0);
                htmlMsg.setFile("data/html/jail_in.htm");
                sendPacket(htmlMsg);
                setIsIn7sDungeon(false);

                teleToLocation(-114356, -249645, -2984, 0); // Jail
                break;
            }
            case CHAR: // Ban Character
            {
                setAccessLevel(-100);
                logout();
                break;
            }
            case ACC: // Ban Account
            {
                setAccountAccesslevel(-100);
                logout();
                break;
            }
            default:
            {
                _punishLevel = state;
                break;
            }
        }

        // store in database
        storeCharBase();
    }

    public long getPunishTimer()
    {
        return _punishTimer;
    }

    public void setPunishTimer(long time)
    {
        _punishTimer = time;
    }

    private void updatePunishState()
    {
        if (getPunishLevel() != PunishLevel.NONE)
        {
            // If punish timer exists, restart punishtask.
            if (_punishTimer > 0)
            {
                _punishTask = ThreadPoolManager.getInstance().scheduleGeneral(new PunishTask(), _punishTimer);
                sendMessage("You are still " + getPunishLevel().string() + " for " + Math.round(_punishTimer / 60000f) + " minutes.");
            }
            if (getPunishLevel() == PunishLevel.JAIL)
            {
                // If player escaped, put him back in jail
                if (!isInsideZone(ZoneId.JAIL))
                    teleToLocation(-114356, -249645, -2984, 20);
            }
        }
    }

    public void stopPunishTask(boolean save)
    {
        if (_punishTask != null)
        {
            if (save)
            {
                long delay = _punishTask.getDelay(TimeUnit.MILLISECONDS);
                if (delay < 0)
                    delay = 0;
                setPunishTimer(delay);
            }
            _punishTask.cancel(false);
            _punishTask = null;
        }
    }

    protected class PunishTask implements Runnable
    {
        @Override
        public void run()
        {
            setPunishLevel(PunishLevel.NONE, 0);
        }
    }

    public int getPowerGrade()
    {
        return _powerGrade;
    }

    public void setPowerGrade(int power)
    {
        _powerGrade = power;
    }

    public boolean isCursedWeaponEquipped()
    {
        return _cursedWeaponEquippedId != 0;
    }

    public void setCursedWeaponEquippedId(int value)
    {
        _cursedWeaponEquippedId = value;
    }

    public int getCursedWeaponEquippedId()
    {
        return _cursedWeaponEquippedId;
    }

    public void shortBuffStatusUpdate(int magicId, int level, int time)
    {
        if (_shortBuffTask != null)
        {
            _shortBuffTask.cancel(false);
            _shortBuffTask = null;
        }
        _shortBuffTask = ThreadPoolManager.getInstance().scheduleGeneral(new ShortBuffTask(), time * 1000);
        setShortBuffTaskSkillId(magicId);

        sendPacket(new ShortBuffStatusUpdate(magicId, level, time));
    }

    public int getShortBuffTaskSkillId()
    {
        return _shortBuffTaskSkillId;
    }

    public void setShortBuffTaskSkillId(int id)
    {
        _shortBuffTaskSkillId = id;
    }

    public int getDeathPenaltyBuffLevel()
    {
        return _deathPenaltyBuffLevel;
    }

    public void setDeathPenaltyBuffLevel(int level)
    {
        _deathPenaltyBuffLevel = level;
    }

    public void calculateDeathPenaltyBuffLevel(L2Character killer)
    {
        if ((getKarma() > 0 || Rnd.get(1, 100) <= Config.DEATH_PENALTY_CHANCE) && !(killer instanceof L2PcInstance) && !isGM() && !(getCharmOfLuck() && killer.isRaid()) && !isPhoenixBlessed() && !(isInsideZone(ZoneId.PVP) || isInsideZone(ZoneId.SIEGE)))
            increaseDeathPenaltyBuffLevel();
    }

    public void increaseDeathPenaltyBuffLevel()
    {
        if (getDeathPenaltyBuffLevel() >= 15) // maximum level reached
            return;

        if (getDeathPenaltyBuffLevel() != 0)
        {
            L2Skill skill = SkillTable.getInstance().getInfo(5076, getDeathPenaltyBuffLevel());

            if (skill != null)
                removeSkill(skill, true);
        }

        _deathPenaltyBuffLevel++;

        addSkill(SkillTable.getInstance().getInfo(5076, getDeathPenaltyBuffLevel()), false);
        sendPacket(new EtcStatusUpdate(this));
        sendPacket(SystemMessage.getSystemMessage(SystemMessageId.DEATH_PENALTY_LEVEL_S1_ADDED).addNumber(getDeathPenaltyBuffLevel()));
    }

    public void reduceDeathPenaltyBuffLevel()
    {
        if (getDeathPenaltyBuffLevel() <= 0)
            return;

        L2Skill skill = SkillTable.getInstance().getInfo(5076, getDeathPenaltyBuffLevel());

        if (skill != null)
            removeSkill(skill, true);

        _deathPenaltyBuffLevel--;

        if (getDeathPenaltyBuffLevel() > 0)
        {
            addSkill(SkillTable.getInstance().getInfo(5076, getDeathPenaltyBuffLevel()), false);
            sendPacket(new EtcStatusUpdate(this));
            sendPacket(SystemMessage.getSystemMessage(SystemMessageId.DEATH_PENALTY_LEVEL_S1_ADDED).addNumber(getDeathPenaltyBuffLevel()));
        }
        else
        {
            sendPacket(new EtcStatusUpdate(this));
            sendPacket(SystemMessageId.DEATH_PENALTY_LIFTED);
        }
    }

    public void restoreDeathPenaltyBuffLevel()
    {
        if (getDeathPenaltyBuffLevel() > 0)
            addSkill(SkillTable.getInstance().getInfo(5076, getDeathPenaltyBuffLevel()), false);
    }

    private final Map<Integer, TimeStamp> _reuseTimeStamps = new ConcurrentHashMap<>();

    public Collection<TimeStamp> getReuseTimeStamps()
    {
        return _reuseTimeStamps.values();
    }

    public Map<Integer, TimeStamp> getReuseTimeStamp()
    {
        return _reuseTimeStamps;
    }

    /**
     * Simple class containing all neccessary information to maintain valid timestamps and reuse for skills upon relog. Filter this carefully as it becomes redundant to store reuse for small delays.
     * @author Yesod
     */
    public static class TimeStamp
    {
        private final int _skillId;
        private final int _skillLvl;
        private final long _reuse;
        private final long _stamp;

        public TimeStamp(L2Skill skill, long reuse)
        {
            _skillId = skill.getId();
            _skillLvl = skill.getLevel();
            _reuse = reuse;
            _stamp = System.currentTimeMillis() + reuse;
        }

        public TimeStamp(L2Skill skill, long reuse, long systime)
        {
            _skillId = skill.getId();
            _skillLvl = skill.getLevel();
            _reuse = reuse;
            _stamp = systime;
        }

        public long getStamp()
        {
            return _stamp;
        }

        public int getSkillId()
        {
            return _skillId;
        }

        public int getSkillLvl()
        {
            return _skillLvl;
        }

        public long getReuse()
        {
            return _reuse;
        }

        public long getRemaining()
        {
            return Math.max(_stamp - System.currentTimeMillis(), 0);
        }

        /*
         * Check if the reuse delay has passed and if it has not then update the stored reuse time according to what is currently remaining on the delay.
         */
        public boolean hasNotPassed()
        {
            return System.currentTimeMillis() < _stamp;
        }
    }

    /**
     * Index according to skill id the current timestamp of use.
     * @param skill
     * @param reuse delay
     */
    @Override
    public void addTimeStamp(L2Skill skill, long reuse)
    {
        _reuseTimeStamps.put(skill.getReuseHashCode(), new TimeStamp(skill, reuse));
    }

    /**
     * Index according to skill this TimeStamp instance for restoration purposes only.
     * @param skill
     * @param reuse
     * @param systime
     */
    public void addTimeStamp(L2Skill skill, long reuse, long systime)
    {
        _reuseTimeStamps.put(skill.getReuseHashCode(), new TimeStamp(skill, reuse, systime));
    }

    @Override
    public L2PcInstance getActingPlayer()
    {
        return this;
    }

    @Override
    public final void sendDamageMessage(L2Character target, int damage, boolean mcrit, boolean pcrit, boolean miss)
    {
        // Check if hit is missed
        if (miss)
        {
            sendPacket(SystemMessageId.MISSED_TARGET);
            return;
        }

        // Check if hit is critical
        if (pcrit)
            sendPacket(SystemMessageId.CRITICAL_HIT);
        if (mcrit)
            sendPacket(SystemMessageId.CRITICAL_HIT_MAGIC);

        if (target.isInvul())
        {
            if (target.isParalyzed())
                sendPacket(SystemMessageId.OPPONENT_PETRIFIED);
            else
                sendPacket(SystemMessageId.ATTACK_WAS_BLOCKED);
        }
        else
            sendPacket(SystemMessage.getSystemMessage(SystemMessageId.YOU_DID_S1_DMG).addNumber(damage));

        if (isInOlympiadMode() && target instanceof L2PcInstance && ((L2PcInstance) target).isInOlympiadMode() && ((L2PcInstance) target).getOlympiadGameId() == getOlympiadGameId())
            OlympiadGameManager.getInstance().notifyCompetitorDamage(this, damage);
    }

    public void checkItemRestriction()
    {
        for (int i = 0; i < Inventory.PAPERDOLL_TOTALSLOTS; i++)
        {
            L2ItemInstance equippedItem = getInventory().getPaperdollItem(i);
            if (equippedItem != null && !equippedItem.getItem().checkCondition(this, this, false))
            {
                getInventory().unEquipItemInSlot(i);

                InventoryUpdate iu = new InventoryUpdate();
                iu.addModifiedItem(equippedItem);
                sendPacket(iu);

                SystemMessage sm = null;
                if (equippedItem.getEnchantLevel() > 0)
                {
                    sm = SystemMessage.getSystemMessage(SystemMessageId.EQUIPMENT_S1_S2_REMOVED);
                    sm.addNumber(equippedItem.getEnchantLevel());
                    sm.addItemName(equippedItem);
                }
                else
                {
                    sm = SystemMessage.getSystemMessage(SystemMessageId.S1_DISARMED);
                    sm.addItemName(equippedItem);
                }
                sendPacket(sm);
            }
        }
    }

    protected class Dismount implements Runnable
    {
        @Override
        public void run()
        {
            try
            {
                dismount();
            }
            catch (Exception e)
            {
                _log.log(Level.WARNING, "Exception on dismount(): " + e.getMessage(), e);
            }
        }
    }

    public void enteredNoLanding(int delay)
    {
        _dismountTask = ThreadPoolManager.getInstance().scheduleGeneral(new Dismount(), delay * 1000);
    }

    public void exitedNoLanding()
    {
        if (_dismountTask != null)
        {
            _dismountTask.cancel(true);
            _dismountTask = null;
        }
    }

    public void setIsInSiege(boolean b)
    {
        _isInSiege = b;
    }

    public boolean isInSiege()
    {
        return _isInSiege;
    }

    public FloodProtectors getFloodProtectors()
    {
        return getClient().getFloodProtectors();
    }

    /**
     * Remove player from BossZones (used on char logout/exit)
     */
    public void removeFromBossZone()
    {
        try
        {
            for (L2BossZone _zone : GrandBossManager.getZones())
                _zone.removePlayer(this);
        }
        catch (Exception e)
        {
            _log.log(Level.WARNING, "Exception on removeFromBossZone(): " + e.getMessage(), e);
        }
    }

    /**
     * Returns the Number of Charges this L2PcInstance got.
     * @return
     */
    public int getCharges()
    {
        return _charges.get();
    }

    public synchronized void increaseCharges(int count, int max)
    {
        if (_charges.get() >= max)
        {
            sendPacket(SystemMessageId.FORCE_MAXLEVEL_REACHED);
            return;
        }

        // if no charges - start clear task
        if (_charges.get() == 0)
            restartChargeTask();

        if (_charges.addAndGet(count) >= max)
        {
            _charges.set(max);
            sendPacket(SystemMessageId.FORCE_MAXLEVEL_REACHED);
        }
        else
            sendPacket(SystemMessage.getSystemMessage(SystemMessageId.FORCE_INCREASED_TO_S1).addNumber(_charges.get()));

        sendPacket(new EtcStatusUpdate(this));
    }

    public synchronized boolean decreaseCharges(int count)
    {
        if (_charges.get() < count)
            return false;

        if (_charges.addAndGet(-count) == 0)
            stopChargeTask();

        sendPacket(new EtcStatusUpdate(this));
        return true;
    }

    public void clearCharges()
    {
        _charges.set(0);
        sendPacket(new EtcStatusUpdate(this));
    }

    /**
     * Starts/Restarts the ChargeTask to Clear Charges after 10 Mins.
     */
    private void restartChargeTask()
    {
        if (_chargeTask != null)
        {
            _chargeTask.cancel(false);
            _chargeTask = null;
        }
        _chargeTask = ThreadPoolManager.getInstance().scheduleGeneral(new ChargeTask(), 600000);
    }

    /**
     * Stops the Charges Clearing Task.
     */
    public void stopChargeTask()
    {
        if (_chargeTask != null)
        {
            _chargeTask.cancel(false);
            _chargeTask = null;
        }
    }

    protected class ChargeTask implements Runnable
    {
        @Override
        public void run()
        {
            clearCharges();
        }
    }

    /**
     * Signets check used to valid who is affected when he entered in the aoe effect.
     * @param cha The target to make checks on.
     * @return true if player can attack the target.
     */
    public boolean canAttackCharacter(L2Character cha)
    {
        if (cha instanceof L2Attackable)
            return true;

        if (cha instanceof L2Playable)
        {
            if (cha.isInArena())
                return true;

            final L2PcInstance target = cha.getActingPlayer();

            if (isInDuel() && target.isInDuel() && target.getDuelId() == getDuelId())
                return true;

            if (isInParty() && target.isInParty())
            {
                if (getParty() == target.getParty())
                    return false;

                if ((getParty().getCommandChannel() != null || target.getParty().getCommandChannel() != null) && (getParty().getCommandChannel() == target.getParty().getCommandChannel()))
                    return false;
            }

            if (getClan() != null && target.getClan() != null)
            {
                if (getClanId() == target.getClanId())
                    return false;

                if ((getAllyId() > 0 || target.getAllyId() > 0) && getAllyId() == target.getAllyId())
                    return false;

                if (getClan().isAtWarWith(target.getClanId()))
                    return true;
            }
            else
            {
                if (target.getPvpFlag() == 0 && target.getKarma() == 0)
                    return false;
            }
        }
        return true;
    }

    /**
     * Request Teleport
     * @param requester The player who requested the teleport.
     * @param skill The used skill.
     * @return true if successful.
     **/
    public boolean teleportRequest(L2PcInstance requester, L2Skill skill)
    {
        if (_summonRequest.getTarget() != null && requester != null)
            return false;

        _summonRequest.setTarget(requester, skill);
        return true;
    }

    /**
     * Action teleport
     * @param answer
     * @param requesterId
     **/
    public void teleportAnswer(int answer, int requesterId)
    {
        if (_summonRequest.getTarget() == null)
            return;

        if (answer == 1 && _summonRequest.getTarget().getObjectId() == requesterId)
            teleToTarget(this, _summonRequest.getTarget(), _summonRequest.getSkill());

        _summonRequest.setTarget(null, null);
    }

    public static void teleToTarget(L2PcInstance targetChar, L2PcInstance summonerChar, L2Skill summonSkill)
    {
        if (targetChar == null || summonerChar == null || summonSkill == null)
            return;

        if (!checkSummonerStatus(summonerChar))
            return;
        if (!checkSummonTargetStatus(targetChar, summonerChar))
            return;

        int itemConsumeId = summonSkill.getTargetConsumeId();
        int itemConsumeCount = summonSkill.getTargetConsume();
        if (itemConsumeId != 0 && itemConsumeCount != 0)
        {
            // Delete by rocknow
            if (targetChar.getInventory().getInventoryItemCount(itemConsumeId, 0) < itemConsumeCount)
            {
                targetChar.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.S1_REQUIRED_FOR_SUMMONING).addItemName(summonSkill.getTargetConsumeId()));
                return;
            }
            targetChar.getInventory().destroyItemByItemId("Consume", itemConsumeId, itemConsumeCount, summonerChar, targetChar);
            targetChar.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.S1_DISAPPEARED).addItemName(summonSkill.getTargetConsumeId()));
        }
        targetChar.teleToLocation(summonerChar.getX(), summonerChar.getY(), summonerChar.getZ(), 20);
    }

    public static boolean checkSummonerStatus(L2PcInstance summonerChar)
    {
        if (summonerChar == null)
            return false;

        if (summonerChar.isInOlympiadMode() || summonerChar.inObserverMode() || summonerChar.isInsideZone(ZoneId.NO_SUMMON_FRIEND) || summonerChar.isMounted())
            return false;

        return true;
    }

    public static boolean checkSummonTargetStatus(L2Object target, L2PcInstance summonerChar)
    {
        if (target == null || !(target instanceof L2PcInstance))
            return false;

        L2PcInstance targetChar = (L2PcInstance) target;

        if (targetChar.isAlikeDead())
        {
            summonerChar.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.S1_IS_DEAD_AT_THE_MOMENT_AND_CANNOT_BE_SUMMONED).addPcName(targetChar));
            return false;
        }

        if (targetChar.isInStoreMode())
        {
            summonerChar.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.S1_CURRENTLY_TRADING_OR_OPERATING_PRIVATE_STORE_AND_CANNOT_BE_SUMMONED).addPcName(targetChar));
            return false;
        }

        if (targetChar.isRooted() || targetChar.isInCombat())
        {
            summonerChar.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.S1_IS_ENGAGED_IN_COMBAT_AND_CANNOT_BE_SUMMONED).addPcName(targetChar));
            return false;
        }

        if (targetChar.isInOlympiadMode())
        {
            summonerChar.sendPacket(SystemMessageId.YOU_CANNOT_SUMMON_PLAYERS_WHO_ARE_IN_OLYMPIAD);
            return false;
        }

        if (targetChar.isFestivalParticipant() || targetChar.isMounted())
        {
            summonerChar.sendPacket(SystemMessageId.YOUR_TARGET_IS_IN_AN_AREA_WHICH_BLOCKS_SUMMONING);
            return false;
        }

        if (targetChar.inObserverMode() || targetChar.isInsideZone(ZoneId.NO_SUMMON_FRIEND))
        {
            summonerChar.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.S1_IN_SUMMON_BLOCKING_AREA).addCharName(targetChar));
            return false;
        }

        return true;
    }

    public final int getClientX()
    {
        return _clientX;
    }

    public final int getClientY()
    {
        return _clientY;
    }

    public final int getClientZ()
    {
        return _clientZ;
    }

    public final int getClientHeading()
    {
        return _clientHeading;
    }

    public final void setClientX(int val)
    {
        _clientX = val;
    }

    public final void setClientY(int val)
    {
        _clientY = val;
    }

    public final void setClientZ(int val)
    {
        _clientZ = val;
    }

    public final void setClientHeading(int val)
    {
        _clientHeading = val;
    }

    /**
     * @return the mailPosition.
     */
    public int getMailPosition()
    {
        return _mailPosition;
    }

    /**
     * @param mailPosition The mailPosition to set.
     */
    public void setMailPosition(int mailPosition)
    {
        _mailPosition = mailPosition;
    }

    /**
     * @param z
     * @return true if character falling now On the start of fall return false for correct coord sync !
     */
    public final boolean isFalling(int z)
    {
        if (isDead() || isFlying() || isInsideZone(ZoneId.WATER))
            return false;

        if (System.currentTimeMillis() < _fallingTimestamp)
            return true;

        final int deltaZ = getZ() - z;
        if (deltaZ <= getBaseTemplate().getFallHeight())
            return false;

        final int damage = (int) Formulas.calcFallDam(this, deltaZ);
        if (damage > 0)
        {
            reduceCurrentHp(Math.min(damage, getCurrentHp() - 1), null, false, true, null);
            sendPacket(SystemMessage.getSystemMessage(SystemMessageId.FALL_DAMAGE_S1).addNumber(damage));
        }

        setFalling();

        return false;
    }

    /**
     * Set falling timestamp
     */
    public final void setFalling()
    {
        _fallingTimestamp = System.currentTimeMillis() + FALLING_VALIDATION_DELAY;
    }

    public boolean isAllowedToEnchantSkills()
    {
        if (isLocked())
            return false;

        if (AttackStanceTaskManager.getInstance().getAttackStanceTask(this))
            return false;

        if (isCastingNow() || isCastingSimultaneouslyNow())
            return false;

        if (isInBoat())
            return false;

        return true;
    }

    /**
     * Friendlist / selected Friendlist (for community board)
     */
    private final List<Integer> _friendList = new ArrayList<>();
    private final List<Integer> _selectedFriendList = new ArrayList<>();

    public List<Integer> getFriendList()
    {
        return _friendList;
    }

    public void selectFriend(Integer friendId)
    {
        if (!_selectedFriendList.contains(friendId))
            _selectedFriendList.add(friendId);
    }

    public void deselectFriend(Integer friendId)
    {
        if (_selectedFriendList.contains(friendId))
            _selectedFriendList.remove(friendId);
    }

    public long getOfflineStartTime()
    {
        return _offlineShopStart;
    }

    public void setOfflineStartTime(long time)
    {
        _offlineShopStart = time;
    }

    public boolean inOfflineShopMode()
    {
        return _inOfflineShopMode;
    }

    public void setOfflineShopMode(boolean value)
    {
        _inOfflineShopMode = value;
    }

    public List<Integer> getSelectedFriendList()
    {
        return _selectedFriendList;
    }

    private void restoreFriendList()
    {
        _friendList.clear();

        try (Connection con = L2DatabaseFactory.getInstance().getConnection())
        {
            PreparedStatement statement = con.prepareStatement("SELECT friend_id FROM character_friends WHERE char_id = ? AND relation = 0");
            statement.setInt(1, getObjectId());
            ResultSet rset = statement.executeQuery();

            int friendId;
            while (rset.next())
            {
                friendId = rset.getInt("friend_id");
                if (friendId == getObjectId())
                    continue;

                _friendList.add(friendId);
            }

            rset.close();
            statement.close();
        }
        catch (Exception e)
        {
            _log.log(Level.WARNING, "Error found in " + getName() + "'s friendlist: " + e.getMessage(), e);
        }
    }

    private void notifyFriends(boolean login)
    {
        for (int id : _friendList)
        {
            L2PcInstance friend = L2World.getInstance().getPlayer(id);
            if (friend != null)
            {
                friend.sendPacket(new FriendList(friend));

                if (login)
                    friend.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.FRIEND_S1_HAS_LOGGED_IN).addPcName(this));
            }
        }
    }

    private final List<Integer> _selectedBlocksList = new ArrayList<>();

    public void selectBlock(Integer friendId)
    {
        if (!_selectedBlocksList.contains(friendId))
            _selectedBlocksList.add(friendId);
    }

    public void deselectBlock(Integer friendId)
    {
        if (_selectedBlocksList.contains(friendId))
            _selectedBlocksList.remove(friendId);
    }

    public List<Integer> getSelectedBlocksList()
    {
        return _selectedBlocksList;
    }

    /**
     * Test if player inventory is under 80% capaity
     * @param includeQuestInv check also quest inventory
     * @return
     */
    public boolean isInventoryUnder80(boolean includeQuestInv)
    {
        if (getInventory().getSize(false) <= (getInventoryLimit() * 0.8))
        {
            if (includeQuestInv)
            {
                if (getInventory().getSize(true) <= (getQuestInventoryLimit() * 0.8))
                    return true;
            }
            else
                return true;
        }
        return false;
    }

    @Override
    public void broadcastRelationsChanges()
    {
        for (L2PcInstance player : getKnownList().getKnownType(L2PcInstance.class))
        {
            player.sendPacket(new RelationChanged(this, getRelation(player), isAutoAttackable(player)));
            if (getPet() != null)
                player.sendPacket(new RelationChanged(getPet(), getRelation(player), isAutoAttackable(player)));
        }
    }

    @Override
    public void sendInfo(L2PcInstance activeChar)
    {
        if (isInBoat())
            getPosition().setWorldPosition(getBoat().getPosition().getWorldPosition());

        if (getPoly().isMorphed())
            activeChar.sendPacket(new AbstractNpcInfo.PcMorphInfo(this, getPoly().getNpcTemplate()));
        else
            activeChar.sendPacket(new CharInfo(this));

        final int relation1 = getRelation(activeChar);
        activeChar.sendPacket(new RelationChanged(this, relation1, isAutoAttackable(activeChar)));
        if (getPet() != null)
            activeChar.sendPacket(new RelationChanged(getPet(), relation1, isAutoAttackable(activeChar)));

        final int relation2 = activeChar.getRelation(this);
        sendPacket(new RelationChanged(activeChar, relation2, activeChar.isAutoAttackable(this)));
        if (activeChar.getPet() != null)
            sendPacket(new RelationChanged(activeChar.getPet(), relation2, activeChar.isAutoAttackable(this)));

        if (isInBoat())
            activeChar.sendPacket(new GetOnVehicle(getObjectId(), getBoat().getObjectId(), getInVehiclePosition()));

        // No reason to try to broadcast shop message if player isn't in store mode
        if (isInStoreMode())
        {
            switch (getPrivateStoreType())
            {
                case STORE_PRIVATE_SELL:
                case STORE_PRIVATE_PACKAGE_SELL:
                    activeChar.sendPacket(new PrivateStoreMsgSell(this));
                    break;
                case STORE_PRIVATE_BUY:
                    activeChar.sendPacket(new PrivateStoreMsgBuy(this));
                    break;
                case STORE_PRIVATE_MANUFACTURE:
                    activeChar.sendPacket(new RecipeShopMsg(this));
                    break;
            }
        }
    }
}