Gecko [ www.vortexaion.com ]

Name	Size	Permission	Date
DuelService.java@2023-12-19_114026	9.85 KB	-rw-rw-rw-	2023-12-19 15:40
gearSets.json@2024-11-13_201146	0 B	-rw-rw-rw-	2024-11-14 00:11
index.html@2024-10-15_162412	153 B	-rw-rw-rw-	2024-10-15 21:24

Rename

package com.aionemu.gameserver.services;

import com.aionemu.gameserver.model.DuelResult;
import com.aionemu.gameserver.model.gameobjects.Creature;
import com.aionemu.gameserver.model.gameobjects.player.Player;
import com.aionemu.gameserver.model.gameobjects.player.RequestResponseHandler;
import com.aionemu.gameserver.model.summons.SummonMode;
import com.aionemu.gameserver.model.summons.UnsummonType;
import com.aionemu.gameserver.model.templates.zone.ZoneType;
import com.aionemu.gameserver.network.aion.AionServerPacket;
import com.aionemu.gameserver.network.aion.serverpackets.SM_DUEL;
import com.aionemu.gameserver.network.aion.serverpackets.SM_QUESTION_WINDOW;
import com.aionemu.gameserver.network.aion.serverpackets.SM_SYSTEM_MESSAGE;
import com.aionemu.gameserver.services.summons.SummonsService;
import com.aionemu.gameserver.skillengine.model.SkillTargetSlot;
import com.aionemu.gameserver.utils.PacketSendUtility;
import com.aionemu.gameserver.utils.ThreadPoolManager;
import com.aionemu.gameserver.world.World;
import com.aionemu.gameserver.world.zone.ZoneInstance;
import java.util.concurrent.Future;
import javolution.util.FastMap;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class DuelService {
  private static Logger log = LoggerFactory.getLogger(DuelService.class);
  
  private FastMap<Integer, Integer> duels;
  
  private FastMap<Integer, Future<?>> drawTasks;
  
  public static final DuelService getInstance() {
    return SingletonHolder.instance;
  }
  
  private DuelService() {
    this.duels = (new FastMap()).shared();
    this.drawTasks = (new FastMap()).shared();
    log.info("DuelService started.");
  }
  
  public void onDuelRequest(Player requester, Player responder) {
    if (requester.isInsideZoneType(ZoneType.PVP) || responder.isInsideZoneType(ZoneType.PVP)) {
      PacketSendUtility.sendPacket(requester, (AionServerPacket)SM_SYSTEM_MESSAGE.STR_DUEL_PARTNER_INVALID(responder.getName()));
      return;
    } 
    if (requester.isEnemy((Creature)responder) || isDueling(requester.getObjectId().intValue()) || isDueling(responder.getObjectId().intValue())) {
      PacketSendUtility.sendPacket(requester, (AionServerPacket)SM_SYSTEM_MESSAGE.STR_DUEL_HE_REJECT_DUEL(responder.getName()));
      return;
    } 
    for (ZoneInstance zone : responder.getPosition().getMapRegion().getZones((Creature)responder)) {
      if ((!zone.isOtherRaceDuelsAllowed() && !responder.getRace().equals(requester.getRace())) || (!zone.isSameRaceDuelsAllowed() && responder.getRace().equals(requester.getRace()))) {
        PacketSendUtility.sendPacket(requester, (AionServerPacket)SM_SYSTEM_MESSAGE.STR_MSG_DUEL_CANT_IN_THIS_ZONE);
        return;
      } 
    } 
    RequestResponseHandler rrh = new RequestResponseHandler((Creature)requester) {
        public void denyRequest(Creature requester, Player responder) {
          DuelService.this.rejectDuelRequest((Player)requester, responder);
        }
        
        public void acceptRequest(Creature requester, Player responder) {
          if (!DuelService.this.isDueling(requester.getObjectId().intValue()))
            DuelService.this.startDuel((Player)requester, responder); 
        }
      };
    responder.getResponseRequester().putRequest(50028, rrh);
    PacketSendUtility.sendPacket(responder, (AionServerPacket)new SM_QUESTION_WINDOW(50028, 0, 0, new Object[] { requester.getName() }));
    PacketSendUtility.sendPacket(responder, (AionServerPacket)SM_SYSTEM_MESSAGE.STR_DUEL_REQUESTED(requester.getName()));
  }
  
  public void confirmDuelWith(Player requester, Player responder) {
    if (requester.isEnemy((Creature)responder))
      return; 
    RequestResponseHandler rrh = new RequestResponseHandler((Creature)responder) {
        public void denyRequest(Creature requester, Player responder) {
          DuelService.log.debug("[Duel] Player " + responder.getName() + " confirmed his duel with " + requester.getName());
        }
        
        public void acceptRequest(Creature requester, Player responder) {
          DuelService.this.cancelDuelRequest(responder, (Player)requester);
        }
      };
    requester.getResponseRequester().putRequest(50030, rrh);
    PacketSendUtility.sendPacket(requester, (AionServerPacket)new SM_QUESTION_WINDOW(50030, 0, 0, new Object[] { responder.getName() }));
    PacketSendUtility.sendPacket(requester, (AionServerPacket)SM_SYSTEM_MESSAGE.STR_DUEL_REQUEST_TO_PARTNER(responder.getName()));
  }
  
  private void rejectDuelRequest(Player requester, Player responder) {
    log.debug("[Duel] Player " + responder.getName() + " rejected duel request from " + requester.getName());
    PacketSendUtility.sendPacket(requester, (AionServerPacket)SM_SYSTEM_MESSAGE.STR_DUEL_HE_REJECT_DUEL(responder.getName()));
    PacketSendUtility.sendPacket(responder, (AionServerPacket)SM_SYSTEM_MESSAGE.STR_DUEL_REJECT_DUEL(requester.getName()));
  }
  
  private void cancelDuelRequest(Player owner, Player target) {
    log.debug("[Duel] Player " + owner.getName() + " cancelled his duel request with " + target.getName());
    PacketSendUtility.sendPacket(target, (AionServerPacket)SM_SYSTEM_MESSAGE.STR_DUEL_REQUESTER_WITHDRAW_REQUEST(owner.getName()));
    PacketSendUtility.sendPacket(owner, (AionServerPacket)SM_SYSTEM_MESSAGE.STR_DUEL_WITHDRAW_REQUEST(target.getName()));
  }
  
  private void startDuel(Player requester, Player responder) {
    PacketSendUtility.sendPacket(requester, (AionServerPacket)SM_DUEL.SM_DUEL_STARTED(responder.getObjectId().intValue()));
    PacketSendUtility.sendPacket(responder, (AionServerPacket)SM_DUEL.SM_DUEL_STARTED(requester.getObjectId().intValue()));
    createDuel(requester.getObjectId().intValue(), responder.getObjectId().intValue());
    createTask(requester, responder);
  }
  
  public void loseDuel(Player player) {
    if (!isDueling(player.getObjectId().intValue()))
      return; 
    int opponnentId = ((Integer)this.duels.get(player.getObjectId())).intValue();
    player.getAggroList().clear();
    Player opponent = World.getInstance().findPlayer(opponnentId);
    if (opponent != null) {
      opponent.getEffectController().removeAbnormalEffectsByTargetSlot(SkillTargetSlot.DEBUFF);
      opponent.getController().cancelCurrentSkill();
      opponent.getAggroList().clear();
      if (player.getSummon() != null)
        SummonsService.doMode(SummonMode.GUARD, player.getSummon(), UnsummonType.UNSPECIFIED); 
      if (opponent.getSummon() != null)
        SummonsService.doMode(SummonMode.GUARD, opponent.getSummon(), UnsummonType.UNSPECIFIED); 
      if (player.getSummonedObj() != null)
        player.getSummonedObj().getController().cancelCurrentSkill(); 
      if (opponent.getSummonedObj() != null)
        opponent.getSummonedObj().getController().cancelCurrentSkill(); 
      PacketSendUtility.sendPacket(opponent, (AionServerPacket)SM_DUEL.SM_DUEL_RESULT(DuelResult.DUEL_WON, player.getName()));
      PacketSendUtility.sendPacket(player, (AionServerPacket)SM_DUEL.SM_DUEL_RESULT(DuelResult.DUEL_LOST, opponent.getName()));
    } else {
      log.warn("CHECKPOINT : duel opponent is already out of world");
    } 
    removeDuel(player.getObjectId().intValue(), opponnentId);
  }
  
  public void loseArenaDuel(Player player) {
    if (!isDueling(player.getObjectId().intValue()))
      return; 
    player.getEffectController().removeAbnormalEffectsByTargetSlot(SkillTargetSlot.DEBUFF);
    player.getController().cancelCurrentSkill();
    int opponnentId = ((Integer)this.duels.get(player.getObjectId())).intValue();
    Player opponent = World.getInstance().findPlayer(opponnentId);
    if (opponent != null) {
      opponent.getEffectController().removeAbnormalEffectsByTargetSlot(SkillTargetSlot.DEBUFF);
      opponent.getController().cancelCurrentSkill();
    } else {
      log.warn("CHECKPOINT : duel opponent is already out of world");
    } 
    removeDuel(player.getObjectId().intValue(), opponnentId);
  }
  
  private void createTask(final Player requester, final Player responder) {
    Future<?> task = ThreadPoolManager.getInstance().schedule(new Runnable() {
          public void run() {
            if (DuelService.this.isDueling(requester.getObjectId().intValue(), responder.getObjectId().intValue())) {
              PacketSendUtility.sendPacket(requester, (AionServerPacket)SM_DUEL.SM_DUEL_RESULT(DuelResult.DUEL_DRAW, requester.getName()));
              PacketSendUtility.sendPacket(responder, (AionServerPacket)SM_DUEL.SM_DUEL_RESULT(DuelResult.DUEL_DRAW, responder.getName()));
              DuelService.this.removeDuel(requester.getObjectId().intValue(), responder.getObjectId().intValue());
            } 
          }
        }, 300000L);
		
    this.drawTasks.put(requester.getObjectId(), task);
    this.drawTasks.put(responder.getObjectId(), task);
  }
  
  public boolean isDueling(int playerObjId) {
    return (this.duels.containsKey(Integer.valueOf(playerObjId)) && this.duels.containsValue(Integer.valueOf(playerObjId)));
  }
  
  public boolean isDueling(int playerObjId, int targetObjId) {
    return (this.duels.containsKey(Integer.valueOf(playerObjId)) && ((Integer)this.duels.get(Integer.valueOf(playerObjId))).intValue() == targetObjId);
  }
  
  public void createDuel(int requesterObjId, int responderObjId) {
    this.duels.put(Integer.valueOf(requesterObjId), Integer.valueOf(responderObjId));
    this.duels.put(Integer.valueOf(responderObjId), Integer.valueOf(requesterObjId));
  }
  
  private void removeDuel(int requesterObjId, int responderObjId) {
    this.duels.remove(Integer.valueOf(requesterObjId));
    this.duels.remove(Integer.valueOf(responderObjId));
    removeTask(requesterObjId);
    removeTask(responderObjId);
  }
  
  private void removeTask(int playerId) {
    Future<?> task = (Future)this.drawTasks.get(Integer.valueOf(playerId));
    if (task != null && !task.isDone()) {
      task.cancel(true);
      this.drawTasks.remove(Integer.valueOf(playerId));
    } 
  }
  
  private static class SingletonHolder {
    protected static final DuelService instance = new DuelService();
  }
}