Fix SkillCoolTime + TimeStamp

**Voldigoad** · August 29, 2023

Depois de algumas Semanas tentando Consegui resolver o Bug do Alt+k

porem o CoolTime da Skill parau de ser Armazenada mesmo com o Fix

**Voldigoad** · September 13, 2023

o problema esta na classe L2PcInstance no metodo "private synchronized void storeEffect"

consegui porem deu erro no CMD
desfiz mas esqueci de salvar
se alguém tiver a disponibilidade de ajudar

Index: com.l2jlegacy.gameserver.model.L2Character.java
======================================================

-import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.Future;
+import java.util.concurrent.ConcurrentHashMap;

@@ 1960

		// Skill reuse check
-		if (reuseDelay > 1600) // 1,600 MiliSecods = 1.6 seconds
+		if (reuseDelay > 0)
		{
			addTimeStamp(skill, reuseDelay);
		}

		// Check if this skill consume MP on start casting
		int initmpcons = getStat().getMpInitialConsume(skill);

@@ 1990

		// Disable the skill during the re-use delay and create a task EnableSkill with Medium priority to enable it at the end of the re-use delay
-		if (reuseDelay > 10)
+		if (reuseDelay > 0)
		{
			disableSkill(skill, reuseDelay);
		}
		
		// For force buff skills, start the effect as long as the player is casting.

@@ 2078 / 2083

			onMagicLaunchedTimer(targets, skill, coolTime, true);
		}
		fireEvent(EventType.CAST.name, new Object[]
		{
			skill,
			target,
			targets
		});
		
	}

-	public void addTimeStamp(final L2Skill skill, final int r)
-	{
-		
-	}
-
-	public void removeTimeStamp(final L2Skill _skill)
-	{
-		
-	}

+	public final Map<Integer, TimeStamp> getSkillReuseTimeStamps()
+	{
+		return _reuseTimeStampsSkills;
+	}
+
+	public final void addTimeStamp(L2Skill skill, long reuse)
+	{
+		addTimeStamp(skill, reuse, -1);
+	}
+
+	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));
+	}
+
+	public synchronized final void removeTimeStamp(L2Skill skill)
+	{
+		if (_reuseTimeStampsSkills != null)
+		{
+			_reuseTimeStampsSkills.remove(skill.getReuseHashCode());
+		}
+	}
+
+	public synchronized final void resetTimeStamps()
+	{
+		if (_reuseTimeStampsSkills != null)
+		{
+			_reuseTimeStampsSkills.clear();
+		}
+	}
+
+	public synchronized final long getSkillRemainingReuseTime(int hashCode)
+	{
+		final TimeStamp reuseStamp = (_reuseTimeStampsSkills != null) ? _reuseTimeStampsSkills.get(hashCode) : null;
+		
+		return reuseStamp != null ? reuseStamp.getRemaining() : -1;
+	}
+
+	public synchronized final boolean hasSkillReuse(int hashCode)
+	{
+		final TimeStamp reuseStamp = (_reuseTimeStampsSkills != null) ? _reuseTimeStampsSkills.get(hashCode) : null;
+		return (reuseStamp != null) && reuseStamp.hasNotPassed();
+	}
+
+	public synchronized final TimeStamp getSkillReuseTimeStamp(int hashCode)
+	{
+		return _reuseTimeStampsSkills != null ? _reuseTimeStampsSkills.get(hashCode) : null;
+	}

	/**
	 * Starts a force buff on target.<br>
	 * @param target the target
	 * @param skill the skill
	 */
	public void startForceBuff(final L2Character target, final L2Skill skill)

@@ 5002

		public Node[] geoPath;
		public int geoPathAccurateTx;
		public int geoPathAccurateTy;
		public int geoPathGtx;
		public int geoPathGty;
	}
+
+	private volatile Map<Integer, TimeStamp> _reuseTimeStampsSkills = new ConcurrentHashMap<>();
+
-	protected List<Integer> _disabledSkills;
+	protected Map<Integer, Long> _disabledSkills;

	private boolean _allSkillsDisabled;

	protected MoveData _move;

@@ 8682

	/**
	 * Reduce the item number of the L2Character.<BR>
	 * <BR>
	 * <B><U> Overriden in </U> :</B><BR>
	 * <BR>
	 * <li>L2PcInstance</li><BR>
	 * <BR>
	 * @param itemConsumeId the item consume id
	 * @param itemCount the item count
	 */
	public void consumeItem(final int itemConsumeId, final int itemCount)
	{
	}
