BETA: Reuse time stamps rework:

	* Using lazy initialization will prevent from useless object creation.
	* All related code is now in `L2Character`.
	* Removed custom skill type GET_PLAYER.
	* Cleanup at `L2PcInstance`, `L2PetInstance` and `TimeStamp`.
	* Effects must be restored '''before''' sending `SkillCoolTime`!
	* Added missing skill level in `SkillCoolTime`.
	* Added missing !JavaDocs.

L2J_Server_BETA/java/com/l2jserver/gameserver/model/TimeStamp.java

@@ -29,26 +29,19 @@ import com.l2jserver.gameserver.model.skills.L2Skill;
  */
 public class TimeStamp
 {
-	private final int _id1; // Item or Skill Id.
-	private final int _id2; // Item Object Id or Skill Level.
+	/** Item or skill ID. */
+	private final int _id1;
+	/** Item object ID or skill level. */
+	private final int _id2;
+	/** Item or skill reuse time. */
 	private final long _reuse;
+	/** Time stamp. */
 	private final long _stamp;
+	/** Shared reuse group. */
 	private final int _group;
 	
 	/**
-	 * @param skill the skill upon the stamp will be created.
-	 * @param reuse the reuse time for this skill.
-	 */
-	public TimeStamp(L2Skill skill, long reuse)
-	{
-		_id1 = skill.getId();
-		_id2 = skill.getLevel();
-		_reuse = reuse;
-		_stamp = System.currentTimeMillis() + reuse;
-		_group = -1;
-	}
-	
-	/**
+	 * Skill time stamp constructor.
 	 * @param skill the skill upon the stamp will be created.
 	 * @param reuse the reuse time for this skill.
 	 * @param systime overrides the system time with a customized one.
@@ -58,24 +51,12 @@ public class TimeStamp
 		_id1 = skill.getId();
 		_id2 = skill.getLevel();
 		_reuse = reuse;
-		_stamp = systime;
+		_stamp = systime > 0 ? systime : System.currentTimeMillis() + reuse;
 		_group = -1;
 	}
 	
 	/**
-	 * @param item the item upon the stamp will be created.
-	 * @param reuse the reuse time for this item.
-	 */
-	public TimeStamp(L2ItemInstance item, long reuse)
-	{
-		_id1 = item.getId();
-		_id2 = item.getObjectId();
-		_reuse = reuse;
-		_stamp = System.currentTimeMillis() + reuse;
-		_group = item.getSharedReuseGroup();
-	}
-	
-	/**
+	 * Item time stamp constructor.
 	 * @param item the item upon the stamp will be created.
 	 * @param reuse the reuse time for this item.
 	 * @param systime overrides the system time with a customized one.
@@ -85,12 +66,13 @@ public class TimeStamp
 		_id1 = item.getId();
 		_id2 = item.getObjectId();
 		_reuse = reuse;
-		_stamp = systime;
+		_stamp = systime > 0 ? systime : System.currentTimeMillis() + reuse;
 		_group = item.getSharedReuseGroup();
 	}
 	
 	/**
-	 * @return the time stamp, either the system time where this time stamp was created or the custom time assigned.
+	 * Gets the time stamp.
+	 * @return the time stamp, either the system time where this time stamp was created or the custom time assigned
 	 */
 	public long getStamp()
 	{
@@ -98,7 +80,8 @@ public class TimeStamp
 	}
 	
 	/**
-	 * @return the first Id for the item, the item Id.
+	 * Gets the item ID.
+	 * @return the item ID
 	 */
 	public int getItemId()
 	{
@@ -106,7 +89,8 @@ public class TimeStamp
 	}
 	
 	/**
-	 * @return the second Id for the item, the item object Id.
+	 * Gets the item object ID.
+	 * @return the item object ID
 	 */
 	public int getItemObjectId()
 	{
@@ -114,7 +98,8 @@ public class TimeStamp
 	}
 	
 	/**
-	 * @return the skill Id.
+	 * Gets the skill ID.
+	 * @return the skill ID
 	 */
 	public int getSkillId()
 	{
@@ -122,7 +107,8 @@ public class TimeStamp
 	}
 	
 	/**
-	 * @return the skill level.
+	 * Gets the skill level.
+	 * @return the skill level
 	 */
 	public int getSkillLvl()
 	{
@@ -130,7 +116,8 @@ public class TimeStamp
 	}
 	
 	/**
-	 * @return the reuse set for this Item/Skill.
+	 * Gets the reuse.
+	 * @return the reuse
 	 */
 	public long getReuse()
 	{
@@ -138,7 +125,9 @@ public class TimeStamp
 	}
 	
 	/**
-	 * @return the shared reuse group for the item, -1 for skills.
+	 * Get the shared reuse group.<br>
+	 * Only used on items.
+	 * @return the shared reuse group
 	 */
 	public int getSharedReuseGroup()
 	{
@@ -146,7 +135,8 @@ public class TimeStamp
 	}
 	
 	/**
-	 * @return the remaining time for this time stamp to expire.
+	 * Gets the remaining time.
+	 * @return the remaining time for this time stamp to expire
 	 */
 	public long getRemaining()
 	{
@@ -154,8 +144,8 @@ public class TimeStamp
 	}
 	
 	/**
-	 * Check if the reuse delay has passed and if it has not then update the stored reuse time according to what is currently remaining on the delay.
-	 * @return {@code true} if this time stamp has expired, {@code false} otherwise.
+	 * Verifies if the reuse delay has passed.
+	 * @return {@code true} if this time stamp has expired, {@code false} otherwise
 	 */
 	public boolean hasNotPassed()
 	{

L2J_Server_BETA/java/com/l2jserver/gameserver/model/actor/L2Character.java

@@ -69,6 +69,7 @@ import com.l2jserver.gameserver.model.L2WorldRegion;
 import com.l2jserver.gameserver.model.Location;
 import com.l2jserver.gameserver.model.PcCondOverride;
 import com.l2jserver.gameserver.model.TeleportWhereType;
+import com.l2jserver.gameserver.model.TimeStamp;
 import com.l2jserver.gameserver.model.actor.events.CharEvents;
 import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
 import com.l2jserver.gameserver.model.actor.instance.L2PetInstance;
@@ -200,10 +201,15 @@ public abstract class L2Character extends L2Object implements ISkillsHolder, IDe
 	
 	/** Table of Calculators containing all used calculator */
 	private Calculator[] _calculators;
-	
 	/** Map containing all skills of this character. */
 	private final Map<Integer, L2Skill> _skills = new FastMap<Integer, L2Skill>().shared();
-	
+	/** Map containing the skill reuse time stamps. */
+	private volatile Map<Integer, TimeStamp> _reuseTimeStampsSkills = null;
+	/** Map containing the item reuse time stamps. */
+	private volatile Map<Integer, TimeStamp> _reuseTimeStampsItems = null;
+	/** Map containing all the disabled skills. */
+	private volatile Map<Integer, Long> _disabledSkills = null;
+	private boolean _allSkillsDisabled;
 	/** Map containing the active chance skills on this character */
 	private volatile ChanceSkillList _chanceSkills;
 	
@@ -1917,6 +1923,7 @@ public abstract class L2Character extends L2Object implements ISkillsHolder, IDe
 				{
 					sm = SystemMessage.getSystemMessage(SystemMessageId.USE_S1);
 					sm.addSkillName(skill);
+					break;
 				}
 			}
 			
@@ -2126,42 +2133,295 @@ public abstract class L2Character extends L2Object implements ISkillsHolder, IDe
 	}
 	
 	/**
-	 * @param item
-	 * @param reuse
+	 * Gets the item reuse time stamps map.
+	 * @return the item reuse time stamps map
 	 */
