эвент типа массового пвп (питон)

import sys
from net.sf.l2j.gameserver.model.quest import State
from net.sf.l2j.gameserver.model.quest import QuestState
from net.sf.l2j.gameserver.datatables import DoorTable
from net.sf.l2j.gameserver.datatables import SkillTable
from net.sf.l2j.gameserver.model.quest.jython import QuestJython as JQuest
from net.sf.l2j.gameserver import Announcements
from net.sf.l2j import L2DatabaseFactory
from net.sf.l2j.gameserver.ai import CtrlIntention
from net.sf.l2j.util import Rnd
from java.lang import System
from net.sf.l2j.gameserver.model import L2World
print "New PvP zone.. OK"

qn = "PvP_Zone"
# =======================================
# Этот стоблик остаётся без изменений
# =======================================
closed=1
reb_timer=0
npc1=0
npc2=0
TEAM1 = []
TEAM2 = []
ONTEAM1 = []
ONTEAM2 = []
attacked = 0
annom = 1
# =======================================
# Все настройки в этой таблице
# =======================================
NAME = "WAR" # Название Эвента (только английские символы)
LOC = "Goddard" # Город, в котором вы хотите поставить регистрирующего НПЦ.
LEVEL = 40 # минимальный лвл
NPC_REG = 300001 # ID-номер регистрирующего нпc
AFTER_RESTART = 1 # Через какое время эвент запустится после рестарта сервера.(указывать в минутах)
ANNOUNCE_INTERVAL = 1 # Как часто аннонсить о регистрации на Эвент.(указывать в минутах)
REBILD_INTERVAL = 2 # Интервал, через которое будут пересматриватся команды (указывать в секундах)
OutLoc = [1,1,1]
Base1 = [147521,46718,-3408]
Base2 = [147521,46718,-3408]
TEAM1_Name = "Komanda 1"
TEAM2_Name = "Komanda 2"
def teleporting(st,player,code) :
if not st : return "Error 405"
if code==1:
teamvar = st.getInt("teamvar")
if teamvar in [1,2]:
player.setTeam(teamvar)
player.broadcastStatusUpdate()
player.broadcastUserInfo()
if teamvar == 1:player.teleToLocation(Base1[0],Base1[1],Base1[2])
else: player.teleToLocation(Base2[0],Base2[1],Base2[2])
else: return "Error 405"
elif code==0:
player.setTeam(0)
player.broadcastStatusUpdate()
player.broadcastUserInfo()
player.teleToLocation(OutLoc[0],OutLoc[1],OutLoc[2])
return



class Quest (JQuest) :
def __init__(self,id,name,descr): JQuest.__init__(self,id,name,descr)

def init_LoadGlobalData(self) :
self.startQuestTimer("open", AFTER_RESTART *60000, None, None)
return

