[SPOILER="L2Player.java"]
[CODE]package l2p.gameserver.model;
import static l2p.gameserver.model.L2Zone.ZoneType.Siege;
import static l2p.gameserver.model.L2Zone.ZoneType.damage;
import static l2p.gameserver.model.L2Zone.ZoneType.instant_skill;
import static l2p.gameserver.model.L2Zone.ZoneType.no_landing;
import static l2p.gameserver.model.L2Zone.ZoneType.no_restart;
import static l2p.gameserver.model.L2Zone.ZoneType.peace_zone;
import static l2p.gameserver.model.L2Zone.ZoneType.poison;
import static l2p.gameserver.model.L2Zone.ZoneType.ssq_zone;
import static l2p.gameserver.model.L2Zone.ZoneType.swamp;
import java.awt.Color;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Collection;
import java.util.ConcurrentModificationException;
import java.util.HashMap;
import java.util.Map;
import java.util.TreeMap;
import java.util.Map.Entry;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.ConcurrentSkipListSet;
import java.util.concurrent.Future;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.locks.ReentrantLock;
import java.util.logging.Level;
import java.util.logging.Logger;
import javolution.text.TextBuilder;
import javolution.util.FastMap;
import l2p.Config;
import l2p.commons.ThreadPoolManager;
import l2p.commons.collections.GArray;
import l2p.commons.collections.GCSArray;
import l2p.commons.random.Rnd;
import l2p.database.DatabaseUtils;
import l2p.database.FiltredPreparedStatement;
import l2p.database.FiltredStatement;
import l2p.database.L2DatabaseFactory;
import l2p.database.ThreadConnection;
import l2p.database.mysql;
import l2p.extensions.Bonus;
import l2p.extensions.Stat;
import l2p.extensions.multilang.CustomMessage;
import l2p.extensions.network.SendablePacket;
import l2p.extensions.scripts.Events;
import l2p.extensions.scripts.Functions;
import l2p.extensions.scripts.Scripts;
import l2p.extensions.scripts.Scripts.ScriptClassAndMethod;
import l2p.gameserver.GameTimeController;
import l2p.gameserver.RecipeController;
import l2p.gameserver.ai.CtrlEvent;
import l2p.gameserver.ai.CtrlIntention;
import l2p.gameserver.ai.DefaultAI;
import l2p.gameserver.ai.L2CharacterAI;
import l2p.gameserver.ai.L2PlayableAI;
import l2p.gameserver.ai.L2PlayerAI;
import l2p.gameserver.ai.L2PlayableAI.nextAction;
import l2p.gameserver.cache.Msg;
import l2p.gameserver.clientpackets.EnterWorld;
import l2p.gameserver.communitybbs.BB.Forum;
import l2p.gameserver.communitybbs.Manager.ForumsBBSManager;
import l2p.gameserver.handler.IItemHandler;
import l2p.gameserver.handler.ItemHandler;
import l2p.gameserver.idfactory.IdFactory;
import l2p.gameserver.instancemanager.CastleManager;
import l2p.gameserver.instancemanager.CastleSiegeManager;
import l2p.gameserver.instancemanager.ClanHallManager;
import l2p.gameserver.instancemanager.CoupleManager;
import l2p.gameserver.instancemanager.CursedWeaponsManager;
import l2p.gameserver.instancemanager.DimensionalRiftManager;
import l2p.gameserver.instancemanager.FortressManager;
import l2p.gameserver.instancemanager.FortressSiegeManager;
import l2p.gameserver.instancemanager.PartyRoomManager;
import l2p.gameserver.instancemanager.PlayerManager;
import l2p.gameserver.instancemanager.QuestManager;
import l2p.gameserver.instancemanager.SiegeManager;
import l2p.gameserver.instancemanager.ZoneManager;
import l2p.gameserver.loginservercon.LSConnection;
import l2p.gameserver.loginservercon.gspackets.ChangeAccessLevel;
import l2p.gameserver.model.BypassManager.BypassType;
import l2p.gameserver.model.BypassManager.DecodedBypass;
import l2p.gameserver.model.L2Clan.RankPrivs;
import l2p.gameserver.model.L2Multisell.MultiSellListContainer;
import l2p.gameserver.model.L2ObjectTasks.*;
import l2p.gameserver.model.L2Skill.AddedSkill;
import l2p.gameserver.model.L2Skill.SkillType;
import l2p.gameserver.model.L2Zone.ZoneType;
import l2p.gameserver.model.base.ClassId;
import l2p.gameserver.model.base.Experience;
import l2p.gameserver.model.base.PlayerAccess;
import l2p.gameserver.model.base.Race;
import l2p.gameserver.model.base.Transaction;
import l2p.gameserver.model.base.Transaction.TransactionType;
import l2p.gameserver.model.entity.DimensionalRift;
import l2p.gameserver.model.entity.Duel;
import l2p.gameserver.model.entity.Hero;
import l2p.gameserver.model.entity.Duel.DuelState;
import l2p.gameserver.model.entity.SevenSignsFestival.DarknessFestival;
import l2p.gameserver.model.entity.olympiad.CompType;
import l2p.gameserver.model.entity.olympiad.Olympiad;
import l2p.gameserver.model.entity.olympiad.OlympiadGame;
import l2p.gameserver.model.entity.residence.Castle;
import l2p.gameserver.model.entity.residence.ClanHall;
import l2p.gameserver.model.entity.residence.Fortress;
import l2p.gameserver.model.entity.residence.Residence;
import l2p.gameserver.model.entity.residence.ResidenceType;
import l2p.gameserver.model.entity.siege.Siege;
import l2p.gameserver.model.entity.siege.territory.TerritorySiege;
import l2p.gameserver.model.entity.vehicle.L2AirShip;
import l2p.gameserver.model.entity.vehicle.L2Ship;
import l2p.gameserver.model.entity.vehicle.L2Vehicle;
import l2p.gameserver.model.instances.L2AgathionInstance;
import l2p.gameserver.model.instances.L2ClanHallManagerInstance;
import l2p.gameserver.model.instances.L2CubicInstance;
import l2p.gameserver.model.instances.L2DecoyInstance;
import l2p.gameserver.model.instances.L2DoorInstance;
import l2p.gameserver.model.instances.L2FestivalMonsterInstance;
import l2p.gameserver.model.instances.L2GuardInstance;
import l2p.gameserver.model.instances.L2HennaInstance;
import l2p.gameserver.model.instances.L2MinionInstance;
import l2p.gameserver.model.instances.L2MonsterInstance;
import l2p.gameserver.model.instances.L2NpcInstance;
import l2p.gameserver.model.instances.L2PetInstance;
import l2p.gameserver.model.instances.L2ReflectionBossInstance;
import l2p.gameserver.model.instances.L2StaticObjectInstance;
import l2p.gameserver.model.instances.L2TamedBeastInstance;
import l2p.gameserver.model.instances.L2TerritoryFlagInstance;
import l2p.gameserver.model.instances.L2TrapInstance;
import l2p.gameserver.model.instances.L2CubicInstance.CubicType;
import l2p.gameserver.model.items.Inventory;
import l2p.gameserver.model.items.L2ItemInstance;
import l2p.gameserver.model.items.MailParcelController;
import l2p.gameserver.model.items.PcFreight;
import l2p.gameserver.model.items.PcInventory;
import l2p.gameserver.model.items.PcWarehouse;
import l2p.gameserver.model.items.Warehouse;
import l2p.gameserver.model.items.MailParcelController.Letter;
import l2p.gameserver.model.items.Warehouse.WarehouseType;
import l2p.gameserver.model.quest.Quest;
import l2p.gameserver.model.quest.QuestEventType;
import l2p.gameserver.model.quest.QuestState;
import l2p.gameserver.network.L2GameClient;
import l2p.gameserver.serverpackets.AbnormalStatusUpdate;
import l2p.gameserver.serverpackets.CameraMode;
import l2p.gameserver.serverpackets.ChangeWaitType;
import l2p.gameserver.serverpackets.CharInfo;
import l2p.gameserver.serverpackets.CharMoveToLocation;
import l2p.gameserver.serverpackets.ConfirmDlg;
import l2p.gameserver.serverpackets.DeleteObject;
import l2p.gameserver.serverpackets.DropItem;
import l2p.gameserver.serverpackets.EtcStatusUpdate;
import l2p.gameserver.serverpackets.ExAirShipInfo;
import l2p.gameserver.serverpackets.ExAutoSoulShot;
import l2p.gameserver.serverpackets.ExBasicActionList;
import l2p.gameserver.serverpackets.ExBrExtraUserInfo;
import l2p.gameserver.serverpackets.ExDuelUpdateUserInfo;
import l2p.gameserver.serverpackets.ExFishingEnd;
import l2p.gameserver.serverpackets.ExGetOnAirShip;
import l2p.gameserver.serverpackets.ExMoveToLocationAirShip;
import l2p.gameserver.serverpackets.ExNoticePostArrived;
import l2p.gameserver.serverpackets.ExOlympiadMatchEnd;
import l2p.gameserver.serverpackets.ExOlympiadMode;
import l2p.gameserver.serverpackets.ExOlympiadSpelledInfo;
import l2p.gameserver.serverpackets.ExSetCompassZoneCode;
import l2p.gameserver.serverpackets.ExStartScenePlayer;
import l2p.gameserver.serverpackets.ExStorageMaxCount;
import l2p.gameserver.serverpackets.ExUseSharedGroupItem;
import l2p.gameserver.serverpackets.GetItem;
import l2p.gameserver.serverpackets.GetOnVehicle;
import l2p.gameserver.serverpackets.HennaInfo;
import l2p.gameserver.serverpackets.L2GameServerPacket;
import l2p.gameserver.serverpackets.MagicSkillUse;
import l2p.gameserver.serverpackets.MyTargetSelected;
import l2p.gameserver.serverpackets.NpcInfo;
import l2p.gameserver.serverpackets.NpcInfoPoly;
import l2p.gameserver.serverpackets.ObserverEnd;
import l2p.gameserver.serverpackets.ObserverStart;
import l2p.gameserver.serverpackets.PartySmallWindowUpdate;
import l2p.gameserver.serverpackets.PartySpelled;
import l2p.gameserver.serverpackets.PetInfo;
import l2p.gameserver.serverpackets.PetItemList;
import l2p.gameserver.serverpackets.PlaySound;
import l2p.gameserver.serverpackets.PledgeShowMemberListDelete;
import l2p.gameserver.serverpackets.PledgeShowMemberListUpdate;
import l2p.gameserver.serverpackets.PrivateStoreListBuy;
import l2p.gameserver.serverpackets.PrivateStoreListSell;
import l2p.gameserver.serverpackets.PrivateStoreMsgBuy;
import l2p.gameserver.serverpackets.PrivateStoreMsgSell;
import l2p.gameserver.serverpackets.QuestList;
import l2p.gameserver.serverpackets.RecipeShopMsg;
import l2p.gameserver.serverpackets.RecipeShopSellList;
import l2p.gameserver.serverpackets.RelationChanged;
import l2p.gameserver.serverpackets.Ride;
import l2p.gameserver.serverpackets.SendTradeDone;
import l2p.gameserver.serverpackets.SetupGauge;
import l2p.gameserver.serverpackets.ShortBuffStatusUpdate;
import l2p.gameserver.serverpackets.ShortCutInit;
import l2p.gameserver.serverpackets.ShortCutRegister;
import l2p.gameserver.serverpackets.SkillCoolTime;
import l2p.gameserver.serverpackets.SkillList;
import l2p.gameserver.serverpackets.SocialAction;
import l2p.gameserver.serverpackets.SpawnItem;
import l2p.gameserver.serverpackets.SpawnItemPoly;
import l2p.gameserver.serverpackets.SpecialCamera;
import l2p.gameserver.serverpackets.StaticObject;
import l2p.gameserver.serverpackets.StatusUpdate;
import l2p.gameserver.serverpackets.SystemMessage;
import l2p.gameserver.serverpackets.TargetSelected;
import l2p.gameserver.serverpackets.TargetUnselected;
import l2p.gameserver.serverpackets.TeleportToLocation;
import l2p.gameserver.serverpackets.UserInfo;
import l2p.gameserver.serverpackets.VehicleDeparture;
import l2p.gameserver.serverpackets.VehicleInfo;
import l2p.gameserver.skills.EffectType;
import l2p.gameserver.skills.Env;
import l2p.gameserver.skills.SkillTimeStamp;
import l2p.gameserver.skills.Stats;
import l2p.gameserver.skills.effects.EffectTemplate;
import l2p.gameserver.skills.skillclasses.Charge;
import l2p.gameserver.skills.skillclasses.Transformation;
import l2p.gameserver.tables.CharTemplateTable;
import l2p.gameserver.tables.ClanTable;
import l2p.gameserver.tables.HennaTable;
import l2p.gameserver.tables.ItemTable;
import l2p.gameserver.tables.MapRegion;
import l2p.gameserver.tables.NpcTable;
import l2p.gameserver.tables.PetDataTable;
import l2p.gameserver.tables.ReflectionTable;
import l2p.gameserver.tables.SkillTable;
import l2p.gameserver.tables.SkillTreeTable;
import l2p.gameserver.taskmanager.AutoSaveManager;
import l2p.gameserver.taskmanager.BreakWarnManager;
import l2p.gameserver.taskmanager.VitalityManager;
import l2p.gameserver.templates.L2Armor;
import l2p.gameserver.templates.L2Henna;
import l2p.gameserver.templates.L2Item;
import l2p.gameserver.templates.L2PlayerTemplate;
import l2p.gameserver.templates.L2Weapon;
import l2p.gameserver.templates.L2Armor.ArmorType;
import l2p.gameserver.templates.L2Weapon.WeaponType;
import l2p.loginserver.Lock.HWIDLockComparator;
import l2p.util.EffectsComparator;
import l2p.util.HWID;
import l2p.util.Location;
import l2p.util.Log;
import l2p.util.SqlBatch;
import l2p.util.Strings;
import l2p.util.Util;
import l2p.util.HWID.HWIDComparator;
import l2p.util.HWID.HardwareID;
import static l2p.gameserver.model.L2Zone.ZoneType.*;
public final class L2Player extends L2Playable
{
static final Logger _log = Logger.getLogger(L2Player.class.getName());
public HashMap<Integer, L2SubClass> _classlist = new HashMap<Integer, L2SubClass>(4);
public static final short STORE_PRIVATE_NONE = 0;
public static final short STORE_PRIVATE_SELL = 1;
public static final short STORE_PRIVATE_BUY = 3;
public static final short STORE_PRIVATE_MANUFACTURE = 5;
public static final short STORE_OBSERVING_GAMES = 7;
public static final short STORE_PRIVATE_SELL_PACKAGE = 8;
public static final int RANK_VAGABOND = 0;
public static final int RANK_VASSAL = 1;
public static final int RANK_HEIR = 2;
public static final int RANK_KNIGHT = 3;
public static final int RANK_WISEMAN = 4;
public static final int RANK_BARON = 5;
public static final int RANK_VISCOUNT = 6;
public static final int RANK_COUNT = 7;
public static final int RANK_MARQUIS = 8;
public static final int RANK_DUKE = 9;
public static final int RANK_GRAND_DUKE = 10;
public static final int RANK_DISTINGUISHED_KING = 11;
public static final int RANK_EMPEROR = 12; // unused
public static final int LANG_ENG = 0;
public static final int LANG_RUS = 1;
public static final int LANG_UNK = -1;
/** The table containing all minimum level needed for each Expertise (None, D, C, B, A, S, S80, S84) */
public static final int[] EXPERTISE_LEVELS = {
//
0, //NONE
20, //D
40, //C
52, //B
61, //A
76, //S
80, //S80
84, //S84
Integer.MAX_VALUE, // затычка
};
private ClassId _skillLearningClassId;
private L2GameClient _connection;
private String _accountName;
private int _karma, _pkKills, _pvpKills;
private int _face, _hairStyle, _hairColor;
private int _recomHave, _recomLeft, _fame;
private int _deleteTimer;
private int _partyMatchingLevels, _partyMatchingRegion;
private Integer _partyRoom = 0;
private long _createTime, _onlineTime, _onlineBeginTime, _leaveClanTime, _deleteClanTime, _NoChannel,
_NoChannelBegin;
/** The Color of players name / title (white is 0xFFFFFF) */
private int _nameColor, _titlecolor;
private int _vitalityLevel = -1;
private double _vitality = 10000;
private int _curWeightPenalty = 0;
private boolean _relax;
boolean sittingTaskLaunched;
/** Time counter when L2Player is sitting */
private int _waitTimeWhenSit;
private boolean AutoLootAdena = Config.AUTO_LOOT_ADENA, AutoLootItems = Config.AUTO_LOOT_ITEMS, AutoLootHerbs = Config.AUTO_LOOT_HERBS;
private final GArray<Integer> _recomChars = new GArray<Integer>();
private final PcInventory _inventory = new PcInventory(this);
private PcWarehouse _warehouse = new PcWarehouse(this);
private PcFreight _freight = new PcFreight(this);
public final BookMarkList bookmarks = new BookMarkList(this, 0);
/** The table containing all L2RecipeList of the L2Player */
private final Map<Integer, L2Recipe> _recipebook = new TreeMap<Integer, L2Recipe>();
private final Map<Integer, L2Recipe> _commonrecipebook = new TreeMap<Integer, L2Recipe>();
/** The table containing all Quests began by the L2Player */
private final HashMap<String, QuestState> _quests = new HashMap<String, QuestState>();
/** The list containing all shortCuts of this L2Player */
private final ShortCuts _shortCuts = new ShortCuts(this);
/** The list containing all macroses of this L2Player */
private final MacroList _macroses = new MacroList(this);
private final StatsChangeRecorder _statsChangeRecorder = new StatsChangeRecorder(this);
public L2Radar radar;
private L2TradeList _tradeList;
private L2ManufactureList _createList;
private ConcurrentLinkedQueue<TradeItem> _sellList, _buyList;
// hennas
private final L2HennaInstance[] _henna = new L2HennaInstance[3];
private short _hennaSTR, _hennaINT, _hennaDEX, _hennaMEN, _hennaWIT, _hennaCON;
private L2Party _party;
private L2Clan _clan;
private int _pledgeClass = 0, _pledgeType = 0, _powerGrade = 0, _lvlJoinedAcademy = 0, _apprentice = 0;
//GM Stuff
private int _accessLevel;
private PlayerAccess _playerAccess = new PlayerAccess();
private boolean _messageRefusal = false, _tradeRefusal = false, _exchangeRefusal = false, _invisible = false,
_blockAll = false;
/** The Private Store type of the L2Player (STORE_PRIVATE_NONE=0, STORE_PRIVATE_SELL=1, sellmanage=2, STORE_PRIVATE_BUY=3, buymanage=4, STORE_PRIVATE_MANUFACTURE=5) */
private short _privatestore;
/** The L2Summon of the L2Player */
private L2Summon _summon = null;
private L2DecoyInstance _decoy = null;
private GCSArray<L2CubicInstance> _cubics = null;
private L2AgathionInstance _agathion = null;
private Transaction _transaction;
private L2ItemInstance _arrowItem;
/** The fists L2Weapon of the L2Player (used when no weapon is equipped) */
private L2Weapon _fistsWeaponItem;
private long _uptime;
private HashMap<Integer, String> _chars = new HashMap<Integer, String>(8);
public byte updateKnownCounter = 0;
/** The current higher Expertise of the L2Player (None=0, D=1, C=2, B=3, A=4, S=5, S80=6, S84=7) */
public int expertiseIndex = 0, expertisePenalty = 0;
private L2ItemInstance _enchantScroll = null;
private WarehouseType _usingWHType;
private boolean _isOnline = false;
private boolean _isDeleting = false;
protected boolean _inventoryDisable = false;
/** The L2NpcInstance corresponding to the last Folk which one the player talked. */
private L2NpcInstance _lastNpc = null;
private String _lastBBS_script_operation = null;
/** тут храним мультиселл с которым работаем, полезно... */
private MultiSellListContainer _multisell = null;
protected ConcurrentSkipListSet<Integer> _activeSoulShots = new ConcurrentSkipListSet<Integer>();
/** Location before entering Observer Mode */
private Location _obsLoc = new Location();
private L2WorldRegion _observNeighbor;
private byte _observerMode = 0;
public int _telemode = 0;
/**
Эта точка проверяется при нештатном выходе чара, и если не равна null чар возвращается в нее
Используется например для возвращения при падении с виверны
Поле heading используется для хранения денег возвращаемых при сбое
*/
public Location _stablePoint = null;
/** new loto ticket * */
public int _loto[] = new int[5];
/** new race ticket * */
public int _race[] = new int[2];
private final FastMap<Integer, String> _blockList = new FastMap<Integer, String>().shared(); // characters blocked with '/block <charname>' cmd
private boolean _isConnected = true;
private boolean _hero = false;
private int _team = 0;
private boolean _checksForTeam = false;
// time on login in game
private long _lastAccess;
/** True if the L2Player is in a boat */
private L2Vehicle _vehicle;
private Location _inVehiclePosition;
protected int _baseClass = -1;
protected L2SubClass _activeClass = null;
private Bonus _bonus;
private Future<?> _bonusExpiration;
public boolean _isSitting = false;
private boolean _noble = false;
private boolean _inOlympiadMode = false;
private int _olympiadGameId = -1;
private int _olympiadSide = -1;
private int _olympiadObserveId = -1;
/** ally with ketra or varka related wars */
private int _varka = 0;
private int _ketra = 0;
private int _ram = 0;
/** The Siege state */
private int _siegeState = 0;
private byte[] _keyBindings;
public ScheduledFuture<?> _taskWater;
protected HashMap<Integer, Long> _StatKills;
protected HashMap<Integer, Long> _StatDrop;
protected HashMap<Integer, Long> _StatCraft;
private Forum _forumMemo;
private ReentrantLock _forumMemoLock = new ReentrantLock();
private int _cursedWeaponEquippedId = 0;
private L2Fishing _fishCombat;
private boolean _fishing = false;
private Location _fishLoc = new Location();
private L2ItemInstance _lure = null;
public ScheduledFuture<?> _taskforfish;
private Future<?> _kickTask;
private boolean _isInCombatZone;
private boolean _isOnSiegeField;
private boolean _isInPeaceZone;
private boolean _isInSSZone;
private boolean _offline = false;
/** Трансформация */
private int _transformationId;
private int _transformationTemplate;
private String _transformationName;
private int pcBangPoints;
/** Коллекция для временного хранения скилов данной трансформации */
HashMap<Integer, L2Skill> _transformationSkills = new HashMap<Integer, L2Skill>();
private int _expandInventory = 0;
private int _expandWarehouse = 0;
private boolean _notShowBuffAnim = false;
private GArray<String> bypasses = null, bypasses_bbs = null;
private static final String NOT_CONNECTED = "<not connected>";
/** Конструктор для L2Player. Напрямую не вызывается, для создания игрока используется PlayerManager.create */
public L2Player(final int objectId, final L2PlayerTemplate template, final String accountName)
{
super(objectId, template);
_accountName = accountName;
_nameColor = 0xFFFFFF;
_titlecolor = 0xFFFF77;
_baseClass = getClassId().getId();
}
/**
Constructor<?> of L2Player (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 L2Player </li>
<li>Create a L2Radar object</li>
<li>Retrieve from the database all items of this L2Player and add them to _inventory </li>
<FONT COLOR=#FF0000><B> <U>Caution</U> : This method DOESN'T SET the account name of the L2Player</B></FONT><BR><BR>
@param objectId Identifier of the object to initialized
@param template The L2PlayerTemplate to apply to the L2Player
*/
private L2Player(final int objectId, final L2PlayerTemplate template)
{
this(objectId, template, null);
_inventory.restore();
// Create an AI
setAI(new L2PlayerAI(this));
// Create a L2Radar object
radar = new L2Radar(this);
if(!Config.EVERYBODY_HAS_ADMIN_RIGHTS)
setPlayerAccess(Config.gmlist.get(objectId));
else
setPlayerAccess(Config.gmlist.get(new Integer(0)));
// Retrieve from the database all macroses of this L2Player and add them to _macroses
_macroses.restore();
}
public String getAccountName()
{
if(_connection == null)
return _accountName;
return _connection.getLoginName();
}
public String getIP()
{
if(_connection == null)
return NOT_CONNECTED;
return _connection.getIpAddr();
}
/**
Возвращает список персонажей на аккаунте, за исключением текущего
@return Список персонажей
*/
public HashMap<Integer, String> getAccountChars()
{
return _chars;
}
@Override
public final L2PlayerTemplate getTemplate()
{
return (L2PlayerTemplate) _template;
}
@Override
public L2PlayerTemplate getBaseTemplate()
{
return (L2PlayerTemplate) _baseTemplate;
}
public void changeSex()
{
boolean male = true;
if(getSex() == 1)
male = false;
_template = CharTemplateTable.getInstance().getTemplate(getClassId(), !male);
}
@Override
public L2PlayableAI getAI()
{
if(_ai == null)
_ai = new L2PlayerAI(this);
return (L2PlayableAI) _ai;
}
@Override
public void doAttack(final L2Character target)
{
super.doAttack(target);
if(_cubics != null)
{
for(L2CubicInstance cubic : _cubics)
{
if(cubic.getType() != CubicType.LIFE_CUBIC)
{
cubic.doAction(target);
}
}
}
if(_agathion != null)
_agathion.doAction(target);
}
@Override
public void doCast(final L2Skill skill, final L2Character target, boolean forceUse)
{
if(skill == null)
return;
if(skill.getId() != 3318 && isCombatFlagEquipped())
{
sendPacket(Msg.YOU_CANNOT_CONTROL_THE_TARGET_WHILE_HOLDING_A_FLAG);
sendActionFailed();
return;
}
else if(skill.getId() != 847 && isTerritoryFlagEquipped())
{
sendPacket(Msg.YOU_CANNOT_CONTROL_THE_TARGET_WHILE_HOLDING_A_FLAG);
sendActionFailed();
return;
}
super.doCast(skill, target, forceUse);
// Это из фреи, нужно доделать
// if(!skill.isOffensive() && target != null && target.isPlayer() && target.getPet() != null && target.getPet().isSummon())
// {
// super.doCast(skill, target.getPet(), forceUse);
// }
if(_useSeed != 0 && skill.getSkillType() == SkillType.SOWING)
sendPacket(new ExUseSharedGroupItem(_useSeed, _useSeed, 5000, 5000));
if(skill.isOffensive() && target != null)
{
if(_cubics != null)
{
for(L2CubicInstance cubic : _cubics)
{
if(cubic.getType() != CubicType.LIFE_CUBIC)
{
cubic.doAction(target);
}
}
}
if(_agathion != null)
_agathion.doAction(target);
}
}
public void refreshSavedStats()
{
_statsChangeRecorder.refreshSaves();
}
@Override
public void sendChanges()
{
_statsChangeRecorder.sendChanges();
}
@Override
public final byte getLevel()
{
return _activeClass == null ? 1 : _activeClass.getLevel();
}
public final boolean setLevel(final int lvl)
{
if(_activeClass != null)
_activeClass.setLevel((byte) lvl);
return lvl == getLevel();
}
public byte getSex()
{
return getTemplate().isMale ? (byte) 0 : (byte) 1;
}
public int getFace()
{
return _face;
}
public void setFace(int face)
{
_face = face;
}
public int getHairColor()
{
return _hairColor;
}
public void setHairColor(int hairColor)
{
_hairColor = hairColor;
}
public int getHairStyle()
{
return _hairStyle;
}
public void setHairStyle(int hairStyle)
{
_hairStyle = hairStyle;
}
public boolean isInStoreMode()
{
return _privatestore != STORE_PRIVATE_NONE && _privatestore != STORE_OBSERVING_GAMES;
}
public void offline()
{
if(Config.SERVICES_TRADE_ONLY_PEACE)
{
if(!_isInPeaceZone)
{
sendMessage(new CustomMessage("l2p.gameserver.model.L2Player.NoTrade", this));
return;
}
}
setNameColor(Config.SERVICES_OFFLINE_TRADE_NAME_COLOR);
setOfflineMode(true);
clearHateList(false);
setVar("offline", String.valueOf(System.currentTimeMillis() / 1000));
if(Config.SERVICES_OFFLINE_TRADE_SECONDS_TO_KICK > 0)
startKickTask(Config.SERVICES_OFFLINE_TRADE_SECONDS_TO_KICK * 1000L);
if(isFestivalParticipant())
{
L2Party playerParty = _party;
if(playerParty != null)
playerParty.broadcastMessageToPartyMembers(getName() + " has been removed from the upcoming festival.");
}
if(_party != null)
_party.oustPartyMember(this);
if(_summon != null && _summon.getNpcId() != PetDataTable.IMPROVED_BABY_KOOKABURRA_ID && _summon.getNpcId() != PetDataTable.IMPROVED_BABY_COUGAR_ID)
_summon.unSummon();
CursedWeaponsManager.getInstance().doLogout(this);
if(_inOlympiadMode || _olympiadGameId > -1)
Olympiad.logoutPlayer(this);
sendPacket(Msg.LeaveWorld);
_isConnected = false;
setOnlineStatus(false);
//LSConnection.getInstance().removeAccount(getNetConnection());
//LSConnection.getInstance().sendPacket(new PlayerLogout(getNetConnection().getLoginName()));
broadcastUserInfo(true);
store(false);
_connection.OnOfflineTrade();
//TODO освобождать кучу других объектов связанных с игроком не нужных в оффлайне
}
/**
Сохраняет персонажа в бд и запускает необходимые процедуры.
@param shutdown тру при шатдауне
@param restart тру при рестарте. Игнорируется шатдаун.
@param kicked Отобразить у клиента табличку с мессагой о закрытии коннекта, отобрать проклятое оружие.
@param instant Выкидывает моментально, не оставляя чара в игре.
*/
public void logout(boolean shutdown, boolean restart, boolean kicked, boolean instant)
{
if(_logoutStarted)
return;
Log.LogChar(this, Log.Logout, "");
// Msg.ExRestartClient - 2 таблички появляется (вторая GG Fail), нажатие ок приводит к закрытию клиента
// Msg.ServerClose - табличка появляется, после нажатия ок переходит к диалогу ввода логина/пароля
// Msg.LeaveWorld - молча закрывает клиент (используется при выходе из игры)
if(kicked && Config.ALLOW_CURSED_WEAPONS && Config.DROP_CURSED_WEAPONS_ON_KICK)
{
if(isCursedWeaponEquipped())
{
_pvpFlag = 0;
CursedWeaponsManager.getInstance().dropPlayer(this);
}
}
if(restart)
{
// При рестарте просто обнуляем коннект
if(instant || Config.PLAYER_LOGOUT_INGAME_TIME == 0)
deleteMe();
else
scheduleDelete(Config.PLAYER_LOGOUT_INGAME_TIME);
if(_connection != null)
_connection.setActiveChar(null);
}
else
{
L2GameServerPacket sp = shutdown || kicked ? Msg.ServerClose : Msg.LeaveWorld;
sendPacket(sp);
if(_connection != null && _connection.getConnection() != null)
_connection.getConnection().close(sp);
if(instant || Config.PLAYER_LOGOUT_INGAME_TIME == 0)
deleteMe();
else
scheduleDelete(Config.PLAYER_LOGOUT_INGAME_TIME);
}
_connection = null;
_isConnected = false;
broadcastUserInfo(false);
}
public void prepareToLogout()
{
if(isFlying() && !checkLandingState())
setLoc(MapRegion.getTeleToClosestTown(this));
if(isCastingNow())
abortCast(true);
// При логауте автоматом проигрывается дуэль.
if(_duel != null)
_duel.onPlayerDefeat(this);
if(isFestivalParticipant())
{
L2Party playerParty = _party;
if(playerParty != null)
playerParty.broadcastMessageToPartyMembers(getName() + " has been removed from the upcoming festival.");
}
CursedWeaponsManager.getInstance().doLogout(this);
if(inObserverMode())
{
if(_olympiadObserveId == -1)
leaveObserverMode();
else
leaveOlympiadObserverMode();
}
if(_inOlympiadMode || _olympiadGameId > -1)
Olympiad.logoutPlayer(this);
// Вызов всех хэндлеров, определенных в скриптах
Object[] script_args = new Object[]{this};
for(ScriptClassAndMethod handler : Scripts.onPlayerExit)
{
callScripts(handler.scriptClass, handler.method, script_args);
}
if(_stablePoint != null)
{
teleToLocation(_stablePoint);
addAdena(_stablePoint.h);
unsetVar("wyvern_moneyback");
}
if(_recomChars.isEmpty())
unsetVar("recomChars");
else
{
String recomList = Integer.toHexString(_recomChars.get(0));
for(int i = 1; i < _recomChars.size(); i++)
{
recomList += "," + Integer.toHexString(_recomChars.get(i));
}
setVar("recomChars", recomList);
}
if(_summon != null)
{
try
{
_summon.unSummon();
}
catch(Throwable t)
{
t.printStackTrace();
_log.log(Level.WARNING, "prepareToLogout()", t);
}
}
if(isInParty())
{
try
{
leaveParty();
}
catch(Throwable t)
{
t.printStackTrace();
_log.log(Level.WARNING, "prepareToLogout()", t);
}
}
}
private boolean _logoutStarted = false;
public boolean isLogoutStarted()
{
return _logoutStarted;
}
public void setLogoutStarted(boolean logoutStarted)
{
_logoutStarted = logoutStarted;
}
/** @return a table containing all L2RecipeList of the L2Player.<BR><BR> */
public Collection<L2Recipe> getDwarvenRecipeBook()
{
return _recipebook.values();
}
public Collection<L2Recipe> getCommonRecipeBook()
{
return _commonrecipebook.values();
}
public int recipesCount()
{
return _commonrecipebook.size() + _recipebook.size();
}
public boolean hasRecipe(final L2Recipe id)
{
return _recipebook.containsValue(id) || _commonrecipebook.containsValue(id);
}
public boolean findRecipe(final int id)
{
return _recipebook.containsKey(id) || _commonrecipebook.containsKey(id);
}
/** Add a new L2RecipList to the table _recipebook containing all L2RecipeList of the L2Player */
public void registerRecipe(final L2Recipe recipe, boolean saveDB)
{
if(recipe.isDwarvenRecipe())
_recipebook.put(recipe.getId(), recipe);
else
_commonrecipebook.put(recipe.getId(), recipe);
if(saveDB)
mysql.set("REPLACE INTO character_recipebook (char_id, id) VALUES(?,?)", getObjectId(), recipe.getId());
}
/** Remove a L2RecipList from the table _recipebook containing all L2RecipeList of the L2Player */
public void unregisterRecipe(final int RecipeID)
{
if(_recipebook.containsKey(RecipeID))
{
mysql.set("DELETE FROM `character_recipebook` WHERE `char_id`=? AND `id`=? LIMIT 1", getObjectId(), RecipeID);
_recipebook.remove(RecipeID);
}
else if(_commonrecipebook.containsKey(RecipeID))
{
mysql.set("DELETE FROM `character_recipebook` WHERE `char_id`=? AND `id`=? LIMIT 1", getObjectId(), RecipeID);
_commonrecipebook.remove(RecipeID);
}
else
_log.warning("Attempted to remove unknown RecipeList" + RecipeID);
}
// ------------------- Quest Engine ----------------------
public QuestState getQuestState(String quest)
{
return _quests != null ? _quests.get(quest) : null;
}
public QuestState getQuestState(Class<?> quest)
{
return getQuestState(quest.getSimpleName());
}
public boolean isQuestCompleted(String quest)
{
QuestState q = getQuestState(quest);
return q != null && q.isCompleted();
}
public boolean isQuestCompleted(Class<?> quest)
{
QuestState q = getQuestState(quest);
return q != null && q.isCompleted();
}
public void setQuestState(QuestState qs)
{
_quests.put(qs.getQuest().getName(), qs);
}
public void delQuestState(String quest)
{
_quests.remove(quest);
}
public Quest[] getAllActiveQuests()
{
GArray<Quest> quests = new GArray<Quest>();
for(final QuestState qs : _quests.values())
{
if(qs != null && qs.isStarted())
quests.add(qs.getQuest());
}
return quests.toArray(new Quest[quests.size()]);
}
public QuestState[] getAllQuestsStates()
{
return _quests.values().toArray(new QuestState[_quests.size()]);
}
public GArray<QuestState> getQuestsForEvent(L2NpcInstance npc, QuestEventType event)
{
GArray<QuestState> states = new GArray<QuestState>();
Quest[] quests = npc.getTemplate().getEventQuests(event);
if(quests != null)
{
for(Quest quest : quests)
{
if(getQuestState(quest.getName()) != null && !getQuestState(quest.getName()).isCompleted())
states.add(getQuestState(quest.getName()));
}
}
return states;
}
public void processQuestEvent(String quest, String event, L2NpcInstance npc)
{
if(event == null)
event = "";
QuestState qs = getQuestState(quest);
if(qs == null)
{
Quest q = QuestManager.getQuest(quest);
if(q == null)
{
System.out.println("Quest " + quest + " not found!!!");
return;
}
qs = q.newQuestState(this, Quest.CREATED);
}
if(qs == null || qs.isCompleted())
return;
qs.getQuest().notifyEvent(event, qs, npc);
sendPacket(new QuestList(this));
}
/**
Проверка на переполнение инвентаря и перебор в весе для квестов и эвентов
@return true если ве проверки прошли успешно
*/
public boolean isQuestContinuationPossible(boolean msg)
{
if(_curWeightPenalty >= 3 || getInventoryLimit() * 0.8 < _inventory.getSize())
{
if(msg)
sendPacket(Msg.PROGRESS_IN_A_QUEST_IS_POSSIBLE_ONLY_WHEN_YOUR_INVENTORYS_WEIGHT_AND_VOLUME_ARE_LESS_THAN_80_PERCENT_OF_CAPACITY);
return false;
}
return true;
}
// ----------------- End of Quest Engine -------------------
public Collection<L2ShortCut> getAllShortCuts()
{
return _shortCuts.getAllShortCuts();
}
public L2ShortCut getShortCut(int slot, int page)
{
return _shortCuts.getShortCut(slot, page);
}
public void registerShortCut(L2ShortCut shortcut)
{
_shortCuts.registerShortCut(shortcut);
}
public void deleteShortCut(int slot, int page)
{
_shortCuts.deleteShortCut(slot, page);
}
public void registerMacro(L2Macro macro)
{
_macroses.registerMacro(macro);
}
public void deleteMacro(int id)
{
_macroses.deleteMacro(id);
}
public MacroList getMacroses()
{
return _macroses;
}
/**
Возвращает состояние осады L2Player.<BR>
1 = attacker, 2 = defender, 0 = не учавствует
@return состояние осады
*/
public int getSiegeState()
{
return _siegeState;
}
/**
Устанавливает состояние осады L2Player.<BR>
1 = attacker, 2 = defender, 0 = не учавствует
*/
public void setSiegeState(int siegeState)
{
_siegeState = siegeState;
broadcastRelationChanged();
}
public boolean isCastleLord(int castleId)
{
return _clan != null && isClanLeader() && _clan.getHasCastle() == castleId;
}
/**
Проверяет является ли этот персонаж владельцем крепости
@param fortressId
@return true если владелец
*/
public boolean isFortressLord(int fortressId)
{
return _clan != null && isClanLeader() && _clan.getHasFortress() == fortressId;
}
public int getPkKills()
{
return _pkKills;
}
public void setPkKills(final int pkKills)
{
_pkKills = pkKills;
}
public long getCreateTime()
{
return _createTime;
}
public void setCreateTime(final long createTime)
{
_createTime = createTime;
}
public int getDeleteTimer()
{
return _deleteTimer;
}
public void setDeleteTimer(final int deleteTimer)
{
_deleteTimer = deleteTimer;
}
public int getCurrentLoad()
{
return _inventory.getTotalWeight();
}
public long getLastAccess()
{
return _lastAccess;
}
public void setLastAccess(long value)
{
_lastAccess = value;
}
public int getRecomHave()
{
return _recomHave;
}
public void setRecomHave(int value)
{
if(value > 255)
_recomHave = 255;
else if(value < 0)
_recomHave = 0;
else
_recomHave = value;
}
public int getRecomLeft()
{
return _recomLeft;
}
public void setRecomLeft(final int value)
{
_recomLeft = value;
}
public void giveRecom(final L2Player target)
{
int targetRecom = target._recomHave;
if(targetRecom < 255)
target.setRecomHave(targetRecom + 1);
if(_recomLeft > 0)
_recomLeft--;
_recomChars.add(target.getObjectId());
}
public boolean canRecom(final L2Player target)
{
return !_recomChars.contains(target.getObjectId());
}
@Override
public int getKarma()
{
return _karma;
}
public void setKarma(int karma)
{
if(karma < 0)
karma = 0;
if(_karma == karma)
return;
_karma = karma;
if(karma > 0)
{
for(final L2Character object : L2World.getAroundCharacters(this))
{
if(object instanceof L2GuardInstance && object.getAI().getIntention() == CtrlIntention.AI_INTENTION_IDLE)
object.getAI().setIntention(CtrlIntention.AI_INTENTION_ACTIVE, null, null);
}
}
sendChanges();
if(_summon != null)
_summon.broadcastPetInfo();
}
public int getMaxLoad()
{
// Weight Limit = (CON Modifier*69000)*Skills
// Source
http://l2p.bravehost.com/weightlimit.html (May 2007)
// Fitted exponential curve to the data
int con = getCON();
if(con < 1)
return (int) (31000 * Config.MAXLOAD_MODIFIER);
else if(con > 59)
return (int) (176000 * Config.MAXLOAD_MODIFIER);
else
return (int) calcStat(Stats.MAX_LOAD, Math.pow(1.029993928, con) * 30495.627366 * Config.MAXLOAD_MODIFIER, this, null);
}
public int getExpertisePenalty()
{
return expertisePenalty;
}
public int getWeightPenalty()
{
return _curWeightPenalty;
}
@Override
public void updateEffectIcons()
{
if(isMassUpdating())
return;
L2Effect[] effects = getEffectList().getAllFirstEffects();
Arrays.sort(effects, EffectsComparator.getInstance());
PartySpelled ps = new PartySpelled(this, false);
AbnormalStatusUpdate mi = new AbnormalStatusUpdate();
for(L2Effect effect : effects)
{
if(effect != null && effect.isInUse())
{
if(effect.getStackType().equalsIgnoreCase("HpRecoverCast"))
sendPacket(new ShortBuffStatusUpdate(effect));
else
effect.addIcon(mi);
if(_party != null)
effect.addPartySpelledIcon(ps);
}
}
sendPacket(mi);
if(_party != null)
_party.broadcastToPartyMembers(ps);
if(Config.ENABLE_OLYMPIAD && _inOlympiadMode && isOlympiadCompStart())
{
OlympiadGame olymp_game = Olympiad.getOlympiadGame(_olympiadGameId);
if(olymp_game != null)
{
ExOlympiadSpelledInfo OlympiadSpelledInfo = new ExOlympiadSpelledInfo();
for(L2Effect effect : effects)
{
if(effect != null && effect.isInUse())
effect.addOlympiadSpelledIcon(this, OlympiadSpelledInfo);
}
if(olymp_game.getType() == CompType.CLASSED || olymp_game.getType() == CompType.NON_CLASSED)
{
for(L2Player member : olymp_game.getTeamMembers(this))
{
member.sendPacket(OlympiadSpelledInfo);
}
}
for(L2Player member : olymp_game.getSpectators())
{
member.sendPacket(OlympiadSpelledInfo);
}
}
}
}
public void refreshOverloaded()
{
if(isMassUpdating() || getMaxLoad() <= 0)
{
return;
}
setOverloaded(getCurrentLoad() > getMaxLoad());
double weightproc = 100. * (getCurrentLoad() - calcStat(Stats.MAX_NO_PENALTY_LOAD, 0, this, null)) / getMaxLoad();
int newWeightPenalty = 0;
if(weightproc < 50)
newWeightPenalty = 0;
else if(weightproc < 66.6)
newWeightPenalty = 1;
else if(weightproc < 80)
newWeightPenalty = 2;
else if(weightproc < 100)
newWeightPenalty = 3;
else
newWeightPenalty = 4;
if(_curWeightPenalty == newWeightPenalty)
return;
_curWeightPenalty = newWeightPenalty;
if(_curWeightPenalty > 0)
super.addSkill(SkillTable.getInstance().getInfo(4270, _curWeightPenalty));
else
super.removeSkill(getKnownSkill(4270));
sendPacket(new EtcStatusUpdate(this));
}
public void refreshExpertisePenalty()
{
if(isMassUpdating())
return;
// Calculate the current higher Expertise of the L2Player
int level = (int) calcStat(Stats.GRADE_EXPERTISE_LEVEL, getLevel(), null, null);
int i = 0;
for(i = 0; i < EXPERTISE_LEVELS.length; i++)
{
if(level < EXPERTISE_LEVELS[i + 1])
break;
}
// Add the Expertise skill corresponding to its Expertise level
if(expertiseIndex != i)
{
expertiseIndex = i;
if(expertiseIndex > 0)
addSkill(SkillTable.getInstance().getInfo(239, expertiseIndex), false);
}
int newPenalty = 0;
L2ItemInstance[] items = _inventory.getItems();
for(L2ItemInstance item : items)
{
if(item != null && item.isEquipped())
{
int crystaltype = item.getItem().getCrystalType().ordinal();
if(crystaltype > newPenalty)
newPenalty = crystaltype;
}
}
newPenalty = newPenalty - expertiseIndex;
if(newPenalty <= 0)
newPenalty = 0;
if(expertisePenalty == newPenalty)
return;
expertisePenalty = newPenalty;
if(newPenalty > 0)
super.addSkill(SkillTable.getInstance().getInfo(4267, expertisePenalty));
else
super.removeSkill(getKnownSkill(4267));
sendPacket(new EtcStatusUpdate(this));
}
public int getPvpKills()
{
return _pvpKills;
}
public void setPvpKills(int pvpKills)
{
_pvpKills = pvpKills;
}
public ClassId getClassId()
{
return getTemplate().classId;
}
public void addClanPointsOnProfession(final int id)
{
if(_lvlJoinedAcademy != 0 && _clan != null && _clan.getLevel() >= 5 && ClassId.values()[id].getLevel() == 2)
_clan.incReputation(100, true, "Academy");
else if(_lvlJoinedAcademy != 0 && _clan != null && _clan.getLevel() >= 5 && ClassId.values()[id].getLevel() == 3)
{
int earnedPoints = 0;
if(_lvlJoinedAcademy <= 16)
earnedPoints = 650;
else if(_lvlJoinedAcademy >= 39)
earnedPoints = 190;
else
earnedPoints = 650 - (_lvlJoinedAcademy - 16) * 20;
_clan.removeClanMember(getObjectId());
SystemMessage sm = new SystemMessage(SystemMessage.CLAN_ACADEMY_MEMBER_S1_HAS_SUCCESSFULLY_COMPLETED_THE_2ND_CLASS_TRANSFER_AND_OBTAINED_S2_CLAN_REPUTATION_POINTS);
sm.addString(getName());
sm.addNumber(_clan.incReputation(earnedPoints, true, "Academy"));
_clan.broadcastToOnlineMembers(sm);
_clan.broadcastToOtherOnlineMembers(new PledgeShowMemberListDelete(getName()), this);
setClan(null);
setTitle("");
sendPacket(Msg.CONGRATULATIONS_YOU_WILL_NOW_GRADUATE_FROM_THE_CLAN_ACADEMY_AND_LEAVE_YOUR_CURRENT_CLAN_AS_A_GRADUATE_OF_THE_ACADEMY_YOU_CAN_IMMEDIATELY_JOIN_A_CLAN_AS_A_REGULAR_MEMBER_WITHOUT_BEING_SUBJECT_TO_ANY_PENALTIES);
_leaveClanTime = 0;
broadcastUserInfo(true);
broadcastRelationChanged();
sendPacket(Msg.PledgeShowMemberListDeleteAll);
L2ItemInstance academyCirclet = ItemTable.getInstance().createItem(8181);
_inventory.addItem(academyCirclet);
sendPacket(new SystemMessage(SystemMessage.YOU_HAVE_EARNED_S1).addItemName(academyCirclet.getItemId()));
}
}
/**
Set the template of the L2Player.
@param id The Identifier of the L2PlayerTemplate to set to the L2Player
*/
public synchronized void setClassId(final int id, boolean noban)
{
if(!noban && !(ClassId.values()[id].equalsOrChildOf(ClassId.values()[getActiveClassId()]) || _playerAccess.CanChangeClass || Config.EVERYBODY_HAS_ADMIN_RIGHTS))
{
Thread.dumpStack();
Util.handleIllegalPlayerAction(this, "L2Player[1535]", "tried to change class " + getActiveClassId() + " to " + id, 1);
return;
}
//Если новый ID не принадлежит имеющимся классам значит это новая профа
if(!_classlist.containsKey(id))
{
final L2SubClass cclass = _activeClass;
_classlist.remove(getActiveClassId());
changeClassInDb(cclass.getClassId(), id);
if(cclass.isBase())
{
_baseClass = id;
addClanPointsOnProfession(id);
L2ItemInstance coupons = null;
if(ClassId.values()[id].getLevel() == 2)
{
if(Config.ALT_ALLOW_SHADOW_WEAPONS)
coupons = ItemTable.getInstance().createItem(8869);
unsetVar("newbieweapon");
unsetVar("p1q2");
unsetVar("p1q3");
unsetVar("p1q4");
unsetVar("prof1");
unsetVar("ng1");
unsetVar("ng2");
unsetVar("ng3");
unsetVar("ng4");
}
else if(ClassId.values()[id].getLevel() == 3)
{
if(Config.ALT_ALLOW_SHADOW_WEAPONS)
coupons = ItemTable.getInstance().createItem(8870);
unsetVar("newbiearmor");
unsetVar("dd1"); // удаляем отметки о выдаче дименшен даймондов
unsetVar("dd2");
unsetVar("dd3");
unsetVar("prof2.1");
unsetVar("prof2.2");
unsetVar("prof2.3");
checkReferralBonus(1);
}
else if(ClassId.values()[id].getLevel() == 4)
checkReferralBonus(2);
if(coupons != null)
{
coupons.setCount(15);
_inventory.addItem(coupons);
sendPacket(SystemMessage.obtainItems(coupons));
}
}
// Выдача Holy Pomander
switch(ClassId.values()[id])
{
case cardinal:
Functions.addItem(this, 15307, 1);
break;
case evaSaint:
Functions.addItem(this, 15308, 1);
break;
case shillienSaint:
Functions.addItem(this, 15309, 4);
break;
}
cclass.setClassId(id);
_classlist.put(id, cclass);
rewardSkills();
storeCharSubClasses();
// Социалка при получении профы
broadcastPacket(new MagicSkillUse(this, this, 5103, 1, 1000, 0));
//broadcastPacket(new SocialAction(getObjectId(), 16));
sendPacket(new PlaySound("ItemSound.quest_fanfare_2"));
broadcastUserInfo(true);
}
L2PlayerTemplate t = CharTemplateTable.getInstance().getTemplate(id, getSex() == 1);
if(t == null)
{
_log.severe("Missing template for classId: " + id);
// do not throw error - only print error
return;
}
// Set the template of the L2Player
setTemplate(t);
// Update class icon in party and clan
if(isInParty())
_party.broadcastToPartyMembers(new PartySmallWindowUpdate(this));
if(_clan != null)
_clan.broadcastToOnlineMembers(new PledgeShowMemberListUpdate(this));
}
public void setClassId(final int id)
{
setClassId(id, false);
}
public long getExp()
{
return _activeClass == null ? 0 : _activeClass.getExp();
}
public long getMaxExp()
{
return _activeClass == null ? Experience.LEVEL[Experience.getMaxLevel() + 1] : _activeClass.getMaxExp();
}
public void addExp(long val)
{
if(_activeClass != null)
_activeClass.addExp(val);
}
public void setEnchantScroll(final L2ItemInstance scroll)
{
_enchantScroll = scroll;
}
public L2ItemInstance getEnchantScroll()
{
return _enchantScroll;
}
public void setFistsWeaponItem(final L2Weapon weaponItem)
{
_fistsWeaponItem = weaponItem;
}
public L2Weapon getFistsWeaponItem()
{
return _fistsWeaponItem;
}
public L2Weapon findFistsWeaponItem(final int classId)
{
//human fighter fists
if(classId >= 0x00 && classId <= 0x09)
return (L2Weapon) ItemTable.getInstance().getTemplate(246);
//human mage fists
if(classId >= 0x0a && classId <= 0x11)
return (L2Weapon) ItemTable.getInstance().getTemplate(251);
//elven fighter fists
if(classId >= 0x12 && classId <= 0x18)
return (L2Weapon) ItemTable.getInstance().getTemplate(244);
//elven mage fists
if(classId >= 0x19 && classId <= 0x1e)
return (L2Weapon) ItemTable.getInstance().getTemplate(249);
//dark elven fighter fists
if(classId >= 0x1f && classId <= 0x25)
return (L2Weapon) ItemTable.getInstance().getTemplate(245);
//dark elven mage fists
if(classId >= 0x26 && classId <= 0x2b)
return (L2Weapon) ItemTable.getInstance().getTemplate(250);
//orc fighter fists
if(classId >= 0x2c && classId <= 0x30)
return (L2Weapon) ItemTable.getInstance().getTemplate(248);
//orc mage fists
if(classId >= 0x31 && classId <= 0x34)
return (L2Weapon) ItemTable.getInstance().getTemplate(252);
//dwarven fists
if(classId >= 0x35 && classId <= 0x39)
return (L2Weapon) ItemTable.getInstance().getTemplate(247);
return null;
}
/** Добавляет чару опыт и/или сп с учетом личного бонуса */
@Override
public void addExpAndSp(long addToExp, long addToSp)
{
addExpAndSp(addToExp, addToSp, true, true);
}
/** Добавляет чару опыт и/или сп, с учетом личного бонуса или нет */
@Override
public void addExpAndSp(long addToExp, long addToSp, boolean applyBonus, boolean appyToPet)
{
if(applyBonus)
{
addToExp *= Config.RATE_XP * getRateExp();
addToSp *= Config.RATE_SP * getRateSp();
}
if(addToExp > 0)
{
if(appyToPet)
{
L2Summon pet = _summon;
if(pet != null && !pet.isDead())
// Sin Eater забирает всю экспу у персонажа
{
if(pet.getNpcId() == PetDataTable.SIN_EATER_ID)
{
pet.addExpAndSp(addToExp, 0);
addToExp = 0;
}
if(pet.isPet() && pet.getLevel() == 85)
addToExp *= 1f;
else if(pet.isPet() && pet.getExpPenalty() > 0f)
{
if(pet.getLevel() > getLevel() - 20 && pet.getLevel() < getLevel() + 5)
{
pet.addExpAndSp((long) (addToExp * pet.getExpPenalty()), 0);
addToExp *= 1f - pet.getExpPenalty();
}
else
{
pet.addExpAndSp((long) (addToExp * pet.getExpPenalty() / 5f), 0);
addToExp *= 1f - pet.getExpPenalty() / 5f;
}
}
else if(pet.isSummon())
{
addToExp *= 1f - pet.getExpPenalty();
}
}
}
// Remove Karma when the player kills L2MonsterInstance
if(!isCursedWeaponEquipped() && addToSp > 0 && _karma > 0)
{
_karma -= addToSp / (Config.KARMA_SP_DIVIDER * Config.RATE_SP);
}
if(_karma < 0)
{
_karma = 0;
}
long max_xp = getVarB("NoExp") ? Experience.LEVEL[getLevel() + 1] - 1 : getMaxExp();
addToExp = Math.min(addToExp, max_xp - getExp());
}
addExp(addToExp);
addSp(addToSp);
if(addToSp > 0 && addToExp == 0)
sendPacket(new SystemMessage(SystemMessage.YOU_HAVE_ACQUIRED_S1_SP).addNumber(addToSp));
else if(addToSp > 0 || addToExp > 0)
sendPacket(new SystemMessage(SystemMessage.YOU_HAVE_EARNED_S1_EXPERIENCE_AND_S2_SP).addNumber(addToExp).addNumber(addToSp));
long exp = getExp();
int level = getLevel();
while(exp >= Experience.LEVEL[level + 1] && increaseLevel())
{
level = getLevel();
}
while(exp < Experience.LEVEL[level] && decreaseLevel())
{
level = getLevel();
}
sendChanges();
}
/**
Give Expertise skill of this level.<BR><BR>
<B><U> Actions</U> :</B><BR><BR>
<li>Get the Level of the L2Player </li>
<li>Add the Expertise skill corresponding to its Expertise level</li>
<li>Update the overloaded status of the L2Player</li><BR><BR>
<FONT COLOR=#FF0000><B> <U>Caution</U> : This method DOESN'T give other free skills (SP needed = 0)</B></FONT><BR><BR>
*/
private void rewardSkills()
{
boolean update = false;
if(Config.AUTO_LEARN_SKILLS)
{
int unLearnable = 0;
GArray<L2SkillLearn> skills = SkillTreeTable.getInstance().getAvailableSkills(this, getClassId());
while(skills.size() > unLearnable)
{
unLearnable = 0;
for(L2SkillLearn s : skills)
{
L2Skill sk = SkillTable.getInstance().getInfo(s.id, s.skillLevel);
if(sk == null || !sk.getCanLearn(getClassId()))
{
unLearnable++;
continue;
}
addSkill(sk, true);
}
skills = SkillTreeTable.getInstance().getAvailableSkills(this, getClassId());
}
update = true;
}
else
// Скиллы дающиеся бесплатно не требуют изучения
{
for(L2SkillLearn skill : SkillTreeTable.getInstance().getAvailableSkills(this, getClassId()))
{
if(skill._repCost == 0 && skill._spCost == 0 && skill.itemCount == 0)
{
L2Skill sk = SkillTable.getInstance().getInfo(skill.getId(), skill.getLevel());
addSkill(sk, true);
if(!getAllShortCuts().isEmpty() && sk.getLevel() > 1)
{
for(L2ShortCut sc : getAllShortCuts())
{
if(sc.id == sk.getId() && sc.type == L2ShortCut.TYPE_SKILL)
{
L2ShortCut newsc = new L2ShortCut(sc.slot, sc.page, sc.type, sc.id, sk.getLevel());
sendPacket(new ShortCutRegister(newsc));
registerShortCut(newsc);
}
}
}
update = true;
}
}
}
if(update)
sendPacket(new SkillList(this));
// This function gets called on login, so not such a bad place to check weight
// Update the overloaded status of the L2Player
refreshOverloaded();
refreshExpertisePenalty();
}
public Race getRace()
{
return getBaseTemplate().race;
}
public int getIntSp()
{
return (int) getSp();
}
public long getSp()
{
return _activeClass == null ? 0 : _activeClass.getSp();
}
public void setSp(long sp)
{
if(_activeClass != null)
_activeClass.setSp(sp);
}
public void addSp(long val)
{
if(_activeClass != null)
_activeClass.addSp(val);
}
public int getClanId()
{
return _clan == null ? 0 : _clan.getClanId();
}
@Override
public int getClanCrestId()
{
return _clan == null ? 0 : _clan.getCrestId();
}
@Override
public int getClanCrestLargeId()
{
return _clan == null ? 0 : _clan.getCrestLargeId();
}
public long getLeaveClanTime()
{
return _leaveClanTime;
}
public long getDeleteClanTime()
{
return _deleteClanTime;
}
public void setLeaveClanTime(final long time)
{
_leaveClanTime = time;
}
public void setDeleteClanTime(final long time)
{
_deleteClanTime = time;
}
public void setOnlineTime(final long time)
{
_onlineTime = time;
_onlineBeginTime = System.currentTimeMillis();
}
public void setNoChannel(final long time)
{
_NoChannel = time;
if(_NoChannel > 2145909600000L || _NoChannel < 0)
_NoChannel = -1;
if(_NoChannel > 0)
_NoChannelBegin = System.currentTimeMillis();
else
_NoChannelBegin = 0;
sendPacket(new EtcStatusUpdate(this));
}
public long getNoChannel()
{
return _NoChannel;
}
public long getNoChannelRemained()
{
if(_NoChannel == 0)
return 0;
else if(_NoChannel < 0)
return -1;
else
{
long remained = _NoChannel - System.currentTimeMillis() + _NoChannelBegin;
if(remained < 0)
return 0;
return remained;
}
}
public void setLeaveClanCurTime()
{
_leaveClanTime = System.currentTimeMillis();
}
public void setDeleteClanCurTime()
{
_deleteClanTime = System.currentTimeMillis();
}
public boolean canJoinClan()
{
if(_leaveClanTime == 0)
return true;
if(System.currentTimeMillis() - _leaveClanTime >= 24 * 60 * 60 * 1000L)
{
_leaveClanTime = 0;
return true;
}
return false;
}
public boolean canCreateClan()
{
if(_deleteClanTime == 0)
{
return true;
}
if(System.currentTimeMillis() - _deleteClanTime >= 10 * 24 * 60 * 60 * 1000L)
{
_deleteClanTime = 0;
return true;
}
return false;
}
public SystemMessage canJoinParty(L2Player inviter)
{
Transaction transaction = _transaction;
if(transaction != null && transaction.isInProgress() && transaction.getOtherPlayer(this) != inviter)
return Msg.WAITING_FOR_ANOTHER_REPLY; // занят
if(_blockAll || _messageRefusal) // всех нафиг
return Msg.THE_PERSON_IS_IN_A_MESSAGE_REFUSAL_MODE;
if(isInParty()) // уже
return new SystemMessage(SystemMessage.S1_IS_A_MEMBER_OF_ANOTHER_PARTY_AND_CANNOT_BE_INVITED).addString(getName());
if(ReflectionTable.getInstance().findSoloKamaloka(getObjectId()) != null) // в соло каме
return Msg.INVALID_TARGET;
if(isCursedWeaponEquipped() || inviter.isCursedWeaponEquipped()) // зарич
return Msg.INVALID_TARGET;
if(inviter._inOlympiadMode || _inOlympiadMode) // олимпиада
return Msg.INVALID_TARGET;
if(!inviter._playerAccess.CanJoinParty || !_playerAccess.CanJoinParty) // низя
return Msg.INVALID_TARGET;
if(_team != 0) // участник пвп эвента или дуэли
return Msg.INVALID_TARGET;
return null;
}
@Override
public PcInventory getInventory()
{
return _inventory;
}
public void removeItemFromShortCut(final int objectId)
{
_shortCuts.deleteShortCutByObjectId(objectId);
}
public void removeSkillFromShortCut(final int skillId)
{
_shortCuts.deleteShortCutBySkillId(skillId);
}
@Override
public boolean isSitting()
{
return inObserverMode() || _isSitting;
}
public void setSitting(boolean val)
{
_isSitting = val;
}
public boolean getSittingTask()
{
return sittingTaskLaunched;
}
@Override
public void sitDown()
{
if(isSitting() || sittingTaskLaunched || isAlikeDead())
return;
if(isStunned() || isSleeping() || isParalyzed() || isAttackingNow() || isCastingNow() || isMoving)
{
getAI().setNextAction(nextAction.REST, null, null, false, false);
return;
}
resetWaitSitTime();
getAI().setIntention(CtrlIntention.AI_INTENTION_REST, null, null);
broadcastPacket(new ChangeWaitType(this, ChangeWaitType.WT_SITTING));
sittingTaskLaunched = true;
_isSitting = true;
ThreadPoolManager.getInstance().scheduleAi(new EndSitDownTask(this), 2500, true);
}
@Override
public void standUp()
{
if(_isSitting && !sittingTaskLaunched && !isInStoreMode() && !isAlikeDead())
{
if(_relax)
{
_relax = false;
getEffectList().stopAllSkillEffects(EffectType.Relax);
}
getAI().clearNextAction();
broadcastPacket(new ChangeWaitType(this, ChangeWaitType.WT_STANDING));
sittingTaskLaunched = true;
_isSitting = true;
ThreadPoolManager.getInstance().scheduleAi(new EndStandUpTask(this), 2500, true);
}
}
public void setRelax(final boolean val)
{
_relax = val;
}
public void updateWaitSitTime()
{
if(_waitTimeWhenSit < 200)
{
_waitTimeWhenSit += 2;
}
}
public int getWaitSitTime()
{
return _waitTimeWhenSit;
}
public void resetWaitSitTime()
{
_waitTimeWhenSit = 0;
}
public Warehouse getWarehouse()
{
return _warehouse;
}
public Warehouse getFreight()
{
return _freight;
}
public long getAdena()
{
return _inventory.getAdena();
}
/**
Забирает адену у игрока.<BR><BR>
@param adena - сколько адены забрать
@param notify - отображать системное сообщение
@return L2ItemInstance - остаток адены
*/
public L2ItemInstance reduceAdena(long adena, boolean notify)
{
if(notify && adena > 0)
{
sendPacket(new SystemMessage(SystemMessage.S1_ADENA_DISAPPEARED).addNumber(adena));
}
return _inventory.reduceAdena(adena);
}
/**
Добавляет адену игроку.<BR><BR>
@param adena - сколько адены дать
@return L2ItemInstance - новое количество адены
TODO добавить параметр update как в reduceAdena
*/
public L2ItemInstance addAdena(final long adena)
{
return _inventory.addAdena(adena);
}
public L2GameClient getNetConnection()
{
return _connection;
}
public int getRevision()
{
return _connection == null ? 0 : _connection.getRevision();
}
public void setNetConnection(final L2GameClient connection)
{
_connection = connection;
_isConnected = connection != null && connection.isConnected();
}
public void closeNetConnection()
{
if(_connection != null)
_connection.closeNow(false);
}
@Override
public void onAction(final L2Player player, boolean shift)
{
if(Events.onAction(player, this, shift))
return;
// Check if the other player already target this L2Player
if(player.getTarget() != this)
{
player.setTarget(this);
if(player.getTarget() == this)
player.sendPacket(new MyTargetSelected(getObjectId(), 0)); // The color to display in the select window is White
else
sendActionFailed();
}
else if(getPrivateStoreType() != L2Player.STORE_PRIVATE_NONE)
{
if(getDistance(player) > INTERACTION_DISTANCE && getAI().getIntention() != CtrlIntention.AI_INTENTION_INTERACT)
{
if(!shift)
player.getAI().setIntention(CtrlIntention.AI_INTENTION_INTERACT, this, null);
}
else
player.doInteract(this);
}
else 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.sendActionFailed();
else
player.getAI().Attack(this, false, shift);
}
else if(player != this && !shift)
player.getAI().setIntention(CtrlIntention.AI_INTENTION_FOLLOW, this, Config.FOLLOW_RANGE);
else
sendActionFailed();
}
@Override
public void broadcastStatusUpdate()
{
// Send the Server->Client packet StatusUpdate with current HP and MP to all L2Player that must be informed of HP/MP updates of this L2Player
if(Config.FORCE_STATUSUPDATE)
super.broadcastStatusUpdate();
else if(!needStatusUpdate()) //По идее еше должно срезать траффик. Будут глюки с отображением - убрать это условие.
return;
sendStatusUpdate(false, StatusUpdate.CUR_HP, StatusUpdate.CUR_MP, StatusUpdate.CUR_CP);
// Check if a party is in progress
if(isInParty())
// Send the Server->Client packet PartySmallWindowUpdate with current HP, MP and Level to all other L2Player of the Party
_party.broadcastToPartyMembers(this, new PartySmallWindowUpdate(this));
if(_duel != null)
_duel.broadcastToOppositTeam(this, new ExDuelUpdateUserInfo(this));
if(_inOlympiadMode && isOlympiadCompStart())
{
OlympiadGame game = Olympiad.getOlympiadGame(_olympiadGameId);
if(game != null)
game.broadcastInfo(this, null, false);
}
}
public Future<?> _broadcastCharInfoTask;
/**
Отправляет UserInfo даному игроку и CharInfo всем окружающим.<BR><BR>
<B><U> Концепт</U> :</B><BR><BR>
Сервер шлет игроку UserInfo.
Сервер вызывает метод {@link L2Player#broadcastPacketToOthers(l2p.gameserver.serverpackets.L2GameServerPacket)} для рассылки CharInfo<BR><BR>
<B><U> Действия</U> :</B><BR><BR>
<li>Отсылка игроку UserInfo(личные и общие данные)</li>
<li>Отсылка другим игрокам CharInfo(Public data only)</li><BR><BR>
<FONT COLOR=#FF0000><B> <U>Внимание</U> : НЕ ПОСЫЛАЙТЕ UserInfo другим игрокам либо CharInfo даному игроку.<BR>
НЕ ВЫЗЫВАЕЙТЕ ЭТОТ МЕТОД КРОМЕ ОСОБЫХ ОБСТОЯТЕЛЬСТВ(смена сабкласса к примеру)!!! Траффик дико кушается у игроков и начинаются лаги.<br>
Используйте метод {@link l2p.gameserver.model.L2Player#sendChanges()}</B></FONT><BR><BR>
*/
@Override
public void broadcastUserInfo(boolean force)
{
sendUserInfo(force);
if(_invisible)
return;
if(Config.BROADCAST_CHAR_INFO_INTERVAL == 0)
force = true;
if(force)
{
broadcastCharIn...