-	public void addTimeStampItem(L2ItemInstance item, long reuse)
+	public final Map<Integer, TimeStamp> getItemReuseTimeStamps()
 	{
-		// Dummy
+		return _reuseTimeStampsItems;
 	}
 	
 	/**
-	 * @param itemObjId the item object Id
-	 * @return the reuse time stamp
+	 * Adds a item reuse time stamp.
+	 * @param item the item
+	 * @param reuse the reuse
 	 */
-	public long getItemRemainingReuseTime(int itemObjId)
+	public final void addTimeStampItem(L2ItemInstance item, long reuse)
 	{
-		return -1;
+		addTimeStampItem(item, reuse, -1);
 	}
 	
 	/**
-	 * Index according to skill id the current time stamp of use.
-	 * @param skill id
-	 * @param reuse delay
+	 * Adds a item reuse time stamp.<br>
+	 * Used for restoring purposes.
+	 * @param item the item
+	 * @param reuse the reuse
+	 * @param systime the system time
 	 */
-	public void addTimeStamp(L2Skill skill, long reuse)
+	public final void addTimeStampItem(L2ItemInstance item, long reuse, long systime)
 	{
-		// Dummy
+		if (_reuseTimeStampsItems == null)
+		{
+			synchronized (this)
+			{
+				if (_reuseTimeStampsItems == null)
+				{
+					_reuseTimeStampsItems = new ConcurrentHashMap<>();
+				}
+			}
+		}
+		_reuseTimeStampsItems.put(item.getObjectId(), new TimeStamp(item, reuse, systime));
 	}
 	
 	/**
-	 * @param skillReuseHashId
-	 * @return -1
+	 * Gets the item remaining reuse time for a given item object ID.
+	 * @param itemObjId the item object ID
+	 * @return if the item has a reuse time stamp, the remaining time, otherwise -1
 	 */