def onTalk (Self,npc,player):
global TEAM1,TEAM2,ONTEAM1,ONTEAM2,npc1,npc2,closed
st = player.getQuestState(qn)
print "ontalk = ok"
npcId = npc.getNpcId()
if npcId == NPC_REG:
if closed<>1:
if not player.isInOlympiadMode() :
if player.getLevel() >= LEVEL:
if player.getName() not in TEAM1 + TEAM2 and not st.getInt("teamvar") in [1,2]:
return "reg.htm" #все ОК - регистрируемся (РЕГИСТРАЦИЯ)
else: #если чар или в 1й или во 2й команде
if player.getName() in TEAM1 or st.getInt("teamvar") == 1:
return "inteam1.htm" #если чар в первой команде
else:
return "inteam2.htm" #если чар во второй команде
else: return "lowlvl.htm"
else: return "You register in olympiad games now"
else: return "noreg.htm"
else: return "Error 404"
def onAdvEvent (self,event,npc,player):
global TEAM1,TEAM2,ONTEAM1,ONTEAM2,npc1,npc2,reb_timer,annom,closed
if event == "open" : #включает квест после перезагрузки
closed=0
reb_timer=1
self.startQuestTimer("announce", ANNOUNCE_INTERVAL*60000, None, None)
Announcements.getInstance().announceToAll("Opened registration for "+str(NAME)+" event! You can register in "+str(LOC)+".")
self.startQuestTimer("rebild", REBILD_INTERVAL *1000, None, None)
if event == "announce" and closed==0:
Announcements.getInstance().announceToAll("Event "+str(NAME)+" was started! You can register in "+str(LOC)+".")
Announcements.getInstance().announceToAll("There are "+str(len(ONTEAM1))+" players in "+TEAM1_Name+" and "+str(len(ONTEAM2))+" players in "+TEAM2_Name+" now online.")
self.startQuestTimer("announce", ANNOUNCE_INTERVAL*60000, None, None)
if event == "rebild": #пересматривает списки команд
for nm in TEAM1: #проверка тим1 на наличие онлаин неучтенных чаров
i=L2World.getInstance().getPlayer(nm)
if i<>None:
if i.isOnline() and not i.isInOlympiadMode() and not nm in ONTEAM1:
ONTEAM1.append(nm)
i.setTeam(1)
i.broadcastStatusUpdate()
i.broadcastUserInfo()
for nm in ONTEAM1: #проверка тим1-ОНЛАИН на наличие офлаин чаров
i=L2World.getInstance().getPlayer(nm)
if i<>None:
if not i.isOnline() or i.isInOlympiadMode():
ONTEAM1.remove(nm)
else:
ONTEAM1.remove(nm)
for nm in TEAM2: #проверка тим2 на наличие онлаин неучтенных чаров
i=L2World.getInstance().getPlayer(nm)
if i<>None:
if i.isOnline() and not i.isInOlympiadMode() and not nm in ONTEAM2:
ONTEAM2.append(nm)
print nm
i.setTeam(2)
i.broadcastStatusUpdate()
i.broadcastUserInfo()
for nm in ONTEAM2: #проверка тим2-ОНЛАИН на наличие офлаин чаров
i=L2World.getInstance().getPlayer(nm)
if i<>None:
if not i.isOnline() or i.isInOlympiadMode():
ONTEAM2.remove(nm)
else:
ONTEAM2.remove(nm)
if reb_timer == 1:
self.startQuestTimer("rebild", REBILD_INTERVAL *1000, None, None)
if event == "reg1" :#регистрация в команду 1
st = player.getQuestState(qn)
if not st : return "Error Player"
state = st.getInt("state")
teamvar = st.getInt("teamvar")
if state == 1:
return "EteamOn.htm"
else:
if not teamvar in [1,2]:
st.setState(State.STARTED)
st.set("state","1")
st.set("teamvar","1")
TEAM1.append(player.getName())
ONTEAM1.append(player.getName())
player.stopAllEffects()
st.playSound("ItemSound.quest_accept")
teleporting(st,player,1)
return "regteam1.htm"
else: return "EteamIs.htm"
if event == "reg2" :#регистрация в команду 2
st = player.getQuestState(qn)
if not st : return "Error Player"
state = st.getInt("state")
teamvar = st.getInt("teamvar")
if state == 1:
return "EteamOn.htm"
else:
if not teamvar in [1,2]:
st.setState(State.STARTED)
st.set("state","1")
st.set("teamvar","2")
TEAM2.append(player.getName())
ONTEAM2.append(player.getName())
player.stopAllEffects()
st.playSound("ItemSound.quest_accept")
teleporting(st,player,1)
return "regteam2.htm"
else: return "EteamIs.htm"
if event == "stateON": #продолжение участия в эвенте
st = player.getQuestState(qn)
if not st : return "Error Player"
state = st.getInt("state")
teamvar = st.getInt("teamvar")
if not teamvar in [1,2]:
st.set("state","0")
if player.getName() in ONTEAM1: ONTEAM1.remove(player.getName())
if player.getName() in TEAM1: TEAM1.remove(player.getName())
if player.getName() in ONTEAM2: ONTEAM2.remove(player.getName())
if player.getName() in TEAM2: ONTEAM2.remove(player.getName())
teleporting(st,player,0)
return "Error - No Team"
st.exitQuest(1)
else:
st.set("state","1")
if teamvar == 1:
TEAM1.append(player.getName())
ONTEAM1.append(player.getName())
else:
TEAM2.append(player.getName())
ONTEAM2.append(player.getName())
teleporting(st,player,1)
return "teleporting in War zone..."
if event == "stateOFF": #выход из эвента
st = player.getQuestState(qn)
if not st : return "Error Player"
state = st.getInt("state")
teamvar = st.getInt("teamvar")
if not teamvar in [1,2]:
st.set("state","0")
if player.getName() in ONTEAM1: ONTEAM1.remove(player.getName())
if player.getName() in TEAM1: TEAM1.remove(player.getName())
if player.getName() in ONTEAM2: ONTEAM2.remove(player.getName())
if player.getName() in TEAM2: ONTEAM2.remove(player.getName())
teleporting(st,player,0)
return "Error - No Team"
st.exitQuest(1)
else:
st.set("state","0")
if player.getName() in ONTEAM1: ONTEAM1.remove(player.getName())
if player.getName() in TEAM1: TEAM1.remove(player.getName())
if player.getName() in ONTEAM2: ONTEAM2.remove(player.getName())
if player.getName() in TEAM2: ONTEAM2.remove(player.getName())
teleporting(st,player,0)
return "teleporting out War zone..."
QUEST = Quest(-1, qn, "custom")

QUEST.addStartNpc(int(NPC_REG))
QUEST.addTalkId(int(NPC_REG))

onAttack(self, npc, player)

Эта функция вызывается, когда игрок атакует NPC, который зарегистрирован для квеста.
Параметр "npc" содержит ссылку на идентификатор (ID) NPC который был атакован.
Параметр "player" содержит ссылку на идентификатор игрока, который атаковал.

package net.sf.l2j.gameserver.model.entity;

import java.util.Calendar;
import java.util.Iterator;
import java.util.logging.Level;
import java.util.logging.Logger;
import javolution.util.FastList;
import net.sf.l2j.gameserver.ThreadPoolManager;
import net.sf.l2j.gameserver.ai.CtrlIntention;
import net.sf.l2j.gameserver.ai.L2CharacterAI;
import net.sf.l2j.gameserver.instancemanager.DuelManager;
import net.sf.l2j.gameserver.model.L2Effect;
import net.sf.l2j.gameserver.model.L2Party;
import net.sf.l2j.gameserver.model.actor.instance.L2PcInstance;
import net.sf.l2j.gameserver.network.SystemMessageId;
import net.sf.l2j.gameserver.network.serverpackets.*;