+
+	public Map<Integer, Long> getDisabledSkills()
+	{
+		return _disabledSkills;
+	}
+
-	public void enableSkill(final L2Skill _skill)
+	public void enableSkill(L2Skill _skill)
	{
-		if (_disabledSkills == null)
+		if (_skill == null || _disabledSkills == null)
+		{
			return;
+		}
+
-		_disabledSkills.remove(Integer.valueOf(_skill.getReuseHashCode()));
+		_disabledSkills.remove(_skill.getReuseHashCode());
-
-		if (this instanceof L2PcInstance)
-		{
-			removeTimeStamp(_skill);
-		}
	}

-	public void disableSkill(final L2Skill skill)
-	{
-		if (_disabledSkills == null)
-		{
-			_disabledSkills = Collections.synchronizedList(new FastList<Integer>());
-		}
-
-		_disabledSkills.add(skill.getReuseHashCode());
-	}
-
	public void disableSkill(L2Skill skill, long delay)
	{
		if (skill == null)
+		{
			return;
+		}
+
		disableSkill(skill);
		
-		if (delay > 10)
-		{
-			ThreadPoolManager.getInstance().scheduleAi(new EnableSkill(skill), delay);
-		}
-	}

+		if (_disabledSkills == null)
+		{
+			synchronized (this)
+			{
+				if (_disabledSkills == null)
+				{
+					_disabledSkills = new ConcurrentHashMap<>();
+				}
+			}
+		}
+
+		_disabledSkills.put(skill.getReuseHashCode(), delay > 0 ? System.currentTimeMillis() + delay : Long.MAX_VALUE);
+	}
+
+	public boolean isSkillDisabled(int hashCode)
+	{
+		/*
+		 * if (isAllSkillsDisabled()) { return true; }
+		 */
+
+		if (_disabledSkills == null)
+		{
+			return false;
+		}
+
+		final Long stamp = _disabledSkills.get(hashCode);
+		if (stamp == null)
+		{
+			return false;
+		}
+
+		if (stamp < System.currentTimeMillis())
+		{
+			_disabledSkills.remove(hashCode);
+			return false;
+		}
+		return true;
+	}
	
@@ 8794

			if (activeChar.isHero() && HeroSkillTable.isHeroSkill(_skill.getId()) && activeChar.isInOlympiadMode() && activeChar.isOlympiadStart())
			{
				activeChar.sendMessage("You can't use Hero skills during Olympiad match.");
				return true;
			}
		}

		if (_disabledSkills == null)
			return false;

-		return _disabledSkills.contains(_skill.getReuseHashCode());
+		return isSkillDisabled(skill.getReuseHashCode());
	}

+
+	public synchronized final void resetDisabledSkills()
+	{
+		if (_disabledSkills != null)
+		{
+			_disabledSkills.clear();
+		}
+	}
+
	/**
	 * Disable all skills (set _allSkillsDisabled to True).<BR>
	 * <BR>
	 */
	public void disableAllSkills()


Index: com.l2jlegacy.gameserver.model.TimeStamp.java
====================================================
+package com.l2jlegacy.gameserver.model;
+
+import com.l2jlegacy.gameserver.model.actor.instance.L2ItemInstance;
+
+public class TimeStamp
+{
+	private final int _id1;
+	private final int _id2;
+	private final long _reuse;
+	private final long _stamp;
+	private final int _group;
+	
+	public TimeStamp(L2Skill skill, long reuse, long systime)
+	{
+		_id1 = skill.getId();
+		_id2 = skill.getLevel();
+		_reuse = reuse;
+		_stamp = systime > 0 ? systime : System.currentTimeMillis() + reuse;
+		_group = -1;
+	}
+	
+	public TimeStamp(L2ItemInstance item, long reuse, long systime)
+	{
+		_id1 = item.getItemId();
+		_id2 = item.getObjectId();
+		_reuse = reuse;
+		_stamp = systime > 0 ? systime : System.currentTimeMillis() + reuse;
+		_group = -1;// item.getSharedReuseGroup();
+	}
+	
+	public long getStamp()
+	{
+		return _stamp;
+	}
+	
+	public int getItemId()
+	{
+		return _id1;
+	}
+	
+	public int getItemObjectId()
+	{
+		return _id2;
+	}
+	
+	public int getSkillId()
+	{
+		return _id1;
+	}
+	
+	public int getSkillLvl()
+	{
+		return _id2;
+	}
+	
+	public long getReuse()
+	{
+		return _reuse;
+	}
+	
+	public int getSharedReuseGroup()
+	{
+		return _group;
+	}
+	
+	public long getRemaining()
+	{
+		return Math.max(_stamp - System.currentTimeMillis(), 0);
+	}
+	
+	public boolean hasNotPassed()
+	{
+		return System.currentTimeMillis() < _stamp;
+	}
+}

