Você não é registrado, por favor registre-se para ter acesso ao conteúdo completo.
Caso seja registrado, efetue login.
Esqueceu sua senha? Clique aqui
Recomendamos o uso do Mozilla Firefox para uma melhor visualização.
Guma
mais a MOD tel VIP eu tava falando com inspector ak ino msn ele disse que nao tava funfando direito
Estou indeciso entre a Teon a 2010 ea rox 6.0 =/
/*
* 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 2, 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
* 02111-1307, USA.
*
* [Somente Usuários Registrados Podem Visualizar os Links Desta PáginaClique aqui para se Registrar]
*/
package com.l2jfrozen.gameserver.model.actor.instance;
/**
* This class represents all player characters in the world.<br>
* There is always a client-thread connected to this (except if a player-store is activated upon logout).
* @version $Revision: 1.6.4 $ $Date: 2009/05/12 19:46:09 $
* @author l2jfrozen dev
*/
public final class L2PcInstance extends L2PlayableInstance
{
/** The Constant RESTORE_SKILLS_FOR_CHAR. */
private static final String RESTORE_SKILLS_FOR_CHAR = "SELECT skill_id,skill_level FROM character_skills WHERE char_obj_id=? AND class_index=?";
/** The Constant ADD_NEW_SKILL. */
private static final String ADD_NEW_SKILL = "INSERT INTO character_skills (char_obj_id,skill_id,skill_level,skill_name,class _index) VALUES (?,?,?,?,?)";
/** The Constant UPDATE_CHARACTER_SKILL_LEVEL. */
private static final String UPDATE_CHARACTER_SKILL_LEVEL = "UPDATE character_skills SET skill_level=? WHERE skill_id=? AND char_obj_id=? AND class_index=?";
/** The Constant DELETE_SKILL_FROM_CHAR. */
private static final String DELETE_SKILL_FROM_CHAR = "DELETE FROM character_skills WHERE skill_id=? AND char_obj_id=? AND class_index=?";
/** The Constant DELETE_CHAR_SKILLS. */
private static final String DELETE_CHAR_SKILLS = "DELETE FROM character_skills WHERE char_obj_id=? AND class_index=?";
/** The Constant ADD_SKILL_SAVE. */
//private static final String ADD_SKILL_SAVE = "INSERT INTO character_skills_save (char_obj_id,skill_id,skill_level,effect_count,eff ect_cur_time,reuse_delay,restore_type,class_index, buff_index) VALUES (?,?,?,?,?,?,?,?,?)";
private static final String ADD_SKILL_SAVE = "INSERT INTO character_skills_save (char_obj_id,skill_id,skill_level,effect_count,eff ect_cur_time,reuse_delay,systime,restore_type,clas s_index,buff_index) VALUES (?,?,?,?,?,?,?,?,?,?)";
/** The Constant RESTORE_SKILL_SAVE. */
private static final String RESTORE_SKILL_SAVE = "SELECT skill_id,skill_level,effect_count,effect_cur_time, reuse_delay FROM character_skills_save WHERE char_obj_id=? AND class_index=? AND restore_type=? ORDER BY buff_index ASC";
/** The Constant DELETE_SKILL_SAVE. */
private static final String DELETE_SKILL_SAVE = "DELETE FROM character_skills_save WHERE char_obj_id=? AND class_index=?";
/** The _is the vip. */
public boolean _isVIP = false, _inEventVIP = false, _isNotVIP = false, _isTheVIP = false;
/** The _original karma vip. */
public int _originalNameColourVIP, _originalKarmaVIP;
/** The _vote timestamp. */
private long _voteTimestamp = 0;
/** The _posticipate sit. */
private boolean _posticipateSit;
/** The sitting task launched. */
protected boolean sittingTaskLaunched;
/** The saved_status. */
private PlayerStatus saved_status = null;
/** The _instance login time. */
private final long _instanceLoginTime;
/** The _last teleport action. */
private long _lastTeleportAction = 0;
/**
* Gets the actual status.
*
* @return the actual status
*/
public PlayerStatus getActualStatus(){
saved_status = new PlayerStatus(this);
return saved_status;
}
/**
* Gets the last saved status.
*
* @return the last saved status
*/
public PlayerStatus getLastSavedStatus(){
return saved_status;
}
/**
* Gets the vote timestamp.
*
* @return the _voteTimestamp
*/
public long getVoteTimestamp()
{
return _voteTimestamp;
}
L2Clan clan = getClan();
clan.setReputationScore(clan.getReputationScore() + Config.REPUTATION_QUANTITY, true);
sendMessage((new StringBuilder()).append("Admin give to you ").append(Config.REPUTATION_QUANTITY).append(" Reputation Points.").toString());
sendMessage("Admin give to you all Clan Skills");
}
/**
* Sets the vote timestamp.
*
* @param timestamp the _voteTimestamp to set
*/
public void setVoteTimestamp(long timestamp)
{
_voteTimestamp = timestamp;
}
/**
* Gets the vote points.
*
* @return the vote points
*/
public int getVotePoints()
{
Connection con = null;
int votePoints = 0;
try
{
con = L2DatabaseFactory.getInstance().getConnection(fals e);
PreparedStatement statement;
statement = con.prepareStatement("select votePoints from accounts where login=?");
statement.setString(1, _accountName);
/**
* Sets the vote points.
*
* @param points the new vote points
*/
public void setVotePoints(int points)
{
Connection con = null;
try
{
con = L2DatabaseFactory.getInstance().getConnection(fals e);
PreparedStatement statement;
statement = con.prepareStatement("update accounts set votePoints="+points+" where login='"+_accountName+"'");
statement.execute();
statement.close();
statement = null;
}
catch(Exception e)
{
if(Config.ENABLE_ALL_EXCEPTIONS)
e.printStackTrace();
}
finally
{
CloseUtil.close(con);
con = null;
}
}
/**
* Gets the vote time.
*
* @return the vote time
*/
public int getVoteTime()
{
Connection con = null;
int lastVote = 0;
try
{
con = L2DatabaseFactory.getInstance().getConnection(fals e);
PreparedStatement statement;
statement = con.prepareStatement("select lastVote from accounts where login=?");
statement.setString(1, _accountName);
/** The Constant STATUS_DATA_GET. */
private static final String STATUS_DATA_GET = "SELECT hero, noble, donator, hero_end_date FROM characters_custom_data WHERE obj_Id = ?";
/** The Constant RESTORE_SKILLS_FOR_CHAR_ALT_SUBCLASS. */
private static final String RESTORE_SKILLS_FOR_CHAR_ALT_SUBCLASS = "SELECT skill_id,skill_level FROM character_skills WHERE char_obj_id=? ORDER BY (skill_level+0)";
// ---------------------- L2JFrozen Addons ---------------------------------- //
/** The Constant RESTORE_CHAR_SUBCLASSES. */
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";
/** The Constant ADD_CHAR_SUBCLASS. */
private static final String ADD_CHAR_SUBCLASS = "INSERT INTO character_subclasses (char_obj_id,class_id,exp,sp,level,class_index) VALUES (?,?,?,?,?,?)";
/** The Constant UPDATE_CHAR_SUBCLASS. */
private static final String UPDATE_CHAR_SUBCLASS = "UPDATE character_subclasses SET exp=?,sp=?,level=?,class_id=? WHERE char_obj_id=? AND class_index =?";
/** The Constant DELETE_CHAR_SUBCLASS. */
private static final String DELETE_CHAR_SUBCLASS = "DELETE FROM character_subclasses WHERE char_obj_id=? AND class_index=?";
/** The Constant RESTORE_CHAR_HENNAS. */
private static final String RESTORE_CHAR_HENNAS = "SELECT slot,symbol_id FROM character_hennas WHERE char_obj_id=? AND class_index=?";
/** The Constant ADD_CHAR_HENNA. */
private static final String ADD_CHAR_HENNA = "INSERT INTO character_hennas (char_obj_id,symbol_id,slot,class_index) VALUES (?,?,?,?)";
/** The Constant DELETE_CHAR_HENNA. */
private static final String DELETE_CHAR_HENNA = "DELETE FROM character_hennas WHERE char_obj_id=? AND slot=? AND class_index=?";
/** The Constant DELETE_CHAR_HENNAS. */
private static final String DELETE_CHAR_HENNAS = "DELETE FROM character_hennas WHERE char_obj_id=? AND class_index=?";
/** The Constant DELETE_CHAR_SHORTCUTS. */
private static final String DELETE_CHAR_SHORTCUTS = "DELETE FROM character_shortcuts WHERE char_obj_id=? AND class_index=?";
/** The Constant RESTORE_CHAR_RECOMS. */
private static final String RESTORE_CHAR_RECOMS = "SELECT char_id,target_id FROM character_recommends WHERE char_id=?";
/** The Constant ADD_CHAR_RECOM. */
private static final String ADD_CHAR_RECOM = "INSERT INTO character_recommends (char_id,target_id) VALUES (?,?)";
/** The Constant DELETE_CHAR_RECOMS. */
private static final String DELETE_CHAR_RECOMS = "DELETE FROM character_recommends WHERE char_id=?";
/** The Constant REQUEST_TIMEOUT. */
public static final int REQUEST_TIMEOUT = 15;
/** The Constant STORE_PRIVATE_NONE. */
public static final int STORE_PRIVATE_NONE = 0;
/** The Constant STORE_PRIVATE_SELL. */
public static final int STORE_PRIVATE_SELL = 1;
/** The Constant STORE_PRIVATE_BUY. */
public static final int STORE_PRIVATE_BUY = 3;
/** The Constant STORE_PRIVATE_MANUFACTURE. */
public static final int STORE_PRIVATE_MANUFACTURE = 5;
/** The Constant STORE_PRIVATE_PACKAGE_SELL. */
public static final int STORE_PRIVATE_PACKAGE_SELL = 8;
/** The fmt. */
private final SimpleDateFormat fmt = new SimpleDateFormat("H:mm.");
/** 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
};
/**
* The Class AIAccessor.
*/
public class AIAccessor extends L2Character.AIAccessor
{
/**
* Instantiates a new aI accessor.
*/
protected AIAccessor()
{}
/**
* Gets the player.
*
* @return the player
*/
public L2PcInstance getPlayer()
{
return L2PcInstance.this;
}
/**
* Do pickup item.
*
* @param object the object
*/
public void doPickupItem(L2Object object)
{
L2PcInstance.this.doPickupItem(object);
}
/**
* Do interact.
*
* @param target the target
*/
public void doInteract(L2Character target)
{
L2PcInstance.this.doInteract(target);
}
/*
* (non-Javadoc)
* @see com.l2jfrozen.gameserver.model.L2Character.AIAcces sor#doAttack(com.l2jfrozen.gameserver.model.L2Char acter)
*/
@Override
public void doAttack(L2Character target)
{
if (isInsidePeaceZone(L2PcInstance.this, target))
{
// if(target instanceof L2PcInstance){ //the only case where to avoid the attack is if the attacked is L2PcInstance
// //and one of them is not into a fun event, otherwise continue
//
// if (!isInFunEvent() || !((L2PcInstance)target).isInFunEvent()) {
// getAI().setIntention(CtrlIntention.AI_INTENTION_ID LE);
sendPacket(ActionFailed.STATIC_PACKET);
return;
// }
// }
}
// during teleport phase, players cant do any attack
if ((TvT.is_teleport() && _inEventTvT) || (CTF.is_teleport() && _inEventCTF) || (DM.is_teleport() && _inEventDM))
{
sendPacket(ActionFailed.STATIC_PACKET);
return;
}
super.doAttack(target);
// cancel the recent fake-death protection instantly if the player attacks or casts spells
getPlayer().setRecentFakeDeath(false);
synchronized (_cubics)
{
for (L2CubicInstance cubic : _cubics.values())
if (cubic.getId() != L2CubicInstance.LIFE_CUBIC)
{
cubic.doAction(/* target */);
}
}
}
/* (non-Javadoc)
* @see com.l2jfrozen.gameserver.model.L2Character.AIAcces sor#doCast(com.l2jfrozen.gameserver.model.L2Skill)
*/
@Override
public void doCast(L2Skill skill)
{
// cancel the recent fake-death protection instantly if the player attacks or casts spells
getPlayer().setRecentFakeDeath(false);
if(skill == null)
return;
// Like L2OFF you can use cupid bow skills on peace zone
// Like L2OFF players can use TARGET_AURA skills on peace zone, all targets will be ignored.
if (skill.isOffensive() && (isInsidePeaceZone(L2PcInstance.this, getTarget()) && skill.getTargetType() != SkillTargetType.TARGET_AURA) && (skill.getId() != 3261 && skill.getId() != 3260 && skill.getId() != 3262)) //check limited to active target
{
sendPacket(ActionFailed.STATIC_PACKET);
return;
/** The _in boat position. */
private Point3D _inBoatPosition;
/** The _mount type. */
private int _mountType;
/** Store object used to summon the strider you are mounting *. */
private int _mountObjectID = 0;
/** The _telemode. */
public int _telemode = 0;
/** The _is silent moving. */
private int _isSilentMoving = 0;
/** The _in crystallize. */
private boolean _inCrystallize;
/** The _in craft mode. */
private boolean _inCraftMode;
/** The table containing all L2RecipeList of the L2PcInstance. */
private Map<Integer, L2RecipeList> _dwarvenRecipeBook = new FastMap<Integer, L2RecipeList>();
/** The _common recipe book. */
private Map<Integer, L2RecipeList> _commonRecipeBook = new FastMap<Integer, L2RecipeList>();
/** True if the L2PcInstance is sitting. */
private boolean _waitTypeSitting;
/** True if the L2PcInstance is using the relax skill. */
private boolean _relax;
/** Location before entering Observer Mode. */
private int _obsX;
/** The _obs y. */
private int _obsY;
/** The _obs z. */
private int _obsZ;
/** The _observer mode. */
private boolean _observerMode = false;
/** Stored from last ValidatePosition *. */
private Location _lastClientPosition = new Location(0, 0, 0);
/** The _last server position. */
private Location _lastServerPosition = new Location(0, 0, 0);
/** The number of recommandation obtained by the L2PcInstance. */
private int _recomHave; // how much I was recommended by others
/** The number of recommandation that the L2PcInstance can give. */
private int _recomLeft; // how many recomendations I can give to others
/** Date when recom points were updated last time. */
private long _lastRecomUpdate;
/** List with the recomendations that I've give. */
private List<Integer> _recomChars = new FastList<Integer>();
/** The random number of the L2PcInstance. */
//private static final Random _rnd = new Random();
private PcInventory _inventory = new PcInventory(this);
/** The _warehouse. */
private PcWarehouse _warehouse;
/** The _freight. */
private PcFreight _freight = new PcFreight(this);
/** 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;
/** The _active trade list. */
private TradeList _activeTradeList;
/** The _active warehouse. */
private ItemContainer _activeWarehouse;
/** The _create list. */
private L2ManufactureList _createList;
/** The _sell list. */
private TradeList _sellList;
/** The _buy list. */
private TradeList _buyList;
/** True if the L2PcInstance is newbie. */
private boolean _newbie;
/** The _noble. */
private boolean _noble = false;
/** The _hero. */
private boolean _hero = false;
/** The _donator. */
private boolean _donator = false;
/** The L2FolkInstance corresponding to the last Folk wich one the player talked. */
private L2FolkInstance _lastFolkNpc = null;
/** Last NPC Id talked on a quest. */
private int _questNpcObject = 0;
private int _party_find = 0;
//summon friend
/** The _summon request. */
private SummonRequest _summonRequest = new SummonRequest();
/**
* The Class SummonRequest.
*/
protected static class SummonRequest
{
/** The _target. */
private L2PcInstance _target = null;
/** The _skill. */
private L2Skill _skill = null;
/**
* Sets the target.
*
* @param destination the destination
* @param skill the skill
*/
public void setTarget(L2PcInstance destination, L2Skill skill)
{
_target = destination;
_skill = skill;
}
/**
* Gets the target.
*
* @return the target
*/
public L2PcInstance getTarget()
{
return _target;
}
/**
* Gets the skill.
*
* @return the skill
*/
public L2Skill getSkill()
{
return _skill;
}
}
/** The table containing all Quests began by the L2PcInstance. */
private Map<String, QuestState> _quests = new FastMap<String, QuestState>();
/** The list containing all shortCuts of this L2PcInstance. */
private ShortCuts _shortCuts = new ShortCuts(this);
/** The list containing all macroses of this L2PcInstance. */
private MacroList _macroses = new MacroList(this);
/** The _snoop listener. */
private List<L2PcInstance> _snoopListener = new FastList<L2PcInstance>();
/** The _snooped player. */
private List<L2PcInstance> _snoopedPlayer = new FastList<L2PcInstance>();
/** The _skill learning class id. */
private ClassId _skillLearningClassId;
// hennas
/** The _henna. */
private final L2HennaInstance[] _henna = new L2HennaInstance[3];
/** The _henna str. */
private int _hennaSTR;
/** The _henna int. */
private int _hennaINT;
/** The _henna dex. */
private int _hennaDEX;
/** The _henna men. */
private int _hennaMEN;
/** The _henna wit. */
private int _hennaWIT;
/** The _henna con. */
private int _hennaCON;
/** The L2Summon of the L2PcInstance. */
private L2Summon _summon = null;
// apparently, a L2PcInstance CAN have both a summon AND a tamed beast at the same time!!
/** The _tamed beast. */
private L2TamedBeastInstance _tamedBeast = null;
// client radar
/** The _radar. */
private L2Radar _radar;
// Clan related attributes
/** The Clan Identifier of the L2PcInstance. */
private int _clanId = 0;
/** The Clan object of the L2PcInstance. */
private L2Clan _clan;
/** Apprentice and Sponsor IDs. */
private int _apprentice = 0;
/** The _sponsor. */
private int _sponsor = 0;
/** The _clan join expiry time. */
private long _clanJoinExpiryTime;
/** The _clan create expiry time. */
private long _clanCreateExpiryTime;
/** The _power grade. */
private int _powerGrade = 0;
/** The _clan privileges. */
private int _clanPrivileges = 0;
/** L2PcInstance's pledge class (knight, Baron, etc.) */
private int _pledgeClass = 0;
/** The _pledge type. */
private int _pledgeType = 0;
/** Level at which the player joined the clan as an academy member. */
private int _lvlJoinedAcademy = 0;
/** The _wants peace. */
private int _wantsPeace = 0;
//Death Penalty Buff Level
/** The _death penalty buff level. */
private int _deathPenaltyBuffLevel = 0;
// private int _ChatFilterCount = 0;
//GM related variables
// private boolean _isGm;
/** The _access level. */
private AccessLevel _accessLevel;
// this is needed to find the inviting player for Party response
// there can only be one active party request at once
/** The _active requester. */
private L2PcInstance _activeRequester;
/** The _request expire time. */
private long _requestExpireTime = 0;
/** The _request. */
private L2Request _request = new L2Request(this);
/** The _arrow item. */
private L2ItemInstance _arrowItem;
// Used for protection after teleport
/** The _protect end time. */
private long _protectEndTime = 0;
public boolean isSpawnProtected() { return _protectEndTime > GameTimeController.getGameTicks(); }
private long _teleportProtectEndTime = 0;
public boolean isTeleportProtected() { return _teleportProtectEndTime > GameTimeController.getGameTicks(); }
// protects a char from agro mobs when getting up from fake death
/** The _recent fake death end time. */
private long _recentFakeDeathEndTime = 0;
/** The fists L2Weapon of the L2PcInstance (used when no weapon is equiped). */
private L2Weapon _fistsWeaponItem;
/** The _chars. */
private final Map<Integer, String> _chars = new FastMap<Integer, String>();
//private byte _updateKnownCounter = 0;
/** 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
/** The _expertise penalty. */
private int _expertisePenalty = 0;
/** The _heavy_mastery. */
private boolean _heavy_mastery = false;
/** The _light_mastery. */
private boolean _light_mastery = false;
/** The _robe_mastery. */
private boolean _robe_mastery = false;
/** The _mastery penalty. */
private int _masteryPenalty = 0;
/** The _inventory disable. */
protected boolean _inventoryDisable = false;
/** The _cubics. */
protected Map<Integer, L2CubicInstance> _cubics = new FastMap<Integer, L2CubicInstance>();
/** Active shots. A FastSet variable would actually suffice but this was changed to fix threading stability... */
protected Map<Integer, Integer> _activeSoulShots = new FastMap<Integer, Integer>().shared();
/** The soul shot lock. */
public final ReentrantLock soulShotLock = new ReentrantLock();
/** The dialog. */
public Quest dialog = null;
/** new loto ticket *. */
private int _loto[] = new int[5];
//public static int _loto_nums[] = {0,1,2,3,4,5,6,7,8,9,};
/** new race ticket *. */
private int _race[] = new int[2];
/** The _block list. */
private final BlockList _blockList = new BlockList(this);
/** The _team. */
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;
/** ************************************************** ******************* Adventurers' coupon (0-no 1-NG 2-D 3-NG & D) 0 = No coupon 1 = coupon for No Grade 2 = coupon for D Grade 3 = coupon for No & D Grade ************************************************** ******************. */
private int _hasCoupon = 0;
/** The _fish combat. */
private L2Fishing _fishCombat;
/** The _fishing. */
private boolean _fishing = false;
/** The _fishx. */
private int _fishx = 0;
/** The _fishy. */
private int _fishy = 0;
/** The _fishz. */
private int _fishz = 0;
/** The _task rent pet. */
private ScheduledFuture<?> _taskRentPet;
/** The _task water. */
private ScheduledFuture<?> _taskWater;
/** Bypass validations. */
private List<String> _validBypass = new FastList<String>();
/** The _valid bypass2. */
private List<String> _validBypass2 = new FastList<String>();
/** The _valid link. */
private List<String> _validLink = new FastList<String>();
/** The _forum mail. */
private Forum _forumMail;
/** The _forum memo. */
private Forum _forumMemo;
/** Current skill in use. */
private SkillDat _currentSkill;
private SkillDat _currentPetSkill;
/** Skills queued because a skill is already in progress. */
private SkillDat _queuedSkill;
/* Flag to disable equipment/skills while wearing formal wear **/
/** The _ is wearing formal wear. */
private boolean _IsWearingFormalWear = false;
/** The _current skill world position. */
private Point3D _currentSkillWorldPosition;
/** The _cursed weapon equiped id. */
private int _cursedWeaponEquipedId = 0;
// private boolean _combatFlagEquippedId = false;
/** The _revive requested. */
private int _reviveRequested = 0;
/** The _revive power. */
private double _revivePower = 0;
/** The _revive pet. */
private boolean _revivePet = false;
//private boolean isInDangerArea;
////////////////////////////////////////////////////////////////////
//START CHAT BAN SYSTEM
////////////////////////////////////////////////////////////////////
//private long _chatBanTimer = 0L;
//private ScheduledFuture<?> _chatBanTask = null;
////////////////////////////////////////////////////////////////////
//END CHAT BAN SYSTEM
////////////////////////////////////////////////////////////////////
/** The _is offline. */
private boolean _isOffline = false;
/** The _offline shop start. */
private long _offlineShopStart = 0;
/** The _original name color offline. */
public int _originalNameColorOffline = 0xFFFFFF;
/** Herbs Task Time *. */
private int _herbstask = 0;
/**
* Task for Herbs.
*/
public class HerbTask implements Runnable
{
/** The _process. */
private String _process;
/** The _item id. */
private int _itemId;
/** The _count. */
private int _count;
/** The _reference. */
private L2Object _reference;
/** The _send message. */
private boolean _sendMessage;
/**
* Instantiates a new herb task.
*
* @param process the process
* @param itemId the item id
* @param count the count
* @param reference the reference
* @param sendMessage the send message
*/
HerbTask(String process, int itemId, int count, L2Object reference, boolean sendMessage)
{
_process = process;
_itemId = itemId;
_count = count;
_reference = reference;
_sendMessage = sendMessage;
}
/** The _married type. */
private int _marriedType = 0;
/** The _partner id. */
private int _partnerId = 0;
/** The _couple id. */
private int _coupleId = 0;
/** The _engagerequest. */
private boolean _engagerequest = false;
/** The _engageid. */
private int _engageid = 0;
/** The _marryrequest. */
private boolean _marryrequest = false;
/** The _marryaccepted. */
private boolean _marryaccepted = false;
/** Quake System. */
private int quakeSystem = 0;
/** The _is locked. */
private boolean _isLocked = false;
/** The _is stored. */
private boolean _isStored = false;
/**
* Skill casting information (used to queue when several skills are cast in a short time) *.
*/
public class SkillDat
{
/** The _skill. */
private L2Skill _skill;
/** The _ctrl pressed. */
private boolean _ctrlPressed;
/** The _shift pressed. */
private boolean _shiftPressed;
/**
* Instantiates a new skill dat.
*
* @param skill the skill
* @param ctrlPressed the ctrl pressed
* @param shiftPressed the shift pressed
*/
protected SkillDat(L2Skill skill, boolean ctrlPressed, boolean shiftPressed)
{
_skill = skill;
_ctrlPressed = ctrlPressed;
_shiftPressed = shiftPressed;
}
/**
* Checks if is ctrl pressed.
*
* @return true, if is ctrl pressed
*/
public boolean isCtrlPressed()
{
return _ctrlPressed;
}
/**
* Checks if is shift pressed.
*
* @return true, if is shift pressed
*/
public boolean isShiftPressed()
{
return _shiftPressed;
}
/**
* Gets the skill.
*
* @return the skill
*/
public L2Skill getSkill()
{
return _skill;
}
/**
* Gets the skill id.
*
* @return the skill id
*/
public int getSkillId()
{
return getSkill() != null ? getSkill().getId() : -1;
}
}
/**
* 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
* @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);
app = null;
// 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;
}
/**
* Creates the dummy player.
*
* @param objectId the object id
* @param name the name
* @return the l2 pc instance
*/
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;
}
/**
* Gets the account name.
*
* @return the account name
*/
public String getAccountName()
{
if(getClient()!=null)
return getClient().getAccountName();
return _accountName;
}
/**
* Gets the account chars.
*
* @return the account chars
*/
public Map<Integer, String> getAccountChars()
{
return _chars;
}
/**
* Gets the relation.
*
* @param target the target
* @return the relation
*/
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;
}
}
/**
* Retrieve a L2PcInstance from the characters table of the database and add it in _allObjects of the L2world (call
* restore method).<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 load(int objectId)
{
return restore(objectId);
}
/**
* 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 app
*/
private L2PcInstance(int objectId, L2PcTemplate template, String accountName, PcAppearance app)
{
super(objectId, template);
getKnownList(); // init knownlist
getStat(); // init stats
getStatus(); // init status
super.initCharStatusUpdateValues();
initPcStatusUpdateValues();
_accountName = accountName;
_appearance = app;
// Create an AI
_ai = new L2PlayerAI(new L2PcInstance.AIAccessor());
// Create a L2Radar object
_radar = new L2Radar(this);
// Retrieve from the database all skills of this L2PcInstance and add them to _skills
// Retrieve from the database all items of this L2PcInstance and add them to _inventory
getInventory().restore();
if(!Config.WAREHOUSE_CACHE)
{
getWarehouse();
}
getFreight().restore();
/**
* Gets the appearance.
*
* @return the appearance
*/
public final PcAppearance getAppearance()
{
return _appearance;
}
/**
* Return the base L2PcTemplate link to the L2PcInstance.<BR>
* <BR>
*
* @return the base template
*/
public final L2PcTemplate getBaseTemplate()
{
return CharTemplateTable.getInstance().getTemplate(_baseC lass);
}
/**
* Return the L2PcTemplate link to the L2PcInstance.
*
* @return the template
*/
@Override
public final L2PcTemplate getTemplate()
{
return (L2PcTemplate) super.getTemplate();
}
/**
* Sets the template.
*
* @param newclass the new template
*/
public void setTemplate(ClassId newclass)
{
super.setTemplate(CharTemplateTable.getInstance(). getTemplate(newclass));
}
public void setTimerToAttack (long time)
{
timerToAttack = time;
}
public long getTimerToAttack ()
{
return timerToAttack;
}
/**
* Return the AI of the L2PcInstance (create it if necessary).<BR>
* <BR>
*
* @return the aI
*/
@Override
public L2CharacterAI getAI()
{
if(_ai == null)
{
synchronized (this)
{
if(_ai == null)
{
_ai = new L2PlayerAI(new L2PcInstance.AIAccessor());
}
}
}
return _ai;
}
/**
* Calculate a destination to explore the area and set the AI Intension to AI_INTENTION_MOVE_TO.<BR>
* <BR>
*
* @return the level
*//* TODO
public void explore()
{
if(!_exploring)
return;
if(getMountType() == 2)
return;
// Calculate the destination point (random)
int x = getX() + Rnd.nextInt(6000) - 3000;
int y = getY() + Rnd.nextInt(6000) - 3000;
if(x > Universe.MAX_X)
{
x = Universe.MAX_X;
}
if(x < Universe.MIN_X)
{
x = Universe.MIN_X;
}
if(y > Universe.MAX_Y)
{
y = Universe.MAX_Y;
}
if(y < Universe.MIN_Y)
{
y = Universe.MIN_Y;
}
int z = getZ();
L2CharPosition pos = new L2CharPosition(x, y, z, 0);
// Set the AI Intention to AI_INTENTION_MOVE_TO
getAI().setIntention(CtrlIntention.AI_INTENTION_MO VE_TO, pos);
pos = null;
}*/
/** Return the Level of the L2PcInstance. */
@Override
public final int getLevel()
{
int level = getStat().getLevel();
/**
* Return the _newbie state of the L2PcInstance.<BR>
* <BR>
*
* @return true, if is newbie
*/
public boolean isNewbie()
{
return _newbie;
}
/**
* Set the _newbie state of the L2PcInstance.<BR>
* <BR>
*
* @param isNewbie The Identifier of the _newbie state<BR>
* <BR>
*/
public void setNewbie(boolean isNewbie)
{
_newbie = isNewbie;
}
/**
* Sets the base class.
*
* @param baseClass the new base class
*/
public void setBaseClass(int baseClass)
{
_baseClass = baseClass;
}
/**
* Sets the base class.
*
* @param classId the new base class
*/
public void setBaseClass(ClassId classId)
{
_baseClass = classId.ordinal();
}
/**
* Checks if is in store mode.
*
* @return true, if is in store mode
*/
public boolean isInStoreMode()
{
return getPrivateStoreType() > 0;
}
// public boolean isInCraftMode() { return (getPrivateStoreType() == STORE_PRIVATE_MANUFACTURE); }
/**
* Checks if is in craft mode.
*
* @return true, if is in craft mode
*/
public boolean isInCraftMode()
{
return _inCraftMode;
}
/**
* Checks if is in craft mode.
*
* @param b the b
*/
public void isInCraftMode(boolean b)
{
_inCraftMode = b;
}
/** The _kicked. */
private boolean _kicked = false;
/**
* Manage Logout Task.<BR>
* <BR>
*
* @param kicked the kicked
*/
public void logout(boolean kicked)
{
// prevent from player disconnect when in Event
if(atEvent)
{
sendMessage("A superior power doesn't allow you to leave the event.");
sendPacket(ActionFailed.STATIC_PACKET);
}
_kicked = kicked;
closeNetConnection();
}
/**
* Checks if is kicked.
*
* @return true, if is kicked
*/
public boolean isKicked(){
return _kicked;
}
/**
* Sets the kicked.
*
* @param value the new kicked
*/
public void setKicked(boolean value){
_kicked = value;
}
/**
* Manage Logout Task.<BR>
* <BR>
*/
public void logout()
{
for(L2PcInstance player : players)
{
if(player != null)
{
if(player.getClient()!=null && !player.getClient().getConnection().isClosed()){
String ip = player.getClient().getConnection().getSocketChanne l().socket().getInetAddress().getHostAddress();
if(thisip.equals(ip) && this != player && player != null)
{
player._active_boxes = _active_boxes;
}
}
}
}
}
*/
}
/**
* Return a table containing all Common L2RecipeList of the L2PcInstance.<BR>
* <BR>
*
* @return the common recipe book
*/
public L2RecipeList[] getCommonRecipeBook()
{
return _commonRecipeBook.values().toArray(new L2RecipeList[_commonRecipeBook.values().size()]);
}
/**
* Return a table containing all Dwarf L2RecipeList of the L2PcInstance.<BR>
* <BR>
*
* @return the dwarven recipe book
*/
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 <BR>
* <BR>.
*
* @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 <BR>
* <BR>.
*
* @param recipe The L2RecipeList to add to the _recipebook
*/
public void registerDwarvenRecipeList(L2RecipeList recipe)
{
_dwarvenRecipeBook.put(recipe.getId(), recipe);
}
/**
* Checks for recipe list.
*
* @param recipeId the recipe id
* @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;
else if(_commonRecipeBook.containsKey(recipeId))
return true;
else
return false;
}
/**
* Tries to remove a L2RecipList from the table _DwarvenRecipeBook or from table _CommonRecipeBook, those table
* contain all L2RecipeList of the L2PcInstance <BR>
* <BR>.
*
* @param recipeId the recipe id
*/
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);
}
/**
* Returns the Id for the last talked quest NPC.<BR>
* <BR>
*
* @return the last quest npc object
*/
public int getLastQuestNpcObject()
{
return _questNpcObject;
}
/**
* Sets the last quest npc object.
*
* @param npcId the new last quest npc object
*/
public void setLastQuestNpcObject(int npcId)
{
_questNpcObject = npcId;
}
/**
* Return the QuestState object corresponding to the quest name.<BR>
* <BR>
*
* @param quest The name of the quest
* @return the quest state
*/
public QuestState getQuestState(String quest)
{
return _quests.get(quest);
}
/**
* Add a QuestState to the table _quest containing all quests began by the L2PcInstance.<BR>
* <BR>
*
* @param qs The QuestState to add to _quest
*/
public void setQuestState(QuestState qs)
{
_quests.put(qs.getQuestName(), qs);
}
/**
* Remove a QuestState from the table _quest containing all quests began by the L2PcInstance.<BR>
* <BR>
*
* @param quest The name of the quest
*/
public void delQuestState(String quest)
{
_quests.remove(quest);
}
/**
* Adds the to quest state array.
*
* @param questStateArray the quest state array
* @param state the state
* @return the quest state[]
*/
private QuestState[] addToQuestStateArray(QuestState[] questStateArray, QuestState state)
{
int len = questStateArray.length;
QuestState[] tmp = new QuestState[len + 1];
for(int i = 0; i < len; i++)
{
tmp[i] = questStateArray[i];
}
tmp[len] = state;
return tmp;
}
/**
* Return a table containing all Quest in progress from the table _quests.<BR>
* <BR>
*
* @return the all active quests
*/
public Quest[] getAllActiveQuests()
{
FastList<Quest> quests = new FastList<Quest>();
/**
* Return a table containing all QuestState to modify after a L2Attackable killing.<BR>
* <BR>
*
* @param npc the npc
* @return the quests for attacks
*/
public QuestState[] getQuestsForAttacks(L2NpcInstance npc)
{
// Create a QuestState table that will contain all QuestState to modify
QuestState[] states = null;
// Go through the QuestState of the L2PcInstance quests
for(Quest quest : npc.getTemplate().getEventQuests(Quest.QuestEventT ype.ON_ATTACK))
{
// Check if the Identifier of the L2Attackable attck is needed for the current quest
if(getQuestState(quest.getName()) != null)
{
// Copy the current L2PcInstance QuestState in the QuestState table
if(states == null)
{
states = new QuestState[]
{
getQuestState(quest.getName())
};
}
else
{
states = addToQuestStateArray(states, getQuestState(quest.getName()));
}
}
}
// Return a table containing all QuestState to modify
return states;
}
/**
* Return a table containing all QuestState to modify after a L2Attackable killing.<BR>
* <BR>
*
* @param npc the npc
* @return the quests for kills
*/
public QuestState[] getQuestsForKills(L2NpcInstance npc)
{
// Create a QuestState table that will contain all QuestState to modify
QuestState[] states = null;
// Go through the QuestState of the L2PcInstance quests
for(Quest quest : npc.getTemplate().getEventQuests(Quest.QuestEventT ype.ON_KILL))
{
// Check if the Identifier of the L2Attackable killed is needed for the current quest
if(getQuestState(quest.getName()) != null)
{
// Copy the current L2PcInstance QuestState in the QuestState table
if(states == null)
{
states = new QuestState[]
{
getQuestState(quest.getName())
};
}
else
{
states = addToQuestStateArray(states, getQuestState(quest.getName()));
}
}
}
// Return a table containing all QuestState to modify
return states;
}
/**
* Return a table containing all QuestState from the table _quests in which the L2PcInstance must talk to the NPC.<BR>
* <BR>
*
* @param npcId The Identifier of the NPC
* @return the quests for talk
*/
public QuestState[] getQuestsForTalk(int npcId)
{
// Create a QuestState table that will contain all QuestState to modify
QuestState[] states = null;
// Go through the QuestState of the L2PcInstance quests
for(Quest quest : NpcTable.getInstance().getTemplate(npcId).getEvent Quests(Quest.QuestEventType.QUEST_TALK))
{
if(quest != null)
{
// Copy the current L2PcInstance QuestState in the QuestState table
if(getQuestState(quest.getName()) != null)
{
if(states == null)
{
states = new QuestState[]
{
getQuestState(quest.getName())
};
}
else
{
states = addToQuestStateArray(states, getQuestState(quest.getName()));
}
}
}
}
// Return a table containing all QuestState to modify
return states;
}
/**
* Process quest event.
*
* @param quest the quest
* @param event the event
* @return the quest state
*/
public QuestState processQuestEvent(String quest, String event)
{
QuestState retval = null;
if(event == null)
{
event = "";
}
/**
* Return a table containing all L2ShortCut of the L2PcInstance.<BR>
* <BR>
*
* @return the all short cuts
*/
public L2ShortCut[] getAllShortCuts()
{
return _shortCuts.getAllShortCuts();
}
/**
* Return the L2ShortCut of the L2PcInstance corresponding to the position (page-slot).<BR>
* <BR>
*
* @param slot The slot in wich the shortCuts is equiped
* @param page The page of shortCuts containing the slot
* @return the short cut
*/
public L2ShortCut getShortCut(int slot, int page)
{
return _shortCuts.getShortCut(slot, page);
}
/**
* Add a L2shortCut to the L2PcInstance _shortCuts<BR>
* <BR>.
*
* @param shortcut the shortcut
*/
public void registerShortCut(L2ShortCut shortcut)
{
_shortCuts.registerShortCut(shortcut);
}
/**
* Delete the L2ShortCut corresponding to the position (page-slot) from the L2PcInstance _shortCuts.<BR>
* <BR>
*
* @param slot the slot
* @param page the page
*/
public void deleteShortCut(int slot, int page)
{
_shortCuts.deleteShortCut(slot, page);
}
/**
* Add a L2Macro to the L2PcInstance _macroses<BR>
* <BR>.
*
* @param macro the macro
*/
public void registerMacro(L2Macro macro)
{
_macroses.registerMacro(macro);
}
/**
* Delete the L2Macro corresponding to the Identifier from the L2PcInstance _macroses.<BR>
* <BR>
*
* @param id the id
*/
public void deleteMacro(int id)
{
_macroses.deleteMacro(id);
}
/**
* Return all L2Macro of the L2PcInstance.<BR>
* <BR>
*
* @return the macroses
*/
public MacroList getMacroses()
{
return _macroses;
}
/**
* Set the siege state of the L2PcInstance.<BR>
* <BR>
* 1 = attacker, 2 = defender, 0 = not involved
*
* @param siegeState the new siege state
*/
public void setSiegeState(byte siegeState)
{
_siegeState = siegeState;
}
/**
* Get the siege state of the L2PcInstance.<BR>
* <BR>
* 1 = attacker, 2 = defender, 0 = not involved
*
* @return the siege state
*/
public byte getSiegeState()
{
return _siegeState;
}
/**
* Set the PvP Flag of the L2PcInstance.<BR>
* <BR>
*
* @param pvpFlag the new pvp flag
*/
public void setPvpFlag(int pvpFlag)
{
_pvpFlag = (byte) pvpFlag;
}
/**
* Gets the pvp flag.
*
* @return the pvp flag
*/
public byte getPvpFlag()
{
return _pvpFlag;
}
// If this player has a pet update the pets pvp flag as well
if(getPet() != null)
{
sendPacket(new RelationChanged(getPet(), getRelation(this), false));
}
/* (non-Javadoc)
* @see com.l2jfrozen.gameserver.model.L2Character#revalid ateZone(boolean)
*/
@Override
public void revalidateZone(boolean force)
{
// Cannot validate if not in a world region (happens during teleport)
if(getWorldRegion() == null)
return;
if (Config.ALLOW_WATER)
checkWaterState();
// This function is called very often from movement code
if(force)
{
_zoneValidateCounter = 4;
}
else
{
_zoneValidateCounter--;
if(_zoneValidateCounter < 0)
{
_zoneValidateCounter = 4;
}
else
return;
}
/**
* Return True if the L2PcInstance can Craft Dwarven Recipes.<BR>
* <BR>
*
* @return true, if successful
*/
public boolean hasDwarvenCraft()
{
return getSkillLevel(L2Skill.SKILL_CREATE_DWARVEN) >= 1;
}
/**
* Gets the dwarven craft.
*
* @return the dwarven craft
*/
public int getDwarvenCraft()
{
return getSkillLevel(L2Skill.SKILL_CREATE_DWARVEN);
}
/**
* Return True if the L2PcInstance can Craft Dwarven Recipes.<BR>
* <BR>
*
* @return true, if successful
*/
public boolean hasCommonCraft()
{
return getSkillLevel(L2Skill.SKILL_CREATE_COMMON) >= 1;
}
/**
* Gets the common craft.
*
* @return the common craft
*/
public int getCommonCraft()
{
return getSkillLevel(L2Skill.SKILL_CREATE_COMMON);
}
/**
* Return the PK counter of the L2PcInstance.<BR>
* <BR>
*
* @return the pk kills
*/
public int getPkKills()
{
return _pkKills;
}
/**
* Set the PK counter of the L2PcInstance.<BR>
* <BR>
*
* @param pkKills the new pk kills
*/
public void setPkKills(int pkKills)
{
_pkKills = pkKills;
}
/**
* Return the _deleteTimer of the L2PcInstance.<BR>
* <BR>
*
* @return the delete timer
*/
public long getDeleteTimer()
{
return _deleteTimer;
}
/**
* Set the _deleteTimer of the L2PcInstance.<BR>
* <BR>
*
* @param deleteTimer the new delete timer
*/
public void setDeleteTimer(long deleteTimer)
{
_deleteTimer = deleteTimer;
}
/**
* Return the current weight of the L2PcInstance.<BR>
* <BR>
*
* @return the current load
*/
public int getCurrentLoad()
{
return _inventory.getTotalWeight();
}
/**
* Return date of las update of recomPoints.
*
* @return the last recom update
*/
public long getLastRecomUpdate()
{
return _lastRecomUpdate;
}
/**
* Sets the last recom update.
*
* @param date the new last recom update
*/
public void setLastRecomUpdate(long date)
{
_lastRecomUpdate = date;
}
/**
* Return the number of recommandation obtained by the L2PcInstance.<BR>
* <BR>
*
* @return the recom have
*/
public int getRecomHave()
{
return _recomHave;
}
/**
* Increment the number of recommandation obtained by the L2PcInstance (Max : 255).<BR>
* <BR>
*/
protected void incRecomHave()
{
if(_recomHave < 255)
{
_recomHave++;
}
}
/**
* Set the number of recommandation obtained by the L2PcInstance (Max : 255).<BR>
* <BR>
*
* @param value the new recom have
*/
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.<BR>
* <BR>
*
* @return the recom left
*/
public int getRecomLeft()
{
return _recomLeft;
}
/**
* Increment the number of recommandation that the L2PcInstance can give.<BR>
* <BR>
*/
protected void decRecomLeft()
{
if(_recomLeft > 0)
{
_recomLeft--;
}
}
/**
* Give recom.
*
* @param target the target
*/
public void giveRecom(L2PcInstance target)
{
if(Config.ALT_RECOMMEND)
{
Connection con = null;
try
{
con = L2DatabaseFactory.getInstance().getConnection(fals e);
PreparedStatement statement = con.prepareStatement(ADD_CHAR_RECOM);
statement.setInt(1, getObjectId());
statement.setInt(2, target.getObjectId());
statement.execute();
statement.close();
statement = null;
}
catch(Exception e)
{
if(Config.ENABLE_ALL_EXCEPTIONS)
e.printStackTrace();
_log.warning("could not update char recommendations:" + e);
}
finally
{
CloseUtil.close(con);
con = null;
}
}
target.incRecomHave();
decRecomLeft();
_recomChars.add(target.getObjectId());
}
/**
* Can recom.
*
* @param target the target
* @return true, if successful
*/
public boolean canRecom(L2PcInstance target)
{
return !_recomChars.contains(target.getObjectId());
}
/**
* Set the exp of the L2PcInstance before a death.
*
* @param exp the new exp before death
*/
public void setExpBeforeDeath(long exp)
{
_expBeforeDeath = exp;
}
/**
* Gets the exp before death.
*
* @return the exp before death
*/
public long getExpBeforeDeath()
{
return _expBeforeDeath;
}
/**
* Return the Karma of the L2PcInstance.<BR>
* <BR>
*
* @return the karma
*/
public int getKarma()
{
return _karma;
}
/**
* Set the Karma of the L2PcInstance and send a Server->Client packet StatusUpdate (broadcast).<BR>
* <BR>
*
* @param karma the new karma
*/
public void setKarma(int karma)
{
if(karma < 0)
{
karma = 0;
}
if(((L2GuardInstance) object).getAI().getIntention() == CtrlIntention.AI_INTENTION_IDLE)
{
((L2GuardInstance) object).getAI().setIntention(CtrlIntention.AI_INTE NTION_ACTIVE, null);
}
}
}
else if(_karma > 0 && karma == 0)
{
// Send a Server->Client StatusUpdate packet with Karma and PvP Flag to the L2PcInstance and all L2PcInstance to inform (broadcast)
setKarmaFlag(0);
}
_karma = karma;
broadcastKarma();
}
/**
* Return the max weight that the L2PcInstance can load.<BR>
* <BR>
*
* @return the max load
*/
public int getMaxLoad()
{
// Weight Limit = (CON Modifier*69000)*Skills
// Source [Somente Usuários Registrados Podem Visualizar os Links Desta PáginaClique aqui para se Registrar]
(May 2007)
// Fitted exponential curve to the data
int con = getCON();
if(con < 1)
return 31000;
for (L2Skill actual_skill : char_skills)
{
if (actual_skill.getName().contains("Heavy Armor Mastery"))
{
_heavy_mastery = true;
}
if (actual_skill.getName().contains("Light Armor Mastery"))
{
_light_mastery = true;
}
if (actual_skill.getName().contains("Robe Mastery"))
{
_robe_mastery = true;
}
}
int newMasteryPenalty = 0;
if (!_heavy_mastery && !_light_mastery && !_robe_mastery)
{
// not completed 1st class transfer or not acquired yet the mastery skills
newMasteryPenalty = 0;
}
else
{
for (L2ItemInstance item : getInventory().getItems())
{
if (item != null && item.isEquipped() && item.getItem() instanceof L2Armor)
{
// No penality for formal wear
if (item.getItemId() == 6408)
continue;
L2Armor armor_item = (L2Armor) item.getItem();
switch (armor_item.getItemType())
{
case HEAVY:
{
if (!_heavy_mastery)
newMasteryPenalty++;
}
break;
case LIGHT:
{
if (!_light_mastery)
newMasteryPenalty++;
}
break;
case MAGIC:
{
if (!_robe_mastery)
newMasteryPenalty++;
}
break;
}
}
}
}
if (_masteryPenalty != newMasteryPenalty)
{
int penalties = _masteryWeapPenalty + _expertisePenalty + newMasteryPenalty;
if (penalties > 0)
{
super.addSkill(SkillTable.getInstance().getInfo(42 67, 1)); // level used to be newPenalty
}
else
{
super.removeSkill(getKnownSkill(4267));
}
if (!_bow_mastery && !_blunt_mastery && !_dagger_mastery && !_fist_mastery && !_dual_mastery && !_pole_mastery && !_sword_mastery && !_2hands_mastery)
{ // not completed 1st class transfer or not acquired yet the mastery skills
newMasteryPenalty = 0;
}
else
{
for (L2ItemInstance item : getInventory().getItems())
{
if (item != null && item.isEquipped() && item.getItem() instanceof L2Weapon && !isCursedWeaponEquiped())
{
// No penality for cupid's bow
if (item.isCupidBow())
continue;
L2Weapon weap_item = (L2Weapon) item.getItem();
switch (weap_item.getItemType())
{
case BIGBLUNT:
case BIGSWORD:
{
if (!_2hands_mastery)
newMasteryPenalty++;
}
break;
case BLUNT:
{
if (!_blunt_mastery)
newMasteryPenalty++;
}
break;
case BOW:
{
if (!_bow_mastery)
newMasteryPenalty++;
}
break;
case DAGGER:
{
if (!_dagger_mastery)
newMasteryPenalty++;
}
break;
case DUAL:
{
if (!_dual_mastery)
newMasteryPenalty++;
}
break;
case DUALFIST:
case FIST:
{
if (!_fist_mastery)
newMasteryPenalty++;
}
break;
case POLE:
{
if (!_pole_mastery)
newMasteryPenalty++;
}
break;
case SWORD:
{
if (!_sword_mastery)
newMasteryPenalty++;
}
break;
}
}
}
}
if (_masteryWeapPenalty != newMasteryPenalty)
{
int penalties = _masteryPenalty + _expertisePenalty + newMasteryPenalty;
if (penalties > 0)
{
super.addSkill(SkillTable.getInstance().getInfo(42 67, 1)); // level used to be newPenalty
}
else
{
super.removeSkill(getKnownSkill(4267));
}
if(penalties > 0)
{
super.addSkill(SkillTable.getInstance().getInfo(42 67, 1)); // level used to be newPenalty
sendSkillList(); // Update skill list
}
else
{
super.removeSkill(getKnownSkill(4267));
sendSkillList(); // Update skill list
}
sendPacket(new EtcStatusUpdate(this));
}
}
public void checkIfWeaponIsAllowed()
{
// Override for Gamemasters
if (isGM())
{
return;
}
// Iterate through all effects currently on the character.
for (L2Effect currenteffect : getAllEffects())
{
L2Skill effectSkill = currenteffect.getSkill();
// Ignore all buff skills that are party related (ie. songs, dances) while still remaining weapon dependant on cast though.
if (!effectSkill.isOffensive() && !(effectSkill.getTargetType() == SkillTargetType.TARGET_PARTY && effectSkill.getSkillType() == SkillType.BUFF))
{
// Check to rest to assure current effect meets weapon requirements.
if (!effectSkill.getWeaponDependancy(this))
{
sendMessage(effectSkill.getName() + " cannot be used with this weapon.");
if (Config.DEBUG)
{
_log.info(" | Skill " + effectSkill.getName() + " has been disabled for (" + getName() + "); Reason: Incompatible Weapon Type.");
}
currenteffect.exit();
}
}
continue;
}
}
/**
* Check ss match.
*
* @param equipped the equipped
* @param unequipped the unequipped
*/
public void checkSSMatch(L2ItemInstance equipped, L2ItemInstance unequipped)
{
if(unequipped == null)
return;
if(unequipped.getItem().getType2() == L2Item.TYPE2_WEAPON && (equipped == null ? true : equipped.getItem().getCrystalType() != unequipped.getItem().getCrystalType()))
// && getInventory().getItem() != null - must be fixed.
{
for(L2ItemInstance ss : getInventory().getItems())
{
int _itemId = ss.getItemId();
SystemMessage sm = new SystemMessage(SystemMessageId.AUTO_USE_OF_S1_CANCE LLED);
sm.addString(ss.getItemName());
sendPacket(sm);
}
}
}
}
/**
* Return the the PvP Kills of the L2PcInstance (Number of player killed during a PvP).<BR>
* <BR>
*
* @return the pvp kills
*/
public int getPvpKills()
{
return _pvpKills;
}
/**
* Set the the PvP Kills of the L2PcInstance (Number of player killed during a PvP).<BR>
* <BR>
*
* @param pvpKills the new pvp kills
*/
public void setPvpKills(int pvpKills)
{
_pvpKills = pvpKills;
/*// Set hero aura if pvp kills > 100
if (pvpKills > 100)
{
isPermaHero = true;
setHeroAura(true);
}*/
}
/**
* Return the ClassId object of the L2PcInstance contained in L2PcTemplate.<BR>
* <BR>
*
* @return the class id
*/
public ClassId getClassId()
{
return getTemplate().classId;
}
/**
* Set the template of the L2PcInstance.<BR>
* <BR>
*
* @param Id The Identifier of the L2PcTemplate to set to the L2PcInstance
*/
public void setClassId(int Id)
{
_clan.broadcastToOnlineMembers(new PledgeShowInfoUpdate(_clan));
setLvlJoinedAcademy(0);
//oust pledge member from the academy, cuz he has finished his 2nd class transfer
SystemMessage msg = new SystemMessage(SystemMessageId.CLAN_MEMBER_S1_EXPEL LED);
msg.addString(getName());
_clan.broadcastToOnlineMembers(msg);
_clan.broadcastToOnlineMembers(new PledgeShowMemberListDelete(getName()));
_clan.removeClanMember(getName(), 0);
sendPacket(new SystemMessage(SystemMessageId.ACADEMY_MEMBERSHIP_T ERMINATED));
msg = null;
// receive graduation gift
getInventory().addItem("Gift", 8181, 1, this, null); // give academy circlet
getInventory().updateDatabase(); // update database
}
if(isSubClassActive())
{
getSubClasses().get(_classIndex).setClassId(Id);
}
doCast(SkillTable.getInstance().getInfo(5103, 1));
setClassTemplate(Id);
}
/**
* Return the Experience of the L2PcInstance.
*
* @return the exp
*/
public long getExp()
{
return getStat().getExp();
}
/**
* Sets the active enchant item.
*
* @param scroll the new active enchant item
*/
public void setActiveEnchantItem(L2ItemInstance scroll)
{
_activeEnchantItem = scroll;
}
/**
* Gets the active enchant item.
*
* @return the active enchant item
*/
public L2ItemInstance getActiveEnchantItem()
{
return _activeEnchantItem;
}
/**
* Set the fists weapon of the L2PcInstance (used when no weapon is equiped).<BR>
* <BR>
*
* @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 equiped).<BR>
* <BR>
*
* @return the fists weapon item
*/
public L2Weapon getFistsWeaponItem()
{
return _fistsWeaponItem;
}
/**
* Give Expertise skill of this level and remove beginner Lucky skill.<BR>
* <BR>
* <B><U> Actions</U> :</B><BR>
* <BR>
* <li>Get the Level of the L2PcInstance</li> <li>If L2PcInstance Level is 5, remove beginner Lucky skill</li> <li>
* Add the Expertise skill corresponding to its Expertise level</li> <li>Update the overloaded status of the
* L2PcInstance</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>
*/
public synchronized void rewardSkills()
{
// Get the Level of the L2PcInstance
int lvl = getLevel();
// 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);
if(Config.DEBUG)
{
_log.fine("awarded " + getName() + " with new expertise.");
}
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);
skill = null;
}
}
// Auto-Learn skills if activated
if(Config.AUTO_LEARN_SKILLS)
{
giveAvailableSkills();
}
sendSkillList();
if (_clan != null)
{
if (_clan.getLevel() > 3 && isClanLeader())
SiegeManager.getInstance().addSiegeSkills(this);
}
// This function gets called on login, so not such a bad place to check weight
refreshOverloaded(); // Update the overloaded status of the L2PcInstance
refreshExpertisePenalty(); // Update the expertise status of the L2PcInstance
refreshMasteryPenality();
refreshMasteryWeapPenality();
}
/**
* Regive all skills which aren't saved to database, like Noble, Hero, Clan Skills<BR>
* <BR>.
*/
private synchronized void regiveTemporarySkills()
{
// Do not call this on enterworld or char load
// Add noble skills if noble
if(isNoble())
{
setNoble(true);
}
// Add Hero skills if hero
if(isHero())
{
setHero(true);
}
// Penality skill are not auto learn
if(sk.getId() == 4267 || sk.getId() == 4270)
continue;
// fix when learning toggle skills
if(sk.isToggle())
{
L2Effect toggleEffect = getFirstEffect(sk.getId());
if(toggleEffect != null)
{
// stop old toggle skill effect, and give new toggle skill effect back
toggleEffect.exit(false);
sk.getEffects(this, this,false,false,false);
}
}
addSkill(sk, true);
}
// // Get new available skills
// skills = SkillTreeTable.getInstance().getAvailableSkills(th is, getClassId());
// }
sendMessage("You have learned " + skillCounter + " new skills.");
skills = null;
}
/**
* Set the Experience value of the L2PcInstance.
*
* @param exp the new exp
*/
public void setExp(long exp)
{
getStat().setExp(exp);
}
/**
* Return the Race object of the L2PcInstance.<BR>
* <BR>
*
* @return the race
*/
public Race getRace()
{
if(!isSubClassActive())
return getTemplate().race;
/**
* Gets the radar.
*
* @return the radar
*/
public L2Radar getRadar()
{
return _radar;
}
/**
* Return the SP amount of the L2PcInstance.
*
* @return the sp
*/
public int getSp()
{
return getStat().getSp();
}
/**
* Set the SP amount of the L2PcInstance.
*
* @param sp the new sp
*/
public void setSp(int sp)
{
super.getStat().setSp(sp);
}
/**
* Return true if this L2PcInstance is a clan leader in ownership of the passed castle.
*
* @param castleId the castle id
* @return true, if is castle lord
*/
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 ))
{
castle = null;
return true;
}
castle = null;
}
clan = null;
return false;
}
/**
* Return the Clan Identifier of the L2PcInstance.<BR>
* <BR>
*
* @return the clan id
*/
public int getClanId()
{
return _clanId;
}
/**
* Return the Clan Crest Identifier of the L2PcInstance or 0.<BR>
* <BR>
*
* @return the clan crest id
*/
public int getClanCrestId()
{
if(_clan != null && _clan.hasCrest())
return _clan.getCrestId();
return 0;
}
/**
* Gets the clan crest large id.
*
* @return The Clan CrestLarge Identifier or 0
*/
public int getClanCrestLargeId()
{
if(_clan != null && _clan.hasCrestLarge())
return _clan.getCrestLargeId();
return 0;
}
/**
* Gets the clan join expiry time.
*
* @return the clan join expiry time
*/
public long getClanJoinExpiryTime()
{
return _clanJoinExpiryTime;
}
/**
* Sets the clan join expiry time.
*
* @param time the new clan join expiry time
*/
public void setClanJoinExpiryTime(long time)
{
_clanJoinExpiryTime = time;
}
/**
* Gets the clan create expiry time.
*
* @return the clan create expiry time
*/
public long getClanCreateExpiryTime()
{
return _clanCreateExpiryTime;
}
/**
* Sets the clan create expiry time.
*
* @param time the new clan create expiry time
*/
public void setClanCreateExpiryTime(long time)
{
_clanCreateExpiryTime = time;
}
/**
* Sets the online time.
*
* @param time the new online time
*/
public void setOnlineTime(long time)
{
_onlineTime = time;
_onlineBeginTime = System.currentTimeMillis();
}
/**
* Return the PcInventory Inventory of the L2PcInstance contained in _inventory.<BR>
* <BR>
*
* @return the inventory
*/
public PcInventory getInventory()
{
return _inventory;
}
/**
* Delete a ShortCut of the L2PcInstance _shortCuts.<BR>
* <BR>
*
* @param objectId the object id
*/
public void removeItemFromShortCut(int objectId)
{
_shortCuts.deleteShortCutByObjectId(objectId);
}
//MOVING on attack TASK, L2OFF FIX
/** The launched moving task. */
protected MoveOnAttack launchedMovingTask = null;
/**
* MoveOnAttack Task.
*/
public class MoveOnAttack implements Runnable
{
/** The _player. */
final L2PcInstance _player;
/** The _pos. */
L2CharPosition _pos;
/**
* Instantiates a new move on attack.
* @param player the player
* @param pos the pos
*/
public MoveOnAttack(L2PcInstance player, L2CharPosition pos)
{
_player = player;
_pos = pos;
// launchedMovingTask = this;
}
/*
* (non-Javadoc)
* @see java.lang.Runnable#run()
*/
@Override
public void run()
{
synchronized (_movingTaskDefined)
{
launchedMovingTask = null;
_movingTaskDefined = false;
}
// Set the Intention of this AbstractAI to AI_INTENTION_MOVE_TO
_player.getAI().changeIntention(AI_INTENTION_MOVE_ TO, _pos, null);
// Stop the actor auto-attack client side by sending Server->Client packet AutoAttackStop (broadcast)
_player.getAI().clientStopAutoAttack();
// Abort the attack of the L2Character and send Server->Client ActionFailed packet
_player.abortAttack();
// Move the actor to Location (x,y,z) server side AND client side by sending Server->Client packet CharMoveToLocation (broadcast)
_player.getAI().moveTo(_pos.x, _pos.y, _pos.z);
}
/**
* Sets the new position.
* @param pos the new new position
*/
public void setNewPosition(L2CharPosition pos)
{
_pos = pos;
}
}
/**
* Checks if is moving task defined.
*
* @return true, if is moving task defined
*/
public boolean isMovingTaskDefined()
{
return _movingTaskDefined;
//return launchedMovingTask != null;
}
/**
* Define new moving task.
* @param pos the pos
*/
public void defineNewMovingTask(L2CharPosition pos)
{
synchronized (_movingTaskDefined)
{
launchedMovingTask = new MoveOnAttack(this, pos);
_movingTaskDefined = true;
}
}
/**
* Modify moving task.
* @param pos the pos
*/
public void modifyMovingTask(L2CharPosition pos)
{
synchronized (_movingTaskDefined)
{
if (!_movingTaskDefined)
return;
launchedMovingTask.setNewPosition(pos);
}
}
/**
* Start moving task.
*/
public void startMovingTask()
{
synchronized (_movingTaskDefined)
{
if (!_movingTaskDefined)
return;
/**
* Return True if the L2PcInstance is sitting.<BR>
* <BR>
*
* @return true, if is sitting
*/
public boolean isSitting()
{
return _waitTypeSitting || sittingTaskLaunched;
}
/**
* Return True if the L2PcInstance is sitting task launched.<BR>
* <BR>
*
* @return true, if is sitting task launched
*/
public boolean isSittingTaskLaunched()
{
return sittingTaskLaunched;
}
/**
* Set _waitTypeSitting to given value.
*
* @param state the new checks if is sitting
*/
public void setIsSitting(boolean state)
{
_waitTypeSitting = state;
}
/**
* Sets the posticipate sit.
*
* @param act the new posticipate sit
*/
public void setPosticipateSit(boolean act)
{
_posticipateSit = act;
}
/**
* Gets the posticipate sit.
*
* @return the posticipate sit
*/
public boolean getPosticipateSit()
{
return _posticipateSit;
}
/**
* Sit down the L2PcInstance, set the AI Intention to AI_INTENTION_REST and send a Server->Client ChangeWaitType
* packet (broadcast)<BR>
* <BR>.
*/
public void sitDown()
{
if(isFakeDeath())
{
stopFakeDeath(null);
}
if(isMoving()) //since you are moving and want sit down
//the posticipate sitdown task will be always true
{
setPosticipateSit(true);
return;
}
//we are going to sitdown, so posticipate is false
setPosticipateSit(false);
if(isCastingNow() && !_relax)
return;
if(sittingTaskLaunched) //if already started the task
//just return
return;
if(!_waitTypeSitting && !isAttackingDisabled() && !isOutOfControl() && !isImobilised())
{
breakAttack();
setIsSitting(true);
broadcastPacket(new ChangeWaitType(this, ChangeWaitType.WT_SITTING));
sittingTaskLaunched = true;
// Schedule a sit down task to wait for the animation to finish
ThreadPoolManager.getInstance().scheduleGeneral(ne w SitDownTask(this), 2500);
setIsParalyzed(true);
}
}
/**
* Sit down Task.
*/
class SitDownTask implements Runnable
{
/** The _player. */
L2PcInstance _player;
/** The this$0. */
final L2PcInstance this$0;
/**
* Instantiates a new sit down task.
*
* @param player the player
*/
SitDownTask(L2PcInstance player)
{
this$0 = L2PcInstance.this;
_player = player;
}
/**
* Stand up the L2PcInstance, set the AI Intention to AI_INTENTION_IDLE and send a Server->Client ChangeWaitType
* packet (broadcast)<BR>
* <BR>.
*/
public void standUp()
{
if(isFakeDeath())
{
broadcastPacket(new ChangeWaitType(this, ChangeWaitType.WT_STANDING));
// Schedule a stand up task to wait for the animation to finish
setIsImobilised(true);
ThreadPoolManager.getInstance().scheduleGeneral(ne w StandUpTask(this), 2000);
stopFakeDeath(null);
}
if(sittingTaskLaunched){
return;
}
if(L2Event.active && eventSitForced)
{
sendMessage("A dark force beyond your mortal understanding makes your knees to shake when you try to stand up ...");
}
else if((TvT.is_sitForced() && _inEventTvT) || (CTF.is_sitForced() && _inEventCTF) || (DM.is_sitForced() && _inEventDM))
{
sendMessage("The Admin/GM handle if you sit or stand in this match!");
}
else if(VIP._sitForced && _inEventVIP)
{
sendMessage("The Admin/GM handle if you sit or stand in this match!");
}
else if(isAway())
{
sendMessage("You can't stand up if your Status is Away.");
}
else if(_waitTypeSitting && !isInStoreMode() && !isAlikeDead())
{
if(_relax)
{
setRelax(false);
stopEffects(L2Effect.EffectType.RELAXING);
}
broadcastPacket(new ChangeWaitType(this, ChangeWaitType.WT_STANDING));
// Schedule a stand up task to wait for the animation to finish
setIsImobilised(true);
ThreadPoolManager.getInstance().scheduleGeneral(ne w StandUpTask(this), 2500);
}
}
/**
* Set the value of the _relax value. Must be True if using skill Relax and False if not.
*
* @param val the new relax
*/
public void setRelax(boolean val)
{
_relax = val;
}
/**
* Return the PcWarehouse object of the L2PcInstance.<BR>
* <BR>
*
* @return the warehouse
*/
public PcWarehouse getWarehouse()
{
if(_warehouse == null)
{
_warehouse = new PcWarehouse(this);
_warehouse.restore();
}
if(Config.WAREHOUSE_CACHE)
{
WarehouseCacheManager.getInstance().addCacheTask(t his);
}
return _warehouse;
}
/**
* Free memory used by Warehouse.
*/
public void clearWarehouse()
{
if(_warehouse != null)
{
_warehouse.deleteMe();
}
_warehouse = null;
}
/**
* Return the PcFreight object of the L2PcInstance.<BR>
* <BR>
*
* @return the freight
*/
public PcFreight getFreight()
{
return _freight;
}
/**
* Return the Identifier of the L2PcInstance.<BR>
* <BR>
*
* @return the char id
*/
public int getCharId()
{
return _charId;
}
/**
* Set the Identifier of the L2PcInstance.<BR>
* <BR>
*
* @param charId the new char id
*/
public void setCharId(int charId)
{
_charId = charId;
}
/**
* Return the Adena amount of the L2PcInstance.<BR>
* <BR>
*
* @return the adena
*/
public int getAdena()
{
return _inventory.getAdena();
}
/**
* Return the Item amount of the L2PcInstance.<BR>
* <BR>
*
* @param itemId the item id
* @param enchantLevel the enchant level
* @return the item count
*/
public int getItemCount(int itemId, int enchantLevel)
{
return _inventory.getInventoryItemCount(itemId, enchantLevel);
}
/**
* Return the Ancient Adena amount of the L2PcInstance.<BR>
* <BR>
*
* @return the ancient adena
*/
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 (count > 0)
{
if (_inventory.getAdena() == Integer.MAX_VALUE)
{
return;
}
else if (_inventory.getAdena() >= Integer.MAX_VALUE - count)
{
count = Integer.MAX_VALUE - _inventory.getAdena();
_inventory.addAdena(process, count, this, reference);
}
else if (_inventory.getAdena() < Integer.MAX_VALUE - count)
{
_inventory.addAdena(process, count, this, reference);
}
if (sendMessage)
{
SystemMessage sm = new SystemMessage(SystemMessageId.EARNED_ADENA);
sm.addNumber(count);
sendPacket(sm);
sm = null;
}
// Send update packet
if (!Config.FORCE_INVENTORY_UPDATE)
{
InventoryUpdate iu = new InventoryUpdate();
iu.addItem(_inventory.getAdenaInstance());
sendPacket(iu);
iu = null;
}
else
{
sendPacket(new ItemList(this, false));
}
}
}
/**
* 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(new SystemMessage(SystemMessageId.YOU_NOT_ENOUGH_ADENA ));
}
// Send update packet
if(!Config.FORCE_INVENTORY_UPDATE)
{
InventoryUpdate iu = new InventoryUpdate();
iu.addItem(adenaItem);
sendPacket(iu);
iu = null;
}
else
{
sendPacket(new ItemList(this, false));
}
if(sendMessage)
{
SystemMessage sm = new SystemMessage(SystemMessageId.DISSAPEARED_ADENA);
sm.addNumber(count);
sendPacket(sm);
sm = null;
}
adenaItem = null;
}
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)
{
SystemMessage sm = new SystemMessage(SystemMessageId.EARNED_S2_S1_S);
sm.addItemName(PcInventory.ANCIENT_ADENA_ID);
sm.addNumber(count);
sendPacket(sm);
sm = null;
}
if(!Config.FORCE_INVENTORY_UPDATE)
{
InventoryUpdate iu = new InventoryUpdate();
iu.addItem(_inventory.getAncientAdenaInstance());
sendPacket(iu);
iu = null;
}
else
{
sendPacket(new ItemList(this, false));
}
}
}
/**
* 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(new SystemMessage(SystemMessageId.YOU_NOT_ENOUGH_ADENA ));
}
if(!Config.FORCE_INVENTORY_UPDATE)
{
InventoryUpdate iu = new InventoryUpdate();
iu.addItem(ancientAdenaItem);
sendPacket(iu);
iu = null;
}
else
{
sendPacket(new ItemList(this, false));
}
if(sendMessage)
{
SystemMessage sm = new SystemMessage(SystemMessageId.DISSAPEARED_ITEM);
sm.addNumber(count);
sm.addItemName(PcInventory.ANCIENT_ADENA_ID);
sendPacket(sm);
sm = null;
}
ancientAdenaItem = null;
}
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)
{
if(item.isStackable() && !Config.MULTIPLE_ITEM_DROP){
SystemMessage sm = new SystemMessage(SystemMessageId.YOU_PICKED_UP_S1);
sm.addItemName(item.getItemId());
sendPacket(sm);
sm = null;
}else{
SystemMessage sm = new SystemMessage(SystemMessageId.YOU_PICKED_UP_S1_S2) ;
sm.addItemName(item.getItemId());
sm.addNumber(item.getCount());
sendPacket(sm);
sm = null;
}
}
else if(item.getEnchantLevel() > 0)
{
SystemMessage sm = new SystemMessage(SystemMessageId.YOU_PICKED_UP_A_S1_S 2);
sm.addNumber(item.getEnchantLevel());
sm.addItemName(item.getItemId());
sendPacket(sm);
sm = null;
}
else
{
SystemMessage sm = new SystemMessage(SystemMessageId.YOU_PICKED_UP_S1);
sm.addItemName(item.getItemId());
sendPacket(sm);
sm = null;
}
}
// Add the item to inventory
L2ItemInstance newitem = _inventory.addItem(process, item, this, reference);
// Update current load as well
StatusUpdate su = new StatusUpdate(getObjectId());
su.addAttribute(StatusUpdate.CUR_LOAD, getCurrentLoad());
sendPacket(su);
su = null;
// If over capacity, Drop the item
if(!isGM() && !_inventory.validateCapacity(0))
{
dropItem("InvDrop", newitem, null, true, true);
}
else if(CursedWeaponsManager.getInstance().isCursed(new item.getItemId()))
{
CursedWeaponsManager.getInstance().activate(this, newitem);
}
newitem = null;
}
// If you pickup arrows.
if (item.getItem().getItemType() == L2EtcItemType.ARROW)
{
// If a bow is equipped, try to equip them if no arrows is currently equipped.
L2Weapon currentWeapon = getActiveWeaponItem();
if (currentWeapon != null && currentWeapon.getItemType() == L2WeaponType.BOW && getInventory().getPaperdollItem(Inventory.PAPERDOL L_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
*/
public void addItem(String process, int itemId, int count, L2Object reference, boolean sendMessage)
{
if(count > 0)
{
// Sends message to client if requested
if(sendMessage && (!isCastingNow()
&& ItemTable.getInstance().createDummyItem(itemId).ge tItemType() == L2EtcItemType.HERB
|| ItemTable.getInstance().createDummyItem(itemId).ge tItemType() != L2EtcItemType.HERB))
{
if(count > 1)
{
if(process.equalsIgnoreCase("sweep") || process.equalsIgnoreCase("Quest"))
{
SystemMessage sm = new SystemMessage(SystemMessageId.EARNED_S2_S1_S);
sm.addItemName(itemId);
sm.addNumber(count);
sendPacket(sm);
sm = null;
}
else
{
SystemMessage sm = new SystemMessage(SystemMessageId.YOU_PICKED_UP_S1_S2) ;
sm.addItemName(itemId);
sm.addNumber(count);
sendPacket(sm);
sm = null;
}
}
else
{
if(process.equalsIgnoreCase("sweep") || process.equalsIgnoreCase("Quest"))
{
SystemMessage sm = new SystemMessage(SystemMessageId.EARNED_ITEM);
sm.addItemName(itemId);
sendPacket(sm);
sm = null;
}
else
{
SystemMessage sm = new SystemMessage(SystemMessageId.YOU_PICKED_UP_S1);
sm.addItemName(itemId);
sendPacket(sm);
sm = null;
}
}
}
//Auto use herbs - autoloot
if(ItemTable.getInstance().createDummyItem(itemId) .getItemType() == L2EtcItemType.HERB) //If item is herb dont add it to iv :]
{
if(!isCastingNow() && !isCastingPotionNow())
{
L2ItemInstance herb = new L2ItemInstance(_charId, itemId);
IItemHandler handler = ItemHandler.getInstance().getItemHandler(herb.getI temId());
if(handler == null)
{
_log.warning("No item handler registered for Herb - item ID " + herb.getItemId() + ".");
}
else
{
handler.useItem(this, herb);
// Update current load as well
StatusUpdate su = new StatusUpdate(getObjectId());
su.addAttribute(StatusUpdate.CUR_LOAD, getCurrentLoad());
sendPacket(su);
su = null;
// If over capacity, drop the item
if(!isGM() && !_inventory.validateCapacity(item))
{
dropItem("InvDrop", item, null, true, true);
}
else if(CursedWeaponsManager.getInstance().isCursed(ite m.getItemId()))
{
CursedWeaponsManager.getInstance().activate(this, item);
}
item = 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)
{
item = _inventory.destroyItem(process, item, this, reference);
// Update current load as well
StatusUpdate su = new StatusUpdate(getObjectId());
su.addAttribute(StatusUpdate.CUR_LOAD, getCurrentLoad());
sendPacket(su);
su = null;
// Sends message to client if requested
if (sendMessage)
{
if (count > 1)
{
SystemMessage sm = new SystemMessage(SystemMessageId.DISSAPEARED_ITEM);
sm.addItemName(item.getItemId());
sm.addNumber(count);
sendPacket(sm);
sm = null;
}
else
{
SystemMessage sm = new SystemMessage(SystemMessageId.S1_HAS_DISAPPEARED);
sm.addItemName(item.getItemId());
sendPacket(sm);
sm = null;
}
}
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);
// Update current load as well
StatusUpdate su = new StatusUpdate(getObjectId());
su.addAttribute(StatusUpdate.CUR_LOAD, getCurrentLoad());
sendPacket(su);
su = null;
// Sends message to client if requested
if (sendMessage)
{
if (count > 1)
{
SystemMessage sm = new SystemMessage(SystemMessageId.DISSAPEARED_ITEM);
sm.addItemName(item.getItemId());
sm.addNumber(count);
sendPacket(sm);
sm = null;
}
else
{
SystemMessage sm = new SystemMessage(SystemMessageId.S1_HAS_DISAPPEARED);
sm.addItemName(item.getItemId());
sendPacket(sm);
sm = null;
}
}
item = null;
return true;
}
/**
* 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);
// could do also without saving, but let's save approx 1 of 10
if(GameTimeController.getGameTicks() % 10 == 0)
{
item.updateDatabase();
}
_inventory.refreshWeight();
}
}
else
{
// Destroy entire item and save to database
_inventory.destroyItem(process, item, this, reference);
}
// Update current load as well
StatusUpdate su = new StatusUpdate(getObjectId());
su.addAttribute(StatusUpdate.CUR_LOAD, getCurrentLoad());
sendPacket(su);
su = null;
// Sends message to client if requested
if(sendMessage)
{
SystemMessage sm = new SystemMessage(SystemMessageId.S1_HAS_DISAPPEARED);
sm.addNumber(count);
sm.addItemName(item.getItemId());
sendPacket(sm);
sm = null;
}
item = null;
return true;
}
/**
* 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)
{
L2ItemInstance item = _inventory.getItemByItemId(itemId);
// Update current load as well
StatusUpdate su = new StatusUpdate(getObjectId());
su.addAttribute(StatusUpdate.CUR_LOAD, getCurrentLoad());
sendPacket(su);
su = null;
// Sends message to client if requested
if (sendMessage)
{
if (count > 1)
{
SystemMessage sm = new SystemMessage(SystemMessageId.DISSAPEARED_ITEM);
sm.addItemName(item.getItemId());
sm.addNumber(count);
sendPacket(sm);
sm = null;
}
else
{
SystemMessage sm = new SystemMessage(SystemMessageId.S1_HAS_DISAPPEARED);
sm.addItemName(item.getItemId());
sendPacket(sm);
sm = null;
}
}
item = null;
return true;
}
/**
* Destroy all weared items from inventory and send a Server->Client InventoryUpdate packet to the L2PcInstance.
*
* @param process : String Identifier of process triggering this action
* @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 destroyWearedItems(String process, L2Object reference, boolean sendMessage)
{
// Go through all Items of the inventory
for(L2ItemInstance item : getInventory().getItems())
{
// Check if the item is a Try On item in order to remove it
if(item.isWear())
{
if(item.isEquipped())
{
getInventory().unEquipItemInSlotAndRecord(item.get EquipSlot());
}
// Send an Unequipped Message in system window of the player for each Item
SystemMessage sm = new SystemMessage(SystemMessageId.S1_DISARMED);
sm.addItemName(item.getItemId());
sendPacket(sm);
sm = null;
}
}
// Send the StatusUpdate Server->Client Packet to the player with new CUR_LOAD (0x0e) information
StatusUpdate su = new StatusUpdate(getObjectId());
su.addAttribute(StatusUpdate.CUR_LOAD, getCurrentLoad());
sendPacket(su);
su = null;
// Send the ItemList Server->Client Packet to the player in order to refresh its Inventory
ItemList il = new ItemList(getInventory().getItems(), true);
sendPacket(il);
il = null;
// Send a Server->Client packet UserInfo to this L2PcInstance and CharInfo to all L2PcInstance in its _KnownPlayers
broadcastUserInfo();
// Sends message to client if requested
sendMessage("Trying-on mode has ended.");
}
/**
* 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 the object id
* @param count : int Quantity of items to be transfered
* @param target the 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)
{
L2ItemInstance oldItem = checkItemManipulation(objectId, count, "transfer");
if(oldItem == null)
return null;
// Update current load as well
StatusUpdate playerSU = new StatusUpdate(getObjectId());
playerSU.addAttribute(StatusUpdate.CUR_LOAD, getCurrentLoad());
sendPacket(playerSU);
playerSU = null;
/**
* 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 the protect item
* @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);
// Update current load as well
StatusUpdate su = new StatusUpdate(getObjectId());
su.addAttribute(StatusUpdate.CUR_LOAD, getCurrentLoad());
sendPacket(su);
su = null;
// Sends message to client if requested
if(sendMessage)
{
SystemMessage sm = new SystemMessage(SystemMessageId.YOU_DROPPED_S1);
sm.addItemName(item.getItemId());
sendPacket(sm);
sm = null;
}
return true;
}
/**
* 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 the protect item
* @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)
{
// Update current load as well
StatusUpdate su = new StatusUpdate(getObjectId());
su.addAttribute(StatusUpdate.CUR_LOAD, getCurrentLoad());
sendPacket(su);
su = null;
// Sends message to client if requested
if(sendMessage)
{
SystemMessage sm = new SystemMessage(SystemMessageId.YOU_DROPPED_S1);
sm.addItemName(item.getItemId());
sendPacket(sm);
sm = null;
}
invitem = null;
return item;
}
/**
* Check item manipulation.
*
* @param objectId the object id
* @param count the count
* @param action the action
* @return the l2 item instance
*/
public L2ItemInstance checkItemManipulation(int objectId, int count, String action)
{
if(L2World.getInstance().findObject(objectId) == null)
{
_log.finest(getObjectId() + ": player tried to " + action + " item not available in L2World");
return null;
}
if(count > item.getCount())
{
_log.finest(getObjectId() + ": player tried to " + action + " more items than he owns");
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)
{
if(Config.DEBUG)
{
_log.finest(getObjectId() + ": player tried to " + action + " item controling pet");
}
return null;
}
if(getActiveEnchantItem() != null && getActiveEnchantItem().getObjectId() == objectId)
{
if(Config.DEBUG)
{
_log.finest(getObjectId() + ":player tried to " + action + " an enchant scroll he was using");
}
@Override
public void run()
{
try
{
if (_activeChar.isSpawnProtected())
_activeChar.sendMessage("The effect of Spawn Protection has been removed.");
else if (_activeChar.isTeleportProtected())
_activeChar.sendMessage("The effect of Teleport Spawn Protection has been removed.");
if (Config.PLAYER_SPAWN_PROTECTION > 0)
_activeChar.setProtection(false);
if (Config.PLAYER_TELEPORT_PROTECTION > 0)
_activeChar.setTeleportProtection(false);
}
catch (Throwable e)
{
if (Config.ENABLE_ALL_EXCEPTIONS)
e.printStackTrace();
}
}
}
/**
* Set protection from agro mobs when getting up from fake death, according settings.
*
* @param protect the new recent fake death
*/
public void setRecentFakeDeath(boolean protect)
{
_recentFakeDeathEndTime = protect ? GameTimeController.getGameTicks() + Config.PLAYER_FAKEDEATH_UP_PROTECTION * GameTimeController.TICKS_PER_SECOND : 0;
}
/**
* Checks if is recent fake death.
*
* @return true, if is recent fake death
*/
public boolean isRecentFakeDeath()
{
return _recentFakeDeathEndTime > GameTimeController.getGameTicks();
}
/**
* Get the client owner of this char.<BR>
* <BR>
*
* @return the client
*/
public L2GameClient getClient()
{
return _client;
}
/**
* Sets the client.
*
* @param client the new client
*/
public void setClient(L2GameClient client)
{
if(client == null && _client != null)
{
_client.stopGuardTask();
nProtect.getInstance().closeSession(_client);
}
_client = client;
}
/**
* Close the active connection with the client.<BR>
* <BR>
*/
public void closeNetConnection()
{
if(_client != null)
{
_client.close(new LeaveWorld());
setClient(null);
}
}
/**
* 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 a Server->Client packet 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 a Server->Client packet MyTargetSelected to the player (display the select window)</li> <li>If this L2PcInstance has a Private Store, notify the player AI with AI_INTENTION_INTERACT</li> <li>If this L2PcInstance is autoAttackable, notify the player AI with AI_INTENTION_ATTACK</li><BR>
* <BR>
* <li>If this L2PcInstance is NOT autoAttackable, notify the player AI with AI_INTENTION_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)
{
// if ((TvT._started && !Config.TVT_ALLOW_INTERFERENCE) || (CTF._started && !Config.CTF_ALLOW_INTERFERENCE) || (DM._started && !Config.DM_ALLOW_INTERFERENCE))
// no Interaction with not participant to events
if (((TvT.is_started() || TvT.is_teleport()) && !Config.TVT_ALLOW_INTERFERENCE) || ((CTF.is_started() || CTF.is_teleport()) && !Config.CTF_ALLOW_INTERFERENCE) || ((DM.is_started() || DM.is_teleport()) && !Config.DM_ALLOW_INTERFERENCE))
{
if ((_inEventTvT && !player._inEventTvT) || (!_inEventTvT && player._inEventTvT))
{
player.sendPacket(ActionFailed.STATIC_PACKET);
return;
}
else if ((_inEventCTF && !player._inEventCTF) || (!_inEventCTF && player._inEventCTF))
{
player.sendPacket(ActionFailed.STATIC_PACKET);
return;
}
else if ((_inEventDM && !player._inEventDM) || (!_inEventDM && player._inEventDM))
{
player.sendPacket(ActionFailed.STATIC_PACKET);
return;
}
}
// Check if the L2PcInstance is confused
if (player.isOutOfControl())
{
// Send a Server->Client packet ActionFailed to the player
player.sendPacket(ActionFailed.STATIC_PACKET);
return;
}
// Check if the player already target this L2PcInstance
if (player.getTarget() != this)
{
// Set the target of the player
player.setTarget(this);
// Send a Server->Client packet MyTargetSelected to the player
// The color to display in the select window is White
player.sendPacket(new MyTargetSelected(getObjectId(), 0));
if (player != this)
{
player.sendPacket(new ValidateLocation(this));
// To be sure update also the pvp flag / war tag status
if (!player.inObserverMode())
this.broadcastUserInfo();
}
}
else
{
if (player != this)
{
player.sendPacket(new ValidateLocation(this));
}
// Check if this L2PcInstance has a Private Store
if (getPrivateStoreType() != 0)
{
// Notify the L2PcInstance AI with AI_INTENTION_INTERACT
player.getAI().setIntention(CtrlIntention.AI_INTEN TION_INTERACT, this);
// Calculate the distance between the L2PcInstance
if (canInteract(player))
{
// Notify the L2PcInstance AI with AI_INTENTION_INTERACT
player.getAI().setIntention(CtrlIntention.AI_INTEN TION_FOLLOW, this);
}
}
else
{
/*
* //during teleport phase, players cant do any attack if((TvT.is_teleport() && _inEventTvT) || (CTF.is_teleport() && _inEventCTF) || (DM.is_teleport() && _inEventDM)){ player.sendPacket(ActionFailed.STATIC_PACKET); return; } if (TvT.is_started()) { if ((_inEventTvT &&
* player._teamNameTvT.equals(_teamNameTvT))) { player.sendPacket(ActionFailed.STATIC_PACKET); return; } } if(CTF.is_started()){ if ((_inEventCTF && player._teamNameCTF.equals(_teamNameCTF))) { player.sendPacket(ActionFailed.STATIC_PACKET); return; } }
*/
// Check if this L2PcInstance is autoAttackable
// if (isAutoAttackable(player) || (player._inEventTvT && TvT._started) || (player._inEventCTF && CTF._started) || (player._inEventDM && DM._started) || (player._inEventVIP && VIP._started))
if (isAutoAttackable(player))
{
if (Config.ALLOW_CHAR_KILL_PROTECT)
{
Siege siege = SiegeManager.getInstance().getSiege(player);
if (siege != null && siege.getIsInProgress())
{
if (player.getLevel() > 20 && ((L2Character) player.getTarget()).getLevel() < 20)
{
player.sendMessage("Your target is not in your grade!");
player.sendPacket(ActionFailed.STATIC_PACKET);
}
if (player.getLevel() > 40 && ((L2Character) player.getTarget()).getLevel() < 40)
{
player.sendMessage("Your target is not in your grade!");
player.sendPacket(ActionFailed.STATIC_PACKET);
}
if (player.getLevel() > 52 && ((L2Character) player.getTarget()).getLevel() < 52)
{
player.sendMessage("Your target is not in your grade!");
player.sendPacket(ActionFailed.STATIC_PACKET);
}
if (player.getLevel() > 61 && ((L2Character) player.getTarget()).getLevel() < 61)
{
player.sendMessage("Your target is not in your grade!");
player.sendPacket(ActionFailed.STATIC_PACKET);
}
if (player.getLevel() > 76 && ((L2Character) player.getTarget()).getLevel() < 76)
{
player.sendMessage("Your target is not in your grade!");
player.sendPacket(ActionFailed.STATIC_PACKET);
}
if (player.getLevel() < 20 && ((L2Character) player.getTarget()).getLevel() > 20)
{
player.sendMessage("Your target is not in your grade!");
player.sendPacket(ActionFailed.STATIC_PACKET);
}
if (player.getLevel() < 40 && ((L2Character) player.getTarget()).getLevel() > 40)
{
player.sendMessage("Your target is not in your grade!");
player.sendPacket(ActionFailed.STATIC_PACKET);
}
if (player.getLevel() < 52 && ((L2Character) player.getTarget()).getLevel() > 52)
{
player.sendMessage("Your target is not in your grade!");
player.sendPacket(ActionFailed.STATIC_PACKET);
}
if (player.getLevel() < 61 && ((L2Character) player.getTarget()).getLevel() > 61)
{
player.sendMessage("Your target is not in your grade!");
player.sendPacket(ActionFailed.STATIC_PACKET);
}
if (player.getLevel() < 76 && ((L2Character) player.getTarget()).getLevel() > 76)
{
player.sendMessage("Your target is not in your grade!");
player.sendPacket(ActionFailed.STATIC_PACKET);
}
}
siege = null;
}
if (player.getLevel() < Config.ALT_PLAYER_PROTECTION_LEVEL || getLevel() < Config.ALT_PLAYER_PROTECTION_LEVEL)
{
player.sendMessage("You Can't Hit a Player That Is Lower Level From You. Target's Level: " + String.valueOf(Config.ALT_PLAYER_PROTECTION_LEVEL) );
player.sendPacket(ActionFailed.STATIC_PACKET);
}
// Player with lvl < 21 can't attack a cursed weapon holder
// And a cursed weapon holder can't attack players with lvl < 21
if (isCursedWeaponEquiped() && player.getLevel() < 21 || player.isCursedWeaponEquiped() && getLevel() < 21)
{
player.sendPacket(ActionFailed.STATIC_PACKET);
}
else
{
if (Config.GEODATA > 0)
{
if (GeoData.getInstance().canSeeTarget(player, this))
{
player.getAI().setIntention(CtrlIntention.AI_INTEN TION_ATTACK, this);
player.onActionRequest();
}
}
else
{
player.getAI().setIntention(CtrlIntention.AI_INTEN TION_ATTACK, this);
player.onActionRequest();
}
}
}
else
{
if (Config.GEODATA > 0)
{
if (GeoData.getInstance().canSeeTarget(player, this))
{
player.getAI().setIntention(CtrlIntention.AI_INTEN TION_FOLLOW, this);
}
}
else
{
player.getAI().setIntention(CtrlIntention.AI_INTEN TION_FOLLOW, this);
}
}
}
}
}
if (player.isGM())
{
if (this != player.getTarget())
{
player.setTarget(this);
player.sendPacket(new MyTargetSelected(getObjectId(), 0));
if (player != this)
{
player.sendPacket(new ValidateLocation(this));
// To be sure update also the pvp flag / war tag status
if (!player.inObserverMode())
this.broadcastUserInfo();
}
}
else
{
AdminEditChar.gatherCharacterInfo(player, this, "charinfo.htm");
}
}
else
// Like L2OFF set the target of the L2PcInstance player
{
if (((TvT.is_started() || TvT.is_teleport()) && !Config.TVT_ALLOW_INTERFERENCE) || ((CTF.is_started() || CTF.is_teleport()) && !Config.CTF_ALLOW_INTERFERENCE) || ((DM.is_started() || DM.is_teleport()) && !Config.DM_ALLOW_INTERFERENCE))
{
if ((_inEventTvT && !player._inEventTvT) || (!_inEventTvT && player._inEventTvT))
{
player.sendPacket(ActionFailed.STATIC_PACKET);
return;
}
else if ((_inEventCTF && !player._inEventCTF) || (!_inEventCTF && player._inEventCTF))
{
player.sendPacket(ActionFailed.STATIC_PACKET);
return;
}
else if ((_inEventDM && !player._inEventDM) || (!_inEventDM && player._inEventDM))
{
player.sendPacket(ActionFailed.STATIC_PACKET);
return;
}
}
// Check if the L2PcInstance is confused
if (player.isOutOfControl())
{
// Send a Server->Client packet ActionFailed to the player
player.sendPacket(ActionFailed.STATIC_PACKET);
return;
}
// Check if the player already target this L2PcInstance
if (player.getTarget() != this)
{
// Set the target of the player
player.setTarget(this);
// Send a Server->Client packet MyTargetSelected to the player
// The color to display in the select window is White
player.sendPacket(new MyTargetSelected(getObjectId(), 0));
if (player != this)
{
player.sendPacket(new ValidateLocation(this));
}
}
else
{
if (player != this)
{
player.sendPacket(new ValidateLocation(this));
}
// Check if this L2PcInstance has a Private Store
if (getPrivateStoreType() != 0)
{
// Notify the L2PcInstance AI with AI_INTENTION_INTERACT
player.getAI().setIntention(CtrlIntention.AI_INTEN TION_INTERACT, this);
// Calculate the distance between the L2PcInstance
if (canInteract(player))
{
// Notify the L2PcInstance AI with AI_INTENTION_INTERACT
player.getAI().setIntention(CtrlIntention.AI_INTEN TION_FOLLOW, this);
}
}
else
{
// Check if this L2PcInstance is autoAttackable
// if (isAutoAttackable(player) || (player._inEventTvT && TvT._started) || (player._inEventCTF && CTF._started) || (player._inEventDM && DM._started) || (player._inEventVIP && VIP._started))
if (isAutoAttackable(player))
{
if (Config.ALLOW_CHAR_KILL_PROTECT)
{
Siege siege = SiegeManager.getInstance().getSiege(player);
if (siege != null && siege.getIsInProgress())
{
if (player.getLevel() > 20 && ((L2Character) player.getTarget()).getLevel() < 20)
{
player.sendMessage("Your target is not in your grade!");
player.sendPacket(ActionFailed.STATIC_PACKET);
}
if (player.getLevel() > 40 && ((L2Character) player.getTarget()).getLevel() < 40)
{
player.sendMessage("Your target is not in your grade!");
player.sendPacket(ActionFailed.STATIC_PACKET);
}
if (player.getLevel() > 52 && ((L2Character) player.getTarget()).getLevel() < 52)
{
player.sendMessage("Your target is not in your grade!");
player.sendPacket(ActionFailed.STATIC_PACKET);
}
if (player.getLevel() > 61 && ((L2Character) player.getTarget()).getLevel() < 61)
{
player.sendMessage("Your target is not in your grade!");
player.sendPacket(ActionFailed.STATIC_PACKET);
}
if (player.getLevel() > 76 && ((L2Character) player.getTarget()).getLevel() < 76)
{
player.sendMessage("Your target is not in your grade!");
player.sendPacket(ActionFailed.STATIC_PACKET);
}
if (player.getLevel() < 20 && ((L2Character) player.getTarget()).getLevel() > 20)
{
player.sendMessage("Your target is not in your grade!");
player.sendPacket(ActionFailed.STATIC_PACKET);
}
if (player.getLevel() < 40 && ((L2Character) player.getTarget()).getLevel() > 40)
{
player.sendMessage("Your target is not in your grade!");
player.sendPacket(ActionFailed.STATIC_PACKET);
}
if (player.getLevel() < 52 && ((L2Character) player.getTarget()).getLevel() > 52)
{
player.sendMessage("Your target is not in your grade!");
player.sendPacket(ActionFailed.STATIC_PACKET);
}
if (player.getLevel() < 61 && ((L2Character) player.getTarget()).getLevel() > 61)
{
player.sendMessage("Your target is not in your grade!");
player.sendPacket(ActionFailed.STATIC_PACKET);
}
if (player.getLevel() < 76 && ((L2Character) player.getTarget()).getLevel() > 76)
{
player.sendMessage("Your target is not in your grade!");
player.sendPacket(ActionFailed.STATIC_PACKET);
}
}
siege = null;
}
if (player.getLevel() < Config.ALT_PLAYER_PROTECTION_LEVEL || getLevel() < Config.ALT_PLAYER_PROTECTION_LEVEL)
{
player.sendMessage("You Can't Hit a Player That Is Lower Level From You. Target's Level: " + String.valueOf(Config.ALT_PLAYER_PROTECTION_LEVEL) );
player.sendPacket(ActionFailed.STATIC_PACKET);
}
// Player with lvl < 21 can't attack a cursed weapon holder
// And a cursed weapon holder can't attack players with lvl < 21
if (isCursedWeaponEquiped() && player.getLevel() < 21 || player.isCursedWeaponEquiped() && getLevel() < 21)
{
player.sendPacket(ActionFailed.STATIC_PACKET);
}
else
{
if (Config.GEODATA > 0)
{
if (GeoData.getInstance().canSeeTarget(player, this))
{
// Calculate the distance between the L2PcInstance
// Only archer can hit from long
if (currentWeapon != null && currentWeapon.getItemType() == L2WeaponType.BOW)
{
player.getAI().setIntention(CtrlIntention.AI_INTEN TION_ATTACK, this);
player.onActionRequest();
}
else if (canInteract(player))
{
player.getAI().setIntention(CtrlIntention.AI_INTEN TION_ATTACK, this);
player.onActionRequest();
}
else
{
player.sendPacket(ActionFailed.STATIC_PACKET);
}
}
}
else
{
// Calculate the distance between the L2PcInstance
// Only archer can hit from long
if (currentWeapon != null && currentWeapon.getItemType() == L2WeaponType.BOW)
{
player.getAI().setIntention(CtrlIntention.AI_INTEN TION_ATTACK, this);
player.onActionRequest();
}
else if (canInteract(player))
{
player.getAI().setIntention(CtrlIntention.AI_INTEN TION_ATTACK, this);
player.onActionRequest();
}
else
{
player.sendPacket(ActionFailed.STATIC_PACKET);
}
}
}
}
else
{
if (Config.GEODATA > 0)
{
if (GeoData.getInstance().canSeeTarget(player, this))
{
// Calculate the distance between the L2PcInstance
// Only archer can hit from long
if (currentWeapon != null && currentWeapon.getItemType() == L2WeaponType.BOW)
{
player.getAI().setIntention(CtrlIntention.AI_INTEN TION_FOLLOW, this);
}
else if (canInteract(player))
{
player.getAI().setIntention(CtrlIntention.AI_INTEN TION_FOLLOW, this);
}
else
{
player.sendPacket(ActionFailed.STATIC_PACKET);
}
}
}
else
{
// Calculate the distance between the L2PcInstance
// Only archer can hit from long
if (currentWeapon != null && currentWeapon.getItemType() == L2WeaponType.BOW)
{
player.getAI().setIntention(CtrlIntention.AI_INTEN TION_FOLLOW, this);
}
else if (canInteract(player))
{
player.getAI().setIntention(CtrlIntention.AI_INTEN TION_FOLLOW, this);
}
else
{
player.sendPacket(ActionFailed.STATIC_PACKET);
}
}
}
}
}
}
}
public boolean isInStartedTVTEvent(){
return (TvT.is_started() && _inEventTvT);
}
public boolean isRegisteredInTVTEvent(){
return _inEventTvT;
}
public boolean isInStartedDMEvent(){
return (DM.is_started() && _inEventDM);
}
public boolean isRegisteredInDMEvent(){
return _inEventDM;
}
public boolean isInStartedCTFEvent(){
return (CTF.is_started() && _inEventCTF);
}
public boolean isRegisteredInCTFEvent(){
return _inEventCTF;
}
public boolean isInStartedVIPEvent(){
return (VIP._started && _inEventVIP);
}
public boolean isRegisteredInVIPEvent(){
return _inEventVIP;
}
/**
* Checks if is registered in fun event.
*
* @return true, if is registered in fun event
*/
public boolean isRegisteredInFunEvent(){
return (atEvent || (_inEventTvT) || (_inEventDM) || (_inEventCTF) || (_inEventVIP) || Olympiad.getInstance().isRegistered(this));
}
//To Avoid Offensive skills when locked (during oly start or TODO other events start)
/**
* Are player offensive skills locked.
*
* @return true, if successful
*/
public boolean arePlayerOffensiveSkillsLocked(){
return isInOlympiadMode() && !isOlympiadStart();
}
/**
* Returns true if cp update should be done, false if not.
*
* @param barPixels the bar pixels
* @return boolean
*/
private boolean needCpUpdate(int barPixels)
{
double currentCp = getCurrentCp();
/**
* 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()
{
//We mustn't send these informations to other players
// Send the Server->Client packet StatusUpdate with current HP and MP to all L2PcInstance that must be informed of HP/MP updates of this L2PcInstance
//super.broadcastStatusUpdate();
// Send the Server->Client packet StatusUpdate with current HP, MP and CP to this L2PcInstance
if(Config.FORCE_COMPLETE_STATUS_UPDATE){
StatusUpdate su = new StatusUpdate(this);
sendPacket(su);
su = null;
}else{
StatusUpdate su = new StatusUpdate(getObjectId());
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);
su = null;
}
// Check if a party is in progress and party window update is usefull
if(isInParty() && (needCpUpdate(352) || super.needHpUpdate(352) || 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);
getParty().broadcastToPartyMembers(this, update);
update = null;
}
if (isInOlympiadMode())
{
// TODO: implement new OlympiadUserInfo
for (L2PcInstance player : getKnownList().getKnownPlayers().values())
{
if (player.getOlympiadGameId()==getOlympiadGameId() && player.isOlympiadStart())
{
if (Config.DEBUG)
{
_log.fine("Send status for Olympia window of " + getObjectId() + "(" + getName() + ") to " + player.getObjectId() + "(" + player.getName() +"). CP: " + getCurrentCp() + " HP: " + getCurrentHp() + " MP: " + getCurrentMp());
}
player.sendPacket(new ExOlympiadUserInfo(this, 1));
}
}
if(Olympiad.getInstance().getSpectators(_olympiadG ameId) != null && this.isOlympiadStart())
{
for(L2PcInstance spectator : Olympiad.getInstance().getSpectators(_olympiadGame Id))
{
if (spectator == null) continue;
spectator.sendPacket(new ExOlympiadUserInfo(this, getOlympiadSide()));
}
}
}
if(isInDuel())
{
ExDuelUpdateUserInfo update = new ExDuelUpdateUserInfo(this);
DuelManager.getInstance().broadcastToOppositTeam(t his, update);
update = null;
}
}
// Custom PVP Color System - Start
/**
* Update pvp color.
*
* @param pvpKillAmount the pvp kill amount
*/
public void updatePvPColor(int pvpKillAmount)
{
if(Config.PVP_COLOR_SYSTEM_ENABLED)
{
//Check if the character has GM access and if so, let them be.
if(isGM())
return;
//Check if the character is donator and if so, let them be.
if(isDonator())
return;
// Custom Pk Color System - Start
/**
* Update pk color.
*
* @param pkKillAmount the pk kill amount
*/
public void updatePkColor(int pkKillAmount)
{
if(Config.PK_COLOR_SYSTEM_ENABLED)
{
//Check if the character has GM access and if so, let them be, like above.
if(isGM())
return;
/**
* Send a Server->Client packet 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 a Server->Client packet UserInfo to this L2PcInstance (Public and Private Data)</li> <li>Send a
* Server->Client packet 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>
*/
public final void broadcastUserInfo()
{
// Send a Server->Client packet UserInfo to this L2PcInstance
sendPacket(new UserInfo(this));
// Send a Server->Client packet CharInfo to all L2PcInstance in _KnownPlayers of the L2PcInstance
if(Config.DEBUG)
{
_log.fine("players to notify:" + getKnownList().getKnownPlayers().size() + " packet: [S] 03 CharInfo");
}
Broadcast.toKnownPlayers(this, new CharInfo(this));
}
/**
* Broadcast title info.
*/
public final void broadcastTitleInfo()
{
// Send a Server->Client packet UserInfo to this L2PcInstance
sendPacket(new UserInfo(this));
// Send a Server->Client packet TitleUpdate to all L2PcInstance in _KnownPlayers of the L2PcInstance
if(Config.DEBUG)
{
_log.fine("players to notify:" + getKnownList().getKnownPlayers().size() + " packet: [S] cc TitleUpdate");
}
Broadcast.toKnownPlayers(this, new TitleUpdate(this));
}
/**
* Return the Alliance Identifier of the L2PcInstance.<BR>
* <BR>
*
* @return the ally id
*/
public int getAllyId()
{
if(_clan == null)
return 0;
return _clan.getAllyId();
}
/**
* Gets the ally crest id.
*
* @return the ally crest id
*/
public int getAllyCrestId()
{
if(getClanId() == 0 || getClan()==null)
return 0;
if(getClan().getAllyId() == 0)
return 0;
return getClan().getAllyCrestId();
}
/**
* Manage Interact Task with another L2PcInstance.<BR>
* <BR>
* <B><U> Actions</U> :</B><BR>
* <BR>
* <li>If the private store is a STORE_PRIVATE_SELL, send a Server->Client PrivateBuyListSell packet to the
* L2PcInstance</li> <li>If the private store is a STORE_PRIVATE_BUY, send a Server->Client PrivateBuyListBuy packet
* to the L2PcInstance</li> <li>If the private store is a STORE_PRIVATE_MANUFACTURE, send a Server->Client
* RecipeShopSellList packet to the L2PcInstance</li><BR>
* <BR>
*
* @param target The L2Character targeted
*/
public void doInteract(L2Character target)
{
if(target instanceof L2PcInstance)
{
L2PcInstance temp = (L2PcInstance) target;
sendPacket(ActionFailed.STATIC_PACKET);
temp = null;
}
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 a Server->Client packet InventoryUpdate to this L2PcInstance
* with NewItem (use a new slot) or ModifiedItem (increase amount)</li> <li>Send a Server->Client packet
* 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 L2ItemInstance dropped
* @param item the item
*/
public void doAutoLoot(L2Attackable target, L2Attackable.RewardItem item)
{
if(isInParty())
{
getParty().distributeItem(this, item, false, target);
}
else if(item.getItemId() == 57)
{
addAdena("AutoLoot", item.getCount(), target, true);
}
else
{
addItem("AutoLoot", item.getItemId(), item.getCount(), target, true);
}
}
/**
* Manage Pickup Task.<BR>
* <BR>
* <B><U> Actions</U> :</B><BR>
* <BR>
* <li>Send a Server->Client packet 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 a Server->Client packet InventoryUpdate to this L2PcInstance with NewItem (use a new slot) or ModifiedItem (increase amount)</li> <li>Send a Server->Client packet 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 AI_INTENTION_IDLE
getAI().setIntention(CtrlIntention.AI_INTENTION_ID LE);
// 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(this + "trying to pickup wrong target." + getTarget());
return;
}
L2ItemInstance target = (L2ItemInstance) object;
// Send a Server->Client packet ActionFailed to this L2PcInstance
sendPacket(ActionFailed.STATIC_PACKET);
// Send a Server->Client packet StopMove to this L2PcInstance
StopMove sm = new StopMove(this);
if (Config.DEBUG)
_log.fine("pickup pos: " + target.getX() + " " + target.getY() + " " + target.getZ());
sendPacket(sm);
sm = null;
synchronized (target)
{
// Check if the target to pick up is visible
if (!target.isVisible())
{
// Send a Server->Client packet ActionFailed to this L2PcInstance
sendPacket(ActionFailed.STATIC_PACKET);
return;
}
if (!target.getDropProtection().tryPickUp(this) && target.getItemId() != 8190 && target.getItemId() != 8689)
{
sendPacket(ActionFailed.STATIC_PACKET);
SystemMessage smsg = new SystemMessage(SystemMessageId.FAILED_TO_PICKUP_S1) ;
smsg.addItemName(target.getItemId());
sendPacket(smsg);
return;
}
if ((isInParty() && getParty().getLootDistribution() == L2Party.ITEM_LOOTER || !isInParty()) && !_inventory.validateCapacity(target))
{
sendPacket(ActionFailed.STATIC_PACKET);
sendPacket(new SystemMessage(SystemMessageId.SLOTS_FULL));
return;
}
if (isInvul() && !isGM())
{
sendPacket(ActionFailed.STATIC_PACKET);
SystemMessage smsg = new SystemMessage(SystemMessageId.FAILED_TO_PICKUP_S1) ;
smsg.addItemName(target.getItemId());
sendPacket(smsg);
smsg = null;
return;
}
if (target.getOwnerId() != 0 && target.getOwnerId() != getObjectId() && !isInLooterParty(target.getOwnerId()))
{
sendPacket(ActionFailed.STATIC_PACKET);
if (target.getItemId() == 57 && _inventory.getAdena() == Integer.MAX_VALUE)
{
sendMessage("You have reached the maximum amount of adena, please spend or deposit the adena so you may continue obtaining adena.");
return;
}
// Fixed it's not possible pick up the object if you exceed the maximum weight.
if (_inventory.getTotalWeight() + target.getItem().getWeight() * target.getCount() > getMaxLoad())
{
sendMessage("You have reached the maximun weight.");
return;
}
// Remove the L2ItemInstance from the world and send server->client GetItem packets
target.pickupMe(this);
if (Config.SAVE_DROPPED_ITEM)
ItemsOnGroundManager.getInstance().removeObject(ta rget);
}
// Auto use herbs - pick up
if (target.getItemType() == L2EtcItemType.HERB)
{
IItemHandler handler = ItemHandler.getInstance().getItemHandler(target.ge tItemId());
if (handler == null)
_log.fine("No item handler registered for item ID " + target.getItemId() + ".");
else
handler.useItem(this, target);
ItemTable.getInstance().destroyItem("Consume", target, this, null);
handler = null;
}
// Cursed Weapons are not distributed
else if (CursedWeaponsManager.getInstance().isCursed(targe t.getItemId()))
{
/*
* Lineage2.com: When a player that controls Akamanah acquires Zariche,
* the newly-acquired Zariche automatically disappeared,
* and the equipped Akamanah's level increases by 1.
* The same rules also apply in the opposite instance.
*/
addItem("Pickup", target, null, true);
}
else if (FortSiegeManager.getInstance().isCombat(target.ge tItemId()))
{
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 || target.getItem() instanceof L2Armor || target.getItem() instanceof L2Weapon)
{
if (target.getEnchantLevel() > 0)
{
SystemMessage msg = new SystemMessage(SystemMessageId.ATTENTION_S1_PICKED_ UP_S2_S3);
msg.addString(getName());
msg.addNumber(target.getEnchantLevel());
msg.addItemName(target.getItemId());
broadcastPacket(msg, 1400);
}
else
{
SystemMessage msg = new SystemMessage(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);
}
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);
// Like L2OFF Auto-Equip arrows if player has a bow and player picks up arrows.
if (target.getItem() != null && target.getItem().getItemType() == L2EtcItemType.ARROW)
checkAndEquipArrows();
}
}
target = null;
}
/**
* Set a target.<BR>
* <BR>
* <B><U> Actions</U> :</B><BR>
* <BR>
* <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><BR>
* <BR>
*
* @param newTarget The L2Object to target
*/
@Override
public void setTarget(L2Object newTarget)
{
// Check if the new target is visible
if(newTarget != null && !newTarget.isVisible())
{
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);
}
}
oldTarget = null;
// Add the L2PcInstance to the _statusListener of the new target if it's a L2Character
if(newTarget != null && newTarget instanceof L2Character)
{
((L2Character) newTarget).addStatusListener(this);
TargetSelected my = new TargetSelected(getObjectId(), newTarget.getObjectId(), getX(), getY(), getZ());
broadcastPacket(my);
my = null;
}
// 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 equiped in the right hand).<BR>
* <BR>
*
* @return the active weapon instance
*/
@Override
public L2ItemInstance getActiveWeaponInstance()
{
return getInventory().getPaperdollItem(Inventory.PAPERDOL L_RHAND);
}
/**
* Return the active weapon item (always equiped in the right hand).<BR>
* <BR>
*
* @return the active weapon item
*/
@Override
public L2Weapon getActiveWeaponItem()
{
L2ItemInstance weapon = getActiveWeaponInstance();
if(weapon == null)
return getFistsWeaponItem();
return (L2Weapon) weapon.getItem();
}
/**
* Gets the chest armor instance.
*
* @return the chest armor instance
*/
public L2ItemInstance getChestArmorInstance()
{
return getInventory().getPaperdollItem(Inventory.PAPERDOL L_CHEST);
}
/**
* Gets the legs armor instance.
*
* @return the legs armor instance
*/
public L2ItemInstance getLegsArmorInstance()
{
return getInventory().getPaperdollItem(Inventory.PAPERDOL L_LEGS);
}
/**
* Gets the active chest armor item.
*
* @return the active chest armor item
*/
public L2Armor getActiveChestArmorItem()
{
L2ItemInstance armor = getChestArmorInstance();
if(armor == null)
return null;
return (L2Armor) armor.getItem();
}
/**
* Gets the active legs armor item.
*
* @return the active legs armor item
*/
public L2Armor getActiveLegsArmorItem()
{
L2ItemInstance legs = getLegsArmorInstance();
if (legs == null)
return null;
return (L2Armor) legs.getItem();
}
/**
* Checks if is wearing heavy armor.
*
* @return true, if is wearing heavy armor
*/
public boolean isWearingHeavyArmor()
{
L2ItemInstance legs = getLegsArmorInstance();
L2ItemInstance armor = getChestArmorInstance();
if (armor != null && legs != null)
{
if ((L2ArmorType)legs.getItemType() == L2ArmorType.HEAVY
&& ((L2ArmorType)armor.getItemType() == L2ArmorType.HEAVY))
return true;
}
if (armor != null)
{
if ((getInventory().getPaperdollItem(Inventory.PAPERD OLL_CHEST).getItem().getBodyPart() == L2Item.SLOT_FULL_ARMOR
&& (L2ArmorType)armor.getItemType() == L2ArmorType.HEAVY))
return true;
}
return false;
}
/**
* Checks if is wearing light armor.
*
* @return true, if is wearing light armor
*/
public boolean isWearingLightArmor()
{
L2ItemInstance legs = getLegsArmorInstance();
L2ItemInstance armor = getChestArmorInstance();
if (armor != null && legs != null)
{
if ((L2ArmorType)legs.getItemType() == L2ArmorType.LIGHT
&& ((L2ArmorType)armor.getItemType() == L2ArmorType.LIGHT))
return true;
}
if (armor != null)
{
if ((getInventory().getPaperdollItem(Inventory.PAPERD OLL_CHEST).getItem().getBodyPart() == L2Item.SLOT_FULL_ARMOR
&& (L2ArmorType)armor.getItemType() == L2ArmorType.LIGHT))
return true;
}
return false;
}
/**
* Checks if is wearing magic armor.
*
* @return true, if is wearing magic armor
*/
public boolean isWearingMagicArmor()
{
L2ItemInstance legs = getLegsArmorInstance();
L2ItemInstance armor = getChestArmorInstance();
if (armor != null && legs != null)
{
if ((L2ArmorType)legs.getItemType() == L2ArmorType.MAGIC
&& ((L2ArmorType)armor.getItemType() == L2ArmorType.MAGIC))
return true;
}
if (armor != null)
{
if ((getInventory().getPaperdollItem(Inventory.PAPERD OLL_CHEST).getItem().getBodyPart() == L2Item.SLOT_FULL_ARMOR
&& (L2ArmorType)armor.getItemType() == L2ArmorType.MAGIC))
return true;
}
return false;
}
/**
* Checks if is wearing formal wear.
*
* @return true, if is wearing formal wear
*/
public boolean isWearingFormalWear()
{
return _IsWearingFormalWear;
}
/**
* Sets the checks if is wearing formal wear.
*
* @param value the new checks if is wearing formal wear
*/
public void setIsWearingFormalWear(boolean value)
{
_IsWearingFormalWear = value;
}
/**
* Checks if is married.
*
* @return true, if is married
*/
public boolean isMarried()
{
return _married;
}
/**
* Sets the married.
*
* @param state the new married
*/
public void setMarried(boolean state)
{
_married = state;
}
/**
* Married type.
*
* @return the int
*/
public int marriedType()
{
return _marriedType;
}
/**
* Sets the married type.
*
* @param type the new married type
*/
public void setmarriedType(int type)
{
_marriedType = type;
}
/**
* Checks if is engage request.
*
* @return true, if is engage request
*/
public boolean isEngageRequest()
{
return _engagerequest;
}
/**
* Sets the engage request.
*
* @param state the state
* @param playerid the playerid
*/
public void setEngageRequest(boolean state, int playerid)
{
_engagerequest = state;
_engageid = playerid;
}
/**
* Sets the mary request.
*
* @param state the new mary request
*/
public void setMaryRequest(boolean state)
{
_marryrequest = state;
}
/**
* Checks if is mary request.
*
* @return true, if is mary request
*/
public boolean isMaryRequest()
{
return _marryrequest;
}
/**
* Sets the marry accepted.
*
* @param state the new marry accepted
*/
public void setMarryAccepted(boolean state)
{
_marryaccepted = state;
}
/**
* Checks if is marry accepted.
*
* @return true, if is marry accepted
*/
public boolean isMarryAccepted()
{
return _marryaccepted;
}
/**
* Gets the engage id.
*
* @return the engage id
*/
public int getEngageId()
{
return _engageid;
}
/**
* Gets the partner id.
*
* @return the partner id
*/
public int getPartnerId()
{
return _partnerId;
}
/**
* Sets the partner id.
*
* @param partnerid the new partner id
*/
public void setPartnerId(int partnerid)
{
_partnerId = partnerid;
}
/**
* Gets the couple id.
*
* @return the couple id
*/
public int getCoupleId()
{
return _coupleId;
}
/**
* Sets the couple id.
*
* @param coupleId the new couple id
*/
public void setCoupleId(int coupleId)
{
_coupleId = coupleId;
}
/**
* Engage answer.
*
* @param answer the answer
*/
public void EngageAnswer(int answer)
{
if(!_engagerequest)
return;
else if(_engageid == 0)
return;
else
{
L2PcInstance ptarget = (L2PcInstance) L2World.getInstance().findObject(_engageid);
setEngageRequest(false, 0);
if(ptarget != null)
{
if(answer == 1)
{
CoupleManager.getInstance().createCouple(ptarget, L2PcInstance.this);
ptarget.sendMessage("Request to Engage has been >ACCEPTED<");
}
else
{
ptarget.sendMessage("Request to Engage has been >DENIED<!");
}
ptarget = null;
}
}
}
/**
* Return the secondary weapon instance (always equiped in the left hand).<BR>
* <BR>
*
* @return the secondary weapon instance
*/
@Override
public L2ItemInstance getSecondaryWeaponInstance()
{
return getInventory().getPaperdollItem(Inventory.PAPERDOL L_LHAND);
}
/**
* Return the secondary weapon item (always equiped in the left hand) or the fists weapon.<BR>
* <BR>
*
* @return the secondary weapon item
*/
@Override
public L2Weapon getSecondaryWeaponItem()
{
L2ItemInstance weapon = getSecondaryWeaponInstance();
/**
* 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 killer
* @return true, if successful
*/
@Override
public boolean doDie(L2Character killer)
{
if (Config.TW_RESS_ON_DIE)
{
int x1, y1, z1;
x1 = getX();
y1 = getY();
z1 = getZ();
L2TownZone Town;
Town = TownManager.getInstance().getTown(x1, y1, z1);
if (Town != null && isinTownWar())
{
if (Town.getTownId() == Config.TW_TOWN_ID && !Config.TW_ALL_TOWNS)
{
reviveRequest(this, null, false);
}
else if (Config.TW_ALL_TOWNS)
{
reviveRequest(this, null, false);
}
}
}
// Kill the L2PcInstance
if (!super.doDie(killer))
return false;
if (killer != null)
{
final L2PcInstance pk = killer.getActingPlayer();
if (pk != null)
{
PlayerKillsManager.getInstance().onKill(this.getOb jectId(), killer.getObjectId());
if (Config.ENABLE_PK_INFO)
{
doPkInfo(pk);
}
if (atEvent)
{
pk.kills.add(getName());
}
if (_inEventTvT && pk._inEventTvT)
{
if (TvT.is_teleport() || TvT.is_started())
{
if (!(pk._teamNameTvT.equals(_teamNameTvT)))
{
PlaySound ps = new PlaySound(0, "ItemSound.quest_itemget", 1, getObjectId(), getX(), getY(), getZ());
_countTvTdies++;
pk._countTvTkills++;
pk.setTitle("Kills: " + pk._countTvTkills);
pk.sendPacket(ps);
pk.broadcastUserInfo();
TvT.setTeamKillsCount(pk._teamNameTvT, TvT.teamKillsCount(pk._teamNameTvT) + 1);
pk.broadcastUserInfo();
}
else
{
pk.sendMessage("You are a teamkiller !!! Teamkills not counting.");
}
sendMessage("You will be revived and teleported to team spot in " + Config.TVT_REVIVE_DELAY / 1000 + " seconds!");
ThreadPoolManager.getInstance().scheduleGeneral(ne w Runnable()
{
@Override
public void run()
{
teleToLocation(TvT._teamsX.get(TvT._teams.indexOf( _teamNameTvT)) + Rnd.get(201) - 100, TvT._teamsY.get(TvT._teams.indexOf(_teamNameTvT)) + Rnd.get(201) - 100, TvT._teamsZ.get(TvT._teams.indexOf(_teamNameTvT)), false);
doRevive();
}
}, Config.TVT_REVIVE_DELAY);
}
}
else if (_inEventTvT)
{
if (TvT.is_teleport() || TvT.is_started())
{
sendMessage("You will be revived and teleported to team spot in " + Config.TVT_REVIVE_DELAY / 1000 + " seconds!");
ThreadPoolManager.getInstance().scheduleGeneral(ne w Runnable()
{
@Override
public void run()
{
teleToLocation(TvT._teamsX.get(TvT._teams.indexOf( _teamNameTvT)), TvT._teamsY.get(TvT._teams.indexOf(_teamNameTvT)), TvT._teamsZ.get(TvT._teams.indexOf(_teamNameTvT)), false);
doRevive();
broadcastPacket(new SocialAction(getObjectId(), 15));
}
}, Config.TVT_REVIVE_DELAY);
}
}
else if (_inEventCTF)
{
if (CTF.is_teleport() || CTF.is_started())
{
sendMessage("You will be revived and teleported to team flag in 20 seconds!");
if (_haveFlagCTF)
removeCTFFlagOnDie();
ThreadPoolManager.getInstance().scheduleGeneral(ne w Runnable()
{
@Override
public void run()
{
teleToLocation(CTF._teamsX.get(CTF._teams.indexOf( _teamNameCTF)), CTF._teamsY.get(CTF._teams.indexOf(_teamNameCTF)), CTF._teamsZ.get(CTF._teams.indexOf(_teamNameCTF)), false);
doRevive();
}
}, 20000);
}
}
else if (_inEventDM && pk._inEventDM)
{
if (DM.is_teleport() || DM.is_started())
{
pk._countDMkills++;
PlaySound ps = new PlaySound(0, "ItemSound.quest_itemget", 1, getObjectId(), getX(), getY(), getZ());
pk.setTitle("Kills: " + pk._countDMkills);
pk.sendPacket(ps);
pk.broadcastUserInfo();
if (Config.DM_ENABLE_KILL_REWARD)
{
L2Item reward = ItemTable.getInstance().getTemplate(Config.DM_KILL _REWARD_ID);
pk.getInventory().addItem("DM Kill Reward", Config.DM_KILL_REWARD_ID, Config.DM_KILL_REWARD_AMOUNT, this, null);
pk.sendMessage("You have earned " + Config.DM_KILL_REWARD_AMOUNT + " item(s) of ID " + reward.getName() + ".");
}
sendMessage("You will be revived and teleported to spot in 20 seconds!");
ThreadPoolManager.getInstance().scheduleGeneral(ne w Runnable()
{
@Override
public void run()
{
Location p_loc = DM.get_playersSpawnLocation();
teleToLocation(p_loc._x, p_loc._y, p_loc._z, false);
doRevive();
}
}, Config.DM_REVIVE_DELAY);
}
}
else if (_inEventDM)
{
if (DM.is_teleport() || DM.is_started())
{
sendMessage("You will be revived and teleported to spot in 20 seconds!");
ThreadPoolManager.getInstance().scheduleGeneral(ne w Runnable()
{
@Override
public void run()
{
Location players_loc = DM.get_playersSpawnLocation();
teleToLocation(players_loc._x, players_loc._y, players_loc._z, false);
doRevive();
}
}, 20000);
}
}
else if (_inEventVIP && VIP._started)
{
if (_isTheVIP && !pk._inEventVIP)
{
Announcements.getInstance().announceToAll("VIP Killed by non-event character. VIP going back to initial spawn.");
doRevive();
teleToLocation(VIP._startX, VIP._startY, VIP._startZ);
}
else
{
if (_isTheVIP && pk._inEventVIP)
{
VIP.vipDied();
}
else
{
sendMessage("You will be revived and teleported to team spot in 20 seconds!");
ThreadPoolManager.getInstance().scheduleGeneral(ne w Runnable()
{
@Override
public void run()
{
doRevive();
if (_isVIP)
teleToLocation(VIP._startX, VIP._startY, VIP._startZ);
else
teleToLocation(VIP._endX, VIP._endY, VIP._endZ);
}
}, 20000);
}
}
broadcastUserInfo();
}
}
// Clear resurrect xp calculation
setExpBeforeDeath(0);
if (isCursedWeaponEquiped())
{
CursedWeaponsManager.getInstance().drop(_cursedWea ponEquipedId, killer);
}
else
{
if (pk == null || !pk.isCursedWeaponEquiped())
{
// if (getKarma() > 0)
onDieDropItem(killer); // Check if any item should be dropped
for (L2PcInstance onlinePlayer : L2World.getInstance().getAllPlayers())
if (onlinePlayer.getClan() != null)
{
if (onlinePlayer.getClan() == pk.getClan() && onlinePlayer != pk)
{
onlinePlayer.sendPacket(_snd);
}
}
if (getClan().getReputationScore() > 0)
{
pk.getClan().setReputationScore(((L2PcInstance) killer).getClan().getReputationScore() + 2, true);
pk.getClan().broadcastToOnlineMembers(new PledgeShowInfoUpdate(pk.getClan())); // Update status to all members
}
if (pk.getClan().getReputationScore() > 0)
{
_clan.setReputationScore(_clan.getReputationScore( ) - 2, true);
_clan.broadcastToOnlineMembers(new PledgeShowInfoUpdate(_clan)); // Update status to all members
}
}
if (Config.ALT_GAME_DELEVEL)
{
// Reduce the Experience of the L2PcInstance in function of the calculated Death Penalty
// NOTE: deathPenalty +- Exp will update karma
if (getSkillLevel(L2Skill.SKILL_LUCKY) < 0 || getStat().getLevel() > 9)
{
deathPenalty((pk != null && getClan() != null && pk.getClan() != null && pk.getClan().isAtWarWith(getClanId())));
}
}
else
{
onDieUpdateKarma(); // Update karma if delevel is not allowed
}
}
}
}
}
// Unsummon Cubics
unsummonAllCubics();
if (_forceBuff != null)
{
abortCast();
}
for (L2Character character : getKnownList().getKnownCharacters())
if (character.getTarget() == this)
{
if (character.isCastingNow())
character.abortCast();
}
if (isInParty() && getParty().isInDimensionalRift())
{
getParty().getDimensionalRift().getDeadMemberList( ).add(this);
}
// calculate death penalty buff
calculateDeathPenaltyBuffLevel(killer);
stopRentPet();
stopWaterTask();
quakeSystem = 0;
// leave war legend aura if enabled
heroConsecutiveKillCount = 0;
if (Config.WAR_LEGEND_AURA && !_hero && isPVPHero)
{
setHeroAura(false);
this.sendMessage("You leaved War Legend State");
}
// Refresh focus force like L2OFF
sendPacket(new EtcStatusUpdate(this));
return true;
}
/**
* Removes the ctf flag on die.
*/
public void removeCTFFlagOnDie()
{
CTF._flagsTaken.set(CTF._teams.indexOf(_teamNameHa veFlagCTF), false);
CTF.spawnFlag(_teamNameHaveFlagCTF);
CTF.removeFlagFromPlayer(this);
broadcastUserInfo();
_haveFlagCTF = false;
Announcements.getInstance().gameAnnounceToAll(CTF. get_eventName() + "(CTF): " + _teamNameHaveFlagCTF + "'s flag returned.");
}
/**
* On die drop item.
*
* @param killer the killer
*/
private void onDieDropItem(L2Character killer)
{
if(atEvent || (TvT.is_started() && _inEventTvT) || (DM.is_started() && _inEventDM) || (CTF.is_started() && _inEventCTF) || (VIP._started && _inEventVIP) || killer == null)
return;
for(L2ItemInstance itemDrop : getInventory().getItems())
{
// Don't drop
if(itemDrop.isAugmented() || // Dont drop augmented items
itemDrop.isShadowItem() || // Dont drop Shadow Items
itemDrop.getItemId() == 57 || // Adena
itemDrop.getItem().getType2() == L2Item.TYPE2_QUEST || // Quest Items
nonDroppableList.contains(itemDrop.getItemId()) || // Item listed in the non droppable item list
nonDroppableListPet.contains(itemDrop.getItemId()) || // Item listed in the non droppable pet item list
getPet() != null && getPet().getControlItemId() == itemDrop.getItemId() // Control Item of active pet
)
{
continue;
}
if(itemDrop.isEquipped())
{
// Set proper chance according to Item type of equipped Item
itemDropPercent = itemDrop.getItem().getType2() == L2Item.TYPE2_WEAPON ? dropEquipWeapon : dropEquip;
getInventory().unEquipItemInSlotAndRecord(itemDrop .getEquipSlot());
}
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)
{
if(isKarmaDrop)
{
dropItem("DieDrop", itemDrop, killer, true, false);
String text = getName() + " has karma and dropped id = " + itemDrop.getItemId() + ", count = " + itemDrop.getCount();
Log.add(text, "karma_dieDrop");
}
else
{
dropItem("DieDrop", itemDrop, killer, true, true);
String text = getName() + " dropped id = " + itemDrop.getItemId() + ", count = " + itemDrop.getCount();
Log.add(text, "dieDrop");
}
dropCount++;
break;
}
}
}
}
}
/**
* On die update karma.
*/
private void onDieUpdateKarma()
{
// Karma lose for server that does not allow delevel
if(getKarma() > 0)
{
// this formula seems to work relatively well:
// baseKarma * thisLVL * (thisLVL/100)
// Calculate the new Karma of the attacker : newKarma = baseKarma*pkCountMulti*lvlDiffMulti
double karmaLost = Config.KARMA_LOST_BASE;
karmaLost *= getLevel(); // multiply by char lvl
karmaLost *= getLevel() / 100.0; // divide by 0.charLVL
karmaLost = Math.round(karmaLost);
if ( karmaLost < 0 ) karmaLost = 1;
// Decrease Karma of the L2PcInstance and Send it a Server->Client StatusUpdate packet with Karma and PvP Flag if necessary
setKarma(getKarma() - (int) karmaLost);
}
}
/**
* On kill update pvp karma.
* @param target the target
*/
public void onKillUpdatePvPKarma(L2Character target)
{
if (target == null)
return;
if (!(target instanceof L2PlayableInstance))
return;
if (!Config.FORCE_INVENTORY_UPDATE)
{
InventoryUpdate iu = new InventoryUpdate();
iu.addItem(_inventory.getItemByItemId(Config.PVP_R EWARD_ID));
sendPacket(iu);
iu = null;
}
}
else
// target is not pk and not in pvp ---> PK KILL
{
if (Config.PK_REWARD_ENABLED)
{
int item = Config.PK_REWARD_ID;
L2Item reward = ItemTable.getInstance().getTemplate(item);
int amount = Config.PK_REWARD_AMOUNT;
getInventory().addItem("Winning PK", Config.PK_REWARD_ID, Config.PK_REWARD_AMOUNT, this, null);
sendMessage("You have earned " + amount + " item(s) of " + reward.getName() + ".");
}
if (!Config.FORCE_INVENTORY_UPDATE)
{
InventoryUpdate iu = new InventoryUpdate();
iu.addItem(_inventory.getItemByItemId(Config.PK_RE WARD_ID));
sendPacket(iu);
iu = null;
}
}
}
else
{
this.sendMessage("Farm is punishable with Ban! Don't kill your Box!");
_log.warning("PVP POINT FARM ATTEMPT: " + this.getName() + " and " + targetPlayer.getName() + ". SAME IP.");
}
}
}
/**
* Increase the pvp kills count and send the info to the player.
*/
private int spreeKills = 0;
public void increasePvpKills()
{
spreeKills++;
switch(spreeKills)
{
case 1:
Announcements.getInstance().announceToAll("" + this.getName()+ " shed the first blood!");
PlaySound _snd1 = new PlaySound(1, "firstblood", 0, 0, 0, 0, 0);
sendPacket(_snd1);
break;
case 2:
Announcements.getInstance().announceToAll("" + this.getName()+ " is dominating!");
PlaySound _snd2 = new PlaySound(1, "doublekill", 0, 0, 0, 0, 0);
sendPacket(_snd2);
break;
case 3:
Announcements.getInstance().announceToAll("" + this.getName()+ " is on a rampage!");
PlaySound _snd3 = new PlaySound(1, "triplekill", 0, 0, 0, 0, 0);
sendPacket(_snd3);
break;
case 5:
Announcements.getInstance().announceToAll("" + this.getName()+ " is unstoppable!");
PlaySound _snd4 = new PlaySound(1, "megakill", 0, 0, 0, 0, 0);
sendPacket(_snd4);
break;
case 7:
Announcements.getInstance().announceToAll("" + this.getName()+ " is on an ultra kill!");
PlaySound _snd5 = new PlaySound(1, "ultrakill", 0, 0, 0, 0, 0);
sendPacket(_snd5);
break;
case 10:
Announcements.getInstance().announceToAll("" + this.getName()+ " is on a monster kill!");
PlaySound _snd10 = new PlaySound(1, "monsterkill", 0, 0, 0, 0, 0);
sendPacket(_snd10);
break;
case 15:
Announcements.getInstance().announceToAll("" + this.getName()+ " is on a killing spree!");
PlaySound _snd15 = new PlaySound(1, "killingspree", 0, 0, 0, 0, 0);
sendPacket(_snd15);
break;
default:
;
}
int x,y,z;
x = getX();
y = getY();
z = getZ();
L2TownZone Town;
Town = TownManager.getInstance().getTown(x,y,z);
if(Town != null && isinTownWar())
{
if(Town.getTownId() == Config.TW_TOWN_ID && !Config.TW_ALL_TOWNS)
{
getInventory().addItem("TownWar", Config.TW_ITEM_ID, Config.TW_ITEM_AMOUNT, this, this);
sendMessage("You received your prize for a town war kill!");
}
else if(Config.TW_ALL_TOWNS)
{
getInventory().addItem("TownWar", Config.TW_ITEM_ID, Config.TW_ITEM_AMOUNT, this, this);
sendMessage("You received your prize for a town war kill!");
}
}
System.out.println("Could not add pkKills, got: " + e.getMessage());
}
finally
{
CloseUtil.close(conect2);
conect2 = null;
}
sendMessage("This is the first time you have been killed by " + PlayerWhoKilled.getName() + ".");
PlayerWhoKilled.sendMessage("You have killed " + getName() + " for the first time.");
}
killer = null;
killed = null;
}
/**
* Increase pk count, karma and send the info to the player.
*
* @param targLVL : level of the killed player
*/
public void increasePkKillsAndKarma(int targLVL)
{
if((TvT.is_started() && _inEventTvT) || (DM.is_started() && _inEventDM) || (CTF.is_started() && _inEventCTF) || (VIP._started && _inEventVIP))
return;
int baseKarma = Config.KARMA_MIN_KARMA;
int newKarma = baseKarma;
int karmaLimit = Config.KARMA_MAX_KARMA;
int pkLVL = getLevel();
int pkPKCount = getPkKills();
int lvlDiffMulti = 0;
int pkCountMulti = 0;
// Check if the attacker has a PK counter greater than 0
if(pkPKCount > 0)
{
pkCountMulti = pkPKCount / 2;
}
else
{
pkCountMulti = 1;
}
if(pkCountMulti < 1)
{
pkCountMulti = 1;
}
// Calculate the level difference Multiplier between attacker and killed L2PcInstance
if(pkLVL > targLVL)
{
lvlDiffMulti = pkLVL / targLVL;
}
else
{
lvlDiffMulti = 1;
}
if(lvlDiffMulti < 1)
{
lvlDiffMulti = 1;
}
// Calculate the new Karma of the attacker : newKarma = baseKarma*pkCountMulti*lvlDiffMulti
newKarma *= pkCountMulti;
newKarma *= lvlDiffMulti;
// Make sure newKarma is less than karmaLimit and higher than baseKarma
if(newKarma < baseKarma)
{
newKarma = baseKarma;
}
// Fix to prevent overflow (=> karma has a max value of 2 147 483 647)
if(getKarma() > Integer.MAX_VALUE - newKarma)
{
newKarma = Integer.MAX_VALUE - getKarma();
}
Announcements.getInstance().announceToAll("" + this.getName()+ " is a rebel!");
PlaySound _snd = new PlaySound(1, "knife", 0, 0, 0, 0, 0);
sendPacket(_snd);
broadcastPacket(_snd);
// Add karma to attacker and increase its PK counter
int x,y,z;
x = getX();
y = getY();
z = getZ();
//get local town
L2TownZone Town = TownManager.getInstance().getTown(x,y,z);
if(Town != null && isinTownWar())
{
if(Town.getTownId() == Config.TW_TOWN_ID && !Config.TW_ALL_TOWNS)
{
getInventory().addItem("TownWar", Config.TW_ITEM_ID, Config.TW_ITEM_AMOUNT, this, this);
sendMessage("You received your prize for a town war kill!");
}
else if(Config.TW_ALL_TOWNS && Town.getTownId() != 0)
{
getInventory().addItem("TownWar", Config.TW_ITEM_ID, Config.TW_ITEM_AMOUNT, this, this);
sendMessage("You received your prize for a town war kill!");
}
}
if(Config.PVP_PK_TITLE)
{
updateTitle();
}
//Update the character's title color if they reached any of the 5 PK levels.
updatePkColor(getPkKills());
broadcastUserInfo();
// Send a Server->Client UserInfo packet to attacker with its Karma and PK Counter
sendPacket(new UserInfo(this));
}
/**
* Calculate karma lost.
*
* @param exp the exp
* @return the int
*/
public int calculateKarmaLost(long exp)
{
// KARMA LOSS
// When a PKer gets killed by another player or a L2MonsterInstance, it loses a certain amount of Karma based on their level.
// this (with defaults) results in a level 1 losing about ~2 karma per death, and a lvl 70 loses about 11760 karma per death...
// You lose karma as long as you were not in a pvp zone and you did not kill urself.
// NOTE: exp for death (if delevel is allowed) is based on the players level
long expGained = Math.abs(exp);
expGained /= Config.KARMA_XP_DIVIDER;
/**
* Restore the specified % of experience this L2PcInstance has lost and sends a Server->Client StatusUpdate packet.<BR>
* <BR>
*
* @param restorePercent the restore percent
*/
public void restoreExp(double restorePercent)
{
if(getExpBeforeDeath() > 0)
{
// Restore the specified % of lost experience.
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.<BR>
* <BR>
* <B><U> Actions</U> :</B><BR>
* <BR>
* <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><BR>
* <BR>
*
* @param atwar the atwar
*/
public void deathPenalty(boolean atwar)
{
// Get the level of the L2PcInstance
final int lvl = getLevel();
//The death steal you some Exp
double percentLost = 4.0; //standart 4% (lvl>20)
if(Config.DEBUG)
{
_log.fine(getName() + " died and lost " + lostExp + " experience.");
}
// Set the new Experience value of the L2PcInstance
getStat().addExp(-lostExp);
}
/**
* 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 a
* Server->Client packet 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 the HP/MP/CP Regeneration task.<BR>
* <BR>
* <B><U> Actions</U> :</B><BR>
* <BR>
* <li>Set the RegenActive flag to False</li> <li>Stop the HP/MP/CP Regeneration task</li><BR>
* <BR>
*/
public void stopAllTimers()
{
stopHpMpRegeneration();
stopWarnUserTakeBreak();
stopWaterTask();
stopRentPet();
stopPvpRegTask();
stopPunishTask(true);
stopBotChecker();
quakeSystem = 0;
}
/**
* Return the L2Summon of the L2PcInstance or null.<BR>
* <BR>
*
* @return the pet
*/
@Override
public L2Summon getPet()
{
return _summon;
}
/**
* Set the L2Summon of the L2PcInstance.<BR>
* <BR>
*
* @param summon the new pet
*/
public void setPet(L2Summon summon)
{
_summon = summon;
}
/**
* Return the L2Summon of the L2PcInstance or null.<BR>
* <BR>
*
* @return the trained beast
*/
public L2TamedBeastInstance getTrainedBeast()
{
return _tamedBeast;
}
/**
* Set the L2Summon of the L2PcInstance.<BR>
* <BR>
*
* @param tamedBeast the new trained beast
*/
public void setTrainedBeast(L2TamedBeastInstance tamedBeast)
{
_tamedBeast = tamedBeast;
}
/**
* Return the L2PcInstance requester of a transaction (ex : FriendInvite, JoinAlly, JoinParty...).<BR>
* <BR>
*
* @return the request
*/
public L2Request getRequest()
{
return _request;
}
/**
* Set the L2PcInstance requester of a transaction (ex : FriendInvite, JoinAlly, JoinParty...).<BR>
* <BR>
*
* @param requester the new active requester
*/
public synchronized void setActiveRequester(L2PcInstance requester)
{
_activeRequester = requester;
}
/**
* Return the L2PcInstance requester of a transaction (ex : FriendInvite, JoinAlly, JoinParty...).<BR>
* <BR>
*
* @return the active requester
*/
public synchronized L2PcInstance getActiveRequester()
{
L2PcInstance requester = _activeRequester;
if (requester != null)
{
if (requester.isRequestExpired() && _activeTradeList == null)
_activeRequester = null;
}
return _activeRequester;
}
/**
* Return True if a transaction is in progress.<BR>
* <BR>
*
* @return true, if is processing request
*/
public boolean isProcessingRequest()
{
return _activeRequester != null || _requestExpireTime > GameTimeController.getGameTicks();
}
/**
* Return True if a transaction is in progress.<BR>
* <BR>
*
* @return true, if is processing transaction
*/
public boolean isProcessingTransaction()
{
return _activeRequester != null || _activeTradeList != null || _requestExpireTime > GameTimeController.getGameTicks();
}
/**
* Select the Warehouse to be used in next activity.<BR>
* <BR>
*
* @param partner the partner
*/
public void onTransactionRequest(L2PcInstance partner)
{
_requestExpireTime = GameTimeController.getGameTicks() + REQUEST_TIMEOUT * GameTimeController.TICKS_PER_SECOND;
if (partner != null)
{
partner.setActiveRequester(this);
}
}
/**
* Select the Warehouse to be used in next activity.<BR>
* <BR>
*/
public void onTransactionResponse()
{
_requestExpireTime = 0;
}
/**
* Select the Warehouse to be used in next activity.<BR>
* <BR>
*
* @param warehouse the new active warehouse
*/
public void setActiveWarehouse(ItemContainer warehouse)
{
_activeWarehouse = warehouse;
}
/**
* Return active Warehouse.<BR>
* <BR>
*
* @return the active warehouse
*/
public ItemContainer getActiveWarehouse()
{
return _activeWarehouse;
}
/**
* Select the TradeList to be used in next activity.<BR>
* <BR>
*
* @param tradeList the new active trade list
*/
public void setActiveTradeList(TradeList tradeList)
{
_activeTradeList = tradeList;
}
/**
* Return active TradeList.<BR>
* <BR>
*
* @return the active trade list
*/
public TradeList getActiveTradeList()
{
return _activeTradeList;
}
/**
* On trade start.
*
* @param partner the partner
*/
public void onTradeStart(L2PcInstance partner)
{
_activeTradeList = new TradeList(this);
_activeTradeList.setPartner(partner);
/**
* Return the _createList object of the L2PcInstance.<BR>
* <BR>
*
* @return the creates the list
*/
public L2ManufactureList getCreateList()
{
return _createList;
}
/**
* Set the _createList object of the L2PcInstance.<BR>
* <BR>
*
* @param x the new creates the list
*/
public void setCreateList(L2ManufactureList x)
{
_createList = x;
}
/**
* Return the _sellList object of the L2PcInstance.<BR>
* <BR>
*
* @return the sell list
*/
public TradeList getSellList()
{
if(_sellList == null)
{
_sellList = new TradeList(this);
}
return _sellList;
}
/**
* Return the _buyList object of the L2PcInstance.<BR>
* <BR>
*
* @return the buy list
*/
public TradeList getBuyList()
{
if(_buyList == null)
{
_buyList = new TradeList(this);
}
return _buyList;
}
/**
* Set the Private Store type of the L2PcInstance.<BR>
* <BR>
* <B><U> Values </U> :</B><BR>
* <BR>
* <li>0 : STORE_PRIVATE_NONE</li>
* <li>1 : STORE_PRIVATE_SELL</li>
* <li>2 : sellmanage</li><BR>
* <li>3 : STORE_PRIVATE_BUY</li><BR>
* <li>4 : buymanage</li><BR>
* <li>5 : STORE_PRIVATE_MANUFACTURE</li><BR>
*
* @param type the new private store type
*/
public void setPrivateStoreType(int type)
{
_privatestore = type;
if(this.getClient() != null)
{
this.getClient().setActiveChar(null); // prevent deleteMe from being called a second time on disconnection
}
}
}
}
/**
* Return the Private Store type of the L2PcInstance.<BR>
* <BR>
* <B><U> Values </U> :</B><BR>
* <BR>
* <li>0 : STORE_PRIVATE_NONE</li> <li>1 : STORE_PRIVATE_SELL</li> <li>2 : sellmanage</li><BR>
* <li>3 : STORE_PRIVATE_BUY</li><BR>
* <li>4 : buymanage</li><BR>
* <li>5 : STORE_PRIVATE_MANUFACTURE</li><BR>
*
* @return the private store type
*/
public int getPrivateStoreType()
{
return _privatestore;
}
/**
* Set the _skillLearningClassId object of the L2PcInstance.<BR>
* <BR>
*
* @param classId the new skill learning class id
*/
public void setSkillLearningClassId(ClassId classId)
{
_skillLearningClassId = classId;
}
/**
* Return the _skillLearningClassId object of the L2PcInstance.<BR>
* <BR>
*
* @return the skill learning class id
*/
public ClassId getSkillLearningClassId()
{
return _skillLearningClassId;
}
/**
* Set the _clan object, _clanId, _clanLeader Flag and title of the L2PcInstance.<BR>
* <BR>
*
* @param clan the new clan
*/
public void setClan(L2Clan clan)
{
_clan = clan;
setTitle("");
/**
* Return the _clan object of the L2PcInstance.<BR>
* <BR>
*
* @return the clan
*/
public L2Clan getClan()
{
return _clan;
}
/**
* Return True if the L2PcInstance is the leader of its clan.<BR>
* <BR>
*
* @return true, if is clan leader
*/
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().destroyItem("Consume", getInventory().getPaperdollObjectId(Inventory.PAPE RDOLL_LHAND), 1, this, null);
/**
* Equip arrows needed in left hand and send a Server->Client packet ItemList to the L2PcINstance then return True.<BR>
* <BR>
*
* @return true, if successful
*/
@Override
protected boolean checkAndEquipArrows()
{
// Check if nothing is equiped in left hand
if(getInventory().getPaperdollItem(Inventory.PAPER DOLL_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.PAPERDOL L_LHAND, _arrowItem);
// Send a Server->Client packet ItemList to this L2PcINstance to update left hand equipement
ItemList il = new ItemList(this, false);
sendPacket(il);
}
}
else
{
// Get the L2ItemInstance of arrows equiped in left hand
_arrowItem = getInventory().getPaperdollItem(Inventory.PAPERDOL L_LHAND);
}
return _arrowItem != null;
}
/**
* Disarm the player's weapon and shield.<BR>
* <BR>
*
* @return true, if successful
*/
public boolean disarmWeapons()
{
// Don't allow disarming a cursed weapon
if(isCursedWeaponEquiped() && !getAccessLevel().isGm())
return false;
// Remove augementation boni on unequip
if(wpn.isAugmented())
{
wpn.getAugmentation().removeBoni(this);
}
L2ItemInstance[] unequiped = getInventory().unEquipItemInBodySlotAndRecord(wpn. getItem().getBodyPart());
InventoryUpdate iu = new InventoryUpdate();
for(L2ItemInstance element : unequiped)
{
iu.addModifiedItem(element);
}
sendPacket(iu);
iu = null;
abortAttack();
broadcastUserInfo();
// this can be 0 if the user pressed the right mousebutton twice very fast
if(unequiped.length > 0)
{
SystemMessage sm = null;
if(unequiped[0].getEnchantLevel() > 0)
{
sm = new SystemMessage(SystemMessageId.EQUIPMENT_S1_S2_REMO VED);
sm.addNumber(unequiped[0].getEnchantLevel());
sm.addItemName(unequiped[0].getItemId());
}
else
{
sm = new SystemMessage(SystemMessageId.S1_DISARMED);
sm.addItemName(unequiped[0].getItemId());
}
sendPacket(sm);
sm = null;
}
wpn = null;
unequiped = null;
}
L2ItemInstance[] unequiped = getInventory().unEquipItemInBodySlotAndRecord(sld. getItem().getBodyPart());
InventoryUpdate iu = new InventoryUpdate();
for(L2ItemInstance element : unequiped)
{
iu.addModifiedItem(element);
}
sendPacket(iu);
iu = null;
abortAttack();
broadcastUserInfo();
// this can be 0 if the user pressed the right mousebutton twice very fast
if(unequiped.length > 0)
{
SystemMessage sm = null;
if(unequiped[0].getEnchantLevel() > 0)
{
sm = new SystemMessage(SystemMessageId.EQUIPMENT_S1_S2_REMO VED);
sm.addNumber(unequiped[0].getEnchantLevel());
sm.addItemName(unequiped[0].getItemId());
}
else
{
sm = new SystemMessage(SystemMessageId.S1_DISARMED);
sm.addItemName(unequiped[0].getItemId());
}
sendPacket(sm);
sm = null;
}
sld = null;
unequiped = null;
}
return true;
}
/**
* Return True if the L2PcInstance use a dual weapon.<BR>
* <BR>
*
* @return true, if is using dual weapon
*/
@Override
public boolean isUsingDualWeapon()
{
L2Weapon weaponItem = getActiveWeaponItem();
if(weaponItem == null)
return false;
/**
* Sets the uptime.
*
* @param time the new uptime
*/
public void setUptime(long time)
{
_uptime = time;
}
/**
* Gets the uptime.
*
* @return the uptime
*/
public long getUptime()
{
return System.currentTimeMillis() - _uptime;
}
/**
* Return True if the L2PcInstance is invulnerable.<BR>
* <BR>
*
* @return true, if is invul
*/
@Override
public boolean isInvul()
{
return _isInvul || _isTeleporting || _protectEndTime > GameTimeController.getGameTicks() || _teleportProtectEndTime > GameTimeController.getGameTicks();
}
/**
* Return True if the L2PcInstance has a Party in progress.<BR>
* <BR>
*
* @return true, if is in party
*/
@Override
public boolean isInParty()
{
return _party != null;
}
/**
* Set the _party object of the L2PcInstance (without joining it).<BR>
* <BR>
*
* @param party the new party
*/
public void setParty(L2Party party)
{
_party = party;
}
/**
* Set the _party object of the L2PcInstance AND join it.<BR>
* <BR>
*
* @param party the party
*/
public void joinParty(final L2Party party)
{
if(party == null){
sendPacket(ActionFailed.STATIC_PACKET);
return;
}
if(party.getMemberCount()<9)
{
// First set the party otherwise this wouldn't be considered
// as in a party into the L2Character.updateEffectIcons() call.
_party = party;
party.addPartyMember(this);
}
}
/**
* Return true if the L2PcInstance is a GM.<BR>
* <BR>
*
* @return true, if is gM
*/
public boolean isGM()
{
return getAccessLevel().isGm();
}
/**
* Return true if the L2PcInstance is a Administrator.<BR>
* <BR>
*
* @return true, if is administrator
*/
public boolean isAdministrator()
{
return getAccessLevel().getLevel() == Config.MASTERACCESS_LEVEL;
}
/**
* Return true if the L2PcInstance is a User.<BR>
* <BR>
*
* @return true, if is user
*/
public boolean isUser()
{
return getAccessLevel().getLevel() == Config.USERACCESS_LEVEL;
}
/**
* Checks if is normal gm.
*
* @return true, if is normal gm
*/
public boolean isNormalGm()
{
return !isAdministrator() && !isUser();
}
/**
* Manage the Leave Party task of the L2PcInstance.<BR>
* <BR>
*/
public void leaveParty()
{
if(isInParty())
{
_party.removePartyMember(this);
_party = null;
}
}
/**
* Return the _party object of the L2PcInstance.<BR>
* <BR>
*
* @return the party
*/
@Override
public L2Party getParty()
{
return _party;
}
/**
* Set the _isGm Flag of the L2PcInstance.<BR>
* <BR>
*
* @param firstlog the new first log
*/
// public void setIsGM(boolean status)
// {
// _isGm = status;
// }
/**
* Sets the first log.
*
* @param firstlog the new first log
*/
public void setFirstLog(boolean firstlog)
{
_first_log = firstlog;
}
/**
* Gets the first log.
*
* @return the first log
*/
public boolean getFirstLog()
{
return _first_log;
}
/**
* Manage a cancel cast task for the L2PcInstance.<BR>
* <BR>
* <B><U> Actions</U> :</B><BR>
* <BR>
* <li>Set the Intention of the AI to AI_INTENTION_IDLE</li> <li>Enable all skills (set _allSkillsDisabled to False)
* </li> <li>Send a Server->Client Packet MagicSkillCanceld to the L2PcInstance and all L2PcInstance in the
* _KnownPlayers of the L2Character (broadcast)</li><BR>
* <BR>
*/
public void cancelCastMagic()
{
// Set the Intention of the AI to AI_INTENTION_IDLE
getAI().setIntention(CtrlIntention.AI_INTENTION_ID LE);
// Enable all skills (set _allSkillsDisabled to False)
enableAllSkills();
// Send a Server->Client Packet MagicSkillCanceld to the L2PcInstance and all L2PcInstance in the _KnownPlayers of the L2Character (broadcast)
MagicSkillCanceld msc = new MagicSkillCanceld(getObjectId());
// Broadcast the packet to self and known players.
Broadcast.toSelfAndKnownPlayersInRadius(this, msc, 810000/*900*/);
msc = null;
}
/**
* Set the _accessLevel of the L2PcInstance.<BR>
* <BR>
*
* @param level the new access level
*/
public void setAccessLevel(int level)
{
if(level == Config.MASTERACCESS_LEVEL)
{
_log.warning("Admin Login at "+ fmt.format(new Date(System.currentTimeMillis())) +" " + getName() + " logs in game with AccessLevel "+ level +".");
_accessLevel = AccessLevels.getInstance()._masterAccessLevel;
}
else if(level == Config.USERACCESS_LEVEL)
{
_accessLevel = AccessLevels.getInstance()._userAccessLevel;
}
else
{ if(level > 0){
_log.warning("GM Login at "+ fmt.format(new Date(System.currentTimeMillis())) +" " + getName() + " logs in game with AccessLevel "+ level +".");}
AccessLevel accessLevel = AccessLevels.getInstance().getAccessLevel(level);
if(accessLevel == null)
{
if(level < 0)
{
AccessLevels.getInstance().addBanAccessLevel(level );
_accessLevel = AccessLevels.getInstance().getAccessLevel(level);
}
else
{
_log.warning("Tried to set unregistered access level " + level + " to character " + getName() + ". Setting access level without privileges!");
_accessLevel = AccessLevels.getInstance()._userAccessLevel;
}
}
else
{
_accessLevel = 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).<BR>
* <BR>
*
* @param broadcastType the broadcast type
*/
public void updateAndBroadcastStatus(int broadcastType)
{
refreshOverloaded();
refreshExpertisePenalty();
// Send a Server->Client packet UserInfo to this L2PcInstance and CharInfo to all L2PcInstance in its _KnownPlayers (broadcast)
if(broadcastType == 1)
{
this.sendPacket(new UserInfo(this));
}
if(broadcastType == 2)
{
broadcastUserInfo();
}
}
/**
* Send a Server->Client StatusUpdate packet with Karma and PvP Flag to the L2PcInstance and all L2PcInstance to
* inform (broadcast).<BR>
* <BR>
*
* @param flag the new karma flag
*/
public void setKarmaFlag(int flag)
{
sendPacket(new UserInfo(this));
for(L2PcInstance player : getKnownList().getKnownPlayers().values())
{
player.sendPacket(new RelationChanged(this, getRelation(player), isAutoAttackable(player)));
/**
* Send a Server->Client StatusUpdate packet with Karma to the L2PcInstance and all L2PcInstance to inform
* (broadcast).<BR>
* <BR>
*/
public void broadcastKarma()
{
sendPacket(new UserInfo(this));
for(L2PcInstance player : getKnownList().getKnownPlayers().values())
{
player.sendPacket(new RelationChanged(this, getRelation(player), isAutoAttackable(player)));
/**
* 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).<BR>
* <BR>
*
* @param isOnline the new online status
*/
public void setOnlineStatus(boolean isOnline)
{
if(_isOnline != isOnline)
{
_isOnline = isOnline;
}
// Update the characters table of the database with online status and lastAccess (called when login and logout)
updateOnlineStatus();
}
/**
* Sets the checks if is in7s dungeon.
*
* @param isIn7sDungeon the new checks if is in7s dungeon
*/
public void setIsIn7sDungeon(boolean isIn7sDungeon)
{
if(_isIn7sDungeon != isIn7sDungeon)
{
_isIn7sDungeon = isIn7sDungeon;
}
updateIsIn7sDungeonStatus();
}
/**
* Update the characters table of the database with online status and lastAccess of this L2PcInstance (called when
* login and logout).<BR>
* <BR>
*/
public void updateOnlineStatus()
{
Connection con = null;
_log.warning("could not set char isIn7sDungeon status:" + e);
}
finally
{
CloseUtil.close(con);
}
}
/**
* Update first log.
*/
public void updateFirstLog()
{
Connection con = null;
try
{
con = L2DatabaseFactory.getInstance().getConnection(fals e);
PreparedStatement statement = con.prepareStatement("UPDATE characters SET first_log=? WHERE obj_id=?");
_log.warning("could not set char first login:" + e);
}
finally
{
CloseUtil.close(con);
con = null;
}
}
/**
* Create a new player in the characters table of the database.<BR>
* <BR>
*
* @return true, if successful
*/
private boolean createDb()
{
boolean output = false;
_log.severe("Could not insert char data: " + e);
}
finally
{
CloseUtil.close(con);
con = null;
}
if(output)
{
String text = "Created new character : " + getName() + " for account: " + _accountName;
Log.add(text, "New_chars");
}
return output;
}
/**
* 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
*/
private static L2PcInstance restore(int objectId)
{
L2PcInstance player = null;
double curHp = 0;
double curCp = 0;
double curMp = 0;
Connection con = null;
try
{
// Retrieve the L2PcInstance from the characters table of the database
con = L2DatabaseFactory.getInstance().getConnection(fals e);
// 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();
}
}
}
if(player.getClassIndex() == 0 && activeClassId != player.getBaseClass())
{
// Subclass in use but doesn't exist in DB -
// a possible restart-while-modifysubclass cheat has been attempted.
// Switching to use base class
player.setClassId(player.getBaseClass());
_log.warning("Player " + player.getName() + " reverted to base class. Possibly has tried a relogin exploit while subclassing.");
}
else
{
player._activeClass = activeClassId;
}
player.setDeathPenaltyBuffLevel(rset.getInt("death _penalty_level"));
player.setAio(rset.getInt("aio") == 1 ? true : false);
player.setAioEndTime(rset.getLong("aio_end"));
// Add the L2PcInstance object in _allObjects
//L2World.getInstance().storeObject(player);
// Set the x,y,z position of the L2PcInstance and make it invisible
player.setXYZInvisible(rset.getInt("x"), rset.getInt("y"), rset.getInt("z"));
// 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();
// 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();
// Restore pet if exists in the world
player.setPet(L2World.getInstance().getPet(player. getObjectId()));
if(player.getPet() != null)
{
player.getPet().setOwner(player);
}
// Update the overloaded status of the L2PcInstance
player.refreshOverloaded();
//once restored all the skill status, update current CP, MP and HP
player.setCurrentHpDirect(curHp);
player.setCurrentCpDirect(curCp);
player.setCurrentMpDirect(curMp);
//player.setCurrentCp(curCp);
//player.setCurrentMp(curMp);
}
return player;
}
/**
* Gets the mail.
*
* @return the mail
*/
public Forum getMail()
{
if(_forumMail == null)
{
setMail(ForumsBBSManager.getInstance().getForumByN ame("MailRoot").getChildByName(getName()));
/**
* Sets the memo.
*
* @param forum the new memo
*/
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
* @return true, if successful
*/
private static boolean restoreSubClassData(L2PcInstance player)
{
Connection con = null;
/**
* 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.
if(Config.ALT_RECOMMEND)
{
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 synchronized void storeRecipeBook()
{
// If the player is on a sub-class don't even attempt to store a recipe book.
if(isSubClassActive())
return;
/**
* Store.
* @param force the force
*/
public synchronized void store(boolean force)
{
// update client coords, if these look like true
if (!force && isInsideRadius(getClientX(), getClientY(), 1000, true))
{
setXYZ(getClientX(), getClientY(), getClientZ());
}
/**
* Update L2PcInstance stats in the characters table of the database.<BR>
* <BR>
*/
public synchronized void store()
{
store(false);
}
/**
* Store char base.
*/
private synchronized void storeCharBase()
{
Connection con = null;
try
{
// 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;
con = L2DatabaseFactory.getInstance().getConnection(fals e);
PreparedStatement statement;
// TODO allow different colors support to players store
// statement.setString(58, StringToHex(Integer.toHexString(getAppearance().ge tNameColor()).toUpperCase()));
// statement.setString(59, StringToHex(Integer.toHexString(getAppearance().ge tTitleColor()).toUpperCase()));
statement.execute();
statement.close();
statement = null;
}
}
}
catch(Exception e)
{
_log.warning("Could not store sub class data for " + getName() + ": " + e);
e.printStackTrace();
}
finally
{
CloseUtil.close(con);
}
}
@SuppressWarnings("null")
private synchronized void storeEffect()
{
if (!Config.STORE_SKILL_COOLTIME)
return;
Connection con = null;
try
{
con = L2DatabaseFactory.getInstance().getConnection(fals e);
PreparedStatement statement;
// Delete all current stored effects for char to avoid dupe
statement = con.prepareStatement(DELETE_SKILL_SAVE);
statement.setInt(1, getObjectId());
statement.setInt(2, getClassIndex());
statement.execute();
statement.close();
// Store all effect data along with calulated remaining
// reuse delays for matching skills. 'restore_type'= 0.
final L2Effect[] effects = getAllEffects();
statement = con.prepareStatement(ADD_SKILL_SAVE);
List<Integer> storedSkills = new FastList<Integer>();
int buff_index = 0;
for (L2Effect effect : effects)
{
int skillId = effect.getSkill().getId();
if (storedSkills.contains(skillId))
continue;
storedSkills.add(skillId);
if (effect != null && effect.getInUse() && !effect.getSkill().isToggle() && !effect.getStackType().equals("BattleForce") && !effect.getStackType().equals("SpellForce") && effect.getSkill().getSkillType() != SkillType.FORCE_BUFF)
{
statement.setInt(1, getObjectId());
statement.setInt(2, skillId);
statement.setInt(3, effect.getSkill().getLevel());
statement.setInt(4, effect.getCount());
statement.setInt(5, effect.getTime());
if (ReuseTimeStamps.containsKey(skillId))
{
TimeStamp t = ReuseTimeStamps.get(skillId);
statement.setLong(6, t.hasNotPassed() ? t.getReuse() : 0);
statement.setLong(7, t.hasNotPassed() ? t.getStamp() : 0);
}
else
{
statement.setLong(6, 0);
statement.setLong(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 (TimeStamp t : ReuseTimeStamps.values())
{
if (t.hasNotPassed())
{
int skillId = t.getSkill();
if (storedSkills.contains(skillId))
continue;
storedSkills.add(skillId);
/**
* Return True if the L2PcInstance is on line.<BR>
* <BR>
*
* @return the int
*/
public int isOnline()
{
return _isOnline ? 1 : 0;
}
/**
* Checks if is in7s dungeon.
*
* @return true, if is in7s dungeon
*/
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> */
private boolean _learningSkill = false;
/**
* Adds the skill.
*
* @param newSkill the new skill
* @param store the store
* @return the l2 skill
*/
public synchronized L2Skill addSkill(L2Skill newSkill, boolean store)
{
_learningSkill = true;
// 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);
}
_learningSkill = false;
return oldSkill;
}
/**
* Checks if is learning skill.
*
* @return true, if is learning skill
*/
public boolean isLearningSkill(){
return _learningSkill;
}
/**
* Removes the skill.
*
* @param skill the skill
* @param store the store
* @return the l2 skill
*/
public L2Skill removeSkill(L2Skill skill, boolean store)
{
if(store)
return removeSkill(skill);
return super.removeSkill(skill);
}
/**
* 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);
Connection con = null;
try
{
// Remove or update a L2PcInstance skill from the character_skills table of the database
con = L2DatabaseFactory.getInstance().getConnection(fals e);
PreparedStatement statement;
/**
* 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 the new skill
* @param oldSkill the old skill
* @param newClassIndex the new class index
*/
private void storeSkill(L2Skill newSkill, L2Skill oldSkill, int newClassIndex)
{
int classIndex = _classIndex;
_log.warning("Error could not store char skills: " + e);
}
finally
{
CloseUtil.close(con);
}
}
/**
* check player skills and remove unlegit ones (excludes hero, noblesse and cursed weapon skills).
*/
public void checkAllowedSkills()
{
boolean foundskill = false;
if(!isGM())
{
Collection<L2SkillLearn> skillTree = SkillTreeTable.getInstance().getAllowedSkills(getC lassId());
// loop through all skills of player
for(L2Skill skill : getAllSkills())
{
int skillid = skill.getId();
//int skilllevel = skill.getLevel();
foundskill = false;
// loop through all skills in players skilltree
for(L2SkillLearn temp : skillTree)
{
// if the skill was found and the level is possible to obtain for his class everything is ok
if(temp.getId() == skillid)
{
foundskill = true;
}
}
/**
* Retrieve from the database all skills of this L2PcInstance and add them to _skills.<BR>
* <BR>
*/
public synchronized void restoreSkills()
{
Connection con = null;
try
{
if(!Config.KEEP_SUBCLASS_SKILLS)
{
// Retrieve all skills of this L2PcInstance from the database
con = L2DatabaseFactory.getInstance().getConnection(fals e);
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();
rset = null;
statement = null;
}
else
{
// Retrieve all skills of this L2PcInstance from the database
con = L2DatabaseFactory.getInstance().getConnection(fals e);
PreparedStatement statement = con.prepareStatement(RESTORE_SKILLS_FOR_CHAR_ALT_S UBCLASS);
statement.setInt(1, getObjectId());
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);
}
_log.warning("Could not restore character skills: " + e);
}
finally
{
CloseUtil.close(con);
con = null;
}
}
public void restoreEffects()
{
restoreEffects(true);
}
/**
* Retrieve from the database all skill effects of this L2PcInstance and add them to the player.<BR>
* <BR>
* @param activateEffects
*/
public void restoreEffects(boolean activateEffects)
{
Connection con = null;
try
{
con = L2DatabaseFactory.getInstance().getConnection(fals e);
PreparedStatement statement;
ResultSet rset;
/**
* Restore Type 0 These skill were still in effect on the character upon logout. Some of which were self
* casted and might still have had a long reuse delay which also is restored.
*/
statement = con.prepareStatement(RESTORE_SKILL_SAVE);
statement.setInt(1, getObjectId());
statement.setInt(2, getClassIndex());
statement.setInt(3, 0);
rset = statement.executeQuery();
while(rset.next())
{
int skillId = rset.getInt("skill_id");
int skillLvl = rset.getInt("skill_level");
int effectCount = rset.getInt("effect_count");
int effectCurTime = rset.getInt("effect_cur_time");
long reuseDelay = rset.getLong("reuse_delay");
// Just incase the admin minipulated this table incorrectly :x
if(skillId == -1 || effectCount == -1 || effectCurTime == -1 || reuseDelay < 0)
{
continue;
}
/**
* Restore Type 1 The remaning skills lost effect upon logout but were still under a high reuse delay.
*/
statement = con.prepareStatement(RESTORE_SKILL_SAVE);
statement.setInt(1, getObjectId());
statement.setInt(2, getClassIndex());
statement.setInt(3, 1);
rset = statement.executeQuery();
while(rset.next())
{
int skillId = rset.getInt("skill_id");
long reuseDelay = rset.getLong("reuse_delay");
_log.warning("Could not restore active effect data: " + e);
}
finally
{
CloseUtil.close(con);
}
updateEffectIcons();
}
/**
* Retrieve from the database all Henna of this L2PcInstance, add them to _henna and calculate stats of the
* L2PcInstance.<BR>
* <BR>
*/
private void restoreHenna()
{
Connection con = null;
// 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.<BR>
* <BR>
*/
private void restoreRecom()
{
Connection con = null;
_log.warning("could not restore recommendations: " + e);
}
finally
{
CloseUtil.close(con);
con = null;
}
}
/**
* Return the number of Henna empty slot of the L2PcInstance.<BR>
* <BR>
*
* @return the henna empty slots
*/
public int getHennaEmptySlots()
{
int totalSlots = 1 + getClassId().level();
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.<BR>
* <BR>
*
* @param slot the slot
* @return true, if successful
*/
public boolean removeHenna(int slot)
{
if(slot < 1 || slot > 3)
return false;
_log.warning("could not remove char henna: " + e);
}
finally
{
CloseUtil.close(con);
con = null;
}
// 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));
// Add the recovered dyes to the player's inventory and notify them.
getInventory().addItem("Henna", henna.getItemIdDye(), henna.getAmountDyeRequire() / 2, this, null);
SystemMessage sm = new SystemMessage(SystemMessageId.EARNED_S2_S1_S);
sm.addItemName(henna.getItemIdDye());
sm.addNumber(henna.getAmountDyeRequire() / 2);
sendPacket(sm);
sm = null;
henna = null;
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.<BR>
* <BR>
*
* @param henna the henna
* @return true, if successful
*/
public boolean addHenna(L2HennaInstance henna)
{
if(getHennaEmptySlots() == 0)
{
sendMessage("You may not have more than three equipped symbols at a time.");
return false;
}
// int slot = 0;
for(int i = 0; i < 3; i++)
{
if(_henna[i] == null)
{
_henna[i] = henna;
// Calculate Henna modifiers of this L2PcInstance
recalcHennaStats();
/**
* Return the Henna of this L2PcInstance corresponding to the selected slot.<BR>
* <BR>
*
* @param slot the slot
* @return the hennas
*/
public L2HennaInstance getHennas(int slot)
{
if(slot < 1 || slot > 3)
return null;
return _henna[slot - 1];
}
/**
* Return the INT Henna modifier of this L2PcInstance.<BR>
* <BR>
*
* @return the henna stat int
*/
public int getHennaStatINT()
{
return _hennaINT;
}
/**
* Return the STR Henna modifier of this L2PcInstance.<BR>
* <BR>
*
* @return the henna stat str
*/
public int getHennaStatSTR()
{
return _hennaSTR;
}
/**
* Return the CON Henna modifier of this L2PcInstance.<BR>
* <BR>
*
* @return the henna stat con
*/
public int getHennaStatCON()
{
return _hennaCON;
}
/**
* Return the MEN Henna modifier of this L2PcInstance.<BR>
* <BR>
*
* @return the henna stat men
*/
public int getHennaStatMEN()
{
return _hennaMEN;
}
/**
* Return the WIT Henna modifier of this L2PcInstance.<BR>
* <BR>
*
* @return the henna stat wit
*/
public int getHennaStatWIT()
{
return _hennaWIT;
}
/**
* Return the DEX Henna modifier of this L2PcInstance.<BR>
* <BR>
*
* @return the henna stat dex
*/
public int getHennaStatDEX()
{
return _hennaDEX;
}
/**
* Return True if the L2PcInstance is autoAttackable.<BR>
* <BR>
* <B><U> Actions</U> :</B><BR>
* <BR>
* <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> <BR>
* <BR>
* @param attacker the attacker
* @return true, if is auto attackable
*/
@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, excluding duels like L2OFF
if (getParty() != null && getParty().getPartyMembers().contains(attacker) && !(getDuelState() == Duel.DUELSTATE_DUELLING && getDuelId() == ((L2PcInstance) attacker).getDuelId()))
return false;
// Check if the attacker is in olympia and olympia start
if (attacker instanceof L2PcInstance && ((L2PcInstance) attacker).isInOlympiadMode())
{
if (isInOlympiadMode() && isOlympiadStart() && ((L2PcInstance) attacker).getOlympiadGameId() == getOlympiadGameId())
{
if (isFakeDeath())
return false;
return true;
}
return false;
}
// Check if the attacker is not in the same clan, excluding duels like L2OFF
if (getClan() != null && attacker != null && getClan().isMember(attacker.getName()) && !(getDuelState() == Duel.DUELSTATE_DUELLING && getDuelId() == ((L2PcInstance) attacker).getDuelId()))
return false;
if (attacker instanceof L2PlayableInstance && isInFunEvent())
{
L2PcInstance player = null;
if (attacker instanceof L2PcInstance)
{
player = (L2PcInstance) attacker;
}
else if (attacker instanceof L2Summon)
{
player = ((L2Summon) attacker).getOwner();
}
if (L2Character.isInsidePeaceZone(attacker, this))
{
return false;
}
// Check if the L2PcInstance has Karma
if (getKarma() > 0 || getPvpFlag() > 0)
return true;
// Check if the attacker is a L2PcInstance
if (attacker instanceof L2PcInstance)
{
// is AutoAttackable if both players are in the same duel and the duel is still going on
if (getDuelState() == Duel.DUELSTATE_DUELLING && getDuelId() == ((L2PcInstance) attacker).getDuelId())
return true;
// Check if the L2PcInstance is in an arena or a siege area
if (isInsideZone(ZONE_PVP) && ((L2PcInstance) attacker).isInsideZone(ZONE_PVP))
return true;
if (getClan() != null)
{
Siege siege = SiegeManager.getInstance().getSiege(getX(), getY(), getZ());
FortSiege fortsiege = FortSiegeManager.getInstance().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(((L2PcInstance) attacker).getClan()) && siege.checkIsDefender(getClan()))
{
siege = null;
return false;
}
// Check if a siege is in progress and if attacker and the L2PcInstance aren't in the Attacker clan
if (siege.checkIsAttacker(((L2PcInstance) attacker).getClan()) && siege.checkIsAttacker(getClan()))
{
siege = null;
return false;
}
}
if (fortsiege != null)
{
// Check if a siege is in progress and if attacker and the L2PcInstance aren't in the Defender clan
if (fortsiege.checkIsDefender(((L2PcInstance) attacker).getClan()) && fortsiege.checkIsDefender(getClan()))
{
fortsiege = null;
return false;
}
// Check if a siege is in progress and if attacker and the L2PcInstance aren't in the Attacker clan
if (fortsiege.checkIsAttacker(((L2PcInstance) attacker).getClan()) && fortsiege.checkIsAttacker(getClan()))
{
fortsiege = null;
return false;
}
}
// Check if clan is at war
if (getClan() != null && ((L2PcInstance) attacker).getClan() != null && getClan().isAtWarWith(((L2PcInstance) attacker).getClanId()) && getWantsPeace() == 0 && ((L2PcInstance) attacker).getWantsPeace() == 0 && !isAcademyMember())
return true;
}
/**
* 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 AI_INTENTION_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
*/
public void useMagic(L2Skill skill, boolean forceUse, boolean dontMove)
{
if(isDead())
{
abortCast();
sendPacket(ActionFailed.STATIC_PACKET);
return;
}
// Check if the caster is sitting
if(isSitting() && !skill.isPotion())
{
// Send a System Message to the caster
sendPacket(new SystemMessage(SystemMessageId.CANT_MOVE_SITTING));
// Send a Server->Client packet ActionFailed to the L2PcInstance
sendPacket(ActionFailed.STATIC_PACKET);
return;
}
// Check if the skill type is TOGGLE
if(skill.isToggle())
{
// Like L2OFF you can't use fake death if you are mounted
if (skill.getId() == 60 && isMounted())
return;
// Get effects of the skill
L2Effect effect = getFirstEffect(skill);
// Like L2OFF toogle skills have little delay
if(TOGGLE_USE + 400 > System.currentTimeMillis())
{
return;
}
if(effect != null)
{
//fake death exception
if (skill.getId() != 60)
effect.exit(false);
// Send a Server->Client packet ActionFailed to the L2PcInstance
sendPacket(ActionFailed.STATIC_PACKET);
return;
}
TOGGLE_USE = System.currentTimeMillis();
}
// Check if the skill is active
if(skill.isPassive())
{
// just ignore the passive skill request. why does the client send it anyway ??
// Send a Server->Client packet ActionFailed to the L2PcInstance
sendPacket(ActionFailed.STATIC_PACKET);
return;
}
if(_disabledSkills != null && _disabledSkills.contains(skill_id))
{
SystemMessage sm = new SystemMessage(SystemMessageId.S1_PREPARED_FOR_REUS E);
sm.addSkillName(skill_id, skill.getLevel());
sendPacket(sm);
sm = null;
return;
}
//************************************* Check Casting in Progress *******************************************
// If a skill is currently being used, queue this one if this is not the same
// Note that this check is currently imperfect: getCurrentSkill() isn't always null when a skill has
// failed to cast, or the casting is not yet in progress when this is rechecked
if(curr_skill_id != -1 && (isCastingNow() || isCastingPotionNow()))
{
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;
}
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;
}
// Create a new SkillDat object and set the player _currentSkill
// This is used mainly to save & queue the button presses, since L2Character has
// _lastSkillCast which could otherwise replace it
setCurrentSkill(skill, forceUse, dontMove);
if (getQueuedSkill() != null) // wiping out previous values, after casting has been aborted
setQueuedSkill(null, false, false);
//triggered skills cannot be used directly
if(_triggeredSkills.size()>0){
if(Config.DEBUG){
System.out.println("Checking if Triggherable Skill: "+skill.getId());
System.out.println("Saved Triggherable Skills");
//************************************* Check Target *******************************************
// Create and set a L2Object containing the target of the skill
L2Object target = null;
SkillTargetType sklTargetType = skill.getTargetType();
SkillType sklType = skill.getSkillType();
switch(sklTargetType)
{
// Target the player if skill type is AURA, PARTY, CLAN or SELF
case TARGET_AURA:
if(isInOlympiadMode() && !isOlympiadStart())
setTarget(this);
case TARGET_PARTY:
case TARGET_ALLY:
case TARGET_CLAN:
case TARGET_GROUND:
case TARGET_SELF:
target = this;
break;
case TARGET_PET:
target = getPet();
break;
default:
target = getTarget();
break;
}
// Check the validity of the target
if(target == null)
{
sendPacket(new SystemMessage(SystemMessageId.TARGET_CANT_FOUND));
sendPacket(ActionFailed.STATIC_PACKET);
return;
}
// skills can be used on Walls and Doors only durring siege
// Ignore skill UNLOCK
if(skill.isOffensive() && target instanceof L2DoorInstance )
{
boolean isCastle = (((L2DoorInstance) target).getCastle() != null
&& ((L2DoorInstance) target).getCastle().getCastleId() > 0
&& ((L2DoorInstance) target).getCastle().getSiege().getIsInProgress());
boolean isFort = (((L2DoorInstance) target).getFort() != null
&& ((L2DoorInstance) target).getFort().getFortId() > 0
&& ((L2DoorInstance) target).getFort().getSiege().getIsInProgress());
if ((!isCastle && !isFort))
return;
}
// Like L2OFF you can't heal random purple people without using CTRL
SkillDat skilldat = getCurrentSkill();
if (skilldat != null && skill.getSkillType() == SkillType.HEAL && !skilldat.isCtrlPressed() && target instanceof L2PcInstance && ((L2PcInstance) target).getPvpFlag() == 1 && this != target)
{
if ((getClanId() == 0 || ((L2PcInstance) target).getClanId() == 0) || (getClanId() != ((L2PcInstance) target).getClanId()))
{
if ((getAllyId() == 0 || ((L2PcInstance) target).getAllyId() == 0) || (getAllyId() != ((L2PcInstance) target).getAllyId()))
{
if ((getParty() == null || ((L2PcInstance) target).getParty() == null) || (!getParty().equals(((L2PcInstance) target).getParty())))
{
sendPacket(new SystemMessage(SystemMessageId.INCORRECT_TARGET));
sendPacket(ActionFailed.STATIC_PACKET);
return;
}
}
}
}
// Are the target and the player in the same duel?
if(isInDuel())
{
if(!(target instanceof L2PcInstance && ((L2PcInstance) target).getDuelId() == getDuelId()) && !(target instanceof L2SummonInstance && ((L2Summon) target).getOwner().getDuelId() == getDuelId()))
{
sendMessage("You cannot do this while duelling.");
sendPacket(ActionFailed.STATIC_PACKET);
return;
}
}
// Check if this skill is enabled (ex : reuse time)
if(isSkillDisabled(skill_id) /* && !getAccessLevel().allowPeaceAttack() */)
{
// SystemMessage sm = new SystemMessage(SystemMessageId.SKILL_NOT_AVAILABLE) ;
// sm.addString(skill.getName());
// sendPacket(sm);
// Send a Server->Client packet ActionFailed to the L2PcInstance
sendPacket(ActionFailed.STATIC_PACKET);
return;
}
// Check if all skills are disabled
if(isAllSkillsDisabled() && !getAccessLevel().allowPeaceAttack())
{
// Send a Server->Client packet ActionFailed to the L2PcInstance
sendPacket(ActionFailed.STATIC_PACKET);
return;
}
// prevent casting signets to peace zone
if(skill.getSkillType() == SkillType.SIGNET || skill.getSkillType() == SkillType.SIGNET_CASTTIME)
{
if(isInsidePeaceZone(this))
{
SystemMessage sm = new SystemMessage(SystemMessageId.S1_CANNOT_BE_USED);
sm.addSkillName(skill_id);
sendPacket(sm);
return;
}
}
//************************************* Check Consumables *******************************************
// Check if the caster has enough MP
if(getCurrentMp() < getStat().getMpConsume(skill) + getStat().getMpInitialConsume(skill))
{
// Send a System Message to the caster
sendPacket(new SystemMessage(SystemMessageId.NOT_ENOUGH_MP));
// Send a Server->Client packet ActionFailed to the L2PcInstance
sendPacket(ActionFailed.STATIC_PACKET);
return;
}
// Check if the caster has enough HP
if(getCurrentHp() <= skill.getHpConsume())
{
// Send a System Message to the caster
sendPacket(new SystemMessage(SystemMessageId.NOT_ENOUGH_HP));
// Send a Server->Client packet ActionFailed to the L2PcInstance
sendPacket(ActionFailed.STATIC_PACKET);
return;
}
// Check if the spell consummes an Item
if(skill.getItemConsume() > 0)
{
// Get the L2ItemInstance consummed by the spell
L2ItemInstance requiredItems = getInventory().getItemByItemId(skill.getItemConsum eId());
// Check if the caster owns enought consummed Item to cast
if(requiredItems == null || requiredItems.getCount() < skill.getItemConsume())
{
// Checked: when a summon skill failed, server show required consume item count
if(sklType == L2Skill.SkillType.SUMMON)
{
SystemMessage sm = new SystemMessage(SystemMessageId.SUMMONING_SERVITOR_C OSTS_S2_S1);
sm.addItemName(skill.getItemConsumeId());
sm.addNumber(skill.getItemConsume());
sendPacket(sm);
}
else
{
// Send a System Message to the caster
sendPacket(new SystemMessage(SystemMessageId.NOT_ENOUGH_ITEMS));
}
return;
}
}
// Like L2OFF if you are mounted on wyvern you can't use own skills
if (isFlying())
{
if (skill_id != 327 && skill_id != 4289 && !skill.isPotion())
{
sendMessage("You cannot use skills while riding a wyvern.");
return;
}
}
// Like L2OFF if you have a summon you can't summon another one (ignore cubics)
if(sklType == L2Skill.SkillType.SUMMON && skill instanceof L2SkillSummon && !((L2SkillSummon) skill).isCubic())
{
if (getPet() != null || isMounted())
{
sendPacket(new SystemMessage(SystemMessageId.YOU_ALREADY_HAVE_A_P ET));
return;
}
}
// Check if the caster own the weapon needed
if(!skill.getWeaponDependancy(this))
{
// Send a Server->Client packet ActionFailed to the L2PcInstance
sendPacket(ActionFailed.STATIC_PACKET);
return;
}
// Check if all casting conditions are completed
if(!skill.checkCondition(this, target, false))
{
// Send a Server->Client packet ActionFailed to the L2PcInstance
sendPacket(ActionFailed.STATIC_PACKET);
return;
}
//************************************* Check Player State *******************************************
// Abnormal effects(ex : Stun, Sleep...) are checked in L2Character useMagic()
// Check if the player use "Fake Death" skill
if(isAlikeDead() && !skill.isPotion() && skill.getSkillType() != L2Skill.SkillType.FAKE_DEATH)
{
// Send a Server->Client packet ActionFailed to the L2PcInstance
sendPacket(ActionFailed.STATIC_PACKET);
return;
}
//************************************* Check Skill Type *******************************************
// Check if this is offensive magic skill
if(skill.isOffensive())
{
Boolean peace = isInsidePeaceZone(this, target);
if(peace
&& (skill.getId() != 3261 // Like L2OFF you can use cupid bow skills on peace zone
&& skill.getId() != 3260
&& skill.getId() != 3262 && sklTargetType != SkillTargetType.TARGET_AURA)) // Like L2OFF people can use TARGET_AURE skills on peace zone
{
// If L2Character or target is in a peace zone, send a system message TARGET_IN_PEACEZONE a Server->Client packet ActionFailed
sendPacket(new SystemMessage(SystemMessageId.TARGET_IN_PEACEZONE) );
sendPacket(ActionFailed.STATIC_PACKET);
return;
}
if(isInOlympiadMode() && !isOlympiadStart() && sklTargetType != SkillTargetType.TARGET_AURA)
{
// if L2PcInstance is in Olympia and the match isn't already start, send a Server->Client packet ActionFailed
sendPacket(ActionFailed.STATIC_PACKET);
return;
}
{
// Send a Server->Client packet ActionFailed to the L2PcInstance
sendPacket(ActionFailed.STATIC_PACKET);
return;
}
// 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(getCurrentSkillWorldPosition().ge tX(), getCurrentSkillWorldPosition().getY(), getCurrentSkillWorldPosition().getZ(), (int) (skill.getCastRange() + getTemplate().getCollisionRadius()), false, false))
{
// Send a System Message to the caster
sendPacket(SystemMessageId.TARGET_TOO_FAR);
// Send a Server->Client packet ActionFailed to the L2PcInstance
sendPacket(ActionFailed.STATIC_PACKET);
return;
}
}
else if (skill.getCastRange() > 0 && !isInsideRadius(target, skill.getCastRange() + getTemplate().collisionRadius, false, false)) // Calculate the distance between the L2PcInstance and the target
{
// Send a System Message to the caster
sendPacket(new SystemMessage(SystemMessageId.TARGET_TOO_FAR));
// Send a Server->Client packet ActionFailed to the L2PcInstance
sendPacket(ActionFailed.STATIC_PACKET);
return;
}
}
else if (sklType == SkillType.SIGNET) // Check range for SIGNET skills
{
if (!isInsideRadius(getCurrentSkillWorldPosition().ge tX(), getCurrentSkillWorldPosition().getY(), getCurrentSkillWorldPosition().getZ(), (int) (skill.getCastRange() + getTemplate().getCollisionRadius()), false, false))
{
// Send a System Message to the caster
sendPacket(SystemMessageId.TARGET_TOO_FAR);
// Send a Server->Client packet ActionFailed to the L2PcInstance
sendPacket(ActionFailed.STATIC_PACKET);
return;
}
}
}
// Check if the skill is defensive
if(!skill.isOffensive())
{
// check if the target is a monster and if force attack is set.. if not then we don't want to cast.
if(target instanceof L2MonsterInstance && !forceUse && sklTargetType != SkillTargetType.TARGET_PET && sklTargetType != SkillTargetType.TARGET_AURA && sklTargetType != SkillTargetType.TARGET_CLAN && sklTargetType != SkillTargetType.TARGET_SELF && sklTargetType != SkillTargetType.TARGET_PARTY && sklTargetType != SkillTargetType.TARGET_ALLY && sklTargetType != SkillTargetType.TARGET_CORPSE_MOB && sklTargetType != SkillTargetType.TARGET_AREA_CORPSE_MOB && sklTargetType != SkillTargetType.TARGET_GROUND && sklType != SkillType.BEAST_FEED && sklType != SkillType.DELUXE_KEY_UNLOCK && sklType != SkillType.UNLOCK)
{
// send the action failed so that the skill doens't go off.
sendPacket(ActionFailed.STATIC_PACKET);
return;
}
}
// Check if the skill is Spoil type and if the target isn't already spoiled
if(sklType == SkillType.SPOIL)
{
if(!(target instanceof L2MonsterInstance))
{
// Send a System Message to the L2PcInstance
sendPacket(new SystemMessage(SystemMessageId.TARGET_IS_INCORRECT) );
// Send a Server->Client packet ActionFailed to the L2PcInstance
sendPacket(ActionFailed.STATIC_PACKET);
return;
}
}
// Check if the skill is Sweep type and if conditions not apply
if(sklType == SkillType.SWEEP && target instanceof L2Attackable)
{
int spoilerId = ((L2Attackable) target).getIsSpoiledBy();
if(((L2Attackable) target).isDead())
{
if(!((L2Attackable) target).isSpoil())
{
// Send a System Message to the L2PcInstance
sendPacket(new SystemMessage(SystemMessageId.SWEEPER_FAILED_TARGE T_NOT_SPOILED));
// Send a Server->Client packet ActionFailed to the L2PcInstance
sendPacket(ActionFailed.STATIC_PACKET);
return;
}
if(getObjectId() != spoilerId && !isInLooterParty(spoilerId))
{
// Send a System Message to the L2PcInstance
sendPacket(new SystemMessage(SystemMessageId.SWEEP_NOT_ALLOWED));
// Send a Server->Client packet ActionFailed to the L2PcInstance
sendPacket(ActionFailed.STATIC_PACKET);
return;
}
}
}
// Check if the skill is Drain Soul (Soul Crystals) and if the target is a MOB
if(sklType == SkillType.DRAIN_SOUL)
{
if(!(target instanceof L2MonsterInstance))
{
// Send a System Message to the L2PcInstance
sendPacket(new SystemMessage(SystemMessageId.TARGET_IS_INCORRECT) );
// Send a Server->Client packet ActionFailed to the L2PcInstance
sendPacket(ActionFailed.STATIC_PACKET);
return;
}
}
final Point3D worldPosition = getCurrentSkillWorldPosition();
// 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_SELF:
case TARGET_GROUND:
break;
default:
//if pvp skill is not allowed for given target
if(!checkPvpSkill(target, skill) && !getAccessLevel().allowPeaceAttack() && (skill.getId() != 3261 && skill.getId() != 3260 && skill.getId() != 3262))
{
// Send a System Message to the L2PcInstance
sendPacket(new SystemMessage(SystemMessageId.TARGET_IS_INCORRECT) );
// Send a Server->Client packet ActionFailed to the L2PcInstance
sendPacket(ActionFailed.STATIC_PACKET);
return;
}
}
// GeoData Los Check here
if(skill.getCastRange() > 0 && !GeoData.getInstance().canSeeTarget(this, target))
{
sendPacket(new SystemMessage(SystemMessageId.CANT_SEE_TARGET));
sendPacket(ActionFailed.STATIC_PACKET);
return;
}
// If all conditions are checked, create a new SkillDat object and set the player _currentSkill
setCurrentSkill(skill, forceUse, dontMove);
// Check if the active L2Skill can be casted (ex : not sleeping...), Check if the target is correct and Notify the AI with AI_INTENTION_CAST and target
super.useMagic(skill);
}
/**
* Checks if is in looter party.
* @param LooterId the looter id
* @return true, if is in looter party
*/
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().contai ns(looter);
if (isInParty() && looter != null)
return getParty().getPartyMembers().contains(looter);
// check for PC->PC Pvp status
if(character != this && // target is not self and
!(isInDuel() && character.getDuelId() == getDuelId()) && // self is not in a duel and attacking opponent
!isInsideZone(ZONE_PVP) && // Pc is not in PvP zone
!character.isInsideZone(ZONE_PVP) // target is not in PvP zone
)
{
if(skill.isPvpSkill()) // pvp skill
{
if(getClan() != null && character.getClan() != null)
{
if(getClan().isAtWarWith(character.getClan().getCl anId()) && character.getClan().isAtWarWith(getClan().getClanI d()))
return true; // in clan war player can attack whites even with sleep etc.
}
if(character.getPvpFlag() == 0 && // target's pvp flag is not set and
character.getKarma() == 0 // target has no karma
)
return false;
}
else if(getCurrentSkill() != null && !getCurrentSkill().isCtrlPressed() && skill.isOffensive())
{
if(getClan() != null && character.getClan() != null)
{
if(getClan().isAtWarWith(character.getClan().getCl anId()) && character.getClan().isAtWarWith(getClan().getClanI d()))
return true; // in clan war player can attack whites even without ctrl
}
if(character.getPvpFlag() == 0 && // target's pvp flag is not set and
character.getKarma() == 0 // target has no karma
)
return false;
}
}
}
return true;
}
*/
/**
* 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)
{
if ((_inEventTvT && TvT.is_started()) || (_inEventDM && DM.is_started()) || (_inEventCTF && CTF.is_started()) || (_inEventVIP && VIP._started))
return true;
// check for PC->PC Pvp status
if (target instanceof L2Summon)
target = ((L2Summon) target).getOwner();
if (target != null && // target not null and
target != this && // target is not self and
target instanceof L2PcInstance && // target is L2PcInstance and
!(isInDuel() && ((L2PcInstance) target).getDuelId() == getDuelId()) && // self is not in a duel and attacking opponent
!isInsideZone(ZONE_PVP) && // Pc is not in PvP zone
!((L2PcInstance) target).isInsideZone(ZONE_PVP) // target is not in PvP zone
)
{
SkillDat skilldat = getCurrentSkill();
// SkillDat skilldatpet = getCurrentPetSkill();
if (skill.isPvpSkill()) // pvp skill
{
if (getClan() != null && ((L2PcInstance) target).getClan() != null)
{
if (getClan().isAtWarWith(((L2PcInstance) target).getClan().getClanId()) && ((L2PcInstance) target).getClan().isAtWarWith(getClan().getClanId( )))
return true; // in clan war player can attack whites even with sleep etc.
}
if (((L2PcInstance) target).getPvpFlag() == 0 && // target's pvp flag is not set and
((L2PcInstance) target).getKarma() == 0 // target has no karma
)
return false;
}
else if ((skilldat != null && !skilldat.isCtrlPressed() && skill.isOffensive() && !srcIsSummon)
/* || (skilldatpet != null && !skilldatpet.isCtrlPressed() && skill.isOffensive() && srcIsSummon) */)
{
if (getClan() != null && ((L2PcInstance) target).getClan() != null)
{
if (getClan().isAtWarWith(((L2PcInstance) target).getClan().getClanId()) && ((L2PcInstance) target).getClan().isAtWarWith(getClan().getClanId( )))
return true; // in clan war player can attack whites even without ctrl
}
if (((L2PcInstance) target).getPvpFlag() == 0 && // target's pvp flag is not set and
((L2PcInstance) target).getKarma() == 0 // target has no karma
)
return false;
}
}
return true;
}
/**
* Reduce Item quantity of the L2PcInstance Inventory and send it a Server->Client packet InventoryUpdate.<BR>
* <BR>
*
* @param itemConsumeId the item consume id
* @param itemCount the item count
*/
@Override
public void consumeItem(int itemConsumeId, int itemCount)
{
if(itemConsumeId != 0 && itemCount != 0)
{
destroyItemByItemId("Consume", itemConsumeId, itemCount, null, true);
}
}
/**
* Return True if the L2PcInstance is a Mage.<BR>
* <BR>
*
* @return true, if is mage class
*/
public boolean isMageClass()
{
return getClassId().isMage();
}
/**
* Checks if is mounted.
*
* @return true, if is mounted
*/
public boolean isMounted()
{
return _mountType > 0;
}
/**
* Set the type of Pet mounted (0 : none, 1 : Stridder, 2 : Wyvern) and send a Server->Client packet InventoryUpdate
* to the L2PcInstance.<BR>
* <BR>
*
* @return true, if successful
*/
public boolean checkLandingState()
{
// Check if char is in a no landing zone
if(isInsideZone(ZONE_NOLANDING))
return true;
else
// if this is a castle that is currently being sieged, and the rider is NOT a castle owner
// he cannot land.
// castle owner is the leader of the clan that owns the castle where the pc is
if(isInsideZone(ZONE_SIEGE) && !(getClan() != null && CastleManager.getInstance().getCastle(this) == CastleManager.getInstance().getCastleByOwner(getCl an()) && this == getClan().getLeader().getPlayerInstance()))
return true;
return false;
}
// returns false if the change of mount type fails.
/**
* Sets the mount type.
*
* @param mountType the mount type
* @return true, if successful
*/
public boolean setMountType(int mountType)
{
if(checkLandingState() && mountType == 2)
return false;
switch(mountType)
{
case 0:
setIsFlying(false);
setIsRiding(false);
break; //Dismounted
case 1:
setIsRiding(true);
if(isNoble())
{
L2Skill striderAssaultSkill = SkillTable.getInstance().getInfo(325, 1);
addSkill(striderAssaultSkill, false); // not saved to DB
}
break;
case 2:
setIsFlying(true);
break; //Flying Wyvern
}
_mountType = mountType;
// Send a Server->Client packet InventoryUpdate to the L2PcInstance in order to update speed
UserInfo ui = new UserInfo(this);
sendPacket(ui);
ui = null;
return true;
}
/**
* Return the type of Pet mounted (0 : none, 1 : Stridder, 2 : Wyvern).<BR>
* <BR>
*
* @return the mount type
*/
public int getMountType()
{
return _mountType;
}
/**
* Send a Server->Client packet 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 a Server->Client packet UserInfo to this L2PcInstance (Public and Private Data)</li> <li>Send a
* Server->Client packet 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.<BR>
* <BR>
*/
public void tempInvetoryDisable()
{
_inventoryDisable = true;
ThreadPoolManager.getInstance().scheduleGeneral(ne w InventoryEnable(), 1500);
}
/**
* Return True if the Inventory is disabled.<BR>
* <BR>
*
* @return true, if is invetory disabled
*/
public boolean isInvetoryDisabled()
{
return _inventoryDisable;
}
/**
* The Class InventoryEnable.
*/
class InventoryEnable implements Runnable
{
/**
* Gets the cubics.
* @return the cubics
*/
public Map<Integer, L2CubicInstance> getCubics()
{
synchronized (_cubics)
{
// clean cubics instances
Set<Integer> cubicsIds = _cubics.keySet();
for (Integer id : cubicsIds)
{
if (id == null || _cubics.get(id) == null)
try
{
_cubics.remove(id);
}
catch (NullPointerException e)
{
// FIXME: tried to remove a null key, to be found where this action has been performed (DEGUB)
}
}
return _cubics;
}
}
/**
* Add a L2CubicInstance to the L2PcInstance _cubics.<BR>
* <BR>
*
* @param id the id
* @param level the level
* @param matk the matk
* @param activationtime the activationtime
* @param activationchance the activationchance
* @param totalLifetime the total lifetime
* @param givenByOther the given by other
*/
/*public void addCubic(int id, int level, double d)
{
L2CubicInstance cubic = new L2CubicInstance(this, id, level,d);
_cubics.put(id, cubic);
cubic = null;
}*/
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);
synchronized(_cubics){
_cubics.put(id, cubic);
}
}
/**
* Remove a L2CubicInstance from the L2PcInstance _cubics.<BR>
* <BR>
*
* @param id the id
*/
public void delCubic(int id)
{
synchronized(_cubics){
_cubics.remove(id);
}
}
/**
* Return the L2CubicInstance corresponding to the Identifier of the L2PcInstance _cubics.<BR>
* <BR>
*
* @param id the id
* @return the cubic
*/
public L2CubicInstance getCubic(int id)
{
synchronized(_cubics){
return _cubics.get(id);
}
/**
* Return the modifier corresponding to the Enchant Effect of the Active Weapon (Min : 127).<BR>
* <BR>
*
* @return the enchant effect
*/
public int getEnchantEffect()
{
L2ItemInstance wpn = getActiveWeaponInstance();
if(wpn == null)
return 0;
return Math.min(127, wpn.getEnchantLevel());
}
/**
* Set the _lastFolkNpc of the L2PcInstance corresponding to the last Folk wich one the player talked.<BR>
* <BR>
*
* @param folkNpc the new last folk npc
*/
public void setLastFolkNPC(L2FolkInstance folkNpc)
{
_lastFolkNpc = folkNpc;
}
/**
* Return the _lastFolkNpc of the L2PcInstance corresponding to the last Folk wich one the player talked.<BR>
* <BR>
*
* @return the last folk npc
*/
public L2FolkInstance getLastFolkNPC()
{
return _lastFolkNpc;
}
/**
* Set the Silent Moving mode Flag.<BR>
* <BR>
* @param flag the new silent moving
*/
public void setSilentMoving(boolean flag)
{
if (flag)
_isSilentMoving++;
else
_isSilentMoving--;
}
/**
* Return True if the Silent Moving mode is active.<BR>
* <BR>
* @return true, if is silent moving
*/
public boolean isSilentMoving()
{
return _isSilentMoving > 0;
}
/**
* Return True if L2PcInstance is a participant in the Festival of Darkness.<BR>
* <BR>
*
* @return true, if is festival participant
*/
public boolean isFestivalParticipant()
{
return SevenSignsFestival.getInstance().isPlayerParticipa nt(this);
}
/**
* Adds the auto soul shot.
*
* @param itemId the item id
*/
public void addAutoSoulShot(int itemId)
{
_activeSoulShots.put(itemId, itemId);
}
/**
* Removes the auto soul shot.
*
* @param itemId the item id
*/
public void removeAutoSoulShot(int itemId)
{
_activeSoulShots.remove(itemId);
}
/**
* Gets the auto soul shot.
*
* @return the auto soul shot
*/
public Map<Integer, Integer> getAutoSoulShot()
{
return _activeSoulShots;
}
/**
* Recharge auto soul shot.
*
* @param physical the physical
* @param magic the magic
* @param summon the summon
*/
public void rechargeAutoSoulShot(boolean physical, boolean magic, boolean summon)
{
L2ItemInstance item;
IItemHandler handler;
/** The _task bot checker. */
private ScheduledFuture<?> _taskBotChecker;
/** The _task kick bot. */
protected ScheduledFuture<?> _taskKickBot;
/**
* The Class botChecker.
*/
class botChecker implements Runnable
{
/* (non-Javadoc)
* @see java.lang.Runnable#run()
*/
@Override
public void run()
{
/* Start bot checker if player is in combat online without shop and in a zone not peacefull */
if(isOnline() == 1
&& isInCombat()
&& getPrivateStoreType() == 0
&& !isInsideZone(L2Character.ZONE_PEACE))
{
try
{
String text = HtmCache.getInstance().getHtm("data/html/custom/bot.htm");
String word = Config.QUESTION_LIST.get(Rnd.get(Config.QUESTION_L IST.size()));
String output;
_correctWord = Rnd.get(5)+1;
text = text.replace("%Time%", Integer.toString(Config.BOT_PROTECTOR_WAIT_ANSVER) );
for(int i = 1; i <= 5; i++)
{
if(i != _correctWord)
{
output = RandomStringUtils.random(word.length(), word);
}else{
output = word;
}
text = text.replace("%Word"+i+"%", output);
if(i == _correctWord)
{
text = text.replace("%Word%", output);
}
for (int i = Config.BOT_PROTECTOR_WAIT_ANSVER; i >= 10; i -= 10)
{
if (_stopKickBotTask)
{
if (_taskKickBot != null)
{
_taskKickBot = null;
}
_stopKickBotTask = false;
return;
}
L2PcInstance.this.sendMessage("You have " + i + " seconds to choose the answer.");
reduceCurrentHp(reduceHp, L2PcInstance.this, false);
//reduced hp, becouse not rest
SystemMessage sm = new SystemMessage(SystemMessageId.DROWN_DAMAGE_S1);
sm.addNumber((int) reduceHp);
sendPacket(sm);
sm = null;
}
}
/**
* The Class LookingForFishTask.
*/
class LookingForFishTask implements Runnable
{
/** The _is upper grade. */
boolean _isNoob, _isUpperGrade;
/** The _guts check time. */
int _fishType, _fishGutsCheck, _gutsCheckTime;
/** The _end task time. */
long _endTaskTime;
/**
* Instantiates a new looking for fish task.
*
* @param fishWaitTime the fish wait time
* @param fishGutsCheck the fish guts check
* @param fishType the fish type
* @param isNoob the is noob
* @param isUpperGrade the is upper grade
*/
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;
}
/**
* Gets the clan privileges.
*
* @return the clan privileges
*/
public int getClanPrivileges()
{
return _clanPrivileges;
}
/**
* Sets the clan privileges.
*
* @param n the new clan privileges
*/
public void setClanPrivileges(int n)
{
_clanPrivileges = n;
}
// baron etc
/**
* Sets the pledge class.
*
* @param classId the new pledge class
*/
public void setPledgeClass(int classId)
{
_pledgeClass = classId;
}
/**
* Gets the pledge class.
*
* @return the pledge class
*/
public int getPledgeClass()
{
return _pledgeClass;
}
/**
* Sets the pledge type.
*
* @param typeId the new pledge type
*/
public void setPledgeType(int typeId)
{
_pledgeType = typeId;
}
/**
* Gets the pledge type.
*
* @return the pledge type
*/
public int getPledgeType()
{
return _pledgeType;
}
/**
* Gets the apprentice.
*
* @return the apprentice
*/
public int getApprentice()
{
return _apprentice;
}
/**
* Sets the apprentice.
*
* @param apprentice_id the new apprentice
*/
public void setApprentice(int apprentice_id)
{
_apprentice = apprentice_id;
}
/**
* Gets the sponsor.
*
* @return the sponsor
*/
public int getSponsor()
{
return _sponsor;
}
/**
* Sets the sponsor.
*
* @param sponsor_id the new sponsor
*/
public void setSponsor(int sponsor_id)
{
_sponsor = sponsor_id;
}
/**
* Send message.
*
* @param message the message
*/
public void sendMessage(String message)
{
sendPacket(SystemMessage.sendString(message));
}
/** The _was invisible. */
private boolean _wasInvisible = false;
/**
* Enter observer mode.
*
* @param x the x
* @param y the y
* @param z the z
*/
public void enterObserverMode(int x, int y, int z)
{
_obsX = getX();
_obsY = getY();
_obsZ = getZ();
setXYZ(x, y, z);
teleToLocation(x, y, z, false);
sendPacket(new ObservationMode(x, y, z));
_observerMode = true;
broadcastUserInfo();
}
/**
* Enter olympiad observer mode.
*
* @param x the x
* @param y the y
* @param z the z
* @param id the id
*/
public void enterOlympiadObserverMode(int x, int y, int z, int id)
{
if(getPet() != null)
{
getPet().unSummon(this);
}
/**
* Update name title color.
*/
public void updateNameTitleColor()
{
if(isMarried())
{
if(marriedType() == 1)
{
getAppearance().setNameColor(Config.L2JMOD_WEDDING _NAME_COLOR_LESBO);
}
else if(marriedType() == 2)
{
getAppearance().setNameColor(Config.L2JMOD_WEDDING _NAME_COLOR_GEY);
}
else
{
getAppearance().setNameColor(Config.L2JMOD_WEDDING _NAME_COLOR_NORMAL);
}
}
/** Updates title and name color of a donator **/
if(Config.DONATOR_NAME_COLOR_ENABLED && isDonator())
{
getAppearance().setNameColor(Config.DONATOR_NAME_C OLOR);
getAppearance().setTitleColor(Config.DONATOR_TITLE _COLOR);
}
}
/**
* Update gm name title color.
*/
public void updateGmNameTitleColor()// KidZor: needs to be finished when Acces levels system is complite
{
//if this is a GM but has disabled his gM status, so we clear name / title
if(isGM() && !hasGmStatusActive())
{
getAppearance().setNameColor(0xFFFFFF);
getAppearance().setTitleColor(0xFFFF77);
}
// this is a GM but has GM status enabled, so we must set proper values
else if(isGM() && hasGmStatusActive())
{
// Nick Updates
if(getAccessLevel().useNameColor())
{
// this is a normal GM
if(isNormalGm())
{
getAppearance().setNameColor(getAccessLevel().getN ameColor());
}
else if(isAdministrator())
{
getAppearance().setNameColor(Config.MASTERACCESS_N AME_COLOR);
}
}
else
{
getAppearance().setNameColor(0xFFFFFF);
}
// Title Updates
if(getAccessLevel().useTitleColor())
{
// this is a normal GM
if(isNormalGm())
{
getAppearance().setTitleColor(getAccessLevel().get TitleColor());
}
else if(isAdministrator())
{
getAppearance().setTitleColor(Config.MASTERACCESS_ TITLE_COLOR);
}
}
else
{
getAppearance().setTitleColor(0xFFFF77);
}
}
}
/**
* Sets the olympiad side.
*
* @param i the new olympiad side
*/
public void setOlympiadSide(int i)
{
_olympiadSide = i;
}
/**
* Gets the olympiad side.
*
* @return the olympiad side
*/
public int getOlympiadSide()
{
return _olympiadSide;
}
/**
* Sets the olympiad game id.
*
* @param id the new olympiad game id
*/
public void setOlympiadGameId(int id)
{
_olympiadGameId = id;
}
/**
* Gets the olympiad game id.
*
* @return the olympiad game id
*/
public int getOlympiadGameId()
{
return _olympiadGameId;
}
/**
* Gets the obs x.
*
* @return the obs x
*/
public int getObsX()
{
return _obsX;
}
/**
* Gets the obs y.
*
* @return the obs y
*/
public int getObsY()
{
return _obsY;
}
/**
* Gets the obs z.
*
* @return the obs z
*/
public int getObsZ()
{
return _obsZ;
}
/**
* In observer mode.
*
* @return true, if successful
*/
public boolean inObserverMode()
{
return _observerMode;
}
/**
* Gets the tele mode.
*
* @return the tele mode
*/
public int getTeleMode()
{
return _telemode;
}
/**
* Sets the tele mode.
*
* @param mode the new tele mode
*/
public void setTeleMode(int mode)
{
_telemode = mode;
}
/**
* Sets the loto.
*
* @param i the i
* @param val the val
*/
public void setLoto(int i, int val)
{
_loto[i] = val;
}
/**
* Gets the loto.
*
* @param i the i
* @return the loto
*/
public int getLoto(int i)
{
return _loto[i];
}
/**
* Sets the race.
*
* @param i the i
* @param val the val
*/
public void setRace(int i, int val)
{
_race[i] = val;
}
/**
* Gets the race.
*
* @param i the i
* @return the race
*/
public int getRace(int i)
{
return _race[i];
}
/*
public void setChatBanned(boolean isBanned)
{
_chatBanned = isBanned;
if(isChatBanned())
{
sendMessage("You have been chat banned by a server admin.");
}
else
{
sendMessage("Your chat ban has been lifted.");
if(_chatUnbanTask != null)
{
_chatUnbanTask.cancel(false);
}
_chatUnbanTask = null;
}
sendPacket(new EtcStatusUpdate(this));
}
public boolean isChatBanned()
{
return _chatBanned;
}
public void setChatUnbanTask(ScheduledFuture<?> task)
{
_chatUnbanTask = task;
}
public ScheduledFuture<?> getChatUnbanTask()
{
return _chatUnbanTask;
}
*/
/**
* Send a Server->Client packet StatusUpdate to the L2PcInstance.<BR><BR>
*/
@Override
public void sendPacket(L2GameServerPacket packet)
{
if (_client != null)
{
_client.sendPacket(packet);
}
}
/**
* Send SystemMessage packet.<BR><BR>
* @param id
*/
public void sendPacket(SystemMessageId id)
{
sendPacket(SystemMessage.getSystemMessage(id));
}
/**
* Gets the message refusal.
*
* @return the message refusal
*/
public boolean getMessageRefusal()
{
return _messageRefusal;
}
/**
* Sets the message refusal.
*
* @param mode the new message refusal
*/
public void setMessageRefusal(boolean mode)
{
_messageRefusal = mode;
sendPacket(new EtcStatusUpdate(this));
}
/**
* Sets the diet mode.
*
* @param mode the new diet mode
*/
public void setDietMode(boolean mode)
{
_dietMode = mode;
}
/**
* Gets the diet mode.
*
* @return the diet mode
*/
public boolean getDietMode()
{
return _dietMode;
}
/**
* Sets the exchange refusal.
*
* @param mode the new exchange refusal
*/
public void setExchangeRefusal(boolean mode)
{
_exchangeRefusal = mode;
}
/**
* Gets the exchange refusal.
*
* @return the exchange refusal
*/
public boolean getExchangeRefusal()
{
return _exchangeRefusal;
}
/**
* Gets the block list.
*
* @return the block list
*/
public BlockList getBlockList()
{
return _blockList;
}
/**
* Sets the hero aura.
*
* @param heroAura the new hero aura
*/
public void setHeroAura (boolean heroAura)
{
isPVPHero = heroAura;
return;
}
/**
* Gets the checks if is pvp hero.
*
* @return the checks if is pvp hero
*/
public boolean getIsPVPHero()
{
return isPVPHero;
}
/**
* Gets the count.
*
* @return the count
*/
public int getCount()
{
String HERO_COUNT = "SELECT count FROM heroes WHERE char_name=?";
int _count = 0;
Connection con = null;
/**
* Sets the checks if is hero.
*
* @param hero the new checks if is hero
*/
/*
public void setIsHero(boolean hero)
{
if(hero && _baseClass == _activeClass)
{
for(L2Skill s : HeroSkillTable.getHeroSkills())
{
addSkill(s, false); //Dont Save Hero skills to database
}
}
else if(getCount() >= Config.HERO_COUNT && hero && Config.ALLOW_HERO_SUBSKILL)
{
for(L2Skill s : HeroSkillTable.getHeroSkills())
{
addSkill(s, false); //Dont Save Hero skills to database
}
}
else
{
for(L2Skill s : HeroSkillTable.getHeroSkills())
{
super.removeSkill(s); //Just Remove skills from nonHero characters
}
}
_hero = hero;
sendSkillList();
}
*/
/**
* Sets the donator.
*
* @param value the new donator
*/
public void setDonator(boolean value)
{
_donator = value;
}
/**
* Checks if is donator.
*
* @return true, if is donator
*/
public boolean isDonator()
{
return _donator;
}
/**
* Checks if is away.
*
* @return true, if is away
*/
public boolean isAway()
{
return _isAway;
}
/**
* Sets the checks if is away.
*
* @param state the new checks if is away
*/
public void setIsAway(boolean state)
{
_isAway = state;
}
/**
* Sets the checks if is in olympiad mode.
*
* @param b the new checks if is in olympiad mode
*/
public void setIsInOlympiadMode(boolean b)
{
_inOlympiadMode = b;
}
/**
* Sets the checks if is olympiad start.
*
* @param b the new checks if is olympiad start
*/
public void setIsOlympiadStart(boolean b)
{
_OlympiadStart = b;
}
/**
* Checks if is olympiad start.
*
* @return true, if is olympiad start
*/
public boolean isOlympiadStart()
{
return _OlympiadStart;
}
/**
* Sets the olympiad position.
*
* @param pos the new olympiad position
*/
public void setOlympiadPosition(int[] pos)
{
_OlympiadPosition = pos;
}
/**
* Gets the olympiad position.
*
* @return the olympiad position
*/
public int[] getOlympiadPosition()
{
return _OlympiadPosition;
}
/**
* Checks if is hero.
*
* @return true, if is hero
*/
public boolean isHero()
{
return _hero;
}
/**
* Checks if is in olympiad mode.
*
* @return true, if is in olympiad mode
*/
public boolean isInOlympiadMode()
{
return _inOlympiadMode;
}
/**
* Checks if is in duel.
*
* @return true, if is in duel
*/
public boolean isInDuel()
{
return _isInDuel;
}
/**
* Gets the duel id.
*
* @return the duel id
*/
public int getDuelId()
{
return _duelId;
}
/**
* Sets the duel state.
*
* @param mode the new duel state
*/
public void setDuelState(int mode)
{
_duelState = mode;
}
/**
* Gets the duel state.
*
* @return the duel state
*/
public int getDuelState()
{
return _duelState;
}
/**
* Sets the coupon.
*
* @param coupon the new coupon
*/
public void setCoupon(int coupon)
{
if(coupon >= 0 && coupon <= 3)
{
_hasCoupon = coupon;
}
}
/**
* 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 = new SystemMessage(_noDuelReason);
sm.addString(getName());
_noDuelReason = SystemMessageId.THERE_IS_NO_OPPONENT_TO_RECEIVE_YO UR_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() || isInJail())
{
_noDuelReason = SystemMessageId.S1_CANNOT_DUEL_BECAUSE_S1_IS_CURRE NTLY_ENGAGED_IN_BATTLE;
return false;
}
if(isDead() || isAlikeDead() || getCurrentHp() < getMaxHp() / 2 || getCurrentMp() < getMaxMp() / 2)
{
_noDuelReason = SystemMessageId.S1_CANNOT_DUEL_BECAUSE_S1S_HP_OR_M P_IS_BELOW_50_PERCENT;
return false;
}
if(isInDuel())
{
_noDuelReason = SystemMessageId.S1_CANNOT_DUEL_BECAUSE_S1_IS_ALREA DY_ENGAGED_IN_A_DUEL;
return false;
}
if(isInOlympiadMode())
{
_noDuelReason = SystemMessageId.S1_CANNOT_DUEL_BECAUSE_S1_IS_PARTI CIPATING_IN_THE_OLYMPIAD;
return false;
}
if(isCursedWeaponEquiped())
{
_noDuelReason = SystemMessageId.S1_CANNOT_DUEL_BECAUSE_S1_IS_IN_A_ CHAOTIC_STATE;
return false;
}
if(getPrivateStoreType() != STORE_PRIVATE_NONE)
{
_noDuelReason = SystemMessageId.S1_CANNOT_DUEL_BECAUSE_S1_IS_CURRE NTLY_ENGAGED_IN_A_PRIVATE_STORE_OR_MANUFACTURE;
return false;
}
if(isMounted() || isInBoat())
{
_noDuelReason = SystemMessageId.S1_CANNOT_DUEL_BECAUSE_S1_IS_CURRE NTLY_RIDING_A_BOAT_WYVERN_OR_STRIDER;
return false;
}
if(isFishing())
{
_noDuelReason = SystemMessageId.S1_CANNOT_DUEL_BECAUSE_S1_IS_CURRE NTLY_FISHING;
return false;
}
if(isInsideZone(ZONE_PVP) || isInsideZone(ZONE_PEACE) || isInsideZone(ZONE_SIEGE))
{
_noDuelReason = SystemMessageId.S1_CANNOT_MAKE_A_CHALLANGE_TO_A_DU EL_BECAUSE_S1_IS_CURRENTLY_IN_A_DUEL_PROHIBITED_AR EA;
return false;
}
return true;
}
/**
* Checks if is noble.
*
* @return true, if is noble
*/
public boolean isNoble()
{
return _noble;
}
/**
* Sets the noble.
*
* @param val the new noble
*/
public void setNoble(boolean val)
{
if(val)
{
for(L2Skill s : NobleSkillTable.getInstance().GetNobleSkills())
{
addSkill(s, false); //Dont Save Noble skills to Sql
}
}
else
{
for(L2Skill s : NobleSkillTable.getInstance().GetNobleSkills())
{
super.removeSkill(s); //Just Remove skills without deleting from Sql
}
}
_noble = val;
sendSkillList();
}
/**
* Adds the clan leader skills.
*
* @param val the val
*/
public void addClanLeaderSkills(boolean val)
{
if(val)
{
SiegeManager.getInstance().addSiegeSkills(this);
/*
for(L2Skill s : ClanLeaderSkillTable.getInstance().GetClanLeaderSk ills())
{
addSkill(s, false); //Dont Save Noble skills to Sql
}
*/
}
else
{
SiegeManager.getInstance().removeSiegeSkills(this) ;
/*
for(L2Skill s : ClanLeaderSkillTable.getInstance().GetClanLeaderSk ills())
{
super.removeSkill(s); //Just Remove skills without deleting from Sql
}
*/
}
sendSkillList();
}
/**
* Sets the lvl joined academy.
*
* @param lvl the new lvl joined academy
*/
public void setLvlJoinedAcademy(int lvl)
{
_lvlJoinedAcademy = lvl;
}
/**
* Gets the lvl joined academy.
*
* @return the lvl joined academy
*/
public int getLvlJoinedAcademy()
{
return _lvlJoinedAcademy;
}
/**
* Checks if is academy member.
*
* @return true, if is academy member
*/
public boolean isAcademyMember()
{
return _lvlJoinedAcademy > 0;
}
/**
* Sets the team.
*
* @param team the new team
*/
public void setTeam(int team)
{
_team = team;
}
/**
* Gets the team.
*
* @return the team
*/
public int getTeam()
{
return _team;
}
/**
* Sets the wants peace.
*
* @param wantsPeace the new wants peace
*/
public void setWantsPeace(int wantsPeace)
{
_wantsPeace = wantsPeace;
}
/**
* Gets the wants peace.
*
* @return the wants peace
*/
public int getWantsPeace()
{
return _wantsPeace;
}
/**
* Checks if is fishing.
*
* @return true, if is fishing
*/
public boolean isFishing()
{
return _fishing;
}
/**
* Sets the fishing.
*
* @param fishing the new fishing
*/
public void setFishing(boolean fishing)
{
_fishing = fishing;
}
/**
* Sets the alliance with varka ketra.
*
* @param sideAndLvlOfAlliance the new alliance with varka ketra
*/
public void setAllianceWithVarkaKetra(int sideAndLvlOfAlliance)
{
// [-5,-1] varka, 0 neutral, [1,5] ketra
_alliedVarkaKetra = sideAndLvlOfAlliance;
}
/**
* Gets the alliance with varka ketra.
*
* @return the alliance with varka ketra
*/
public int getAllianceWithVarkaKetra()
{
return _alliedVarkaKetra;
}
/**
* Checks if is allied with varka.
*
* @return true, if is allied with varka
*/
public boolean isAlliedWithVarka()
{
return _alliedVarkaKetra < 0;
}
/**
* Checks if is allied with ketra.
*
* @return true, if is allied with ketra
*/
public boolean isAlliedWithKetra()
{
return _alliedVarkaKetra > 0;
}
/**
* 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 the class id
* @param classIndex the class index
* @return boolean subclassAdded
*/
public synchronized boolean addSubClass(int classId, int classIndex)
{
// Reload skills from armors / jewels / weapons
getInventory().reloadEquippedItems();
// Remove Item RHAND
if(Config.REMOVE_WEAPON_SUBCLASS)
{
L2ItemInstance rhand = getInventory().getPaperdollItem(Inventory.PAPERDOL L_RHAND);
if (rhand != null)
{
L2ItemInstance[] unequipped = getInventory().unEquipItemInBodySlotAndRecord(rhan d.getItem().getBodyPart());
InventoryUpdate iu = new InventoryUpdate();
for (L2ItemInstance element : unequipped)
iu.addModifiedItem(element);
sendPacket(iu);
}
}
// Remove Item CHEST
if(Config.REMOVE_CHEST_SUBCLASS)
{
L2ItemInstance chest = getInventory().getPaperdollItem(Inventory.PAPERDOL L_CHEST);
if (chest != null)
{
L2ItemInstance[] unequipped = getInventory().unEquipItemInBodySlotAndRecord(ches t.getItem().getBodyPart());
InventoryUpdate iu = new InventoryUpdate();
for (L2ItemInstance element : unequipped)
iu.addModifiedItem(element);
sendPacket(iu);
}
}
// Remove Item LEG
if(Config.REMOVE_LEG_SUBCLASS)
{
L2ItemInstance legs = getInventory().getPaperdollItem(Inventory.PAPERDOL L_LEGS);
if (legs != null)
{
L2ItemInstance[] unequipped = getInventory().unEquipItemInBodySlotAndRecord(legs .getItem().getBodyPart());
InventoryUpdate iu = new InventoryUpdate();
for (L2ItemInstance element : unequipped)
iu.addModifiedItem(element);
sendPacket(iu);
}
}
if(Config.DEBUG)
{
_log.info(getName() + " was given " + getAllSkills().length + " skills for their new sub class.");
}
}
return output;
}
/**
* 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 the class index
* @param newClassId the new class id
* @return boolean subclassAdded
*/
public boolean modifySubClass(int classIndex, int newClassId)
{
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 + ".");
}
boolean output = false;
Connection con = null;
try
{
con = L2DatabaseFactory.getInstance().getConnection(fals e);
PreparedStatement statement;
// Remove all henna info stored for this sub-class.
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();
statement = null;
_log.warning("Could not modify sub class for " + getName() + " to class index " + classIndex + ": " + e);
}
finally
{
CloseUtil.close(con);
con = null;
}
/**
* Checks if is sub class active.
*
* @return true, if is sub class active
*/
public boolean isSubClassActive()
{
return _classIndex > 0;
}
/**
* Gets the sub classes.
*
* @return the sub classes
*/
public Map<Integer, SubClass> getSubClasses()
{
if(_subClasses == null)
{
_subClasses = new FastMap<Integer, SubClass>();
}
return _subClasses;
}
/**
* Gets the total sub classes.
*
* @return the total sub classes
*/
public int getTotalSubClasses()
{
return getSubClasses().size();
}
/**
* Gets the base class.
*
* @return the base class
*/
public int getBaseClass()
{
return _baseClass;
}
/**
* Gets the active class.
*
* @return the active class
*/
public synchronized int getActiveClass()
{
return _activeClass;
}
/**
* Gets the class index.
*
* @return the class index
*/
public int getClassIndex()
{
return _classIndex;
}
/**
* Sets the class template.
*
* @param classId the new class template
*/
private synchronized void setClassTemplate(int classId)
{
_activeClass = classId;
L2PcTemplate t = CharTemplateTable.getInstance().getTemplate(classI d);
if(t == null)
{
_log.severe("Missing template for classId: " + classId);
throw new Error();
}
// Set the template of the L2PcInstance
setTemplate(t);
t = null;
}
/**
* 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 the class index
* @return true, if successful
*/
public synchronized boolean setActiveClass(int classIndex)
{
if(isInCombat() || this.getAI().getIntention() == CtrlIntention.AI_INTENTION_ATTACK){
sendMessage("Impossible switch class if in combat");
sendPacket( ActionFailed.STATIC_PACKET );
return false;
}
// Delete a force buff upon class change.
//thank l2j-arhid
if(_forceBuff != null)
{
abortCast();
}
/**
* 1. Call store() before modifying _classIndex to avoid skill effects rollover. 2. Register the correct
* _classId against applied 'classIndex'.
*/
store();
/*
* 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.
*/
// Reload skills from armors / jewels / weapons
getInventory().reloadEquippedItems();
// Remove Item RHAND
if(Config.REMOVE_WEAPON_SUBCLASS)
{
L2ItemInstance rhand = getInventory().getPaperdollItem(Inventory.PAPERDOL L_RHAND);
if (rhand != null)
{
L2ItemInstance[] unequipped = getInventory().unEquipItemInBodySlotAndRecord(rhan d.getItem().getBodyPart());
InventoryUpdate iu = new InventoryUpdate();
for (L2ItemInstance element : unequipped)
iu.addModifiedItem(element);
sendPacket(iu);
}
}
// Remove Item CHEST
if(Config.REMOVE_CHEST_SUBCLASS)
{
L2ItemInstance chest = getInventory().getPaperdollItem(Inventory.PAPERDOL L_CHEST);
if (chest != null)
{
L2ItemInstance[] unequipped = getInventory().unEquipItemInBodySlotAndRecord(ches t.getItem().getBodyPart());
InventoryUpdate iu = new InventoryUpdate();
for (L2ItemInstance element : unequipped)
iu.addModifiedItem(element);
sendPacket(iu);
}
}
// Remove Item LEG
if(Config.REMOVE_LEG_SUBCLASS)
{
L2ItemInstance legs = getInventory().getPaperdollItem(Inventory.PAPERDOL L_LEGS);
if (legs != null)
{
L2ItemInstance[] unequipped = getInventory().unEquipItemInBodySlotAndRecord(legs .getItem().getBodyPart());
InventoryUpdate iu = new InventoryUpdate();
for (L2ItemInstance element : unequipped)
iu.addModifiedItem(element);
sendPacket(iu);
}
}
checkAllowedSkills();
sendPacket(new EtcStatusUpdate(this));
//if player has quest 422: Repent Your Sins, remove it
QuestState st = getQuestState("422_RepentYourSins");
// Refresh player infos and update new status
broadcastUserInfo();
refreshOverloaded();
refreshExpertisePenalty();
refreshMasteryPenality();
refreshMasteryWeapPenality();
sendPacket(new UserInfo(this));
sendPacket(new ItemList(this, false));
getInventory().refreshWeight();
if (getClan() != null)
getClan().broadcastToOnlineMembers(new PledgeShowMemberListUpdate(this));
//decayMe();
//spawnMe(getX(), getY(), getZ());
return true;
}
/**
* Broadcast class icon.
*/
public void broadcastClassIcon()
{
// Update class icon in party and clan
if (isInParty())
getParty().broadcastToPartyMembers(new PartySmallWindowUpdate(this));
if (getClan() != null)
getClan().broadcastToOnlineMembers(new PledgeShowMemberListUpdate(this));
}
/**
* Stop warn user take break.
*/
public void stopWarnUserTakeBreak()
{
if(_taskWarnUserTakeBreak != null)
{
_taskWarnUserTakeBreak.cancel(true);
_taskWarnUserTakeBreak = null;
}
}
/**
* Start warn user take break.
*/
public void startWarnUserTakeBreak()
{
if(_taskWarnUserTakeBreak == null)
{
_taskWarnUserTakeBreak = ThreadPoolManager.getInstance().scheduleGeneralAtF ixedRate(new WarnUserTakeBreak(), 7200000, 7200000);
}
}
/**
* Start bot checker.
*/
public void startBotChecker()
{
if(_taskBotChecker == null)
{
if(Config.QUESTION_LIST.size() != 0){
_taskBotChecker = ThreadPoolManager.getInstance().scheduleGeneralAtF ixedRate(new botChecker(), Config.BOT_PROTECTOR_FIRST_CHECK * 60000, Config.BOT_PROTECTOR_NEXT_CHECK * 60000);
}else{
_log.warning("ATTENTION: Bot Checker is bad configured because config/questionwords.txt has 0 words of 6 to 15 keys");
}
}
}
/**
* Check answer.
*
* @param id the id
*/
public void checkAnswer(int id)
{
if(id - 100000 == _correctWord)
{
_stopKickBotTask = true;
}
else
{
closeNetConnection();
}
}
/**
* Stop rent pet.
*/
public void stopRentPet()
{
if(_taskRentPet != null)
{
// if the rent of a wyvern expires while over a flying zone, tp to down before unmounting
if(checkLandingState() && getMountType() == 2)
{
teleToLocation(MapRegionTable.TeleportWhereType.To wn);
}
if(setMountType(0)) // this should always be true now, since we teleported already
{
_taskRentPet.cancel(true);
Ride dismount = new Ride(getObjectId(), Ride.ACTION_DISMOUNT, 0);
sendPacket(dismount);
broadcastPacket(dismount);
dismount = null;
_taskRentPet = null;
}
}
}
/**
* Checks if is in water.
*
* @return true, if is in water
*/
public boolean isInWater()
{
if(_taskWater != null)
return true;
return false;
}
/**
* Check water state.
*/
public void checkWaterState()
{
//checking if char is over base level of water (sea, rivers)
if(getZ() > -3750)
{
stopWaterTask();
return;
}
/**
* On player enter.
*/
public void onPlayerEnter()
{
startWarnUserTakeBreak();
if(Config.BOT_PROTECTOR)
{
startBotChecker();
}
if(SevenSigns.getInstance().isSealValidationPeriod () || SevenSigns.getInstance().isCompResultsPeriod())
{
if(!isGM() && isIn7sDungeon() && SevenSigns.getInstance().getPlayerCabal(this) != SevenSigns.getInstance().getCabalHighestScore())
{
teleToLocation(MapRegionTable.TeleportWhereType.To wn);
setIsIn7sDungeon(false);
sendMessage("You have been teleported to the nearest town due to the beginning of the Seal Validation period.");
}
}
else
{
if(!isGM() && isIn7sDungeon() && SevenSigns.getInstance().getPlayerCabal(this) == SevenSigns.CABAL_NULL)
{
teleToLocation(MapRegionTable.TeleportWhereType.To wn);
setIsIn7sDungeon(false);
sendMessage("You have been teleported to the nearest town because you have not signed for any cabal.");
}
}
// jail task
updatePunishState();
if(_isInvul)
{
sendMessage("Entering world in Invulnerable mode.");
}
if(getAppearance().getInvisible())
{
sendMessage("Entering world in Invisible mode.");
}
if(getMessageRefusal())
{
sendMessage("Entering world in Message Refusal mode.");
}
revalidateZone(true);
notifyFriends(false);
// Fix against exploit on anti-target on login
decayMe();
spawnMe();
broadcastUserInfo();
}
/**
* Gets the last access.
*
* @return the last access
*/
public long getLastAccess()
{
return _lastAccess;
}
/**
* Check recom.
*
* @param recsHave the recs have
* @param recsLeft the recs left
*/
private void checkRecom(int recsHave, int recsLeft)
{
Calendar check = Calendar.getInstance();
check.setTimeInMillis(_lastRecomUpdate);
check.add(Calendar.DAY_OF_MONTH, 1);
// 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);
}
/* (non-Javadoc)
* @see com.l2jfrozen.gameserver.model.L2Character#doReviv e(double)
*/
@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();
}
/**
* Revive request.
*
* @param Reviver the reviver
* @param skill the skill
* @param Pet the pet
*/
public void reviveRequest(L2PcInstance Reviver, L2Skill skill, boolean Pet)
{
if(_reviveRequested == 1)
{
if(_revivePet == Pet)
{
Reviver.sendPacket(new SystemMessage(SystemMessageId.RES_HAS_ALREADY_BEEN _PROPOSED)); // Resurrection is already been proposed.
}
else
{
if(Pet)
{
Reviver.sendPacket(new SystemMessage(SystemMessageId.PET_CANNOT_RES)); // A pet cannot be resurrected while it's owner is in the process of resurrecting.
}
else
{
Reviver.sendPacket(new SystemMessage(SystemMessageId.MASTER_CANNOT_RES)); // While a pet is attempting to resurrect, it cannot help in resurrecting its master.
}
}
return;
}
if(Pet && getPet() != null && getPet().isDead() || !Pet && isDead())
{
_reviveRequested = 1;
if(isPhoenixBlessed())
{
_revivePower = 100;
}
else if(skill != null)
{
_revivePower = Formulas.getInstance().calculateSkillResurrectRest orePercent(skill.getPower(), Reviver);
}
else
{
_revivePower = 0;
}
_revivePet = Pet;
ConfirmDlg dlg = new ConfirmDlg(SystemMessageId.RESSURECTION_REQUEST.ge tId());
dlg.addString(Reviver.getName());
sendPacket(dlg);
dlg = null;
}
}
/**
* Checks if is revive requested.
*
* @return true, if is revive requested
*/
public boolean isReviveRequested()
{
return _reviveRequested == 1;
}
/**
* Checks if is reviving pet.
*
* @return true, if is reviving pet
*/
public boolean isRevivingPet()
{
return _revivePet;
}
/**
* Removes the reviving.
*/
public void removeReviving()
{
_reviveRequested = 0;
_revivePower = 0;
}
/**
* On action request.
*/
public void onActionRequest()
{
if (isSpawnProtected())
sendMessage("The effect of Spawn Protection has been removed.");
else if (isTeleportProtected())
sendMessage("The effect of Teleport Spawn Protection has been removed.");
if (Config.PLAYER_SPAWN_PROTECTION > 0)
setProtection(false);
if (Config.PLAYER_TELEPORT_PROTECTION > 0)
setTeleportProtection(false);
}
/**
* Sets the expertise index.
*
* @param expertiseIndex The expertiseIndex to set.
*/
public void setExpertiseIndex(int expertiseIndex)
{
_expertiseIndex = expertiseIndex;
}
/**
* Gets the expertise index.
*
* @return Returns the expertiseIndex.
*/
public int getExpertiseIndex()
{
return _expertiseIndex;
}
/*
* (non-Javadoc)
* @see com.l2jfrozen.gameserver.model.L2Character#onTelep orted()
*/
@Override
public final void onTeleported()
{
super.onTeleported();
// Force a revalidation
revalidateZone(true);
if ((Config.PLAYER_TELEPORT_PROTECTION > 0) && !isInOlympiadMode())
{
setTeleportProtection(true);
sendMessage("The effects of Teleport Spawn Protection flow through you.");
}
if (Config.ALLOW_WATER)
{
checkWaterState();
}
// Modify the position of the tamed beast if necessary (normal pets are handled by super...though
// L2PcInstance is the only class that actually has pets!!! )
if (getTrainedBeast() != null)
{
getTrainedBeast().getAI().stopFollow();
getTrainedBeast().teleToLocation(getPosition().get X() + Rnd.get(-100, 100), getPosition().getY() + Rnd.get(-100, 100), getPosition().getZ(), false);
getTrainedBeast().getAI().startFollow(this);
}
// To be sure update also the pvp flag / war tag status
if (!inObserverMode())
broadcastUserInfo();
}
/* (non-Javadoc)
* @see com.l2jfrozen.gameserver.model.L2Character#updateP osition(int)
*/
@Override
public final boolean updatePosition(int gameTicks)
{
// Disables custom movement for L2PCInstance when Old Synchronization is selected
if(Config.COORD_SYNCHRONIZE == -1)
return super.updatePosition(gameTicks);
// Get movement data
MoveData m = _move;
if(_move == null)
return true;
if(!isVisible())
{
_move = null;
return true;
}
// Check if the position has alreday be calculated
if(m._moveTimestamp == 0)
{
m._moveTimestamp = m._moveStartTime;
}
// Check if the position has alreday be calculated
if(m._moveTimestamp == gameTicks)
return false;
if(distFraction > 1)
{
// Set the position of the L2Character to the destination
super.setXYZ(m._xDestination, m._yDestination, m._zDestination);
}
else
{
// Set the position of the L2Character to estimated after parcial move
super.setXYZ(getX() + (int) (dx * distFraction + 0.5), getY() + (int) (dy * distFraction + 0.5), getZ() + (int) (dz * distFraction));
}
// Set the timer of last position update to now
m._moveTimestamp = gameTicks;
revalidateZone(false);
return distFraction > 1;
}
/**
* Sets the last client position.
*
* @param x the x
* @param y the y
* @param z the z
*/
public void setLastClientPosition(int x, int y, int z)
{
_lastClientPosition.setXYZ(x, y, z);
}
/**
* Sets the last client position.
*
* @param loc the new last client position
*/
public void setLastClientPosition(Location loc) {
_lastClientPosition = loc;
}
/**
* Check last client position.
*
* @param x the x
* @param y the y
* @param z the z
* @return true, if successful
*/
public boolean checkLastClientPosition(int x, int y, int z)
{
return _lastClientPosition.equals(x, y, z);
}
/**
* Gets the last client distance.
*
* @param x the x
* @param y the y
* @param z the z
* @return the last client distance
*/
public int getLastClientDistance(int x, int y, int z)
{
double dx = x - _lastClientPosition.getX();
double dy = y - _lastClientPosition.getY();
double dz = z - _lastClientPosition.getZ();
return (int) Math.sqrt(dx * dx + dy * dy + dz * dz);
}
/**
* Sets the last server position.
*
* @param x the x
* @param y the y
* @param z the z
*/
public void setLastServerPosition(int x, int y, int z)
{
_lastServerPosition.setXYZ(x, y, z);
}
/**
* Sets the last server position.
*
* @param loc the new last server position
*/
public void setLastServerPosition(Location loc) {
_lastServerPosition = loc;
}
/**
* Check last server position.
*
* @param x the x
* @param y the y
* @param z the z
* @return true, if successful
*/
public boolean checkLastServerPosition(int x, int y, int z)
{
return _lastServerPosition.equals(x, y, z);
}
/**
* Gets the last server distance.
*
* @param x the x
* @param y the y
* @param z the z
* @return the last server distance
*/
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);
}
/* (non-Javadoc)
* @see com.l2jfrozen.gameserver.model.L2Character#addExpA ndSp(long, int)
*/
@Override
public void addExpAndSp(long addToExp, int addToSp)
{
getStat().addExpAndSp(addToExp, addToSp);
}
/**
* Removes the exp and sp.
*
* @param removeExp the remove exp
* @param removeSp the remove sp
*/
public void removeExpAndSp(long removeExp, int removeSp)
{
getStat().removeExpAndSp(removeExp, removeSp);
}
/* (non-Javadoc)
* @see com.l2jfrozen.gameserver.model.L2Character#reduceC urrentHp(double, com.l2jfrozen.gameserver.model.L2Character)
*/
@Override
public void reduceCurrentHp(double i, L2Character attacker)
{
getStatus().reduceHp(i, attacker);
// notify the tamed beast of attacks
if(getTrainedBeast() != null)
{
getTrainedBeast().onOwnerGotAttacked(attacker);
}
}
/*
* Function for skill summon friend or Gate Chant.
*/
/**
* Request Teleport *.
*
* @param requester the requester
* @param skill the 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 the answer
* @param requesterId the requester id
*/
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);
}
/**
* Tele to target.
*
* @param targetChar the target char
* @param summonerChar the summoner char
* @param summonSkill the summon skill
*/
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(i temConsumeId, 0) < itemConsumeCount)
{
SystemMessage sm = SystemMessage.getSystemMessage(SystemMessageId.S1_ REQUIRED_FOR_SUMMONING);
sm.addItemName(summonSkill.getTargetConsumeId());
targetChar.sendPacket(sm);
return;
}
targetChar.getInventory().destroyItemByItemId("Con sume", itemConsumeId, itemConsumeCount, summonerChar, targetChar);
SystemMessage sm = SystemMessage.getSystemMessage(SystemMessageId.S1_ DISAPPEARED);
sm.addItemName(summonSkill.getTargetConsumeId());
targetChar.sendPacket(sm);
}
targetChar.teleToLocation(summonerChar.getX(), summonerChar.getY(), summonerChar.getZ(), true);
}
/**
* Check summoner status.
*
* @param summonerChar the summoner char
* @return true, if successful
*/
public static boolean checkSummonerStatus(L2PcInstance summonerChar)
{
if (summonerChar == null)
return false;
if (summonerChar.isInOlympiadMode())
{
summonerChar.sendPacket(SystemMessage.getSystemMes sage(SystemMessageId.THIS_ITEM_IS_NOT_AVAILABLE_FO R_THE_OLYMPIAD_EVENT));
return false;
}
if (summonerChar.inObserverMode())
{
return false;
}
L2PcInstance player = getClient().getActiveChar();
// We decided to put a kick because when a player is doing quest with a BOT he sends invalid bypass.
Util.handleIllegalPlayerAction(player,"[L2PcInstance] player [" + player.getName() + "] sent invalid bypass '" + cmd + "'", Config.DEFAULT_PUNISH);
return false;
}
/**
* Validate item manipulation by item id.
*
* @param itemId the item id
* @param action the action
* @return true, if successful
*/
public boolean validateItemManipulationByItemId(int itemId, String action)
{
L2ItemInstance item = getInventory().getItemByItemId(itemId);
if(item == null || item.getOwnerId() != getObjectId())
{
_log.finest(getObjectId() + ": player tried to " + action + " item he is not owner of");
return false;
}
if(getActiveEnchantItem() != null && getActiveEnchantItem().getItemId() == itemId)
{
_log.finest(getObjectId() + ":player tried to " + action + " an enchant scroll he was using");
return false;
}
if(CursedWeaponsManager.getInstance().isCursed(ite mId))
// can not trade a cursed weapon
return false;
/**
* Validate item manipulation.
*
* @param objectId the object id
* @param action the action
* @return true, if successful
*/
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(ite m.getItemId()))
// can not trade a cursed weapon
return false;
/**
* Adds the link.
*
* @param link the link
*/
public synchronized void addLink(String link)
{
if(link == null) return;
_validLink.add(link);
}
/**
* Checks if is in boat.
*
* @return Returns the inBoat.
*/
public boolean isInBoat()
{
return _inBoat;
}
/**
* Sets the in boat.
*
* @param inBoat The inBoat to set.
*/
public void setInBoat(boolean inBoat)
{
_inBoat = inBoat;
}
/**
* Gets the boat.
*
* @return the boat
*/
public L2BoatInstance getBoat()
{
return _boat;
}
/**
* Sets the boat.
*
* @param boat the new boat
*/
public void setBoat(L2BoatInstance boat)
{
_boat = boat;
}
/**
* Sets the in crystallize.
*
* @param inCrystallize the new in crystallize
*/
public void setInCrystallize(boolean inCrystallize)
{
_inCrystallize = inCrystallize;
}
/**
* Checks if is in crystallize.
*
* @return true, if is in crystallize
*/
public boolean isInCrystallize()
{
return _inCrystallize;
}
/**
* Gets the in boat position.
*
* @return the in boat position
*/
public Point3D getInBoatPosition()
{
return _inBoatPosition;
}
/**
* Sets the in boat position.
*
* @param pt the new in boat position
*/
public void setInBoatPosition(Point3D pt)
{
_inBoatPosition = 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>
*/
public synchronized void deleteMe()
{
// Check if the L2PcInstance is in observer mode to set its position to its position before entering in observer mode
if(inObserverMode())
{
setXYZ(_obsX, _obsY, _obsZ);
}
// 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)
try
{
setOnlineStatus(false);
}
catch(Throwable t)
{
if(Config.ENABLE_ALL_EXCEPTIONS)
t.printStackTrace();
// Remove the L2PcInstance from the world
if(isVisible())
{
try
{
decayMe();
}
catch(Throwable t)
{
if(Config.ENABLE_ALL_EXCEPTIONS)
t.printStackTrace();
_log.log(Level.SEVERE, "deleteMe()", t);
}
}
// If a Party is in progress, leave it
if(isInParty())
{
try
{
leaveParty();
}
catch(Throwable t)
{
if(Config.ENABLE_ALL_EXCEPTIONS)
t.printStackTrace();
_log.log(Level.SEVERE, "deleteMe()", t);
}
}
// If the L2PcInstance has Pet, unsummon it
if(getPet() != null)
{
try
{
getPet().unSummon(this);
}
catch(Throwable t)
{
if(Config.ENABLE_ALL_EXCEPTIONS)
t.printStackTrace();
_log.log(Level.SEVERE, "deleteMe()", t);
}// returns pet to control item
}
if(getClanId() != 0 && getClan() != null)
{
// set the status for pledge member list to OFFLINE
try
{
L2ClanMember clanMember = getClan().getClanMember(getName());
if(clanMember != null)
{
clanMember.setPlayerInstance(null);
}
clanMember = null;
}
catch(Throwable t)
{
if(Config.ENABLE_ALL_EXCEPTIONS)
t.printStackTrace();
_log.log(Level.SEVERE, "deleteMe()", t);
}
}
if(getActiveRequester() != null)
{
// deals with sudden exit in the middle of transaction
setActiveRequester(null);
}
// If the L2PcInstance is a GM, remove it from the GM List
if(isGM())
{
try
{
GmListTable.getInstance().deleteGm(this);
}
catch(Throwable t)
{
if(Config.ENABLE_ALL_EXCEPTIONS)
t.printStackTrace();
_log.log(Level.SEVERE, "deleteMe()", t);
}
}
// Update database with items in its inventory and remove them from the world
try
{
getInventory().deleteMe();
}
catch(Throwable t)
{
if(Config.ENABLE_ALL_EXCEPTIONS)
t.printStackTrace();
_log.log(Level.SEVERE, "deleteMe()", t);
}
// Update database with items in its warehouse and remove them from the world
try
{
clearWarehouse();
}
catch(Throwable t)
{
if(Config.ENABLE_ALL_EXCEPTIONS)
t.printStackTrace();
// Update database with items in its freight and remove them from the world
try
{
getFreight().deleteMe();
}
catch(Throwable t)
{
if(Config.ENABLE_ALL_EXCEPTIONS)
t.printStackTrace();
_log.log(Level.SEVERE, "deleteMe()", t);
}
// Remove all L2Object from _knownObjects and _knownPlayer of the L2Character then cancel Attak or Cast and notify AI
try
{
getKnownList().removeAllKnownObjects();
}
catch(Throwable t)
{
if(Config.ENABLE_ALL_EXCEPTIONS)
t.printStackTrace();
_log.log(Level.SEVERE, "deleteMe()", t);
}
// Close the connection with the client
closeNetConnection();
// remove from flood protector
//FloodProtector.getInstance().removePlayer(getObjec tId());
// Remove L2Object object from _allObjects of L2World
L2World.getInstance().removeObject(this);
L2World.getInstance().removeFromAllPlayers(this); // force remove in case of crash during teleport
_log.warning("could not restore friend data:" + e);
}
finally
{
CloseUtil.close(con);
con = null;
}
}
*/
/** The _fish. */
private FishData _fish;
/* startFishing() was stripped of any pre-fishing related checks, namely the fishing zone check.
* Also worthy of note is the fact the code to find the hook landing position was also striped. The
* stripped code was moved into fishing.java. In my opinion it makes more sense for it to be there
* since all other skill related checks were also there. Last but not least, moving the zone check
* there, fixed a bug where baits would always be consumed no matter if fishing actualy took place.
* startFishing() now takes up 3 arguments, wich are acurately described as being the hook landing
* coordinates.
*/
/**
* Start fishing.
*
* @param _x the _x
* @param _y the _y
* @param _z the _z
*/
public void startFishing(int _x, int _y, int _z)
{
stopMove(null);
setIsImobilised(true);
_fishing = true;
_fishx = _x;
_fishy = _y;
_fishz = _z;
broadcastUserInfo();
//Starts fishing
int lvl = GetRandomFishLvl();
int group = GetRandomGroup();
int type = GetRandomFishType(group);
List<FishData> fishs = FishTable.getInstance().getfish(lvl, type, group);
if(fishs == null || fishs.size() == 0)
{
sendMessage("Error - Fishes are not definied");
EndFishing(false);
return;
}
int check = Rnd.get(fishs.size());
// Use a copy constructor else the fish data may be over-written below
_fish = new FishData(fishs.get(check));
fishs.clear();
fishs = null;
sendPacket(new SystemMessage(SystemMessageId.CAST_LINE_AND_START_ FISHING));
ExFishingStart efs = null;
/**
* Gets the random group.
*
* @return the int
*/
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;
}
}
/**
* Gets the random fish type.
*
* @param group the group
* @return the int
*/
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;
}
/**
* Gets the random fish lvl.
*
* @return the int
*/
private int GetRandomFishLvl()
{
L2Effect[] effects = getAllEffects();
int skilllvl = getSkillLevel(1315);
for(L2Effect e : effects)
{
if(e.getSkill().getId() == 2274)
{
skilllvl = (int) e.getSkill().getPower(this);
}
}
if(skilllvl <= 0)
return 1;
int randomlvl;
int check = Rnd.get(100);
/**
* Start fish combat.
*
* @param isNoob the is noob
* @param isUpperGrade the is upper grade
*/
public void StartFishCombat(boolean isNoob, boolean isUpperGrade)
{
_fishCombat = new L2Fishing(this, _fish, isNoob, isUpperGrade);
}
/**
* End fishing.
*
* @param win the win
*/
public void EndFishing(boolean win)
{
ExFishingEnd efe = new ExFishingEnd(win, this);
broadcastPacket(efe);
efe = null;
_fishing = false;
_fishx = 0;
_fishy = 0;
_fishz = 0;
broadcastUserInfo();
/**
* Gets the fish combat.
*
* @return the l2 fishing
*/
public L2Fishing GetFishCombat()
{
return _fishCombat;
}
/**
* Gets the fishx.
*
* @return the int
*/
public int GetFishx()
{
return _fishx;
}
/**
* Gets the fishy.
*
* @return the int
*/
public int GetFishy()
{
return _fishy;
}
/**
* Gets the fishz.
*
* @return the int
*/
public int GetFishz()
{
return _fishz;
}
public void SetPartyFind(int find)
{
_party_find = find;
}
public int GetPartyFind()
{
return _party_find;
}
/**
* Sets the lure.
*
* @param lure the lure
*/
public void SetLure(L2ItemInstance lure)
{
_lure = lure;
}
/**
* Gets the lure.
*
* @return the l2 item instance
*/
public L2ItemInstance GetLure()
{
return _lure;
}
/**
* Gets the inventory limit.
*
* @return the int
*/
public int getInventoryLimit()
{
int ivlim;
if(isGM())
{
ivlim = Config.INVENTORY_MAXIMUM_GM;
}
else 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;
}
/**
* Gets the ware house limit.
*
* @return the int
*/
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;
}
/**
* Gets the private sell store limit.
*
* @return the int
*/
public int GetPrivateSellStoreLimit()
{
int pslim;
if(getRace() == Race.dwarf)
{
pslim = Config.MAX_PVTSTORE_SLOTS_DWARF;
}
/**
* Gets the private buy store limit.
*
* @return the int
*/
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;
}
/**
* Gets the freight limit.
*
* @return the int
*/
public int GetFreightLimit()
{
return Config.FREIGHT_SLOTS + (int) getStat().calcStat(Stats.FREIGHT_LIM, 0, null, null);
}
/**
* Gets the dwarf recipe limit.
*
* @return the int
*/
public int GetDwarfRecipeLimit()
{
int recdlim = Config.DWARF_RECIPE_LIMIT;
recdlim += (int) getStat().calcStat(Stats.REC_D_LIM, 0, null, null);
return recdlim;
}
/**
* Gets the common recipe limit.
*
* @return the int
*/
public int GetCommonRecipeLimit()
{
int recclim = Config.COMMON_RECIPE_LIMIT;
recclim += (int) getStat().calcStat(Stats.REC_C_LIM, 0, null, null);
return recclim;
}
/**
* Sets the mount object id.
*
* @param newID the new mount object id
*/
public void setMountObjectID(int newID)
{
_mountObjectID = newID;
}
/**
* Gets the mount object id.
*
* @return the mount object id
*/
public int getMountObjectID()
{
return _mountObjectID;
}
/** The _lure. */
private L2ItemInstance _lure = null;
/**
* Get the current skill in use or return null.<BR>
* <BR>
*
* @return the current skill
*/
public SkillDat getCurrentSkill()
{
return _currentSkill;
}
/**
* Create a new SkillDat object and set the player _currentSkill.<BR>
* <BR>
*
* @param currentSkill the current skill
* @param ctrlPressed the ctrl pressed
* @param shiftPressed the shift pressed
*/
public void setCurrentSkill(L2Skill currentSkill, boolean ctrlPressed, boolean shiftPressed)
{
if(currentSkill == null)
{
if(Config.DEBUG)
{
_log.info("Setting current skill: NULL for " + getName() + ".");
}
_queuedSkill = new SkillDat(queuedSkill, ctrlPressed, shiftPressed);
}
/**
* Gets the power grade.
*
* @return the power grade
*/
public int getPowerGrade()
{
return _powerGrade;
}
/**
* Sets the power grade.
*
* @param power the new power grade
*/
public void setPowerGrade(int power)
{
_powerGrade = power;
}
/**
* Checks if is cursed weapon equiped.
*
* @return true, if is cursed weapon equiped
*/
public boolean isCursedWeaponEquiped()
{
return _cursedWeaponEquipedId != 0;
}
/**
* Sets the cursed weapon equiped id.
*
* @param value the new cursed weapon equiped id
*/
public void setCursedWeaponEquipedId(int value)
{
_cursedWeaponEquipedId = value;
}
/**
* Gets the cursed weapon equiped id.
*
* @return the cursed weapon equiped id
*/
public int getCursedWeaponEquipedId()
{
return _cursedWeaponEquipedId;
}
/** The _charm of courage. */
private boolean _charmOfCourage = false;
/**
* Gets the charm of courage.
*
* @return the charm of courage
*/
public boolean getCharmOfCourage()
{
return _charmOfCourage;
}
/**
* Sets the charm of courage.
*
* @param val the new charm of courage
*/
public void setCharmOfCourage(boolean val)
{
_charmOfCourage = val;
sendPacket(new EtcStatusUpdate(this));
}
/**
* Gets the death penalty buff level.
*
* @return the death penalty buff level
*/
public int getDeathPenaltyBuffLevel()
{
return _deathPenaltyBuffLevel;
}
/**
* Sets the death penalty buff level.
*
* @param level the new death penalty buff level
*/
public void setDeathPenaltyBuffLevel(int level)
{
_deathPenaltyBuffLevel = level;
}
/**
* restore all Custom Data hero/noble/donator.
*/
public void restoreCustomStatus()
{
if(Config.DEVELOPER)
{
_log.info("Restoring character status "+getName()+" from database...");
}
int hero = 0;
int noble = 0;
int donator = 0;
long hero_end = 0;
Connection con = null;
try
{
con = L2DatabaseFactory.getInstance().getConnection(fals e);
PreparedStatement statement = con.prepareStatement(STATUS_DATA_GET);
statement.setInt(1, getObjectId());
if(getDeathPenaltyBuffLevel() > 0)
{
addSkill(SkillTable.getInstance().getInfo(5076, getDeathPenaltyBuffLevel()), false);
SystemMessage sm = new SystemMessage(SystemMessageId.DEATH_PENALTY_LEVEL_ S1_ADDED);
sm.addNumber(getDeathPenaltyBuffLevel());
sendPacket(sm);
sm = null;
}
sendPacket(new EtcStatusUpdate(this));
}
/** The Reuse time stamps. */
private FastMap<Integer, TimeStamp> ReuseTimeStamps = new FastMap<Integer, TimeStamp>().shared();
/**
* 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 class TimeStamp
{
private int skill;
private long reuse;
private Date stamp;
public TimeStamp(int _skill, long _reuse)
{
skill = _skill;
reuse = _reuse;
stamp = new Date(new Date().getTime() + reuse);
}
public int getSkill()
{
return skill;
}
public long getReuse()
{
return reuse;
}
public boolean hasNotPassed()
{
Date d = new Date();
if(d.before(stamp))
{
reuse -= d.getTime() - (stamp.getTime() - reuse);
return true;
}
return false;
}
}
*/
public static class TimeStamp
{
public long getStamp()
{
return stamp;
}
public int getSkill()
{
return skill;
}
public long getReuse()
{
return reuse;
}
public long getRemaining()
{
return Math.max(stamp - System.currentTimeMillis(), 0L);
}
protected TimeStamp(int _skill, long _reuse, long _systime)
{
skill = _skill;
reuse = _reuse;
stamp = _systime;
}
}
/**
* Index according to skill id the current timestamp of use.
*
* @param s the s
* @param r the r
*/
@Override
public void addTimeStamp(int s, int r)
{
ReuseTimeStamps.put(s, new TimeStamp(s, r));
}
/**
* Index according to skill this TimeStamp instance for restoration purposes only.
*
* @param T the t
*/
private void addTimeStamp(TimeStamp T)
{
ReuseTimeStamps.put(T.getSkill(), T);
}
/**
* Index according to skill id the current timestamp of use.
*
* @param s the s
*/
@Override
public void removeTimeStamp(int s)
{
ReuseTimeStamps.remove(s);
}
public Collection<TimeStamp> getReuseTimeStamps()
{
return ReuseTimeStamps.values();
}
addSkill(skill, false);
isInDangerArea = true;
sendPacket(new EtcStatusUpdate(this));
SystemMessage sm = new SystemMessage(SystemMessageId.S1_S2);
sm.addString("You have entered a danger area");
sendPacket(sm);
sm = null;
}
public void exitDangerArea()
{
L2Skill skill = SkillTable.getInstance().getInfo(4268, 1);
isInDangerArea = false;
sendPacket(new EtcStatusUpdate(this));
SystemMessage sm = new SystemMessage(SystemMessageId.S1_S2);
sm.addString("You have left a danger area");
sendPacket(sm);
sm = null;
}
*/
/* (non-Javadoc)
* @see com.l2jfrozen.gameserver.model.L2Character#sendDam ageMessage(com.l2jfrozen.gameserver.model.L2Charac ter, int, boolean, boolean, boolean)
*/
@Override
public final void sendDamageMessage(L2Character target, int damage, boolean mcrit, boolean pcrit, boolean miss)
{
// Check if hit is missed
if(miss)
{
sendPacket(new SystemMessage(SystemMessageId.MISSED_TARGET));
return;
}
// Check if hit is critical
if(pcrit)
{
sendPacket(new SystemMessage(SystemMessageId.CRITICAL_HIT));
/**
* Return true if last request is expired.
*
* @return true, if is request expired
*/
public boolean isRequestExpired()
{
return !(_requestExpireTime > GameTimeController.getGameTicks());
}
/** The _gm status. */
boolean _gmStatus = true; //true by default sincce this is used by GMS
// private Object _BanChatTask;
// private long _banchat_timer;
/**
* Sets the gm status active.
*
* @param state the new gm status active
*/
public void setGmStatusActive(boolean state)
{
_gmStatus = state;
}
/**
* Checks for gm status active.
*
* @return true, if successful
*/
public boolean hasGmStatusActive()
{
return _gmStatus;
}
/*
//////////////////////////////////////////////////////////////////
//START CHAT BAN SYSTEM
//////////////////////////////////////////////////////////////////
public void setChatBanTimer(long time)
{
_chatBanTimer = time;
}
public void run()
{
_player.setChatBanned(false, 0);
}
}
*/
//////////////////////////////////////////////////////////////////
//END CHAT BAN SYSTEM
//////////////////////////////////////////////////////////////////
/** The _saymode. */
public L2Object _saymode = null;
/**
* Gets the say mode.
*
* @return the say mode
*/
public L2Object getSayMode()
{
return _saymode;
}
/**
* Sets the say mode.
*
* @param say the new say mode
*/
public void setSayMode(L2Object say)
{
_saymode = say;
}
/**
* Save event stats.
*/
public void saveEventStats()
{
_originalNameColor = getAppearance().getNameColor();
_originalKarma = getKarma();
_eventKills = 0;
}
/**
* Gets the current skill world position.
*
* @return the current skill world position
*/
public Point3D getCurrentSkillWorldPosition()
{
return _currentSkillWorldPosition;
}
/**
* Sets the current skill world position.
*
* @param worldPosition the new current skill world position
*/
public void setCurrentSkillWorldPosition(final Point3D worldPosition)
{
_currentSkillWorldPosition = worldPosition;
}
////////////////////////////////////////////////
/**
* Checks if is cursed weapon equipped.
*
* @return true, if is cursed weapon equipped
*/
public boolean isCursedWeaponEquipped()
{
return _cursedWeaponEquipedId != 0;
}
// Notify self and others about speed change
broadcastUserInfo();
return true;
}
return false;
}
/**
* Gets the pc bang score.
*
* @return the pc bang score
*/
public int getPcBangScore()
{
return pcBangPoint;
}
/**
* Reduce pc bang score.
*
* @param to the to
*/
public void reducePcBangScore(int to)
{
pcBangPoint -= to;
updatePcBangWnd(to, false, false);
}
/**
* Adds the pc bang score.
*
* @param to the to
*/
public void addPcBangScore(int to)
{
pcBangPoint += to;
}
/**
* Update pc bang wnd.
*
* @param score the score
* @param add the add
* @param duble the duble
*/
public void updatePcBangWnd(int score, boolean add, boolean duble)
{
ExPCCafePointInfo wnd = new ExPCCafePointInfo(this, score, add, 24, duble);
sendPacket(wnd);
}
/**
* Show pc bang window.
*/
public void showPcBangWindow()
{
ExPCCafePointInfo wnd = new ExPCCafePointInfo(this, 0, false, 24, false);
sendPacket(wnd);
}
/**
* String to hex.
*
* @param color the color
* @return the string
*/
private String StringToHex(String color)
{
switch(color.length())
{
case 1:
color = new StringBuilder().append("00000").append(color).toSt ring();
break;
case 2:
color = new StringBuilder().append("0000").append(color).toStr ing();
break;
case 3:
color = new StringBuilder().append("000").append(color).toStri ng();
break;
case 4:
color = new StringBuilder().append("00").append(color).toStrin g();
break;
case 5:
color = new StringBuilder().append('0').append(color).toString ();
break;
}
return color;
}
/**
* Checks if is offline.
*
* @return true, if is offline
*/
public boolean isOffline()
{
return _isOffline;
}
/**
* Sets the offline.
*
* @param set the new offline
*/
public void setOffline(boolean set)
{
_isOffline = set;
}
/**
* Checks if is trade disabled.
*
* @return true, if is trade disabled
*/
public boolean isTradeDisabled()
{
return _isTradeOff || isCastingNow();
}
/**
* Sets the trade disabled.
*
* @param set the new trade disabled
*/
public void setTradeDisabled(boolean set)
{
_isTradeOff = set;
}
/**
* Show teleport html.
*/
public void showTeleportHtml()
{
TextBuilder text = new TextBuilder();
text.append("<html>");
text.append("<body>");
text.append("<title></title>");
text.append("<center>");
text.append("<img src=\"L2UI_CH3.herotower_deco\" width=256 height=32>");
text.append("<br><br>");
text.append("<table width=\"85%\"><tr><td>Your party leader, "+getParty().getLeader().getName()+", requested a group teleport to raidboss. You have 30 seconds from this popup to teleport, or the teleport windows will close</td></tr></table><br>");
text.append("<a action=\"bypass -h rbAnswear\">Port with my party</a><br>");
text.append("<a action=\"bypass -h rbAnswearDenied\">Don't port</a><br1>");
text.append("<center><img src=\"L2UI.SquareGray\" width=\"280\" height=\"1\">");
text.append("<font color=\"999999\">Gates of Fire</font></center>");
text.append("</body>");
text.append("</html>");
NpcHtmlMessage html = new NpcHtmlMessage(1);
html.setHtml(text.toString());
sendPacket(html);
}
/** The Dropzor. */
String Dropzor = "Coin of Luck";
/** The isintwtown. */
private boolean isintwtown = false;
/**
* Checks if is inside tw town.
*
* @return true, if is inside tw town
*/
public boolean isInsideTWTown()
{
if(isintwtown)
return true;
return false;
}
/**
* Sets the inside tw town.
*
* @param b the new inside tw town
*/
public void setInsideTWTown(boolean b)
{
isintwtown = true;
}
/**
* check if local player can make multibox and also refresh local boxes instances number.
*
* @return true, if successful
*/
public boolean checkMultiBox(){
boolean output = true;
int boxes_number = 0; //this one
List<String> active_boxes = new ArrayList<String>();
String ip = player.getClient().getConnection().getInetAddress( ).getHostAddress();
if(thisip.equals(ip) && this != player)
{
if(!Config.ALLOW_DUALBOX){
output=false;
break;
}
if(boxes_number+1>Config.ALLOWED_BOXES){ //actual count+actual player one
output = false;
break;
}
boxes_number++;
active_boxes.add(player.getName());
}
}
}
}
}
if(output){
_active_boxes = boxes_number+1; //current number of boxes+this one
if(!active_boxes.contains(this.getName())){
active_boxes.add(this.getName());
else
{
System.out.println("process "+ process + "no Known while try set end date");
return;
}
Date dt = new Date(end_day);
System.out.println(""+process +" end time for player " + getName() + " is " + dt);
}
else
{
if(process.equals("aio"))
_aio_endTime = 0;
else
{
System.out.println("process "+ process + "no Known while try set end date");
return;
}
}
}
/**
* Gets the aio end time.
*
* @return the aio end time
*/
public long getAioEndTime()
{
return _aio_endTime;
}
/**
* Gets the offline start time.
*
* @return the offline start time
*/
public long getOfflineStartTime()
{
return _offlineShopStart;
}
/**
* Sets the offline start time.
*
* @param time the new offline start time
*/
public void setOfflineStartTime(long time)
{
_offlineShopStart = time;
}
// during fall validations will be disabled for 10 ms.
/** The Constant FALLING_VALIDATION_DELAY. */
private static final int FALLING_VALIDATION_DELAY = 10000;
/** The _falling timestamp. */
private long _fallingTimestamp = 0;
/**
* Return true if character falling now
* On the start of fall return false for correct coord sync !.
*
* @param z the z
* @return true, if is falling
*/
public final boolean isFalling(int z)
{
if (isDead()
|| isFlying()
|| isInvul()
|| isInFunEvent()
|| isInsideZone(ZONE_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);
sendPacket(new SystemMessage(SystemMessageId.FALL_DAMAGE_S1).addN umber(damage));
}
setFalling();
return false;
}
/**
* Set falling timestamp.
*/
public final void setFalling()
{
_fallingTimestamp = System.currentTimeMillis() + FALLING_VALIDATION_DELAY;
}
/** Previous coordinate sent to party in ValidatePosition *. */
private Point3D _lastPartyPosition = new Point3D(0, 0, 0);
/**
* Sets the last party position.
*
* @param x the x
* @param y the y
* @param z the z
*/
public void setLastPartyPosition(int x, int y, int z)
{
_lastPartyPosition.setXYZ(x,y,z);
}
/**
* Gets the last party position distance.
*
* @param x the x
* @param y the y
* @param z the z
* @return the last party position distance
*/
public int getLastPartyPositionDistance(int x, int y, int z)
{
double dx = (x - _lastPartyPosition.getX());
double dy = (y - _lastPartyPosition.getY());
double dz = (z - _lastPartyPosition.getZ());
return (int)Math.sqrt(dx*dx + dy*dy + dz*dz);
}
/**
* Checks if is awaying.
*
* @return the _awaying
*/
public boolean isAwaying()
{
return _awaying;
}
/**
* Sets the _awaying.
*
* @param _awaying the _awaying to set
*/
public void set_awaying(boolean _awaying)
{
this._awaying = _awaying;
}
/**
* Checks if is locked.
*
* @return true, if is locked
*/
public boolean isLocked()
{
return _isLocked;
}
/**
* Sets the locked.
*
* @param a the new locked
*/
public void setLocked(boolean a)
{
_isLocked = a;
}
/**
* Checks if is stored.
*
* @return true, if is stored
*/
public boolean isStored()
{
return _isStored;
}
/**
* Sets the stored.
*
* @param a the new stored
*/
public void setStored(boolean a)
{
_isStored = a;
}
/** The _punish level. */
private PunishLevel _punishLevel = PunishLevel.NONE;
/** The _punish timer. */
private long _punishTimer = 0;
/** The _punish task. */
private ScheduledFuture<?> _punishTask;
/**
* The Enum PunishLevel.
*/
public enum PunishLevel
{
/** The NONE. */
NONE(0, ""),
/** The CHAT. */
CHAT(1, "chat banned"),
/** The JAIL. */
JAIL(2, "jailed"),
/** The CHAR. */
CHAR(3, "banned"),
/** The ACC. */
ACC(4, "banned");
/** The pun value. */
private final int punValue;
/** The pun string. */
private final String punString;
/**
* Instantiates a new punish level.
*
* @param value the value
* @param string the string
*/
PunishLevel(int value, String string)
{
punValue = value;
punString = string;
}
/**
* Value.
*
* @return the int
*/
public int value()
{
return punValue;
}
/**
* String.
*
* @return the string
*/
public String string()
{
return punString;
}
}
// open/close gates
@SuppressWarnings("synthetic-access")
private GatesRequest _gatesRequest = new GatesRequest();
private 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);
}
/**
* returns punishment level of player.
*
* @return the punish level
*/
public PunishLevel getPunishLevel()
{
return _punishLevel;
}
/**
* Checks if is in jail.
*
* @return True if player is jailed
*/
public boolean isInJail()
{
return _punishLevel == PunishLevel.JAIL;
}
/**
* Checks if is chat banned.
*
* @return True if player is chat banned
*/
public boolean isChatBanned()
{
return _punishLevel == PunishLevel.CHAT;
}
/**
* Sets the punish level.
*
* @param state the new punish level
*/
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 the punish level.
*
* @param state the state
* @param delayInMinutes the delay in minutes
*/
public void setPunishLevel(PunishLevel state, int delayInMinutes)
{
long delayInMilliseconds = delayInMinutes * 60000L;
setPunishLevel(state, delayInMilliseconds);
}
/**
* Sets punish level for player based on delay.
*
* @param state the state
* @param delayInMilliseconds 0 - Indefinite
*/
public void setPunishLevel(PunishLevel state, long delayInMilliseconds)
{
switch (state)
{
case NONE: // Remove Punishments
{
switch (_punishLevel)
{
case CHAT:
{
_punishLevel = state;
stopPunishTask(true);
sendPacket(new EtcStatusUpdate(this));
sendMessage("Your Chat ban has been lifted");
break;
}
case JAIL:
{
_punishLevel = state;
// Open a Html message to inform the player
NpcHtmlMessage htmlMsg = new NpcHtmlMessage(0);
String jailInfos = HtmCache.getInstance().getHtm("data/html/jail_out.htm");
if (jailInfos != null)
htmlMsg.setHtml(jailInfos);
else
htmlMsg.setHtml("<html><body>You are free for now, respect server rules!</body></html>");
sendPacket(htmlMsg);
stopPunishTask(true);
teleToLocation(17836, 170178, -3507, true); // Floran
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 (delayInMilliseconds > 0)
{
_punishTimer = delayInMilliseconds;
// start the countdown
int minutes = (int) (delayInMilliseconds/60000);
_punishTask = ThreadPoolManager.getInstance().scheduleGeneral(ne w PunishTask(this), _punishTimer);
sendMessage("You are chat banned for "+minutes+" minutes.");
}
else
sendMessage("You have been chat banned");
break;
}
case JAIL: // Jail Player
{
_punishLevel = state;
_punishTimer = 0;
// Remove the task if any
stopPunishTask(false);
if (delayInMilliseconds > 0)
{
_punishTimer = delayInMilliseconds; // Delay in milliseconds
// start the countdown
_punishTask = ThreadPoolManager.getInstance().scheduleGeneral(ne w PunishTask(this), _punishTimer);
sendMessage("You are in jail for "+delayInMilliseconds/60000+" minutes.");
}
// Open a Html message to inform the player
NpcHtmlMessage htmlMsg = new NpcHtmlMessage(0);
String jailInfos = HtmCache.getInstance().getHtm("data/html/jail_in.htm");
if (jailInfos != null)
htmlMsg.setHtml(jailInfos);
else
htmlMsg.setHtml("<html><body>You have been put in jail by an admin.</body></html>");
sendPacket(htmlMsg);
setInstanceId(0);
setIsIn7sDungeon(false);
teleToLocation(-114356, -249645, -2984, false); // 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();
}
/**
* Gets the punish timer.
*
* @return the punish timer
*/
public long getPunishTimer()
{
return _punishTimer;
}
/**
* Sets the punish timer.
*
* @param time the new punish timer
*/
public void setPunishTimer(long time)
{
_punishTimer = time;
}
/**
* Update punish state.
*/
private void updatePunishState()
{
if (getPunishLevel() != PunishLevel.NONE)
{
// If punish timer exists, restart punishtask.
if (_punishTimer > 0)
{
_punishTask = ThreadPoolManager.getInstance().scheduleGeneral(ne w PunishTask(this), _punishTimer);
sendMessage("You are still " + getPunishLevel().string() + " for " + (_punishTimer / 60000) + " minutes.");
}
if (getPunishLevel() == PunishLevel.JAIL)
{
// If player escaped, put him back in jail
if (!isInsideZone(ZONE_JAIL))
teleToLocation(-114356,-249645,-2984, true);
}
}
}
/**
* Stop punish task.
*
* @param save the save
*/
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);
ThreadPoolManager.getInstance().removeGeneral((Run nable)_punishTask);
_punishTask = null;
}
}
/**
* The Class PunishTask.
*/
private class PunishTask implements Runnable
{
/** The _player. */
L2PcInstance _player;
// protected long _startedAt;
/**
* Instantiates a new punish task.
*
* @param player the player
*/
protected PunishTask(L2PcInstance player)
{
_player = player;
// _startedAt = System.currentTimeMillis();
}
/**
* Gets the flood protectors.
*
* @return the flood protectors
*/
public FloodProtectors getFloodProtectors()
{
return getClient().getFloodProtectors();
}
/**
* Test if player inventory is under 80% capaity.
*
* @return true, if is inventory under80
*/
public boolean isInventoryUnder80()
{
if (getInventory().getSize() <= (getInventoryLimit() * 0.8))
{
return true;
}
return false;
}
// Multisell
/** The _current multi sell id. */
private int _currentMultiSellId = -1;
/**
* Gets the multi sell id.
*
* @return the multi sell id
*/
public final int getMultiSellId()
{
return _currentMultiSellId;
}
/**
* Sets the multi sell id.
*
* @param listid the new multi sell id
*/
public final void setMultiSellId(int listid)
{
_currentMultiSellId = listid;
}
/**
* Checks if is party waiting.
*
* @return true, if is party waiting
*/
public boolean isPartyWaiting()
{
return PartyMatchWaitingList.getInstance().getPlayers().c ontains(this);
}
// these values are only stored temporarily
/** The _partyroom. */
private int _partyroom = 0;
/**
* Sets the party room.
*
* @param id the new party room
*/
public void setPartyRoom(int id)
{
_partyroom = id;
}
/**
* Gets the party room.
*
* @return the party room
*/
public int getPartyRoom()
{
return _partyroom;
}
/**
* Checks if is in party match room.
*
* @return true, if is in party match room
*/
public boolean isInPartyMatchRoom()
{
return _partyroom > 0;
}
/**
* Checks if is item equipped by item id.
*
* @param item_id the item_id
* @return true, if is item equipped by item id
*/
public boolean isItemEquippedByItemId(int item_id)
{
if(_inventory == null)
return false;
public long getLastAttackPacket()
{
return _lastAttackPacket;
}
public void setLastAttackPacket()
{
_lastAttackPacket = System.currentTimeMillis();
}
public void checkItemRestriction()
{
for (int i = 0; i < Inventory.PAPERDOLL_TOTALSLOTS; i++)
{
L2ItemInstance equippedItem = getInventory().getPaperdollItem(i);
if (equippedItem != null && !equippedItem.checkOlympCondition())
{
if (equippedItem.isAugmented())
equippedItem.getAugmentation().removeBoni(this);
L2ItemInstance[] items = getInventory().unEquipItemInSlotAndRecord(i);
if (equippedItem.isWear())
continue;
SystemMessage sm = null;
if (equippedItem.getEnchantLevel() > 0)
{
sm = new SystemMessage(SystemMessageId.EQUIPMENT_S1_S2_REMO VED);
sm.addNumber(equippedItem.getEnchantLevel());
sm.addItemName(equippedItem.getItemId());
}
else
{
sm = new SystemMessage(SystemMessageId.S1_DISARMED);
sm.addItemName(equippedItem.getItemId());
}
sendPacket(sm);
InventoryUpdate iu = new InventoryUpdate();
iu.addItems(Arrays.asList(items));
sendPacket(iu);
broadcastUserInfo();
}
}
}
public void enterOlympiadObserverMode(int x, int y, int z, int id, boolean storeCoords)
{
if (getPet() != null)
getPet().unSummon(this);
public void giveHeroSkills()
{
for (L2Skill s : HeroSkillTable.getHeroSkills())
{
addSkill(s, false); //Dont Save Hero skills to database
}
sendSkillList();
}
public void removeHeroSkills()
{
for (L2Skill s : HeroSkillTable.getHeroSkills())
{
super.removeSkill(s); //Just Remove skills from nonHero characters
}
sendSkillList();
}
/**
* Get the current pet skill in use or return null.<br><br>
* @return
*
*/
public SkillDat getCurrentPetSkill()
{
return _currentPetSkill;
}
/**
* Create a new SkillDat object and set the player _currentPetSkill.<br><br>
* @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);
}
27-06-2010, 05:25 PM
Modo Linear