public class Duel
{
public class ScheduleEndDuelTask
implements Runnable
{

public void run()
{
try
{
_duel.endDuel(_result);
}
catch(Exception e)
{
Duel._log.log(Level.SEVERE, "", e);
}
}

private Duel _duel;
private DuelResultEnum _result;
final Duel this$0;

public ScheduleEndDuelTask(Duel duel, DuelResultEnum result)
{
this$0 = Duel.this;
super();
_duel = duel;
_result = result;
}
}

public class ScheduleStartDuelTask
implements Runnable
{

public void run()
{
try
{
int count = _duel.countdown();
if(count == 4)
{
_duel.teleportPlayers(0xfffe6fa1, 0xfffccf81, -3326);
ThreadPoolManager.getInstance().scheduleGeneral(this, 20000L);
} else
if(count > 0)
ThreadPoolManager.getInstance().scheduleGeneral(this, 1000L);
else
_duel.startDuel();
}
catch(Exception e)
{
Duel._log.log(Level.SEVERE, "", e);
}
}

private Duel _duel;
final Duel this$0;

public ScheduleStartDuelTask(Duel duel)
{
this$0 = Duel.this;
super();
_duel = duel;
}
}

public class ScheduleDuelTask
implements Runnable
{

public void run()
{
try
{
DuelResultEnum status = _duel.checkEndDuelCondition();
if(status == DuelResultEnum.Canceled)
{
setFinished(true);
_duel.endDuel(status);
} else
if(status != DuelResultEnum.Continue)
{
setFinished(true);
playKneelAnimation();
ThreadPoolManager.getInstance().scheduleGeneral(new ScheduleEndDuelTask(_duel, status), 5000L);
} else
{
ThreadPoolManager.getInstance().scheduleGeneral(this, 1000L);
}
}
catch(Exception e)
{
Duel._log.log(Level.SEVERE, "", e);
}
}

private Duel _duel;
final Duel this$0;

public ScheduleDuelTask(Duel duel)
{
this$0 = Duel.this;
super();
_duel = duel;
}
}

public class PlayerCondition
{

public void restoreCondition()
{
if(_player == null)
return;
_player.setCurrentHp(_hp);
_player.setCurrentMp(_mp);
_player.setCurrentCp(_cp);
if(_paDuel)
teleportBack();
if(_debuffs != null)
{
Iterator i$ = _debuffs.iterator();
do
{
if(!i$.hasNext())
break;
L2Effect temp = (L2Effect)i$.next();
if(temp != null)
temp.exit();
} while(true);
}
}

public void registerDebuff(L2Effect debuff)
{
if(_debuffs == null)
_debuffs = new FastList();
_debuffs.add(debuff);
}

public void teleportBack()
{
if(_paDuel)
_player.teleToLocation(_x, _y, _z);
}

public L2PcInstance getPlayer()
{
return _player;
}

private L2PcInstance _player;
private double _hp;
private double _mp;
private double _cp;
private boolean _paDuel;
private int _x;
private int _y;
private int _z;
private FastList _debuffs;
final Duel this$0;

public PlayerCondition(L2PcInstance player, boolean partyDuel)
{
this$0 = Duel.this;
super();
if(player == null)
return;
_player = player;
_hp = _player.getCurrentHp();
_mp = _player.getCurrentMp();
_cp = _player.getCurrentCp();
_paDuel = partyDuel;
if(_paDuel)
{
_x = _player.getX();
_y = _player.getY();
_z = _player.getZ();
}
}
}

public static final class DuelResultEnum extends Enum
{

public static DuelResultEnum[] values()
{
return (DuelResultEnum[])$VALUES.clone();
}

public static DuelResultEnum valueOf(String name)
{
return (DuelResultEnum)Enum.valueOf(net/sf/l2j/gameserver/model/entity/Duel$DuelResultEnum, name);
}

public static final DuelResultEnum Continue;
public static final DuelResultEnum Team1Win;
public static final DuelResultEnum Team2Win;
public static final DuelResultEnum Team1Surrender;
public static final DuelResultEnum Team2Surrender;
public static final DuelResultEnum Canceled;
public static final DuelResultEnum Timeout;
private static final DuelResultEnum $VALUES[];

static
{
Continue = new DuelResultEnum("Continue", 0);
Team1Win = new DuelResultEnum("Team1Win", 1);
Team2Win = new DuelResultEnum("Team2Win", 2);
Team1Surrender = new DuelResultEnum("Team1Surrender", 3);
Team2Surrender = new DuelResultEnum("Team2Surrender", 4);
Canceled = new DuelResultEnum("Canceled", 5);
Timeout = new DuelResultEnum("Timeout", 6);
$VALUES = (new DuelResultEnum[] {
Continue, Team1Win, Team2Win, Team1Surrender, Team2Surrender, Canceled, Timeout
});
}

private DuelResultEnum(String s, int i)
{
super(s, i);
}
}


public Duel(L2PcInstance playerA, L2PcInstance playerB, int partyDuel, int duelId)
{
_surrenderRequest = 0;
_countdown = 4;
_finished = false;
_duelId = duelId;
_playerA = playerA;
_playerB = playerB;
_partyDuel = partyDuel == 1;
_duelEndTime = Calendar.getInstance();
if(_partyDuel)
_duelEndTime.add(13, 300);
else
_duelEndTime.add(13, 120);
_playerConditions = new FastList();
setFinished(false);
if(_partyDuel)
{
_countdown++;
SystemMessage sm = new SystemMessage(SystemMessageId.IN_A_MOMENT_YOU_WILL_BE_TRANSPORTED_TO_THE_SITE_WH
ERE_THE_DUEL_WILL_TAKE_PLACE);
broadcastToTeam1(sm);
broadcastToTeam2(sm);
}
ThreadPoolManager.getInstance().scheduleGeneral(new ScheduleStartDuelTask(this), 3000L);
}

private void stopFighting()
{
ActionFailed af = ActionFailed.STATIC_PACKET;
if(_partyDuel)
{
L2PcInstance temp;
for(Iterator i$ = _playerA.getParty().getPartyMembers().iterator(); i$.hasNext(); temp.sendPacket(af))
{
temp = (L2PcInstance)i$.next();
temp.abortCast();
temp.getAI().setIntention(CtrlIntention.AI_INTENTION_ACTIVE);
temp.setTarget(null);
}

L2PcInstance temp;
for(Iterator i$ = _playerB.getParty().getPartyMembers().iterator(); i$.hasNext(); temp.sendPacket(af))
{
temp = (L2PcInstance)i$.next();
temp.abortCast();
temp.getAI().setIntention(CtrlIntention.AI_INTENTION_ACTIVE);
temp.setTarget(null);
}

} else
{
_playerA.abortCast();
_playerB.abortCast();
_playerA.getAI().setIntention(CtrlIntention.AI_INTENTION_ACTIVE);
_playerA.setTarget(null);
_playerB.getAI().setIntention(CtrlIntention.AI_INTENTION_ACTIVE);
_playerB.setTarget(null);
_playerA.sendPacket(af);
_playerB.sendPacket(af);
}
}

public boolean isDuelistInPvp(boolean sendMessage)
{
if(_partyDuel)
return false;
if(_playerA.getPvpFlag() != 0 || _playerB.getPvpFlag() != 0)
{
if(sendMessage)
{
String engagedInPvP = "The duel was canceled because a duelist engaged in PvP combat.";
_playerA.sendMessage(engagedInPvP);
_playerB.sendMessage(engagedInPvP);
}
return true;
} else
{
return false;
}
}

public void startDuel()
{
savePlayerConditions();
if(_playerA == null || _playerB == null || _playerA.isInDuel() || _playerB.isInDuel())
{
_playerConditions.clear();
_playerConditions = null;
DuelManager.getInstance().removeDuel(this);
return;
}
if(_partyDuel)
{
L2PcInstance temp;
for(Iterator i$ = _playerA.getParty().getPartyMembers().iterator(); i$.hasNext(); temp.broadcastUserInfo())
{
temp = (L2PcInstance)i$.next();
temp.cancelActiveTrade();
temp.setIsInDuel(_duelId);
temp.setTeam(1);
temp.broadcastStatusUpdate();
}

L2PcInstance temp;
for(Iterator i$ = _playerB.getParty().getPartyMembers().iterator(); i$.hasNext(); temp.broadcastUserInfo())
{
temp = (L2PcInstance)i$.next();
temp.cancelActiveTrade();
temp.setIsInDuel(_duelId);
temp.setTeam(2);
temp.broadcastStatusUpdate();
}

ExDuelReady ready = new ExDuelReady(1);
ExDuelStart start = new ExDuelStart(1);
broadcastToTeam1(ready);
broadcastToTeam2(ready);
broadcastToTeam1(start);
broadcastToTeam2(start);
} else
{
_playerA.setIsInDuel(_duelId);
_playerA.setTeam(1);
_playerB.setIsInDuel(_duelId);
_playerB.setTeam(2);
ExDuelReady ready = new ExDuelReady(0);
ExDuelStart start = new ExDuelStart(0);
broadcastToTeam1(ready);
broadcastToTeam2(ready);
broadcastToTeam1(start);
broadcastToTeam2(start);
_playerA.broadcastStatusUpdate();
_playerB.broadcastStatusUpdate();
_playerA.broadcastUserInfo();
_playerB.broadcastUserInfo();
}
PlaySound ps = new PlaySound(1, "B04_S01", 0, 0, 0, 0, 0);
broadcastToTeam1(ps);
broadcastToTeam2(ps);
ThreadPoolManager.getInstance().scheduleGeneral(new ScheduleDuelTask(this), 1000L);
}

public void savePlayerConditions()
{
if(_partyDuel)
{
L2PcInstance temp;
for(Iterator i$ = _playerA.getParty().getPartyMembers().iterator(); i$.hasNext(); _playerConditions.add(new PlayerCondition(temp, _partyDuel)))
temp = (L2PcInstance)i$.next();

L2PcInstance temp;
for(Iterator i$ = _playerB.getParty().getPartyMembers().iterator(); i$.hasNext(); _playerConditions.add(new PlayerCondition(temp, _partyDuel)))
temp = (L2PcInstance)i$.next();

} else
{
_playerConditions.add(new PlayerCondition(_playerA, _partyDuel));
_playerConditions.add(new PlayerCondition(_playerB, _partyDuel));
}
}

public void restorePlayerConditions(boolean abnormalDuelEnd)
{
if(_partyDuel)
{
L2PcInstance temp;
for(Iterator i$ = _playerA.getParty().getPartyMembers().iterator(); i$.hasNext(); temp.broadcastUserInfo())
{
temp = (L2PcInstance)i$.next();
temp.setIsInDuel(0);
temp.setTeam(0);
}

L2PcInstance temp;
for(Iterator i$ = _playerB.getParty().getPartyMembers().iterator(); i$.hasNext(); temp.broadcastUserInfo())
{
temp = (L2PcInstance)i$.next();
temp.setIsInDuel(0);
temp.setTeam(0);
}

} else
{
_playerA.setIsInDuel(0);
_playerA.setTeam(0);
_playerA.broadcastUserInfo();
_playerB.setIsInDuel(0);
_playerB.setTeam(0);
_playerB.broadcastUserInfo();
}
if(abnormalDuelEnd)
return;
javolution.util.FastList.Node e = _playerConditions.head();
for(javolution.util.FastList.Node end = _playerConditions.tail(); (e = e.getNext()) != end;)
((PlayerCondition)e.getValue()).restoreCondition();

}

public int getId()
{
return _duelId;
}

public int getRemainingTime()
{
return (int)(_duelEndTime.getTimeInMillis() - Calendar.getInstance().getTimeInMillis());
}

public L2PcInstance getPlayerA()
{
return _playerA;
}

public L2PcInstance getPlayerB()
{
return _playerB;
}

public boolean isPartyDuel()
{
return _partyDuel;
}

public void setFinished(boolean mode)
{
_finished = mode;
}

public boolean getFinished()
{
return _finished;
}

public void teleportPlayers(int x, int y, int z)
{
if(!_partyDuel)
return;
int offset = 0;
for(Iterator i$ = _playerA.getParty().getPartyMembers().iterator(); i$.hasNext();)
{
L2PcInstance temp = (L2PcInstance)i$.next();
temp.teleToLocation((x + offset) - 180, y - 150, z);
offset += 40;
}

offset = 0;
for(Iterator i$ = _playerB.getParty().getPartyMembers().iterator(); i$.hasNext();)
{
L2PcInstance temp = (L2PcInstance)i$.next();
temp.teleToLocation((x + offset) - 180, y + 150, z);
offset += 40;
}

}

public void broadcastToTeam1(L2GameServerPacket packet)
{
if(_playerA == null)
return;
if(_partyDuel && _playerA.getParty() != null)
{
L2PcInstance temp;
for(Iterator i$ = _playerA.getParty().getPartyMembers().iterator(); i$.hasNext(); temp.sendPacket(packet))
temp = (L2PcInstance)i$.next();

} else
{
_playerA.sendPacket(packet);
}
}

public void broadcastToTeam2(L2GameServerPacket packet)
{
if(_playerB == null)
return;
if(_partyDuel && _playerB.getParty() != null)
{
L2PcInstance temp;
for(Iterator i$ = _playerB.getParty().getPartyMembers().iterator(); i$.hasNext(); temp.sendPacket(packet))
temp = (L2PcInstance)i$.next();

} else
{
_playerB.sendPacket(packet);
}
}

public L2PcInstance getWinner()
{
if(!getFinished() || _playerA == null || _playerB == null)
return null;
if(_playerA.getDuelState() == 3)
return _playerA;
if(_playerB.getDuelState() == 3)
return _playerB;
else
return null;
}

public L2PcInstance getLooser()
{
if(!getFinished() || _playerA == null || _playerB == null)
return null;
if(_playerA.getDuelState() == 3)
return _playerB;
if(_playerA.getDuelState() == 3)
return _playerA;
else
return null;
}

public void playKneelAnimation()
{
L2PcInstance looser = getLooser();
if(looser == null)
return;
if(_partyDuel && looser.getParty() != null)
{
L2PcInstance temp;
for(Iterator i$ = looser.getParty().getPartyMembers().iterator(); i$.hasNext(); temp.broadcastPacket(new SocialAction(temp.getObjectId(), 7)))
temp = (L2PcInstance)i$.next();

} else
{
looser.broadcastPacket(new SocialAction(looser.getObjectId(), 7));
}
}

public int countdown()
{
_countdown--;
if(_countdown > 3)
return _countdown;
SystemMessage sm = null;
if(_countdown > 0)
{
sm = new SystemMessage(SystemMessageId.THE_DUEL_WILL_BEGIN_IN_S1_SECONDS);
sm.addNumber(_countdown);
} else
{
sm = new SystemMessage(SystemMessageId.LET_THE_DUEL_BEGIN);
}
broadcastToTeam1(sm);
broadcastToTeam2(sm);
return _countdown;
}

public void endDuel(DuelResultEnum result)
{
if(_playerA == null || _playerB == null)
{
_playerConditions.clear();
_playerConditions = null;
DuelManager.getInstance().removeDuel(this);
return;
}
SystemMessage sm = null;
static class _cls1
{

static final int $SwitchMap$net$sf$l2j$gameserver$model$entity$Duel$DuelResultEnum[];

static
{
$SwitchMap$net$sf$l2j$gameserver$model$entity$Duel$DuelResultEnum = new int[DuelResultEnum.values().length];
try
{
$SwitchMap$net$sf$l2j$gameserver$model$entity$Duel$DuelResultEnum[DuelResultEnum.Team1Win.ordinal()] = 1;
}
catch(NoSuchFieldError ex) { }
try
{
$SwitchMap$net$sf$l2j$gameserver$model$entity$Duel$DuelResultEnum[DuelResultEnum.Team2Win.ordinal()] = 2;
}
catch(NoSuchFieldError ex) { }
try
{
$SwitchMap$net$sf$l2j$gameserver$model$entity$Duel$DuelResultEnum[DuelResultEnum.Team1Surrender.ordinal()] = 3;
}
catch(NoSuchFieldError ex) { }
try
{
$SwitchMap$net$sf$l2j$gameserver$model$entity$Duel$DuelResultEnum[DuelResultEnum.Team2Surrender.ordinal()] = 4;
}
catch(NoSuchFieldError ex) { }
try
{
$SwitchMap$net$sf$l2j$gameserver$model$entity$Duel$DuelResultEnum[DuelResultEnum.Canceled.ordinal()] = 5;
}
catch(NoSuchFieldError ex) { }
try
{
$SwitchMap$net$sf$l2j$gameserver$model$entity$Duel$DuelResultEnum[DuelResultEnum.Timeout.ordinal()] = 6;
}
catch(NoSuchFieldError ex) { }
}
}

switch(_cls1..SwitchMap.net.sf.l2j.gameserver.model.entity.Duel.DuelResultEnum[r
esult.ordinal()])
{
default:
break;

case 1: // '\001'
restorePlayerConditions(false);
if(_partyDuel)
sm = new SystemMessage(SystemMessageId.C1_PARTY_HAS_WON_THE_DUEL);
else
sm = new SystemMessage(SystemMessageId.C1_HAS_WON_THE_DUEL);
sm.addString(_playerA.getName());
broadcastToTeam1(sm);
broadcastToTeam2(sm);
break;

case 2: // '\002'
restorePlayerConditions(false);
if(_partyDuel)
sm = new SystemMessage(SystemMessageId.C1_PARTY_HAS_WON_THE_DUEL);
else
sm = new SystemMessage(SystemMessageId.C1_HAS_WON_THE_DUEL);
sm.addString(_playerB.getName());
broadcastToTeam1(sm);
broadcastToTeam2(sm);
break;

case 3: // '\003'
restorePlayerConditions(false);
if(_partyDuel)
sm = new SystemMessage(SystemMessageId.SINCE_C1_PARTY_WITHDREW_FROM_THE_DUEL_S2_PARTY_HAS
_WON);
else
sm = new SystemMessage(SystemMessageId.SINCE_C1_WITHDREW_FROM_THE_DUEL_S2_HAS_WON);
sm.addString(_playerA.getName());
sm.addString(_playerB.getName());
broadcastToTeam1(sm);
broadcastToTeam2(sm);
break;

case 4: // '\004'
restorePlayerConditions(false);
if(_partyDuel)
sm = new SystemMessage(SystemMessageId.SINCE_C1_PARTY_WITHDREW_FROM_THE_DUEL_S2_PARTY_HAS
_WON);
else
sm = new SystemMessage(SystemMessageId.SINCE_C1_WITHDREW_FROM_THE_DUEL_S2_HAS_WON);
sm.addString(_playerB.getName());
sm.addString(_playerA.getName());
broadcastToTeam1(sm);
broadcastToTeam2(sm);
break;

case 5: // '\005'
stopFighting();
restorePlayerConditions(true);
sm = new SystemMessage(SystemMessageId.THE_DUEL_HAS_ENDED_IN_A_TIE);
broadcastToTeam1(sm);
broadcastToTeam2(sm);
break;

case 6: // '\006'
stopFighting();
restorePlayerConditions(false);
sm = new SystemMessage(SystemMessageId.THE_DUEL_HAS_ENDED_IN_A_TIE);
broadcastToTeam1(sm);
broadcastToTeam2(sm);
break;
}
ExDuelEnd duelEnd = null;
if(_partyDuel)
duelEnd = new ExDuelEnd(1);
else
duelEnd = new ExDuelEnd(0);
broadcastToTeam1(duelEnd);
broadcastToTeam2(duelEnd);
_playerConditions.clear();
_playerConditions = null;
DuelManager.getInstance().removeDuel(this);
}

public DuelResultEnum checkEndDuelCondition()
{
if(_playerA == null || _playerB == null)
return DuelResultEnum.Canceled;
if(_surrenderRequest != 0)
if(_surrenderRequest == 1)
return DuelResultEnum.Team1Surrender;
else
return DuelResultEnum.Team2Surrender;
if(getRemainingTime() <= 0)
return DuelResultEnum.Timeout;
if(_playerA.getDuelState() == 3)
{
stopFighting();
return DuelResultEnum.Team1Win;
}
if(_playerB.getDuelState() == 3)
{
stopFighting();
return DuelResultEnum.Team2Win;
}
if(!_partyDuel)
{
if(_playerA.getDuelState() == 4 || _playerB.getDuelState() == 4)
return DuelResultEnum.Canceled;
if(!_playerA.isInsideRadius(_playerB, 1600, false, false))
return DuelResultEnum.Canceled;
if(isDuelistInPvp(true))
return DuelResultEnum.Canceled;
if(_playerA.isInsideZone((byte)1) || _playerB.isInsideZone((byte)1) || _playerA.isInsideZone((byte)2) || _playerB.isInsideZone((byte)2) || _playerA.isInsideZone((byte)0) || _playerB.isInsideZone((byte)0))
return DuelResultEnum.Canceled;
}
return DuelResultEnum.Continue;
}

public void doSurrender(L2PcInstance player)
{
if(_surrenderRequest != 0)
return;
stopFighting();
if(_partyDuel)
{
if(_playerA.getParty().getPartyMembers().contains(player))
{
_surrenderRequest = 1;
L2PcInstance temp;
for(Iterator i$ = _playerA.getParty().getPartyMembers().iterator(); i$.hasNext(); temp.setDuelState(2))
temp = (L2PcInstance)i$.next();

L2PcInstance temp;
for(Iterator i$ = _playerB.getParty().getPartyMembers().iterator(); i$.hasNext(); temp.setDuelState(3))
temp = (L2PcInstance)i$.next();

} else
if(_playerB.getParty().getPartyMembers().contains(player))
{
_surrenderRequest = 2;
L2PcInstance temp;
for(Iterator i$ = _playerB.getParty().getPartyMembers().iterator(); i$.hasNext(); temp.setDuelState(2))
temp = (L2PcInstance)i$.next();

L2PcInstance temp;
for(Iterator i$ = _playerA.getParty().getPartyMembers().iterator(); i$.hasNext(); temp.setDuelState(3))
temp = (L2PcInstance)i$.next();

}
} else
if(player == _playerA)
{
_surrenderRequest = 1;
_playerA.setDuelState(2);
_playerB.setDuelState(3);
} else
if(player == _playerB)
{
_surrenderRequest = 2;
_playerB.setDuelState(2);
_playerA.setDuelState(3);
}
}

public void onPlayerDefeat(L2PcInstance player)
{
player.setDuelState(2);
if(_partyDuel)
{
boolean teamdefeated = true;
Iterator i$ = player.getParty().getPartyMembers().iterator();
do
{
if(!i$.hasNext())
break;
L2PcInstance temp = (L2PcInstance)i$.next();
if(temp.getDuelState() != 1)
continue;
teamdefeated = false;
break;
} while(true);
if(teamdefeated)
{
L2PcInstance winner = _playerA;
if(_playerA.getParty().getPartyMembers().contains(player))
winner = _playerB;
L2PcInstance temp;
for(Iterator i$ = winner.getParty().getPartyMembers().iterator(); i$.hasNext(); temp.setDuelState(3))
temp = (L2PcInstance)i$.next();

}
} else
{
if(player != _playerA && player != _playerB)
_log.warning("Error in onPlayerDefeat(): player is not part of this 1vs1 duel");
if(_playerA == player)
_playerB.setDuelState(3);
else
_playerA.setDuelState(3);
}
}

public void onRemoveFromParty(L2PcInstance player)
{
if(!_partyDuel)
return;
if(player == _playerA || player == _playerB)
{
javolution.util.FastList.Node e = _playerConditions.head();
for(javolution.util.FastList.Node end = _playerConditions.tail(); (e = e.getNext()) != end;)
{
((PlayerCondition)e.getValue()).teleportBack();
((PlayerCondition)e.getValue()).getPlayer().setIsInDuel(0);
}

_playerA = null;
_playerB = null;
} else
{
javolution.util.FastList.Node e = _playerConditions.head();
javolution.util.FastList.Node end = _playerConditions.tail();
do
{
if((e = e.getNext()) == end)
break;
if(((PlayerCondition)e.getValue()).getPlayer() != player)
continue;
((PlayerCondition)e.getValue()).teleportBack();
_playerConditions.remove(e.getValue());
break;
} while(true);
player.setIsInDuel(0);
}
}

public void onBuff(L2PcInstance player, L2Effect debuff)
{
javolution.util.FastList.Node e = _playerConditions.head();
for(javolution.util.FastList.Node end = _playerConditions.tail(); (e = e.getNext()) != end;)
if(((PlayerCondition)e.getValue()).getPlayer() == player)
{
((PlayerCondition)e.getValue()).registerDebuff(debuff);
return;
}

}

protected static final Logger _log = Logger.getLogger(net/sf/l2j/gameserver/model/entity/Duel.getName());
public static final int DUELSTATE_NODUEL = 0;
public static final int DUELSTATE_DUELLING = 1;
public static final int DUELSTATE_DEAD = 2;
public static final int DUELSTATE_WINNER = 3;
public static final int DUELSTATE_INTERRUPTED = 4;
private int _duelId;
private L2PcInstance _playerA;
private L2PcInstance _playerB;
private boolean _partyDuel;
private Calendar _duelEndTime;
private int _surrenderRequest;
private int _countdown;
private boolean _finished;
private FastList _playerConditions;

}