-	public long getSkillRemainingReuseTime(int skillReuseHashId)
+	public synchronized final long getItemRemainingReuseTime(int itemObjId)
 	{
+		if ((_reuseTimeStampsItems == null) || !_reuseTimeStampsItems.containsKey(itemObjId))
+		{
+			return -1;
+		}
+		return _reuseTimeStampsItems.get(itemObjId).getRemaining();
+	}
+	
+	/**
+	 * Gets the item remaining reuse time for a given shared reuse item group.
+	 * @param group the shared reuse item group
+	 * @return if the shared reuse item group has a reuse time stamp, the remaining time, otherwise -1
+	 */
+	public final long getReuseDelayOnGroup(int group)
+	{
+		if (group > 0)
+		{
+			for (TimeStamp ts : _reuseTimeStampsItems.values())
+			{
+				if ((ts.getSharedReuseGroup() == group) && ts.hasNotPassed())
+				{
+					return ts.getRemaining();
+				}
+			}
+		}
 		return -1;
 	}
 	
+	/**
+	 * Gets the skill reuse time stamps map.
+	 * @return the skill reuse time stamps map
+	 */
+	public final Map<Integer, TimeStamp> getSkillReuseTimeStamps()
+	{
+		return _reuseTimeStampsSkills;
+	}
+	
+	/**
+	 * Adds the skill reuse time stamp.
+	 * @param skill the skill
+	 * @param reuse the delay
+	 */
+	public final void addTimeStamp(L2Skill skill, long reuse)
+	{
+		addTimeStamp(skill, reuse, -1);
+	}
+	
+	/**
+	 * Adds the skill reuse time stamp.<br>
+	 * Used for restoring purposes.
+	 * @param skill the skill
+	 * @param reuse the reuse
+	 * @param systime the system time
+	 */
+	public final void addTimeStamp(L2Skill skill, long reuse, long systime)
+	{
+		if (_reuseTimeStampsSkills == null)
+		{
+			synchronized (this)
+			{
+				if (_reuseTimeStampsSkills == null)
+				{
+					_reuseTimeStampsSkills = new ConcurrentHashMap<>();
+				}
+			}
+		}
+		_reuseTimeStampsSkills.put(skill.getReuseHashCode(), new TimeStamp(skill, reuse, systime));
+	}
+	
+	/**
+	 * Removes a skill reuse time stamp.
+	 * @param skill the skill to remove
+	 */
+	public synchronized final void removeTimeStamp(L2Skill skill)
+	{
+		if (_reuseTimeStampsSkills != null)
+		{
+			_reuseTimeStampsSkills.remove(skill.getReuseHashCode());
+		}
+	}
+	
+	/**
+	 * Removes all skill reuse time stamps.
+	 */
+	public synchronized final void resetTimeStamps()
+	{
+		if (_reuseTimeStampsSkills != null)
+		{
+			_reuseTimeStampsSkills.clear();
+		}
+	}
+	
+	/**
+	 * Gets the skill remaining reuse time for a given skill hash code.
+	 * @param hashCode the skill hash code
+	 * @return if the skill has a reuse time stamp, the remaining time, otherwise -1
+	 */
+	public synchronized final long getSkillRemainingReuseTime(int hashCode)
+	{
+		if ((_reuseTimeStampsSkills == null) || !_reuseTimeStampsSkills.containsKey(hashCode))
+		{
+			return -1;
+		}
+		return _reuseTimeStampsSkills.get(hashCode).getRemaining();
+	}
+	
+	/**
+	 * Verifies if the skill is under reuse time.
+	 * @param hashCode the skill hash code
+	 * @return {@code true} if the skill is under reuse time, {@code false} otherwise
+	 */
+	public synchronized final boolean hasSkillReuse(int hashCode)
+	{
+		if ((_reuseTimeStampsSkills == null) || !_reuseTimeStampsSkills.containsKey(hashCode))
+		{
+			return false;
+		}
+		return _reuseTimeStampsSkills.get(hashCode).hasNotPassed();
+	}
+	
+	/**
+	 * Gets the skill reuse time stamp.
+	 * @param hashCode the skill hash code
+	 * @return if the skill has a reuse time stamp, the skill reuse time stamp, otherwise {@code null}
+	 */
+	public synchronized final TimeStamp getSkillReuseTimeStamp(int hashCode)
+	{
+		return _reuseTimeStampsSkills != null ? _reuseTimeStampsSkills.get(hashCode) : null;
+	}
+	
+	/**
+	 * Gets the disabled skills map.
+	 * @return the disabled skills map
+	 */
+	public Map<Integer, Long> getDisabledSkills()
+	{
+		return _disabledSkills;
+	}
+	
+	/**
+	 * Enables a skill.
+	 * @param skill the skill to enable
+	 */
+	public void enableSkill(L2Skill skill)
+	{
+		if ((skill == null) || (_disabledSkills == null))
+		{
+			return;
+		}
+		
+		_disabledSkills.remove(skill.getReuseHashCode());
+	}
+	
+	/**
+	 * Disables a skill for a given time.<br>
+	 * If delay is lesser or equal than zero, skill will be disabled "forever".
+	 * @param skill the skill to disable
+	 * @param delay delay in milliseconds
+	 */
+	public void disableSkill(L2Skill skill, long delay)
+	{
+		if (skill == null)
+		{
+			return;
+		}
+		
+		if (_disabledSkills == null)
+		{
+			synchronized (this)
+			{
+				if (_disabledSkills == null)
+				{
+					_disabledSkills = new ConcurrentHashMap<>();
+				}
+			}
+		}
+		
+		_disabledSkills.put(skill.getReuseHashCode(), delay > 0 ? System.currentTimeMillis() + delay : Long.MAX_VALUE);
+	}
+	
+	/**
+	 * Removes all the disabled skills.
+	 */
+	public synchronized final void resetDisabledSkills()
+	{
+		if (_disabledSkills != null)
+		{
+			_disabledSkills.clear();
+		}
+	}
+	
+	/**
+	 * Verifies if the skill is disabled.
+	 * @param skill the skill
+	 * @return {@code true} if the skill is disabled, {@code false} otherwise
+	 */
+	public boolean isSkillDisabled(L2Skill skill)
+	{
+		return (skill != null) && isSkillDisabled(skill.getReuseHashCode());
+	}
+	
+	/**
+	 * Verifies if the skill is disabled.
+	 * @param hashCode the skill hash code
+	 * @return {@code true} if the skill is disabled, {@code false} otherwise
+	 */
+	public boolean isSkillDisabled(int hashCode)
+	{
+		if (isAllSkillsDisabled())
+		{
+			return true;
+		}
+		
+		if ((_disabledSkills == null) || !_disabledSkills.containsKey(hashCode))
+		{
+			return false;
+		}
+		
+		if (_disabledSkills.get(hashCode) < System.currentTimeMillis())
+		{
+			_disabledSkills.remove(hashCode);
+			return false;
+		}
+		
+		return true;
+	}
+	
+	/**
+	 * Disables all skills.
+	 */
+	public void disableAllSkills()
+	{
+		_allSkillsDisabled = true;
+	}
+	
+	/**
+	 * Enables all skills, except those under reuse time or previously disabled.
+	 */
+	public void enableAllSkills()
+	{
+		_allSkillsDisabled = false;
+	}
+	
 	/**
 	 * Kill the L2Character.<br>
 	 * <B><U>Actions</U>:</B>
@@ -3316,22 +3576,13 @@ public abstract class L2Character extends L2Object implements ISkillsHolder, IDe
 		public int geoPathGty;
 	}
 	
-	/** Table containing all skillId that are disabled */
-	protected Map<Integer, Long> _disabledSkills;
-	private boolean _allSkillsDisabled;
-	
-	// private int _flyingRunSpeed;
-	// private int _floatingWalkSpeed;
-	// private int _flyingWalkSpeed;
-	// private int _floatingRunSpeed;
-	
 	/** Movement data of this L2Character */
 	protected MoveData _move;
 	
 	/** Orientation of the L2Character */
 	private int _heading;
 	