Index: com.l2jlegacy.gameserver.model.actor.instance.L2PcInstance.java
======================================================================
import com.l2jlegacy.gameserver.model.PlayerStatus;
import com.l2jlegacy.gameserver.model.ShortCuts;
+import com.l2jlegacy.gameserver.model.TimeStamp;
import com.l2jlegacy.gameserver.model.TradeList;
import com.l2jlegacy.gameserver.model.L2Skill.SkillTargetType;

@@ 10847
			for (final L2Effect effect : effects)
			{
-				final int skillId = effect.getSkill().getId();
-				
-				if (storedSkills.contains(skillId))
+				L2Skill skill = effect.getSkill();
+				if (storedSkills.contains(skill.getReuseHashCode()))
					continue;
+
-				storedSkills.add(skillId);
+				storedSkills.add(skill.getReuseHashCode());
-
				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(2, skill.getId());
+
					statement.setInt(3, effect.getSkill().getLevel());
					statement.setInt(4, effect.getCount());
					statement.setInt(5, effect.getTime());
+
-					if (ReuseTimeStamps.containsKey(effect.getSkill().getReuseHashCode()))
+					if (hasSkillReuse(skill.getReuseHashCode()))
					{
-						final TimeStamp t = ReuseTimeStamps.get(effect.getSkill().getReuseHashCode());
+						TimeStamp t = getSkillReuseTimeStamp(skill.getReuseHashCode());
						statement.setLong(6, t.hasNotPassed() ? t.getReuse() : 0);
-						statement.setLong(7, t.hasNotPassed() ? t.getStamp() : 0);
+						statement.setDouble(7, t.hasNotPassed() ? t.getStamp() : 0);
					}
					else
					{
						statement.setLong(6, 0);

@@ 10866
			// Store the reuse delays of remaining skills which
			// lost effect but still under reuse delay. 'restore_type' 1.
-			for (final TimeStamp t : ReuseTimeStamps.values())
+			for (int hash : getSkillReuseTimeStamps().keySet())
			{
+				if (storedSkills.contains(hash))
+					continue;
+
-				if (t.hasNotPassed())
+				TimeStamp t = getSkillReuseTimeStamps().get(hash);
+				if (t != null && t.hasNotPassed())
				{
-					final int skillId = t.getSkill().getId();
-					final int skillLvl = t.getSkill().getLevel();
-					if (storedSkills.contains(skillId))
-						continue;
-					storedSkills.add(skillId);
+					storedSkills.add(hash);
					
					statement.setInt(1, getObjectId());
-					statement.setInt(2, skillId);
-					statement.setInt(3, skillLvl);
+					statement.setInt(2, t.getSkillId());
+					statement.setInt(3, t.getSkillLvl());
					statement.setInt(4, -1);
					statement.setInt(5, -1);
					statement.setLong(6, t.getReuse());
					statement.setLong(7, t.getStamp());
					statement.setInt(8, 1);
					statement.setInt(9, getClassIndex());
					statement.setInt(10, ++buff_index);
					statement.execute();

@@ 11384
				long remainingTime = systime - System.currentTimeMillis();

				if (remainingTime > 10L)

				{
					L2Skill skill = SkillTable.getInstance().getInfo(skillId, skillLvl);

					if (skill == null)
						continue;

					disableSkill(skill, remainingTime);
-					addTimeStamp(new TimeStamp(skill, reuseDelay, systime));
+					addTimeStamp(skill, reuseDelay, systime);

@@ 11421
				if (remainingTime <= 0L)

				{
					L2Skill skill = SkillTable.getInstance().getInfo(skillId, skillLvl);

					if (skill == null)
						continue;

					disableSkill(skill, remainingTime);
-					addTimeStamp(new TimeStamp(skill, reuseDelay, systime));
+					addTimeStamp(skill, reuseDelay, systime);

@@ 14489
		// 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();
+
+		getSkillReuseTimeStamps().clear();
+
		if (classIndex == 0)

@@ 12135
		// Check if skill is in reause time
-		if (isSkillDisabled(skill))
-		{
-			if (!(skill.getId() == 2166))
-			{
-				SystemMessage sm = new SystemMessage(SystemMessageId.S1_PREPARED_FOR_REUSE);
-				sm.addSkillName(skill.getId(), skill.getLevel());
-				sendPacket(sm);
-				sm = null;
-			}
-			// Cp potion message like L2OFF
-			else if ((skill.getId() == 2166))
-			{
-				if (skill.getLevel() == 2)
-					sendMessage("Greater CP Potion is not available at this time: being prepared for reuse.");
-				else if (skill.getLevel() == 1)
-					sendMessage("CP Potion is not available at this time: being prepared for reuse.");
-			}
-			
-			sendPacket(ActionFailed.STATIC_PACKET);
-			return;
-		}
+		if (isSkillDisabled(skill))
+		{
+			if (hasSkillReuse(skill.getReuseHashCode()))
+			{
+				int remainingTime = (int) (getSkillRemainingReuseTime(skill.getReuseHashCode()) / 1000);
+				int hours = remainingTime / 3600;
+				int minutes = (remainingTime % 3600) / 60;
+				int seconds = (remainingTime % 60);
+
+				if (hours > 0)
+				{
+					sendMessage("There are " + hours + " hour(s), " + minutes + " minute(s), and " + seconds + " second(s) remaining in " + skill.getName() + "'s re-use time.");
+				}
+				else if (minutes > 0)
+				{
+					sendMessage("There are " + minutes + " minute(s), " + seconds + " second(s) remaining in " + skill.getName() + "'s re-use time.");
+				}
+				else
+				{
+					sendMessage("There are " + seconds + " second(s) remaining in " + skill.getName() + "'s re-use time.");
+				}
+
+				SystemMessage sm = new SystemMessage(SystemMessageId.S1_PREPARED_FOR_REUSE);
+				sm.addSkillName(skill.getId(), skill.getLevel());
+				sendPacket(sm);
+			}
+			return;
+		}

		// ************************************* Check Target *******************************************
		// Create and set a L2Object containing the target of the skill

@@ - 17895 - 17980

			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 final FastMap<Integer, TimeStamp> ReuseTimeStamps = new FastMap<Integer, TimeStamp>().shared();
-
-	public static class TimeStamp
-	{
-		
-		public long getStamp()
-		{
-			return stamp;
-		}
-		
-		public L2Skill getSkill()
-		{
-			return skill;
-		}
-		
-		public long getReuse()
-		{
-			return reuse;
-		}
-		
-		public long getRemaining()
-		{
-			return Math.max(stamp - System.currentTimeMillis(), 0L);
-		}
-		
-		protected boolean hasNotPassed()
-		{
-			return System.currentTimeMillis() < stamp;
-		}
-		
-		private final L2Skill skill;
-		private final long reuse;
-		private final long stamp;
-		
-		protected TimeStamp(final L2Skill _skill, final long _reuse)
-		{
-			skill = _skill;
-			reuse = _reuse;
-			stamp = System.currentTimeMillis() + reuse;
-		}
-		
-		protected TimeStamp(final L2Skill _skill, final long _reuse, final long _systime)
-		{
-			skill = _skill;
-			reuse = _reuse;
-			stamp = _systime;
-		}
-	}
-
-	@Override
-	public void addTimeStamp(L2Skill s, int r)
-	{
-		 this.ReuseTimeStamps.put(Integer.valueOf(s.getReuseHashCode()), new TimeStamp(s, r));
-	}
-
-	private void addTimeStamp(TimeStamp T)
-	{
-		this.ReuseTimeStamps.put(Integer.valueOf(T.getSkill().getId()), T);
-	}
-
-	@Override
-	public void removeTimeStamp(L2Skill s)
-	{
-		this.ReuseTimeStamps.remove(Integer.valueOf(s.getReuseHashCode()));
-	}
-	
-	public Collection<TimeStamp> getReuseTimeStamps()
-	{
-		return ReuseTimeStamps.values();
-	}
-	
-	public void resetSkillTime(boolean ssl)
-	{
-		L2Skill arr$[] = getAllSkills();
-		for (L2Skill skill : arr$)
-		{
-			if (skill != null && skill.isActive() && skill.getId() != 1324)
-				enableSkill(skill);
-		}
-		
-		if (ssl)
-			sendSkillList();
-		sendPacket(new SkillCoolTime(this));
-	}

	@Override
	public final void sendDamageMessage(final L2Character target, final int damage, final boolean mcrit, final boolean pcrit, final boolean miss)

Index: com.l2jlegacy.gameserver.network.serverpackets.SkillCoolTime.java
========================================================================
package com.l2jlegacy.gameserver.network.serverpackets;

-import java.util.Collection;
-import java.util.Iterator;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;

+import com.l2jlegacy.gameserver.model.TimeStamp;
import com.l2jlegacy.gameserver.model.actor.instance.L2PcInstance;

 public class SkillCoolTime extends L2GameServerPacket
 {

-	 public Collection<L2PcInstance.TimeStamp> _reuseTimeStamps;
+	 private final List<TimeStamp> _skillReuseTimeStamps = new ArrayList<>();

	 public SkillCoolTime(final L2PcInstance cha)
	 {
-		 _reuseTimeStamps = cha.getReuseTimeStamps();
+		final Map<Integer, TimeStamp> skillReuseTimeStamps = cha.getSkillReuseTimeStamps();
+		if (skillReuseTimeStamps != null)
+		{
+			for (TimeStamp ts : skillReuseTimeStamps.values())
+			{
+				if (ts.hasNotPassed())
+				{
+					_skillReuseTimeStamps.add(ts);
+				}
+			}
+		}
	 }

	 @Override
-	 protected final void writeImpl()
+	 protected void writeImpl()
	 {
-
-		final L2PcInstance activeChar = getClient().getActiveChar();
-
-		if (activeChar == null)
-			return;
-		writeC(193);
-		writeD(_reuseTimeStamps.size());
-		L2PcInstance.TimeStamp ts;
+		writeC(0xc1);
+		writeD(_skillReuseTimeStamps.size());

-		 for (final Iterator<L2PcInstance.TimeStamp> i$ = _reuseTimeStamps.iterator(); i$.hasNext(); writeD((int) ts.getRemaining() / 1000))
+		 for (TimeStamp ts : _skillReuseTimeStamps)
		 {
-			 ts = i$.next();
-			 writeD(ts.getSkill().getId());
+			 writeD(ts.getSkillId());
			 writeD(0);
			 writeD((int) ts.getReuse() / 1000);
+			 writeD((int) ts.getRemaining() / 1000);
		 }

	 }

	 @Override
	 public String getType()
	 {
		 return "[S] c1 SkillCoolTime";
	 }
}

**Voldigoad** · September 19, 2023

OLAA!!!!!!!!! Pelo menos me digam onde procurar para poder corrigir este Delay

ja tentei de tuudo, ja refiz cada parte do codigo acima, com a Frozen 1.5 || L2jOrion || Acis

mas nem um funfou.
O único meio Alternativo que achei foi alterar a seguinte parte da Class SkillCoolTime

de "writeC(0xc1);" para "writeC(0xc0);"... Porem ao alterar a a skill para de ser salva do banco de dados

esta parte "

private synchronized void storeEffect()" fica Morta

**Noku** · September 2, 2024

deletar requestskillcooltime.java

pronto..

l2gamepackethandler.java

pesquisar > msg = new RequestSkillCoolTime();

tirar msg = new RequestSkillCoolTime();

coloco //msg = new RequestSkillCoolTime();

salvar pronto.. troco arma e joia e set e alt+k continua carregado

"Fix skill cooltime l2jFrozen 1132" deu restart carregado voltei 0..

Sign In

Fix SkillCoolTime + TimeStamp

Question

Voldigoad

Link to comment

Share on other sites

3 answers to this question

Recommended Posts

Voldigoad

Link to comment

Share on other sites

Voldigoad

Link to comment

Share on other sites

Noku

Link to comment

Share on other sites

Join the conversation

Announcements

Recently Browsing

Posts

Browse

My Activity Streams

Activity

Important Information