players;
switch (teleportWho)
{
case Owner:
players = getOwnersInZone();
break;
case Attacker:
players = getAttackersInZone();
break;
case DefenderNotOwner:
players = getDefendersButNotOwnersInZone();
break;
case Spectator:
players = getSpectatorsInZone();
break;
default:
players = getPlayersInZone();
}
for (L2PcInstance player : players)
{
if (player.isGM() || player.isInJail())
continue;
player.teleToLocation(teleportWhere);
}
}
// =========================================================
// Method - Private
/**
* Add clan as attacker
* @param clanId The int of clan's id
*/
private void addAttacker(int clanId)
{
getAttackerClans().add(new L2SiegeClan(clanId, SiegeClanType.ATTACKER)); // Add registered attacker to attacker list
}
/**
* Add clan as defender
* @param clanId The int of clan's id
*/
private void addDefender(int clanId)
{
getDefenderClans().add(new L2SiegeClan(clanId, SiegeClanType.DEFENDER)); // Add registered defender to defender list
}
/**
* Add clan as defender with the specified type
* @param clanId The int of clan's id
* @param type the type of the clan
*/
private void addDefender(int clanId, SiegeClanType type)
{
getDefenderClans().add(new L2SiegeClan(clanId, type));
}
/**
* Add clan as defender waiting approval
* @param clanId The int of clan's id
*/
private void addDefenderWaiting(int clanId)
{
getDefenderWaitingClans().add(new L2SiegeClan(clanId, SiegeClanType.DEFENDER_PENDING)); // Add registered defender to defender list
}
/**
* Return true if the player can register.
* @param player The L2PcInstance of the player trying to register
*/
private boolean checkIfCanRegister(L2PcInstance player)
{
if (getIsRegistrationOver())
player.sendMessage("The deadline to register for the siege of " + getCastle().getName() + " has passed.");
else if (getIsInProgress())
player.sendMessage("This is not the time for siege registration and so registration and cancellation cannot be done.");
else if (player.getClan() == null || player.getClan().getLevel() < SiegeManager.getInstance().getSiegeClanMinLevel())
player.sendMessage("Only clans with Level " + SiegeManager.getInstance().getSiegeClanMinLevel() + " and higher may register for a castle siege.");
else if (player.getClan().getHasCastle() > 0)
player.sendMessage("You cannot register because your clan already owns a castle.");
else if (player.getClan().getClanId() == getCastle().getOwnerId())
player.sendPacket(new SystemMessage(SystemMessageId.CLAN_THAT_OWNS_CASTLE_IS_AUTOMATICALLY_REGISTERED_DEFENDING));
else if (SiegeManager.getInstance().checkIsRegistered(player.getClan(), getCastle().getCastleId()))
player.sendPacket(new SystemMessage(SystemMessageId.ALREADY_REQUESTED_SIEGE_BATTLE));
else if (checkIfAlreadyRegisteredForSameDay(player.getClan()))
player.sendPacket(new SystemMessage(SystemMessageId.APPLICATION_DENIED_BECAUSE_ALREADY_SUBMITTED_A_REQUEST_FOR_ANOTHER_SIEGE_BATTLE));
else
return true;
return false;
}
/**
* Return true if the clan has already registered to a siege for the same day.
* @param clan The L2Clan of the player trying to register
*/
public boolean checkIfAlreadyRegisteredForSameDay(L2Clan clan)
{
for (Siege siege : SiegeManager.getInstance().getSieges())
{
if (siege == this)
continue;
if (siege.getSiegeDate().get(Calendar.DAY_OF_WEEK) == this.getSiegeDate().get(Calendar.DAY_OF_WEEK))
{
if (siege.checkIsAttacker(clan))
return true;
if (siege.checkIsDefender(clan))
return true;
if (siege.checkIsDefenderWaiting(clan))
return true;
}
}
return false;
}
/**
* Return the correct siege date as Calendar.
* @param siegeDate The Calendar siege date and time
*/
private void correctSiegeDateTime()
{
boolean corrected = false;
if (getCastle().getSiegeDate().getTimeInMillis() < Calendar.getInstance().getTimeInMillis())
{
// Since siege has past reschedule it to the next one (14 days)
// This is usually caused by server being down
corrected = true;
setNextSiegeDate();
}
if (getCastle().getSiegeDate().get(Calendar.DAY_OF_WEEK) != getCastle().getSiegeDayOfWeek())
{
corrected = true;
getCastle().getSiegeDate().set(Calendar.DAY_OF_WEEK, getCastle().getSiegeDayOfWeek());
}
if (getCastle().getSiegeDate().get(Calendar.HOUR_OF_DAY) != getCastle().getSiegeHourOfDay())
{
corrected = true;
getCastle().getSiegeDate().set(Calendar.HOUR_OF_DAY, getCastle().getSiegeHourOfDay());
}
getCastle().getSiegeDate().set(Calendar.MINUTE, 0);
if (corrected)
saveSiegeDate();
}
/** Load siege clans. */
private void loadSiegeClan()
{
java.sql.Connection con = null;
try
{
getAttackerClans().clear();
getDefenderClans().clear();
getDefenderWaitingClans().clear();
// Add castle owner as defender (add owner first so that they are on the top of the defender list)
if (getCastle().getOwnerId() > 0)
addDefender(getCastle().getOwnerId(), SiegeClanType.OWNER);
PreparedStatement statement = null;
ResultSet rs = null;
con = L2DatabaseFactory.getInstance().getConnection();
statement = con.prepareStatement("SELECT clan_id,type FROM siege_clans where castle_id=?");
statement.setInt(1, getCastle().getCastleId());
rs = statement.executeQuery();
int typeId;
while (rs.next())
{
typeId = rs.getInt("type");
if (typeId == 0)
addDefender(rs.getInt("clan_id"));
else if (typeId == 1)
addAttacker(rs.getInt("clan_id"));
else if (typeId == 2)
addDefenderWaiting(rs.getInt("clan_id"));
}
statement.close();
}
catch (Exception e)
{
_log.warning("Exception: loadSiegeClan(): " + e.getMessage());
e.printStackTrace();
}
finally
{
try
{
con.close();
}
catch (Exception e)
{
}
}
}
/** Remove all control tower spawned. */
private void removeControlTower()
{
if (_controlTowers != null)
{
// Remove all instance of control tower for this castle
for (L2ControlTowerInstance ct : _controlTowers)
{
if (ct != null)
ct.decayMe();
}
_controlTowers = null;
}
}
/** Remove all flags. */
private void removeFlags()
{
for (L2SiegeClan sc : getAttackerClans())
{
if (sc != null)
sc.removeFlags();
}
for (L2SiegeClan sc : getDefenderClans())
{
if (sc != null)
sc.removeFlags();
}
}
/** Remove flags from defenders. */
private void removeDefenderFlags()
{
for (L2SiegeClan sc : getDefenderClans())
{
if (sc != null)
sc.removeFlags();
}
}
/** Save castle siege related to database. */
private void saveCastleSiege()
{
setNextSiegeDate(); // Set the next set date for 2 weeks from now
saveSiegeDate(); // Save the new date
startAutoTask(); // Prepare auto start siege and end registration
}
/** Save siege date to database. */
private void saveSiegeDate()
{
java.sql.Connection con = null;
try
{
con = L2DatabaseFactory.getInstance().getConnection();
PreparedStatement statement = con.prepareStatement("Update castle set siegeDate = ? where id = ?");
statement.setLong(1, getSiegeDate().getTimeInMillis());
statement.setInt(2, getCastle().getCastleId());
statement.execute();
statement.close();
}
catch (Exception e)
{
_log.warning("Exception: saveSiegeDate(): " + e.getMessage());
e.printStackTrace();
}
finally
{
try
{
con.close();
}
catch (Exception e)
{
}
}
}
/**
* Save registration to database.
* @param clan The L2Clan of player
* @param typeId -1 = owner 0 = defender, 1 = attacker, 2 = defender waiting
*/
private void saveSiegeClan(L2Clan clan, int typeId, boolean isUpdateRegistration)
{
if (clan.getHasCastle() > 0)
return;
java.sql.Connection con = null;
try
{
if (typeId == 0 || typeId == 2 || typeId == -1)
{
if (getDefenderClans().size() + getDefenderWaitingClans().size() >= SiegeManager.getInstance().getDefenderMaxClans())
return;
}
else
{
if (getAttackerClans().size() >= SiegeManager.getInstance().getAttackerMaxClans())
return;
}
con = L2DatabaseFactory.getInstance().getConnection();
PreparedStatement statement;
if (!isUpdateRegistration)
{
statement = con.prepareStatement("INSERT INTO siege_clans (clan_id,castle_id,type,castle_owner) values (?,?,?,0)");
statement.setInt(1, clan.getClanId());
statement.setInt(2, getCastle().getCastleId());
statement.setInt(3, typeId);
statement.execute();
statement.close();
}
else
{
statement = con.prepareStatement("Update siege_clans set type = ? where castle_id = ? and clan_id = ?");
statement.setInt(1, typeId);
statement.setInt(2, getCastle().getCastleId());
statement.setInt(3, clan.getClanId());
statement.execute();
statement.close();
}
if (typeId == 0 || typeId == -1)
{
addDefender(clan.getClanId());
announceToPlayer(clan.getName() + " has been registered to defend " + getCastle().getName(), false);
}
else if (typeId == 1)
{
addAttacker(clan.getClanId());
announceToPlayer(clan.getName() + " has been registered to attack " + getCastle().getName(), false);
}
else if (typeId == 2)
{
addDefenderWaiting(clan.getClanId());
announceToPlayer(clan.getName() + " has requested to defend " + getCastle().getName(), false);
}
}
catch (Exception e)
{
_log.warning("Exception: saveSiegeClan(L2Clan clan, int typeId, boolean isUpdateRegistration): " + e.getMessage());
e.printStackTrace();
}
finally
{
try
{
con.close();
}
catch (Exception e)
{
}
}
}
/** Set the date for the next siege. */
private void setNextSiegeDate()
{
while (getCastle().getSiegeDate().getTimeInMillis() < Calendar.getInstance().getTimeInMillis())
{
// Set next siege date if siege has passed
getCastle().getSiegeDate().add(Calendar.DAY_OF_MONTH, 14); // Schedule to happen in 14 days
}
_isRegistrationOver = false; // Allow registration for next siege
}
/** Spawn control tower. */
private void spawnControlTower(int Id)
{
//Set control tower array size if one does not exist
if (_controlTowers == null)
_controlTowers = new FastList();
for (SiegeSpawn _sp : SiegeManager.getInstance().getControlTowerSpawnList(Id))
{
L2ControlTowerInstance ct;
L2NpcTemplate template = NpcTable.getInstance().getTemplate(_sp.getNpcId());
// TODO: Check/confirm if control towers have any special weapon resistances/vulnerabilities
// template.addVulnerability(Stats.BOW_WPN_VULN,0);
// template.addVulnerability(Stats.BLUNT_WPN_VULN,0);
// template.addVulnerability(Stats.DAGGER_WPN_VULN,0);
ct = new L2ControlTowerInstance(IdFactory.getInstance().getNextId(), template);
ct.setCurrentHpMp(_sp.getHp(), ct.getMaxMp());
ct.spawnMe(_sp.getLocation().getX(), _sp.getLocation().getY(), _sp.getLocation().getZ() + 20);
_controlTowerCount++;
_controlTowerMaxCount++;
_controlTowers.add(ct);
}
}
/**
* Spawn siege guard.
*/
private void spawnSiegeGuard()
{
getSiegeGuardManager().spawnSiegeGuard();
// Register guard to the closest Control Tower
// When CT dies, so do all the guards that it controls
if (getSiegeGuardManager().getSiegeGuardSpawn().size() > 0 && _controlTowers.size() > 0)
{
L2ControlTowerInstance closestCt;
double distance, x, y, z;
double distanceClosest = 0;
for (L2Spawn spawn : getSiegeGuardManager().getSiegeGuardSpawn())
{
if (spawn == null)
continue;
closestCt = null;
distanceClosest = 0;
for (L2ControlTowerInstance ct : _controlTowers)
{
if (ct == null)
continue;
x = (spawn.getLocx() - ct.getX());
y = (spawn.getLocy() - ct.getY());
z = (spawn.getLocz() - ct.getZ());
distance = (x * x) + (y * y) + (z * z);
if (closestCt == null || distance < distanceClosest)
{
closestCt = ct;
distanceClosest = distance;
}
}
if (closestCt != null)
closestCt.registerGuard(spawn);
}
}
}
public final L2SiegeClan getAttackerClan(L2Clan clan)
{
if (clan == null)
return null;
return getAttackerClan(clan.getClanId());
}
public final L2SiegeClan getAttackerClan(int clanId)
{
for (L2SiegeClan sc : getAttackerClans())
if (sc != null && sc.getClanId() == clanId)
return sc;
return null;
}
public final List getAttackerClans()
{
if (_isNormalSide)
return _attackerClans;
return _defenderClans;
}
public final int getAttackerRespawnDelay()
{
return (SiegeManager.getInstance().getAttackerRespawnDelay());
}
public final Castle getCastle()
{
if (_castle == null || _castle.length <= 0)
return null;
return _castle[0];
}
public final L2SiegeClan getDefenderClan(L2Clan clan)
{
if (clan == null)
return null;
return getDefenderClan(clan.getClanId());
}
public final L2SiegeClan getDefenderClan(int clanId)
{
for (L2SiegeClan sc : getDefenderClans())
if (sc != null && sc.getClanId() == clanId)
return sc;
return null;
}
public final List getDefenderClans()
{
if (_isNormalSide)
return _defenderClans;
return _attackerClans;
}
public final L2SiegeClan getDefenderWaitingClan(L2Clan clan)
{
if (clan == null)
return null;
return getDefenderWaitingClan(clan.getClanId());
}
public final L2SiegeClan getDefenderWaitingClan(int clanId)
{
for (L2SiegeClan sc : getDefenderWaitingClans())
if (sc != null && sc.getClanId() == clanId)
return sc;
return null;
}
public final List getDefenderWaitingClans()
{
return _defenderWaitingClans;
}
public final int getDefenderRespawnDelay()
{
return (SiegeManager.getInstance().getDefenderRespawnDelay() + _defenderRespawnDelayPenalty);
}
public final boolean getIsInProgress()
{
return _isInProgress;
}
public final boolean getIsRegistrationOver()
{
return _isRegistrationOver;
}
public final Calendar getSiegeDate()
{
return getCastle().getSiegeDate();
}
public List getFlag(L2Clan clan)
{
if (clan != null)
{
L2SiegeClan sc = getAttackerClan(clan);
if (sc != null)
return sc.getFlag();
}
return null;
}
public final SiegeGuardManager getSiegeGuardManager()
{
if (_siegeGuardManager == null)
{
_siegeGuardManager = new SiegeGuardManager(getCastle());
}
return _siegeGuardManager;
}
}