-	/** L2Charcater targeted by the L2Character */
+	/** This creature's target. */
 	private L2Object _target;
 	
 	// set by the start of attack, in game ticks
@@ -5827,118 +6078,6 @@ public abstract class L2Character extends L2Object implements ISkillsHolder, IDe
 		
 	}
 	
-	public Map<Integer, Long> getDisabledSkills()
-	{
-		return _disabledSkills;
-	}
-	
-	/**
-	 * Enable a skill (remove it from _disabledSkills of the L2Character).<br>
-	 * <B><U>Concept</U>:</B><br>
-	 * All skills disabled are identified by their skillId in <B>_disabledSkills</B> of the L2Character
-	 * @param skill the skill to enable.
-	 */
-	public void enableSkill(L2Skill skill)
-	{
-		if ((skill == null) || (_disabledSkills == null))
-		{
-			return;
-		}
-		
-		_disabledSkills.remove(Integer.valueOf(skill.getReuseHashCode()));
-	}
-	
-	/**
-	 * Disable this skill id for the duration of the delay in milliseconds.
-	 * @param skill
-	 * @param delay (seconds * 1000)
-	 */
-	public void disableSkill(L2Skill skill, long delay)
-	{
-		if (skill == null)
-		{
-			return;
-		}
-		
-		if (_disabledSkills == null)
-		{
-			synchronized (this)
-			{
-				if (_disabledSkills == null)
-				{
-					_disabledSkills = new ConcurrentHashMap<>();
-				}
-			}
-		}
-		
-		_disabledSkills.put(Integer.valueOf(skill.getReuseHashCode()), delay > 10 ? System.currentTimeMillis() + delay : Long.MAX_VALUE);
-	}
-	
-	/**
-	 * <B><U>Concept</U>:</B><br>
-	 * All skills disabled are identified by their reuse hashcodes in <B>_disabledSkills</B> of the L2Character
-	 * @param skill The L2Skill to check
-	 * @return true if a skill is disabled.
-	 */
-	public boolean isSkillDisabled(L2Skill skill)
-	{
-		if (skill == null)
-		{
-			return true;
-		}
-		
-		return isSkillDisabled(skill.getReuseHashCode());
-	}
-	
-	/**
-	 * <B><U>Concept</U>:</B><br>
-	 * All skills disabled are identified by their reuse hashcodes in <B>_disabledSkills</B> of the L2Character
-	 * @param reuseHashcode The reuse hashcode of the skillId/level to check
-	 * @return true if a skill is disabled.
-	 */
-	public boolean isSkillDisabled(int reuseHashcode)
-	{
-		if (isAllSkillsDisabled())
-		{
-			return true;
-		}
-		
-		if (_disabledSkills == null)
-		{
-			return false;
-		}
-		
-		final Long timeStamp = _disabledSkills.get(Integer.valueOf(reuseHashcode));
-		if (timeStamp == null)
-		{
-			return false;
-		}
-		
-		if (timeStamp < System.currentTimeMillis())
-		{
-			_disabledSkills.remove(Integer.valueOf(reuseHashcode));
-			return false;
-		}
-		
-		return true;
-	}
-	
-	/**
-	 * Disable all skills (set _allSkillsDisabled to True).
-	 */
-	public void disableAllSkills()
-	{
-		_allSkillsDisabled = true;
-	}
-	
-	/**
-	 * Enable all skills (set _allSkillsDisabled to False).
-	 */
-	public void enableAllSkills()
-	{
-		_allSkillsDisabled = false;
-	}
-	
 	/**
 	 * Launch the magic skill and calculate its effects on each target contained in the targets table.
 	 * @param skill The L2Skill to use

L2J_Server_BETA/java/com/l2jserver/gameserver/model/actor/instance/L2PcInstance.java

@@ -4271,7 +4271,7 @@ public final class L2PcInstance extends L2Playable
 	public void enableSkill(L2Skill skill)
 	{
 		super.enableSkill(skill);
-		_reuseTimeStampsSkills.remove(skill.getReuseHashCode());
+		removeTimeStamp(skill);
 	}
 	
 	@Override
@@ -7771,50 +7771,45 @@ public final class L2PcInstance extends L2Playable
 					statement.setInt(3, skill.getLevel());
 					statement.setInt(4, info.getTime());
 					
-					if (_reuseTimeStampsSkills.containsKey(skill.getReuseHashCode()))
-					{
-						TimeStamp t = _reuseTimeStampsSkills.get(skill.getReuseHashCode());
-						statement.setLong(5, t.hasNotPassed() ? t.getReuse() : 0);
-						statement.setDouble(6, t.hasNotPassed() ? t.getStamp() : 0);
-					}
-					else
-					{
-						statement.setLong(5, 0);
-						statement.setDouble(6, 0);
-					}
+					final TimeStamp t = getSkillReuseTimeStamp(skill.getReuseHashCode());
+					statement.setLong(5, (t != null) && t.hasNotPassed() ? t.getReuse() : 0);
+					statement.setDouble(6, (t != null) && t.hasNotPassed() ? t.getStamp() : 0);
 					
-					statement.setInt(7, 0);
+					statement.setInt(7, 0); // Store type 0, active buffs/debuffs.
 					statement.setInt(8, getClassIndex());
 					statement.setInt(9, ++buff_index);
 					statement.execute();
 				}
 			}
 			
-			// Store the reuse delays of remaining skills which
-			// lost effect but still under reuse delay. 'restore_type' 1.
-			for (Entry<Integer, TimeStamp> ts : _reuseTimeStampsSkills.entrySet())
+			// Skills under reuse.
+			final Map<Integer, TimeStamp> reuseTimeStamps = getSkillReuseTimeStamps();
+			if (reuseTimeStamps != null)
 			{
-				final int hash = ts.getKey();
-				if (storedSkills.contains(hash))
+				for (Entry<Integer, TimeStamp> ts : reuseTimeStamps.entrySet())
 				{
-					continue;
-				}
-				
-				final TimeStamp t = ts.getValue();
-				if ((t != null) && t.hasNotPassed())
-				{
-					storedSkills.add(hash);
+					final int hash = ts.getKey();
+					if (storedSkills.contains(hash))
+					{
+						continue;
+					}
 					
-					statement.setInt(1, getObjectId());
-					statement.setInt(2, t.getSkillId());
-					statement.setInt(3, t.getSkillLvl());
-					statement.setInt(4, -1);
-					statement.setLong(5, t.getReuse());
-					statement.setDouble(6, t.getStamp());
-					statement.setInt(7, 1);
-					statement.setInt(8, getClassIndex());
-					statement.setInt(9, ++buff_index);
-					statement.execute();
+					final TimeStamp t = ts.getValue();
+					if ((t != null) && t.hasNotPassed())
+					{
+						storedSkills.add(hash);
+						
+						statement.setInt(1, getObjectId());
+						statement.setInt(2, t.getSkillId());
+						statement.setInt(3, t.getSkillLvl());
+						statement.setInt(4, -1);
+						statement.setLong(5, t.getReuse());
+						statement.setDouble(6, t.getStamp());
+						statement.setInt(7, 1); // Restore type 1, skill reuse.
+						statement.setInt(8, getClassIndex());
+						statement.setInt(9, ++buff_index);
+						statement.execute();
+					}
 				}
 			}
 		}
@@ -7833,16 +7828,20 @@ public final class L2PcInstance extends L2Playable
 			ps1.setInt(1, getObjectId());
 			ps1.execute();
 			
-			for (TimeStamp ts : _reuseTimeStampsItems.values())
+			final Map<Integer, TimeStamp> itemReuseTimeStamps = getItemReuseTimeStamps();
+			if (itemReuseTimeStamps != null)
 			{
-				if ((ts != null) && ts.hasNotPassed())
+				for (TimeStamp ts : itemReuseTimeStamps.values())
 				{
-					ps2.setInt(1, getObjectId());
-					ps2.setInt(2, ts.getItemId());
-					ps2.setInt(3, ts.getItemObjectId());
-					ps2.setLong(4, ts.getReuse());
-					ps2.setDouble(5, ts.getStamp());
-					ps2.execute();
+					if ((ts != null) && ts.hasNotPassed())
+					{
+						ps2.setInt(1, getObjectId());
+						ps2.setInt(2, ts.getItemId());
+						ps2.setInt(3, ts.getItemObjectId());
+						ps2.setLong(4, ts.getReuse());
+						ps2.setDouble(5, ts.getStamp());
+						ps2.execute();
+					}
 				}
 			}
 		}
@@ -8874,10 +8873,10 @@ public final class L2PcInstance extends L2Playable
 		// Check if this skill is enabled (ex : reuse time)
 		if (isSkillDisabled(skill))
 		{
-			SystemMessage sm = null;
-			if (_reuseTimeStampsSkills.containsKey(skill.getReuseHashCode()))
+			final SystemMessage sm;
+			if (hasSkillReuse(skill.getReuseHashCode()))
 			{
-				int remainingTime = (int) (_reuseTimeStampsSkills.get(skill.getReuseHashCode()).getRemaining() / 1000);
+				int remainingTime = (int) (getSkillRemainingReuseTime(skill.getReuseHashCode()) / 1000);
 				int hours = remainingTime / 3600;
 				int minutes = (remainingTime % 3600) / 60;
 				int seconds = (remainingTime % 60);
@@ -10538,7 +10537,8 @@ public final class L2PcInstance extends L2Playable
 			// 1. Call store() before modifying _classIndex to avoid skill effects rollover.
 			// 2. Register the correct _classId against applied 'classIndex'.
 			store(Config.SUBCLASS_STORE_SKILL_COOLTIME);
-			_reuseTimeStampsSkills.clear();
+			
+			resetTimeStamps();
 			
 			// clear charges
 			_charges.set(0);
@@ -10603,10 +10603,7 @@ public final class L2PcInstance extends L2Playable
 			regiveTemporarySkills();
 			
 			// Prevents some issues when changing between subclases that shares skills
-			if ((_disabledSkills != null) && !_disabledSkills.isEmpty())
-			{
-				_disabledSkills.clear();
-			}
+			resetDisabledSkills();
 			
 			restoreEffects();
 			
@@ -12744,97 +12741,6 @@ public final class L2PcInstance extends L2Playable
 		}
 	}
 	
-	private final Map<Integer, TimeStamp> _reuseTimeStampsItems = new FastMap<>();
-	
-	@Override
-	public void addTimeStampItem(L2ItemInstance item, long reuse)
-	{
-		_reuseTimeStampsItems.put(item.getObjectId(), new TimeStamp(item, reuse));
-	}
-	
-	public void addTimeStampItem(L2ItemInstance item, long reuse, long systime)
-	{
-		_reuseTimeStampsItems.put(item.getObjectId(), new TimeStamp(item, reuse, systime));
-	}
-	
-	@Override
-	public long getItemRemainingReuseTime(int itemObjId)
-	{
-		if (!_reuseTimeStampsItems.containsKey(itemObjId))
-		{
-			return -1;
-		}
-		return _reuseTimeStampsItems.get(itemObjId).getRemaining();
-	}
-	
-	public long getReuseDelayOnGroup(int group)
-	{
-		if (group > 0)
-		{
-			for (TimeStamp ts : _reuseTimeStampsItems.values())
-			{
-				if ((ts.getSharedReuseGroup() == group) && ts.hasNotPassed())
-				{
-					return ts.getRemaining();
-				}
-			}
-		}
-		return 0;
-	}
-	
-	private final Map<Integer, TimeStamp> _reuseTimeStampsSkills = new FastMap<>();
-	
-	public Map<Integer, TimeStamp> getSkillReuseTimeStamps()
-	{
-		return _reuseTimeStampsSkills;
-	}
-	
-	@Override
-	public long getSkillRemainingReuseTime(int skillReuseHashId)
-	{
-		if (!_reuseTimeStampsSkills.containsKey(skillReuseHashId))
-		{
-			return -1;
-		}
-		return _reuseTimeStampsSkills.get(skillReuseHashId).getRemaining();
-	}
-	
-	public boolean hasSkillReuse(int skillReuseHashId)
-	{
-		if (!_reuseTimeStampsSkills.containsKey(skillReuseHashId))
-		{
-			return false;
-		}
-		return _reuseTimeStampsSkills.get(skillReuseHashId).hasNotPassed();
-	}
-	
-	public TimeStamp getSkillReuseTimeStamp(int skillReuseHashId)
-	{
-		return _reuseTimeStampsSkills.get(skillReuseHashId);
-	}
-	
-	/**
-	 * Index according to skill id the current timestamp of use.
-	 * @param skill
-	 * @param reuse delay
-	 */
-	@Override
-	public void addTimeStamp(L2Skill skill, long reuse)
-	{
-		_reuseTimeStampsSkills.put(skill.getReuseHashCode(), new TimeStamp(skill, reuse));
-	}
-	
-	/**
-	 * Index according to skill this TimeStamp instance for restoration purposes only.
-	 * @param skill
-	 * @param reuse
-	 * @param systime
-	 */
-	public void addTimeStamp(L2Skill skill, long reuse, long systime)
-	{
-		_reuseTimeStampsSkills.put(skill.getReuseHashCode(), new TimeStamp(skill, reuse, systime));
-	}
-	
 	@Override
 	public L2PcInstance getActingPlayer()
 	{

L2J_Server_BETA/java/com/l2jserver/gameserver/model/actor/instance/L2PetInstance.java

@@ -22,13 +22,11 @@ import java.sql.Connection;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.util.List;
-import java.util.Map;
 import java.util.concurrent.Future;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
 import javolution.util.FastList;
-import javolution.util.FastMap;
 
 import com.l2jserver.Config;
 import com.l2jserver.L2DatabaseFactory;
@@ -53,7 +51,6 @@ import com.l2jserver.gameserver.model.L2Party;
 import com.l2jserver.gameserver.model.L2PetData;
 import com.l2jserver.gameserver.model.L2PetLevelData;
 import com.l2jserver.gameserver.model.L2World;
-import com.l2jserver.gameserver.model.TimeStamp;
 import com.l2jserver.gameserver.model.actor.L2Character;
 import com.l2jserver.gameserver.model.actor.L2Summon;
 import com.l2jserver.gameserver.model.actor.stat.PetStat;
@@ -87,9 +84,6 @@ public class L2PetInstance extends L2Summon
 	private static final String RESTORE_SKILL_SAVE = "SELECT petObjItemId,skill_id,skill_level,remaining_time,buff_index FROM character_pet_skills_save WHERE petObjItemId=? ORDER BY buff_index ASC";
 	private static final String DELETE_SKILL_SAVE = "DELETE FROM character_pet_skills_save WHERE petObjItemId=?";
 	
-	private final Map<Integer, TimeStamp> _reuseTimeStampsSkills = new FastMap<>();
-	private final Map<Integer, TimeStamp> _reuseTimeStampsItems = new FastMap<>();
-	
 	private int _curFed;
 	private final PetInventory _inventory;
 	private final int _controlObjectId;
@@ -1466,43 +1460,6 @@ public class L2PetInstance extends L2Summon
 		return _data.getFood().contains(itemId);
 	}
 	