package net.sf.l2j.gameserver.instancemanager;

import java.util.Iterator;
import java.util.logging.Logger;
import javolution.util.FastList;
import net.sf.l2j.gameserver.model.L2Effect;
import net.sf.l2j.gameserver.model.L2Party;
import net.sf.l2j.gameserver.model.actor.instance.L2PcInstance;
import net.sf.l2j.gameserver.model.entity.Duel;
import net.sf.l2j.gameserver.network.serverpackets.L2GameServerPacket;

public class DuelManager
{
private static class SingletonHolder
{

protected static final DuelManager _instance = new DuelManager();


private SingletonHolder()
{
}
}


public static final DuelManager getInstance()
{
return SingletonHolder._instance;
}

private DuelManager()
{
_currentDuelId = 144;
_log.info("Initializing DuelManager");
_duels = new FastList();
}

private int getNextDuelId()
{
if(++_currentDuelId >= 0x7ffffff8)
_currentDuelId = 1;
return _currentDuelId;
}

public Duel getDuel(int duelId)
{
javolution.util.FastList.Node e = _duels.head();
for(javolution.util.FastList.Node end = _duels.tail(); (e = e.getNext()) != end;)
if(((Duel)e.getValue()).getId() == duelId)
return (Duel)e.getValue();

return null;
}

public void addDuel(L2PcInstance playerA, L2PcInstance playerB, int partyDuel)
{
label0:
{
String engagedInPvP;
label1:
{
boolean playerInPvP;
label2:
{
if(playerA == null || playerB == null)
return;
engagedInPvP = "The duel was canceled because a duelist engaged in PvP combat.";
if(partyDuel != 1)
break label1;
playerInPvP = false;
Iterator i$ = playerA.getParty().getPartyMembers().iterator();
L2PcInstance temp;
do
{
if(!i$.hasNext())
break;
temp = (L2PcInstance)i$.next();
if(temp.getPvpFlag() == 0)
continue;
playerInPvP = true;
break;
} while(true);
if(playerInPvP)
break label2;
i$ = playerB.getParty().getPartyMembers().iterator();
do
{
if(!i$.hasNext())
break label2;
temp = (L2PcInstance)i$.next();
} while(temp.getPvpFlag() == 0);
playerInPvP = true;
}
if(playerInPvP)
{
L2PcInstance temp;
for(Iterator i$ = playerA.getParty().getPartyMembers().iterator(); i$.hasNext(); temp.sendMessage(engagedInPvP))
temp = (L2PcInstance)i$.next();

L2PcInstance temp;
for(Iterator i$ = playerB.getParty().getPartyMembers().iterator(); i$.hasNext(); temp.sendMessage(engagedInPvP))
temp = (L2PcInstance)i$.next();

return;
}
break label0;
}
if(playerA.getPvpFlag() != 0 || playerB.getPvpFlag() != 0)
{
playerA.sendMessage(engagedInPvP);
playerB.sendMessage(engagedInPvP);
return;
}
}
Duel duel = new Duel(playerA, playerB, partyDuel, getNextDuelId());
_duels.add(duel);
}

public void removeDuel(Duel duel)
{
_duels.remove(duel);
}

public void doSurrender(L2PcInstance player)
{
if(player == null || !player.isInDuel())
{
return;
} else
{
Duel duel = getDuel(player.getDuelId());
duel.doSurrender(player);
return;
}
}

public void onPlayerDefeat(L2PcInstance player)
{
if(player == null || !player.isInDuel())
return;
Duel duel = getDuel(player.getDuelId());
if(duel != null)
duel.onPlayerDefeat(player);
}

public void onBuff(L2PcInstance player, L2Effect buff)
{
if(player == null || !player.isInDuel() || buff == null)
return;
Duel duel = getDuel(player.getDuelId());
if(duel != null)
duel.onBuff(player, buff);
}

public void onRemoveFromParty(L2PcInstance player)
{
if(player == null || !player.isInDuel())
return;
Duel duel = getDuel(player.getDuelId());
if(duel != null)
duel.onRemoveFromParty(player);
}

public void broadcastToOppositTeam(L2PcInstance player, L2GameServerPacket packet)
{
if(player == null || !player.isInDuel())
return;
Duel duel = getDuel(player.getDuelId());
if(duel == null)
return;
if(duel.getPlayerA() == null || duel.getPlayerB() == null)
return;
if(duel.getPlayerA() == player)
duel.broadcastToTeam2(packet);
else
if(duel.getPlayerB() == player)
duel.broadcastToTeam1(packet);
else
if(duel.isPartyDuel())
if(duel.getPlayerA().getParty() != null && duel.getPlayerA().getParty().getPartyMembers().contains(player))
duel.broadcastToTeam2(packet);
else
if(duel.getPlayerB().getParty() != null && duel.getPlayerB().getParty().getPartyMembers().contains(player))
duel.broadcastToTeam1(packet);
}


private static final Logger _log = Logger.getLogger(net/sf/l2j/gameserver/instancemanager/DuelManager.getName());
private FastList _duels;
private int _currentDuelId;