-	public Map<Integer, TimeStamp> getSkillReuseTimeStamps()
-	{
-		return _reuseTimeStampsSkills;
-	}
-	
-	@Override
-	public void addTimeStamp(L2Skill skill, long reuse)
-	{
-		_reuseTimeStampsSkills.put(skill.getReuseHashCode(), new TimeStamp(skill, reuse));
-	}
-	
-	@Override
-	public long getSkillRemainingReuseTime(int skillReuseHashId)
-	{
-		if (_reuseTimeStampsSkills.isEmpty() || !_reuseTimeStampsSkills.containsKey(skillReuseHashId))
-		{
-			return -1;
-		}
-		return _reuseTimeStampsSkills.get(skillReuseHashId).getRemaining();
-	}
-	
-	@Override
-	public void addTimeStampItem(L2ItemInstance item, long reuse)
-	{
-		_reuseTimeStampsItems.put(item.getObjectId(), new TimeStamp(item, reuse));
-	}
-	
-	@Override
-	public long getItemRemainingReuseTime(int itemObjId)
-	{
-		if (_reuseTimeStampsItems.isEmpty() || !_reuseTimeStampsItems.containsKey(itemObjId))
-		{
-			return -1;
-		}
-		return _reuseTimeStampsItems.get(itemObjId).getRemaining();
-	}
-	
 	@Override
 	public boolean isPet()
 	{

L2J_Server_BETA/java/com/l2jserver/gameserver/model/skills/L2SkillType.java

@@ -47,7 +47,6 @@ public enum L2SkillType
 	TAKEFORT,
 	DELUXE_KEY_UNLOCK,
 	SOW,
-	GET_PLAYER,
 	DETECTION,
 	DUMMY,
 	// Summons

L2J_Server_BETA/java/com/l2jserver/gameserver/network/clientpackets/EnterWorld.java

@@ -496,14 +496,14 @@ public class EnterWorld extends L2GameClientPacket
 			sendPacket(new Die(activeChar));
 		}
 		
+		activeChar.onPlayerEnter();
+		
 		sendPacket(new SkillCoolTime(activeChar));
 		sendPacket(new ExVoteSystemInfo(activeChar));
 		sendPacket(new ExNevitAdventPointInfoPacket(0));
 		sendPacket(new ExNevitAdventTimeChange(-1)); // only set pause state...
 		sendPacket(new ExShowContactList(activeChar));
 		
-		activeChar.onPlayerEnter();
-		
 		for (L2ItemInstance i : activeChar.getInventory().getItems())
 		{
 			if (i.isTimeLimitedItem())

L2J_Server_BETA/java/com/l2jserver/gameserver/network/serverpackets/SkillCoolTime.java

@@ -20,24 +20,30 @@ package com.l2jserver.gameserver.network.serverpackets;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Map;
 
 import com.l2jserver.gameserver.model.TimeStamp;
 import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
 
 /**
+ * Skill Cool Time server packet implementation.
  * @author KenM, Zoey76
  */
 public class SkillCoolTime extends L2GameServerPacket
 {
 	private final List<TimeStamp> _skillReuseTimeStamps = new ArrayList<>();
 	
-	public SkillCoolTime(L2PcInstance cha)
+	public SkillCoolTime(L2PcInstance player)
 	{
-		for (TimeStamp ts : cha.getSkillReuseTimeStamps().values())
+		final Map<Integer, TimeStamp> skillReuseTimeStamps = player.getSkillReuseTimeStamps();
+		if (skillReuseTimeStamps != null)
 		{
-			if (ts.hasNotPassed())
+			for (TimeStamp ts : skillReuseTimeStamps.values())
 			{
-				_skillReuseTimeStamps.add(ts);
+				if (ts.hasNotPassed())
+				{
+					_skillReuseTimeStamps.add(ts);
+				}
 			}
 		}
 	}
@@ -46,11 +52,11 @@ public class SkillCoolTime extends L2GameServerPacket
 	protected void writeImpl()
 	{
 		writeC(0xC7);
-		writeD(_skillReuseTimeStamps.size()); // list size
+		writeD(_skillReuseTimeStamps.size());
 		for (TimeStamp ts : _skillReuseTimeStamps)
 		{
 			writeD(ts.getSkillId());
-			writeD(0x00);
+			writeD(ts.getSkillLvl());
 			writeD((int) ts.getReuse() / 1000);
 			writeD((int) ts.getRemaining() / 1000);
 		}