Help Seven Sign

EloBoost · March 26, 2016

Hey guys i have a problem with seven signs

My problem is that i can tp without participate

At pre-period (when i wipe my db) i must participate to join but when the period start players without reg can tp at catas too

i have this html on Priest

i have try to take the java from other pack where it works but nothing ....

any help?

my config is this

#============================================================#
#                       Seven Signs                          #
#============================================================#
#           Pack: l2jfrozen Site: www.l2jfrozen.com          #
#============================================================#


# -----------------------
#  Rule 7 Seals -
# -----------------------
# To join the warrior Dawn would require that the player is in the castle allied clan.
AltRequireCastleForDawn = False


# Definition for the ownership of the castle clan or alliance.
AltRequireClanCastle = False


# Need to be winner to enter in Catacombs/Necropolis in validation period
# Default: True
AltRequireWin7s = True


# --------------------------------------------
#  The Rules Of The Festival -
# --------------------------------------------
# Minimum number of players to participate in the festival of the seven seals.
AltFestivalMinPlayer = 5


# The maximum contribution to the player during the festival
# This value does not affect the level of loot.
AltMaxPlayerContrib = 1000000


# The start time of the festival.
# Default: 2 minutes
AltFestivalManagerStart = 120000


# Duration of the festival.
# Default: 18 minutes
AltFestivalLength = 1080000


# The length of the cycle of the Festival.
# Default: 38 minutes (20 minutes of waiting time + festival)
AltFestivalCycleLength = 2280000


# Initial spawn festival.
# Default: 2 minutes
AltFestivalFirstSpawn = 120000


# The initial training of the Festival.
# Default: 5 minutes
AltFestivalFirstSwarm = 300000


# Following should spawn Festival.
# Default: 9 minutes
AltFestivalSecondSpawn = 540000


# The following preparation of the Festival.
# Default: 12 minutes
AltFestivalSecondSwarm = 720000


# Spawn Chests.
# Default: 15 minutes
AltFestivalChestspawn = 900000

TaskSevenSignsUpdate.java :

/* L2jFrozen Project - www.l2jfrozen.com 
 * 
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 *
 * http://www.gnu.org/copyleft/gpl.html
 */
package com.l2jfrozen.gameserver.taskmanager.tasks;


import java.util.logging.Logger;


import com.l2jfrozen.Config;
import com.l2jfrozen.gameserver.model.entity.sevensigns.SevenSigns;
import com.l2jfrozen.gameserver.model.entity.sevensigns.SevenSignsFestival;
import com.l2jfrozen.gameserver.taskmanager.Task;
import com.l2jfrozen.gameserver.taskmanager.TaskManager;
import com.l2jfrozen.gameserver.taskmanager.TaskManager.ExecutedTask;
import com.l2jfrozen.gameserver.taskmanager.TaskTypes;




/**
 * Updates all data for the Seven Signs and Festival of Darkness engines, when time is elapsed.
 * @author Tempy
 */
public class TaskSevenSignsUpdate extends Task
{
private static final Logger _log = Logger.getLogger(TaskSevenSignsUpdate.class.getName());
public static final String NAME = "sevensignsupdate";


@Override
public String getName()
{
return NAME;
}


@Override
public void onTimeElapsed(final ExecutedTask task)
{
try
{
SevenSigns.getInstance().saveSevenSignsData(null, true);


if (!SevenSigns.getInstance().isSealValidationPeriod())
SevenSignsFestival.getInstance().saveFestivalData(false);


_log.info("[GlobalTask] SevenSigns save launched.");
}
catch (final Exception e)
{
if (Config.ENABLE_ALL_EXCEPTIONS)
e.printStackTrace();


_log.warning("SevenSigns: Failed to save Seven Signs configuration: " + e);
}
}


@Override
public void initializate()
{
super.initializate();
TaskManager.addUniqueTask(NAME, TaskTypes.TYPE_FIXED_SHEDULED, "1800000", "1800000", "");
}
}

Edited March 26, 2016 by EloBoost

EloBoost · March 26, 2016

SevenSigns.java



/* This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2, or (at your option)

 * any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA

 * 02111-1307, USA.

 *

 * http://www.gnu.org/copyleft/gpl.html

 */

package com.l2jfrozen.gameserver.model.entity.sevensigns;



import java.sql.Connection;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.Calendar;

import java.util.Map;

import java.util.logging.Logger;



import javolution.util.FastMap;



import com.l2jfrozen.Config;

import com.l2jfrozen.gameserver.datatables.csv.MapRegionTable;

import com.l2jfrozen.gameserver.handler.AutoChatHandler;

import com.l2jfrozen.gameserver.managers.CastleManager;

import com.l2jfrozen.gameserver.model.L2World;

import com.l2jfrozen.gameserver.model.actor.instance.L2PcInstance;

import com.l2jfrozen.gameserver.model.spawn.AutoSpawn;

import com.l2jfrozen.gameserver.model.spawn.AutoSpawn.AutoSpawnInstance;

import com.l2jfrozen.gameserver.network.SystemMessageId;

import com.l2jfrozen.gameserver.network.serverpackets.SignsSky;

import com.l2jfrozen.gameserver.network.serverpackets.SystemMessage;

import com.l2jfrozen.gameserver.templates.StatsSet;

import com.l2jfrozen.gameserver.thread.ThreadPoolManager;

import com.l2jfrozen.util.CloseUtil;

import com.l2jfrozen.util.database.L2DatabaseFactory;



/**

 * Seven Signs Engine TODO: - Implementation of the Seal of Strife for sieges.

 * 

 * @author programmos

 */

public class SevenSigns

{



/** The Constant _log. */

protected static final Logger _log = Logger.getLogger(SevenSigns.class.getName());



/** The _instance. */

private static SevenSigns _instance;



// Basic Seven Signs Constants \\

/** The Constant SEVEN_SIGNS_DATA_FILE. */

public static final String SEVEN_SIGNS_DATA_FILE = "config/signs.properties";



/** The Constant SEVEN_SIGNS_HTML_PATH. */

public static final String SEVEN_SIGNS_HTML_PATH = "data/html/seven_signs/";



/** The Constant CABAL_NULL. */

public static final int CABAL_NULL = 0;



/** The Constant CABAL_DUSK. */

public static final int CABAL_DUSK = 1;



/** The Constant CABAL_DAWN. */

public static final int CABAL_DAWN = 2;



/** The Constant SEAL_NULL. */

public static final int SEAL_NULL = 0;



/** The Constant SEAL_AVARICE. */

public static final int SEAL_AVARICE = 1;



/** The Constant SEAL_GNOSIS. */

public static final int SEAL_GNOSIS = 2;



/** The Constant SEAL_STRIFE. */

public static final int SEAL_STRIFE = 3;



/** The Constant PERIOD_COMP_RECRUITING. */

public static final int PERIOD_COMP_RECRUITING = 0;



/** The Constant PERIOD_COMPETITION. */

public static final int PERIOD_COMPETITION = 1;



/** The Constant PERIOD_COMP_RESULTS. */

public static final int PERIOD_COMP_RESULTS = 2;



/** The Constant PERIOD_SEAL_VALIDATION. */

public static final int PERIOD_SEAL_VALIDATION = 3;



/** The Constant PERIOD_START_HOUR. */

public static final int PERIOD_START_HOUR = 18;



/** The Constant PERIOD_START_MINS. */

public static final int PERIOD_START_MINS = 00;



/** The Constant PERIOD_START_DAY. */

public static final int PERIOD_START_DAY = Calendar.MONDAY;



// The quest event and seal validation periods last for approximately one week

// with a 15 minutes "interval" period sandwiched between them.

/** The Constant PERIOD_MINOR_LENGTH. */

public static final int PERIOD_MINOR_LENGTH = 900000;



/** The Constant PERIOD_MAJOR_LENGTH. */

public static final int PERIOD_MAJOR_LENGTH = 604800000 - PERIOD_MINOR_LENGTH;



/** The Constant ANCIENT_ADENA_ID. */

public static final int ANCIENT_ADENA_ID = 5575;



/** The Constant RECORD_SEVEN_SIGNS_ID. */

public static final int RECORD_SEVEN_SIGNS_ID = 5707;



/** The Constant CERTIFICATE_OF_APPROVAL_ID. */

public static final int CERTIFICATE_OF_APPROVAL_ID = 6388;



/** The Constant RECORD_SEVEN_SIGNS_COST. */

public static final int RECORD_SEVEN_SIGNS_COST = 500;



/** The Constant ADENA_JOIN_DAWN_COST. */

public static final int ADENA_JOIN_DAWN_COST = 50000;



// NPC Related Constants \\

/** The Constant ORATOR_NPC_ID. */

public static final int ORATOR_NPC_ID = 31094;



/** The Constant PREACHER_NPC_ID. */

public static final int PREACHER_NPC_ID = 31093;



/** The Constant MAMMON_MERCHANT_ID. */

public static final int MAMMON_MERCHANT_ID = 31113;



/** The Constant MAMMON_BLACKSMITH_ID. */

public static final int MAMMON_BLACKSMITH_ID = 31126;



/** The Constant MAMMON_MARKETEER_ID. */

public static final int MAMMON_MARKETEER_ID = 31092;



/** The Constant SPIRIT_IN_ID. */

public static final int SPIRIT_IN_ID = 31111;



/** The Constant SPIRIT_OUT_ID. */

public static final int SPIRIT_OUT_ID = 31112;



/** The Constant LILITH_NPC_ID. */

public static final int LILITH_NPC_ID = 25283;



/** The Constant ANAKIM_NPC_ID. */

public static final int ANAKIM_NPC_ID = 25286;



/** The Constant CREST_OF_DAWN_ID. */

public static final int CREST_OF_DAWN_ID = 31170;



/** The Constant CREST_OF_DUSK_ID. */

public static final int CREST_OF_DUSK_ID = 31171;

// Seal Stone Related Constants \\

/** The Constant SEAL_STONE_BLUE_ID. */

public static final int SEAL_STONE_BLUE_ID = 6360;



/** The Constant SEAL_STONE_GREEN_ID. */

public static final int SEAL_STONE_GREEN_ID = 6361;



/** The Constant SEAL_STONE_RED_ID. */

public static final int SEAL_STONE_RED_ID = 6362;



/** The Constant SEAL_STONE_BLUE_VALUE. */

public static final int SEAL_STONE_BLUE_VALUE = 3;



/** The Constant SEAL_STONE_GREEN_VALUE. */

public static final int SEAL_STONE_GREEN_VALUE = 5;



/** The Constant SEAL_STONE_RED_VALUE. */

public static final int SEAL_STONE_RED_VALUE = 10;



/** The Constant BLUE_CONTRIB_POINTS. */

public static final int BLUE_CONTRIB_POINTS = 3;



/** The Constant GREEN_CONTRIB_POINTS. */

public static final int GREEN_CONTRIB_POINTS = 5;



/** The Constant RED_CONTRIB_POINTS. */

public static final int RED_CONTRIB_POINTS = 10;



/** The _calendar. */

private final Calendar _calendar = Calendar.getInstance();



/** The _active period. */

protected int _activePeriod;



/** The _current cycle. */

protected int _currentCycle;



/** The _dawn stone score. */

protected double _dawnStoneScore;



/** The _dusk stone score. */

protected double _duskStoneScore;



/** The _dawn festival score. */

protected int _dawnFestivalScore;



/** The _dusk festival score. */

protected int _duskFestivalScore;



/** The _comp winner. */

protected int _compWinner;



/** The _previous winner. */

protected int _previousWinner;



/** The _signs player data. */

private Map<Integer, StatsSet> _signsPlayerData;



/** The _signs seal owners. */

private Map<Integer, Integer> _signsSealOwners;



/** The _signs dusk seal totals. */

private Map<Integer, Integer> _signsDuskSealTotals;



/** The _signs dawn seal totals. */

private Map<Integer, Integer> _signsDawnSealTotals;



/** The _merchant spawn. */

private static AutoSpawnInstance _merchantSpawn;



/** The _blacksmith spawn. */

private static AutoSpawnInstance _blacksmithSpawn;



/** The _spirit in spawn. */

private static AutoSpawnInstance _spiritInSpawn;



/** The _spirit out spawn. */

private static AutoSpawnInstance _spiritOutSpawn;



/** The _lilith spawn. */

private static AutoSpawnInstance _lilithSpawn;



/** The _anakim spawn. */

private static AutoSpawnInstance _anakimSpawn;



/** The _crestofdawnspawn. */

private static AutoSpawnInstance _crestofdawnspawn;



/** The _crestofduskspawn. */

private static AutoSpawnInstance _crestofduskspawn;



/** The _orator spawns. */

private static Map<Integer, AutoSpawnInstance> _oratorSpawns;



/** The _preacher spawns. */

private static Map<Integer, AutoSpawnInstance> _preacherSpawns;



/** The _marketeer spawns. */

private static Map<Integer, AutoSpawnInstance> _marketeerSpawns;



/**

* Instantiates a new seven signs.

*/

@SuppressWarnings("unused")

public SevenSigns()

{

_signsPlayerData = new FastMap<Integer, StatsSet>();

_signsSealOwners = new FastMap<Integer, Integer>();

_signsDuskSealTotals = new FastMap<Integer, Integer>();

_signsDawnSealTotals = new FastMap<Integer, Integer>();



try

{

restoreSevenSignsData();

}

catch(Exception e)

{

if(Config.ENABLE_ALL_EXCEPTIONS)

e.printStackTrace();



_log.severe("SevenSigns: Failed to load configuration: " + e);

}



_log.info("SevenSigns: Currently in the " + getCurrentPeriodName() + " period!");

initializeSeals();



if(isSealValidationPeriod())

if(getCabalHighestScore() == CABAL_NULL)

{

_log.info("SevenSigns: The competition ended with a tie last week.");

}

else

{

_log.info("SevenSigns: The " + getCabalName(getCabalHighestScore()) + " were victorious last week.");

}

else if(getCabalHighestScore() == CABAL_NULL)

{

_log.info("SevenSigns: The competition, if the current trend continues, will end in a tie this week.");

}

else

{

_log.info("SevenSigns: The " + getCabalName(getCabalHighestScore()) + " are in the lead this week.");

}



synchronized (this)

{

setCalendarForNextPeriodChange();

long milliToChange = getMilliToPeriodChange();



SevenSignsPeriodChange sspc = new SevenSignsPeriodChange();

ThreadPoolManager.getInstance().scheduleGeneral(sspc, milliToChange);

sspc = null;



// Thanks to http://rainbow.arch.scriptmania.com/scripts/timezone_countdown.html for help with this.

double numSecs = milliToChange / 1000 % 60;

double countDown = (milliToChange / 1000 - numSecs) / 60;

int numMins = (int) Math.floor(countDown % 60);

countDown = (countDown - numMins) / 60;

int numHours = (int) Math.floor(countDown % 24);

int numDays = (int) Math.floor((countDown - numHours) / 24);



_log.info("SevenSigns: Next period begins in " + numDays + " days, " + numHours + " hours and " + numMins + " mins.");

}



spawnSevenSignsNPC();

}



/**

* Registers all random spawns and auto-chats for Seven Signs NPCs, along with spawns for the Preachers of Doom and

* Orators of Revelations at the beginning of the Seal Validation period.

*/

public void spawnSevenSignsNPC()

{

_merchantSpawn = AutoSpawn.getInstance().getAutoSpawnInstance(MAMMON_MERCHANT_ID, false);

_blacksmithSpawn = AutoSpawn.getInstance().getAutoSpawnInstance(MAMMON_BLACKSMITH_ID, false);

_marketeerSpawns = AutoSpawn.getInstance().getAutoSpawnInstances(MAMMON_MARKETEER_ID);

_spiritInSpawn = AutoSpawn.getInstance().getAutoSpawnInstance(SPIRIT_IN_ID, false);

_spiritOutSpawn = AutoSpawn.getInstance().getAutoSpawnInstance(SPIRIT_OUT_ID, false);

_lilithSpawn = AutoSpawn.getInstance().getAutoSpawnInstance(LILITH_NPC_ID, false);

_anakimSpawn = AutoSpawn.getInstance().getAutoSpawnInstance(ANAKIM_NPC_ID, false);

_crestofdawnspawn = AutoSpawn.getInstance().getAutoSpawnInstance(CREST_OF_DAWN_ID, false);

_crestofduskspawn = AutoSpawn.getInstance().getAutoSpawnInstance(CREST_OF_DUSK_ID, false);

_oratorSpawns = AutoSpawn.getInstance().getAutoSpawnInstances(ORATOR_NPC_ID);

_preacherSpawns = AutoSpawn.getInstance().getAutoSpawnInstances(PREACHER_NPC_ID);



if(isSealValidationPeriod() || isCompResultsPeriod())

{

for(AutoSpawnInstance spawnInst : _marketeerSpawns.values())

{

AutoSpawn.getInstance().setSpawnActive(spawnInst, true);

}



if(getSealOwner(SEAL_GNOSIS) == getCabalHighestScore() && getSealOwner(SEAL_GNOSIS) != CABAL_NULL)

{

if(!Config.ANNOUNCE_MAMMON_SPAWN)

{

_blacksmithSpawn.setBroadcast(false);

}



if(!AutoSpawn.getInstance().getAutoSpawnInstance(_blacksmithSpawn.getObjectId(), true).isSpawnActive())

{

AutoSpawn.getInstance().setSpawnActive(_blacksmithSpawn, true);

}



for(AutoSpawnInstance spawnInst : _oratorSpawns.values())

if(!AutoSpawn.getInstance().getAutoSpawnInstance(spawnInst.getObjectId(), true).isSpawnActive())

{

AutoSpawn.getInstance().setSpawnActive(spawnInst, true);

}



for(AutoSpawnInstance spawnInst : _preacherSpawns.values())

if(!AutoSpawn.getInstance().getAutoSpawnInstance(spawnInst.getObjectId(), true).isSpawnActive())

{

AutoSpawn.getInstance().setSpawnActive(spawnInst, true);

}



if(!AutoChatHandler.getInstance().getAutoChatInstance(PREACHER_NPC_ID, false).isActive() && !AutoChatHandler.getInstance().getAutoChatInstance(ORATOR_NPC_ID, false).isActive())

{

AutoChatHandler.getInstance().setAutoChatActive(true);

}

}

else

{

AutoSpawn.getInstance().setSpawnActive(_blacksmithSpawn, false);



for(AutoSpawnInstance spawnInst : _oratorSpawns.values())

{

AutoSpawn.getInstance().setSpawnActive(spawnInst, false);

}



for(AutoSpawnInstance spawnInst : _preacherSpawns.values())

{

AutoSpawn.getInstance().setSpawnActive(spawnInst, false);

}



AutoChatHandler.getInstance().setAutoChatActive(false);

}



if(getSealOwner(SEAL_AVARICE) == getCabalHighestScore() && getSealOwner(SEAL_AVARICE) != CABAL_NULL)

{

if(!Config.ANNOUNCE_MAMMON_SPAWN)

{

_merchantSpawn.setBroadcast(false);

}



if(!AutoSpawn.getInstance().getAutoSpawnInstance(_merchantSpawn.getObjectId(), true).isSpawnActive())

{

AutoSpawn.getInstance().setSpawnActive(_merchantSpawn, true);

}



if(!AutoSpawn.getInstance().getAutoSpawnInstance(_spiritInSpawn.getObjectId(), true).isSpawnActive())

{

AutoSpawn.getInstance().setSpawnActive(_spiritInSpawn, true);

}



if(!AutoSpawn.getInstance().getAutoSpawnInstance(_spiritOutSpawn.getObjectId(), true).isSpawnActive())

{

AutoSpawn.getInstance().setSpawnActive(_spiritOutSpawn, true);

}



switch(getCabalHighestScore())

{

case CABAL_DAWN:

if(!AutoSpawn.getInstance().getAutoSpawnInstance(_lilithSpawn.getObjectId(), true).isSpawnActive())

{

AutoSpawn.getInstance().setSpawnActive(_lilithSpawn, true);

}



AutoSpawn.getInstance().setSpawnActive(_anakimSpawn, false);

if(!AutoSpawn.getInstance().getAutoSpawnInstance(_crestofdawnspawn.getObjectId(), true).isSpawnActive())

{

AutoSpawn.getInstance().setSpawnActive(_crestofdawnspawn, true);

}



AutoSpawn.getInstance().setSpawnActive(_crestofduskspawn, false);

break;



case CABAL_DUSK:

if(!AutoSpawn.getInstance().getAutoSpawnInstance(_anakimSpawn.getObjectId(), true).isSpawnActive())

{

AutoSpawn.getInstance().setSpawnActive(_anakimSpawn, true);

}



AutoSpawn.getInstance().setSpawnActive(_lilithSpawn, false);

if(!AutoSpawn.getInstance().getAutoSpawnInstance(_crestofduskspawn.getObjectId(), true).isSpawnActive())

{

AutoSpawn.getInstance().setSpawnActive(_crestofduskspawn, true);

}



AutoSpawn.getInstance().setSpawnActive(_crestofdawnspawn, false);

break;

}

}

else

{

AutoSpawn.getInstance().setSpawnActive(_merchantSpawn, false);

AutoSpawn.getInstance().setSpawnActive(_lilithSpawn, false);

AutoSpawn.getInstance().setSpawnActive(_anakimSpawn, false);

AutoSpawn.getInstance().setSpawnActive(_crestofdawnspawn, false);

AutoSpawn.getInstance().setSpawnActive(_crestofduskspawn, false);

AutoSpawn.getInstance().setSpawnActive(_spiritInSpawn, false);

AutoSpawn.getInstance().setSpawnActive(_spiritOutSpawn, false);

}

}

else

{

AutoSpawn.getInstance().setSpawnActive(_merchantSpawn, false);

AutoSpawn.getInstance().setSpawnActive(_blacksmithSpawn, false);

AutoSpawn.getInstance().setSpawnActive(_lilithSpawn, false);

AutoSpawn.getInstance().setSpawnActive(_anakimSpawn, false);

AutoSpawn.getInstance().setSpawnActive(_crestofdawnspawn, false);

AutoSpawn.getInstance().setSpawnActive(_crestofduskspawn, false);

AutoSpawn.getInstance().setSpawnActive(_spiritInSpawn, false);

AutoSpawn.getInstance().setSpawnActive(_spiritOutSpawn, false);



for(AutoSpawnInstance spawnInst : _oratorSpawns.values())

{

AutoSpawn.getInstance().setSpawnActive(spawnInst, false);

}



for(AutoSpawnInstance spawnInst : _preacherSpawns.values())

{

AutoSpawn.getInstance().setSpawnActive(spawnInst, false);

}



for(AutoSpawnInstance spawnInst : _marketeerSpawns.values())

{

AutoSpawn.getInstance().setSpawnActive(spawnInst, false);

}



AutoChatHandler.getInstance().setAutoChatActive(false);

}

}



/**

* Gets the single instance of SevenSigns.

*

* @return single instance of SevenSigns

*/

public static SevenSigns getInstance()

{

if(_instance == null)

{

_instance = new SevenSigns();

}



return _instance;

}



/**

* Calc contribution score.

*

* @param blueCount the blue count

* @param greenCount the green count

* @param redCount the red count

* @return the int

*/

public static int calcContributionScore(int blueCount, int greenCount, int redCount)

{

int contrib = blueCount * BLUE_CONTRIB_POINTS;

contrib += greenCount * GREEN_CONTRIB_POINTS;

contrib += redCount * RED_CONTRIB_POINTS;



return contrib;

}



/**

* Calc ancient adena reward.

*

* @param blueCount the blue count

* @param greenCount the green count

* @param redCount the red count

* @return the int

*/

public static int calcAncientAdenaReward(int blueCount, int greenCount, int redCount)

{

int reward = blueCount * SEAL_STONE_BLUE_VALUE;

reward += greenCount * SEAL_STONE_GREEN_VALUE;

reward += redCount * SEAL_STONE_RED_VALUE;



return reward;

}



/**

* Gets the cabal short name.

*

* @param cabal the cabal

* @return the cabal short name

*/

public static final String getCabalShortName(int cabal)

{

switch(cabal)

{

case CABAL_DAWN:

return "dawn";

case CABAL_DUSK:

return "dusk";

}



return "No Cabal";

}



/**

* Gets the cabal name.

*

* @param cabal the cabal

* @return the cabal name

*/

public static final String getCabalName(int cabal)

{

switch(cabal)

{

case CABAL_DAWN:

return "Lords of Dawn";

case CABAL_DUSK:

return "Revolutionaries of Dusk";

}



return "No Cabal";

}



/**

* Gets the seal name.

*

* @param seal the seal

* @param shortName the short name

* @return the seal name

*/

public static final String getSealName(int seal, boolean shortName)

{

String sealName = !shortName ? "Seal of " : "";



switch(seal)

{

case SEAL_AVARICE:

sealName += "Avarice";

break;

case SEAL_GNOSIS:

sealName += "Gnosis";

break;

case SEAL_STRIFE:

sealName += "Strife";

break;

}



return sealName;

}



/**

* Gets the current cycle.

*

* @return the current cycle

*/

public final int getCurrentCycle()

{

return _currentCycle;

}



/**

* Gets the current period.

*

* @return the current period

*/

public final int getCurrentPeriod()

{

return _activePeriod;

}



/**

* Gets the days to period change.

*

* @return the days to period change

*/

private final int getDaysToPeriodChange()

{

int numDays = _calendar.get(Calendar.DAY_OF_WEEK) - PERIOD_START_DAY;



if(numDays < 0)

return 0 - numDays;



return 7 - numDays;

}



/**

* Gets the milli to period change.

*

* @return the milli to period change

*/

public final long getMilliToPeriodChange()

{

long currTimeMillis = System.currentTimeMillis();

long changeTimeMillis = _calendar.getTimeInMillis();



return changeTimeMillis - currTimeMillis;

}



/**

* Sets the calendar for next period change.

*/

protected void setCalendarForNextPeriodChange()

{

// Calculate the number of days until the next period

// A period starts at 18:00 pm (local time), like on official servers.

switch(getCurrentPeriod())

{

case PERIOD_SEAL_VALIDATION:

case PERIOD_COMPETITION:

int daysToChange = getDaysToPeriodChange();



if(daysToChange == 7)

if(_calendar.get(Calendar.HOUR_OF_DAY) < PERIOD_START_HOUR)

{

daysToChange = 0;

}

else if(_calendar.get(Calendar.HOUR_OF_DAY) == PERIOD_START_HOUR && _calendar.get(Calendar.MINUTE) < PERIOD_START_MINS)

{

daysToChange = 0;

}



// Otherwise...

if(daysToChange > 0)

{

_calendar.add(Calendar.DATE, daysToChange);

}



_calendar.set(Calendar.HOUR_OF_DAY, PERIOD_START_HOUR);

_calendar.set(Calendar.MINUTE, PERIOD_START_MINS);

break;

case PERIOD_COMP_RECRUITING:

case PERIOD_COMP_RESULTS:

_calendar.add(Calendar.MILLISECOND, PERIOD_MINOR_LENGTH);

break;

}

}



/**

* Gets the current period name.

*

* @return the current period name

*/

public final String getCurrentPeriodName()

{

String periodName = null;



switch(_activePeriod)

{

case PERIOD_COMP_RECRUITING:

periodName = "Quest Event Initialization";

break;

case PERIOD_COMPETITION:

periodName = "Competition (Quest Event)";

break;

case PERIOD_COMP_RESULTS:

periodName = "Quest Event Results";

break;

case PERIOD_SEAL_VALIDATION:

periodName = "Seal Validation";

break;

}



return periodName;

}



/**

* Checks if is seal validation period.

*

* @return true, if is seal validation period

*/

public final boolean isSealValidationPeriod()

{

return _activePeriod == PERIOD_SEAL_VALIDATION;

}



/**

* Checks if is comp results period.

*

* @return true, if is comp results period

*/

public final boolean isCompResultsPeriod()

{

return _activePeriod == PERIOD_COMP_RESULTS;

}



/**

* Gets the current score.

*

* @param cabal the cabal

* @return the current score

*/

public final int getCurrentScore(int cabal)

{

double totalStoneScore = _dawnStoneScore + _duskStoneScore;



switch(cabal)

{

case CABAL_NULL:

return 0;

case CABAL_DAWN:

return Math.round((float) (_dawnStoneScore / ((float) totalStoneScore == 0 ? 1 : totalStoneScore)) * 500) + _dawnFestivalScore;

case CABAL_DUSK:

return Math.round((float) (_duskStoneScore / ((float) totalStoneScore == 0 ? 1 : totalStoneScore)) * 500) + _duskFestivalScore;

}



return 0;

}



/**

* Gets the current stone score.

*

* @param cabal the cabal

* @return the current stone score

*/

public final double getCurrentStoneScore(int cabal)

{

switch(cabal)

{

case CABAL_NULL:

return 0;

case CABAL_DAWN:

return _dawnStoneScore;

case CABAL_DUSK:

return _duskStoneScore;

}



return 0;

}



/**

* Gets the current festival score.

*

* @param cabal the cabal

* @return the current festival score

*/

public final int getCurrentFestivalScore(int cabal)

{

switch(cabal)

{

case CABAL_NULL:

return 0;

case CABAL_DAWN:

return _dawnFestivalScore;

case CABAL_DUSK:

return _duskFestivalScore;

}



return 0;

}



/**

* Gets the cabal highest score.

*

* @return the cabal highest score

*/

public final int getCabalHighestScore()

{

if(getCurrentScore(CABAL_DUSK) == getCurrentScore(CABAL_DAWN))

return CABAL_NULL;

else if(getCurrentScore(CABAL_DUSK) > getCurrentScore(CABAL_DAWN))

return CABAL_DUSK;

else

return CABAL_DAWN;

}



/**

* Gets the seal owner.

*

* @param seal the seal

* @return the seal owner

*/

public final int getSealOwner(int seal)

{

return _signsSealOwners.get(seal);

}



/**

* Gets the seal proportion.

*

* @param seal the seal

* @param cabal the cabal

* @return the seal proportion

*/

public final int getSealProportion(int seal, int cabal)

{

if(cabal == CABAL_NULL)

return 0;

else if(cabal == CABAL_DUSK)

return _signsDuskSealTotals.get(seal);

else

return _signsDawnSealTotals.get(seal);

}



/**

* Gets the total members.

*

* @param cabal the cabal

* @return the total members

*/

public final int getTotalMembers(int cabal)

{

int cabalMembers = 0;

String cabalName = getCabalShortName(cabal);



for(StatsSet sevenDat : _signsPlayerData.values())

if(sevenDat.getString("cabal").equals(cabalName))

{

cabalMembers++;

}



cabalName = null;



return cabalMembers;

}



/**

* Gets the player data.

*

* @param player the player

* @return the player data

*/

public final StatsSet getPlayerData(L2PcInstance player)

{

if(!hasRegisteredBefore(player))

return null;



return _signsPlayerData.get(player.getObjectId());

}



/**

* Gets the player stone contrib.

*

* @param player the player

* @return the player stone contrib

*/

public int getPlayerStoneContrib(L2PcInstance player)

{

if(!hasRegisteredBefore(player))

return 0;



int stoneCount = 0;



StatsSet currPlayer = getPlayerData(player);



stoneCount += currPlayer.getInteger("red_stones");

stoneCount += currPlayer.getInteger("green_stones");

stoneCount += currPlayer.getInteger("blue_stones");



currPlayer = null;



return stoneCount;

}



/**

* Gets the player contrib score.

*

* @param player the player

* @return the player contrib score

*/

public int getPlayerContribScore(L2PcInstance player)

{

if(!hasRegisteredBefore(player))

return 0;



StatsSet currPlayer = getPlayerData(player);



return currPlayer.getInteger("contribution_score");

}



/**

* Gets the player adena collect.

*

* @param player the player

* @return the player adena collect

*/

public int getPlayerAdenaCollect(L2PcInstance player)

{

if(!hasRegisteredBefore(player))

return 0;



return _signsPlayerData.get(player.getObjectId()).getInteger("ancient_adena_amount");

}



/**

* Gets the player seal.

*

* @param player the player

* @return the player seal

*/

public int getPlayerSeal(L2PcInstance player)

{

if(!hasRegisteredBefore(player))

return SEAL_NULL;



return getPlayerData(player).getInteger("seal");

}



/**

* Gets the player cabal.

*

* @param player the player

* @return the player cabal

*/

public int getPlayerCabal(L2PcInstance player)

{

if(!hasRegisteredBefore(player))

return CABAL_NULL;



String playerCabal = getPlayerData(player).getString("cabal");



if(playerCabal.equalsIgnoreCase("dawn"))

return CABAL_DAWN;

else if(playerCabal.equalsIgnoreCase("dusk"))

{

playerCabal = null;

return CABAL_DUSK;

}

else

return CABAL_NULL;

}



/**

* Restores all Seven Signs data and settings, usually called at server startup.

*

*/

protected void restoreSevenSignsData()

{

Connection con = null;



try

{

con = L2DatabaseFactory.getInstance().getConnection(false);

PreparedStatement statement = con.prepareStatement("SELECT char_obj_id, cabal, seal, red_stones, green_stones, blue_stones, " + "ancient_adena_amount, contribution_score FROM seven_signs");

ResultSet rset = statement.executeQuery();



while(rset.next())

{

int charObjId = rset.getInt("char_obj_id");



StatsSet sevenDat = new StatsSet();

sevenDat.set("char_obj_id", charObjId);

sevenDat.set("cabal", rset.getString("cabal"));

sevenDat.set("seal", rset.getInt("seal"));

sevenDat.set("red_stones", rset.getInt("red_stones"));

sevenDat.set("green_stones", rset.getInt("green_stones"));

sevenDat.set("blue_stones", rset.getInt("blue_stones"));

sevenDat.set("ancient_adena_amount", rset.getDouble("ancient_adena_amount"));

sevenDat.set("contribution_score", rset.getDouble("contribution_score"));



if(Config.DEBUG)

{

_log.info("SevenSigns: Loaded data from DB for char ID " + charObjId + " (" + sevenDat.getString("cabal") + ")");

}



_signsPlayerData.put(charObjId, sevenDat);

}



rset.close();

statement.close();



statement = con.prepareStatement("SELECT * FROM seven_signs_status WHERE id=0");

rset = statement.executeQuery();



while(rset.next())

{

_currentCycle = rset.getInt("current_cycle");

_activePeriod = rset.getInt("active_period");

_previousWinner = rset.getInt("previous_winner");



_dawnStoneScore = rset.getDouble("dawn_stone_score");

_dawnFestivalScore = rset.getInt("dawn_festival_score");

_duskStoneScore = rset.getDouble("dusk_stone_score");

_duskFestivalScore = rset.getInt("dusk_festival_score");



_signsSealOwners.put(SEAL_AVARICE, rset.getInt("avarice_owner"));

_signsSealOwners.put(SEAL_GNOSIS, rset.getInt("gnosis_owner"));

_signsSealOwners.put(SEAL_STRIFE, rset.getInt("strife_owner"));



_signsDawnSealTotals.put(SEAL_AVARICE, rset.getInt("avarice_dawn_score"));

_signsDawnSealTotals.put(SEAL_GNOSIS, rset.getInt("gnosis_dawn_score"));

_signsDawnSealTotals.put(SEAL_STRIFE, rset.getInt("strife_dawn_score"));

_signsDuskSealTotals.put(SEAL_AVARICE, rset.getInt("avarice_dusk_score"));

_signsDuskSealTotals.put(SEAL_GNOSIS, rset.getInt("gnosis_dusk_score"));

_signsDuskSealTotals.put(SEAL_STRIFE, rset.getInt("strife_dusk_score"));

}



rset.close();

statement.close();



statement = con.prepareStatement("UPDATE seven_signs_status SET date=? WHERE id=0");

statement.setInt(1, Calendar.getInstance().get(Calendar.DAY_OF_WEEK));

statement.execute();



statement.close();





}

catch(SQLException e)

{

if(Config.ENABLE_ALL_EXCEPTIONS)

e.printStackTrace();



_log.severe("SevenSigns: Unable to load Seven Signs data from database: " + e);

}

finally

{

CloseUtil.close(con);

con = null;

}



// Festival data is loaded now after the Seven Signs engine data.

}



/**

* Saves all Seven Signs data, both to the database and properties file (if updateSettings = True). Often called to

* preserve data integrity and synchronization with DB, in case of errors. <BR>

* If player != null, just that player's data is updated in the database, otherwise all player's data is

* sequentially updated.

*

* @param player the player

* @param updateSettings the update settings

*/

public void saveSevenSignsData(L2PcInstance player, boolean updateSettings)

{

Connection con = null;



if(Config.DEBUG)

{

_log.info("SevenSigns: Saving data to disk.");

}



try

{

con = L2DatabaseFactory.getInstance().getConnection(false);

PreparedStatement statement = null;



for(StatsSet sevenDat : _signsPlayerData.values())

{

if(player != null)

if(sevenDat.getInteger("char_obj_id") != player.getObjectId())

{

continue;

}



statement = con.prepareStatement("UPDATE seven_signs SET cabal=?, seal=?, red_stones=?, " + "green_stones=?, blue_stones=?, " + "ancient_adena_amount=?, contribution_score=? " + "WHERE char_obj_id=?");

statement.setString(1, sevenDat.getString("cabal"));

statement.setInt(2, sevenDat.getInteger("seal"));

statement.setInt(3, sevenDat.getInteger("red_stones"));

statement.setInt(4, sevenDat.getInteger("green_stones"));

statement.setInt(5, sevenDat.getInteger("blue_stones"));

statement.setDouble(6, sevenDat.getDouble("ancient_adena_amount"));

statement.setDouble(7, sevenDat.getDouble("contribution_score"));

statement.setInt(8, sevenDat.getInteger("char_obj_id"));

statement.execute();



statement.close();



if(Config.DEBUG)

{

_log.info("SevenSigns: Updated data in database for char ID " + sevenDat.getInteger("char_obj_id") + " (" + sevenDat.getString("cabal") + ")");

}

}



if(updateSettings)

{

String sqlQuery = "UPDATE seven_signs_status SET current_cycle=?, active_period=?, previous_winner=?, " + "dawn_stone_score=?, dawn_festival_score=?, dusk_stone_score=?, dusk_festival_score=?, " + "avarice_owner=?, gnosis_owner=?, strife_owner=?, avarice_dawn_score=?, gnosis_dawn_score=?, " + "strife_dawn_score=?, avarice_dusk_score=?, gnosis_dusk_score=?, strife_dusk_score=?, " + "festival_cycle=?, ";



for(int i = 0; i < SevenSignsFestival.FESTIVAL_COUNT; i++)

{

sqlQuery += "accumulated_bonus" + String.valueOf(i) + "=?, ";

}



sqlQuery += "date=? WHERE id=0";



statement = con.prepareStatement(sqlQuery);

statement.setInt(1, _currentCycle);

statement.setInt(2, _activePeriod);

statement.setInt(3, _previousWinner);

statement.setDouble(4, _dawnStoneScore);

statement.setInt(5, _dawnFestivalScore);

statement.setDouble(6, _duskStoneScore);

statement.setInt(7, _duskFestivalScore);

statement.setInt(8, _signsSealOwners.get(SEAL_AVARICE));

statement.setInt(9, _signsSealOwners.get(SEAL_GNOSIS));

statement.setInt(10, _signsSealOwners.get(SEAL_STRIFE));

statement.setInt(11, _signsDawnSealTotals.get(SEAL_AVARICE));

statement.setInt(12, _signsDawnSealTotals.get(SEAL_GNOSIS));

statement.setInt(13, _signsDawnSealTotals.get(SEAL_STRIFE));

statement.setInt(14, _signsDuskSealTotals.get(SEAL_AVARICE));

statement.setInt(15, _signsDuskSealTotals.get(SEAL_GNOSIS));

statement.setInt(16, _signsDuskSealTotals.get(SEAL_STRIFE));

statement.setInt(17, SevenSignsFestival.getInstance().getCurrentFestivalCycle());



for(int i = 0; i < SevenSignsFestival.FESTIVAL_COUNT; i++)

{

statement.setInt(18 + i, SevenSignsFestival.getInstance().getAccumulatedBonus(i));

}



statement.setInt(18 + SevenSignsFestival.FESTIVAL_COUNT, Calendar.getInstance().get(Calendar.DAY_OF_WEEK));

statement.execute();



statement.close();



if(Config.DEBUG)

{

_log.info("SevenSigns: Updated data in database.");

}



sqlQuery = null;



}

}

catch(SQLException e)

{

if(Config.ENABLE_ALL_EXCEPTIONS)

e.printStackTrace();



_log.severe("SevenSigns: Unable to save data to database: " + e);

}

finally

{

CloseUtil.close(con);

con = null;

}

}



/**

* Used to reset the cabal details of all players, and update the database.<BR>

* Primarily used when beginning a new cycle, and should otherwise never be called.

*/

protected void resetPlayerData()

{

if(Config.DEBUG)

{

_log.info("SevenSigns: Resetting player data for new event period.");

}



// Reset each player's contribution data as well as seal and cabal.

for(StatsSet sevenDat : _signsPlayerData.values())

{

int charObjId = sevenDat.getInteger("char_obj_id");



// Reset the player's cabal and seal information

sevenDat.set("cabal", "");

sevenDat.set("seal", SEAL_NULL);

sevenDat.set("contribution_score", 0);



_signsPlayerData.put(charObjId, sevenDat);

}

}



/**

* Tests whether the specified player has joined a cabal in the past.

*

* @param player the player

* @return boolean hasRegistered

*/

private boolean hasRegisteredBefore(L2PcInstance player)

{

return _signsPlayerData.containsKey(player.getObjectId());

}



/**

* Used to specify cabal-related details for the specified player. This method checks to see if the player has

* registered before and will update the database if necessary. <BR>

* Returns the cabal ID the player has joined.

*

* @param player the player

* @param chosenCabal the chosen cabal

* @param chosenSeal the chosen seal

* @return int cabal

*/

public int setPlayerInfo(L2PcInstance player, int chosenCabal, int chosenSeal)

{

int charObjId = player.getObjectId();

Connection con = null;

PreparedStatement statement = null;

StatsSet currPlayerData = getPlayerData(player);



if(currPlayerData != null)

{

// If the seal validation period has passed,

// cabal information was removed and so "re-register" player

currPlayerData.set("cabal", getCabalShortName(chosenCabal));

currPlayerData.set("seal", chosenSeal);



_signsPlayerData.put(charObjId, currPlayerData);

}

else

{

currPlayerData = new StatsSet();

currPlayerData.set("char_obj_id", charObjId);

currPlayerData.set("cabal", getCabalShortName(chosenCabal));

currPlayerData.set("seal", chosenSeal);

currPlayerData.set("red_stones", 0);

currPlayerData.set("green_stones", 0);

currPlayerData.set("blue_stones", 0);

currPlayerData.set("ancient_adena_amount", 0);

currPlayerData.set("contribution_score", 0);



_signsPlayerData.put(charObjId, currPlayerData);



// Update data in database, as we have a new player signing up.

try

{

con = L2DatabaseFactory.getInstance().getConnection(false);

statement = con.prepareStatement("INSERT INTO seven_signs (char_obj_id, cabal, seal) VALUES (?,?,?)");

statement.setInt(1, charObjId);

statement.setString(2, getCabalShortName(chosenCabal));

statement.setInt(3, chosenSeal);

statement.execute();



statement.close();





if(Config.DEBUG)

{

_log.info("SevenSigns: Inserted data in DB for char ID " + currPlayerData.getInteger("char_obj_id") + " (" + currPlayerData.getString("cabal") + ")");

}

}

catch(SQLException e)

{

if(Config.ENABLE_ALL_EXCEPTIONS)

e.printStackTrace();



_log.severe("SevenSigns: Failed to save data: " + e);

}

finally

{

CloseUtil.close(con);

con = null;

}

}



// Increasing Seal total score for the player chosen Seal.

if(currPlayerData.getString("cabal") == "dawn")

{

_signsDawnSealTotals.put(chosenSeal, _signsDawnSealTotals.get(chosenSeal) + 1);

}

else

{

_signsDuskSealTotals.put(chosenSeal, _signsDuskSealTotals.get(chosenSeal) + 1);

}



currPlayerData = null;



saveSevenSignsData(player, true);



if(Config.DEBUG)

{

_log.info("SevenSigns: " + player.getName() + " has joined the " + getCabalName(chosenCabal) + " for the " + getSealName(chosenSeal, false) + "!");

}



return chosenCabal;

}



/**

* Returns the amount of ancient adena the specified player can claim, if any.<BR>

* If removeReward = True, all the ancient adena owed to them is removed, then DB is updated.

*

* @param player the player

* @param removeReward the remove reward

* @return int rewardAmount

*/

public int getAncientAdenaReward(L2PcInstance player, boolean removeReward)

{

StatsSet currPlayer = getPlayerData(player);

int rewardAmount = currPlayer.getInteger("ancient_adena_amount");



currPlayer.set("red_stones", 0);

currPlayer.set("green_stones", 0);

currPlayer.set("blue_stones", 0);

currPlayer.set("ancient_adena_amount", 0);



if(removeReward)

{

_signsPlayerData.put(player.getObjectId(), currPlayer);

saveSevenSignsData(player, true);

}



currPlayer = null;



return rewardAmount;

}



/**

* Used to add the specified player's seal stone contribution points to the current total for their cabal. Returns

* the point score the contribution was worth. Each stone count <B>must be</B> broken down and specified by the

* stone's color.

*

* @param player the player

* @param blueCount the blue count

* @param greenCount the green count

* @param redCount the red count

* @return int contribScore

*/

public int addPlayerStoneContrib(L2PcInstance player, int blueCount, int greenCount, int redCount)

{

StatsSet currPlayer = getPlayerData(player);



int contribScore = calcContributionScore(blueCount, greenCount, redCount);

int totalAncientAdena = currPlayer.getInteger("ancient_adena_amount") + calcAncientAdenaReward(blueCount, greenCount, redCount);

int totalContribScore = currPlayer.getInteger("contribution_score") + contribScore;



if(totalContribScore > Config.ALT_MAXIMUM_PLAYER_CONTRIB)

return -1;



currPlayer.set("red_stones", currPlayer.getInteger("red_stones") + redCount);

currPlayer.set("green_stones", currPlayer.getInteger("green_stones") + greenCount);

currPlayer.set("blue_stones", currPlayer.getInteger("blue_stones") + blueCount);

currPlayer.set("ancient_adena_amount", totalAncientAdena);

currPlayer.set("contribution_score", totalContribScore);

_signsPlayerData.put(player.getObjectId(), currPlayer);



currPlayer = null;



switch(getPlayerCabal(player))

{

case CABAL_DAWN:

_dawnStoneScore += contribScore;

break;

case CABAL_DUSK:

_duskStoneScore += contribScore;

break;

}



saveSevenSignsData(player, true);



if(Config.DEBUG)

{

_log.info("SevenSigns: " + player.getName() + " contributed " + contribScore + " seal stone points to their cabal.");

}



return contribScore;

}



/**

* Adds the specified number of festival points to the specified cabal. Remember, the same number of points are

* <B>deducted from the rival cabal</B> to maintain proportionality.

*

* @param cabal the cabal

* @param amount the amount

*/

public void addFestivalScore(int cabal, int amount)

{

if(cabal == CABAL_DUSK)

{

_duskFestivalScore += amount;



// To prevent negative scores!

if(_dawnFestivalScore >= amount)

{

_dawnFestivalScore -= amount;

}

}

else

{

_dawnFestivalScore += amount;



if(_duskFestivalScore >= amount)

{

_duskFestivalScore -= amount;

}

}

}



/**

* Send info on the current Seven Signs period to the specified player.

*

* @param player the player

*/

public void sendCurrentPeriodMsg(L2PcInstance player)

{

SystemMessage sm = null;



switch(getCurrentPeriod())

{

case PERIOD_COMP_RECRUITING:

sm = new SystemMessage(SystemMessageId.PREPARATIONS_PERIOD_BEGUN);

break;

case PERIOD_COMPETITION:

sm = new SystemMessage(SystemMessageId.COMPETITION_PERIOD_BEGUN);

break;

case PERIOD_COMP_RESULTS:

sm = new SystemMessage(SystemMessageId.RESULTS_PERIOD_BEGUN);

break;

case PERIOD_SEAL_VALIDATION:

sm = new SystemMessage(SystemMessageId.VALIDATION_PERIOD_BEGUN);

break;

}



player.sendPacket(sm);

sm = null;

}



/**

* Sends the built-in system message specified by sysMsgId to all online players.

*

* @param sysMsgId the sys msg id

*/

public void sendMessageToAll(SystemMessageId sysMsgId)

{

SystemMessage sm = new SystemMessage(sysMsgId);



for(L2PcInstance player : L2World.getInstance().getAllPlayers())

{

player.sendPacket(sm);

}

sm = null;

}



/**

* Used to initialize the seals for each cabal. (Used at startup or at beginning of a new cycle). This method should

* be called after <B>resetSeals()</B> and <B>calcNewSealOwners()</B> on a new cycle.

*/

protected void initializeSeals()

{

for(Integer currSeal : _signsSealOwners.keySet())

{

int sealOwner = _signsSealOwners.get(currSeal);



if(sealOwner != CABAL_NULL)

if(isSealValidationPeriod())

{

_log.info("SevenSigns: The " + getCabalName(sealOwner) + " have won the " + getSealName(currSeal, false) + ".");

}

else

{

_log.info("SevenSigns: The " + getSealName(currSeal, false) + " is currently owned by " + getCabalName(sealOwner) + ".");

}

else

{

_log.info("SevenSigns: The " + getSealName(currSeal, false) + " remains unclaimed.");

}

}

}



/**

* Only really used at the beginning of a new cycle, this method resets all seal-related data.

*/

protected void resetSeals()

{

_signsDawnSealTotals.put(SEAL_AVARICE, 0);

_signsDawnSealTotals.put(SEAL_GNOSIS, 0);

_signsDawnSealTotals.put(SEAL_STRIFE, 0);

_signsDuskSealTotals.put(SEAL_AVARICE, 0);

_signsDuskSealTotals.put(SEAL_GNOSIS, 0);

_signsDuskSealTotals.put(SEAL_STRIFE, 0);

}



/**

* Calculates the ownership of the three Seals of the Seven Signs, based on various criterion. <BR>

* <BR>

* Should only ever called at the beginning of a new cycle.

*/

protected void calcNewSealOwners()

{

if(Config.DEBUG)

{

_log.info("SevenSigns: (Avarice) Dawn = " + _signsDawnSealTotals.get(SEAL_AVARICE) + ", Dusk = " + _signsDuskSealTotals.get(SEAL_AVARICE));

_log.info("SevenSigns: (Gnosis) Dawn = " + _signsDawnSealTotals.get(SEAL_GNOSIS) + ", Dusk = " + _signsDuskSealTotals.get(SEAL_GNOSIS));

_log.info("SevenSigns: (Strife) Dawn = " + _signsDawnSealTotals.get(SEAL_STRIFE) + ", Dusk = " + _signsDuskSealTotals.get(SEAL_STRIFE));

}



for(Integer currSeal : _signsDawnSealTotals.keySet())

{

int prevSealOwner = _signsSealOwners.get(currSeal);

int newSealOwner = CABAL_NULL;

int dawnProportion = getSealProportion(currSeal, CABAL_DAWN);

int totalDawnMembers = getTotalMembers(CABAL_DAWN) == 0 ? 1 : getTotalMembers(CABAL_DAWN);

int dawnPercent = Math.round((float) dawnProportion / (float) totalDawnMembers * 100);

int duskProportion = getSealProportion(currSeal, CABAL_DUSK);

int totalDuskMembers = getTotalMembers(CABAL_DUSK) == 0 ? 1 : getTotalMembers(CABAL_DUSK);

int duskPercent = Math.round((float) duskProportion / (float) totalDuskMembers * 100);



/*

* - If a Seal was already closed or owned by the opponent and the new winner wants

*   to assume ownership of the Seal, 35% or more of the members of the Cabal must

*   have chosen the Seal. If they chose less than 35%, they cannot own the Seal.

*

* - If the Seal was owned by the winner in the previous Seven Signs, they can retain

*   that seal if 10% or more members have chosen it. If they want to possess a new Seal,

*   at least 35% of the members of the Cabal must have chosen the new Seal.

*/

switch(prevSealOwner)

{

case CABAL_NULL:

switch(getCabalHighestScore())

{

case CABAL_NULL:

newSealOwner = CABAL_NULL;

break;

case CABAL_DAWN:

if(dawnPercent >= 35)

{

newSealOwner = CABAL_DAWN;

}

else

{

newSealOwner = CABAL_NULL;

}

break;

case CABAL_DUSK:

if(duskPercent >= 35)

{

newSealOwner = CABAL_DUSK;

}

else

{

newSealOwner = CABAL_NULL;

}

break;

}

break;

case CABAL_DAWN:

switch(getCabalHighestScore())

{

case CABAL_NULL:

if(dawnPercent >= 10)

{

newSealOwner = CABAL_DAWN;

}

else

{

newSealOwner = CABAL_NULL;

}

break;

case CABAL_DAWN:

if(dawnPercent >= 10)

{

newSealOwner = CABAL_DAWN;

}

else

{

newSealOwner = CABAL_NULL;

}

break;

case CABAL_DUSK:

if(duskPercent >= 35)

{

newSealOwner = CABAL_DUSK;

}

else if(dawnPercent >= 10)

{

newSealOwner = CABAL_DAWN;

}

else

{

newSealOwner = CABAL_NULL;

}

break;

}

break;

case CABAL_DUSK:

switch(getCabalHighestScore())

{

case CABAL_NULL:

if(duskPercent >= 10)

{

newSealOwner = CABAL_DUSK;

}

else

{

newSealOwner = CABAL_NULL;

}

break;

case CABAL_DAWN:

if(dawnPercent >= 35)

{

newSealOwner = CABAL_DAWN;

}

else if(duskPercent >= 10)

{

newSealOwner = CABAL_DUSK;

}

else

{

newSealOwner = CABAL_NULL;

}

break;

case CABAL_DUSK:

if(duskPercent >= 10)

{

newSealOwner = CABAL_DUSK;

}

else

{

newSealOwner = CABAL_NULL;

}

break;

}

break;

}



_signsSealOwners.put(currSeal, newSealOwner);



// Alert all online players to new seal status.

switch(currSeal)

{

case SEAL_AVARICE:

if(newSealOwner == CABAL_DAWN)

{

sendMessageToAll(SystemMessageId.DAWN_OBTAINED_AVARICE);

}

else if(newSealOwner == CABAL_DUSK)

{

sendMessageToAll(SystemMessageId.DUSK_OBTAINED_AVARICE);

}

break;

case SEAL_GNOSIS:

if(newSealOwner == CABAL_DAWN)

{

sendMessageToAll(SystemMessageId.DAWN_OBTAINED_GNOSIS);

}

else if(newSealOwner == CABAL_DUSK)

{

sendMessageToAll(SystemMessageId.DUSK_OBTAINED_GNOSIS);

}

break;

case SEAL_STRIFE:

if(newSealOwner == CABAL_DAWN)

{

sendMessageToAll(SystemMessageId.DAWN_OBTAINED_STRIFE);

}

else if(newSealOwner == CABAL_DUSK)

{

sendMessageToAll(SystemMessageId.DUSK_OBTAINED_STRIFE);

}



CastleManager.getInstance().validateTaxes(newSealOwner);

break;

}

}

}



/**

* This method is called to remove all players from catacombs and necropolises, who belong to the losing cabal. <BR>

* <BR>

* Should only ever called at the beginning of Seal Validation.

*

* @param compWinner the comp winner

*/

protected void teleLosingCabalFromDungeons(String compWinner)

{

for(L2PcInstance onlinePlayer : L2World.getInstance().getAllPlayers())

{

StatsSet currPlayer = getPlayerData(onlinePlayer);



if(isSealValidationPeriod() || isCompResultsPeriod())

{

if(!onlinePlayer.isGM() && onlinePlayer.isIn7sDungeon() && !currPlayer.getString("cabal").equals(compWinner))

{

onlinePlayer.teleToLocation(MapRegionTable.TeleportWhereType.Town);

onlinePlayer.setIsIn7sDungeon(false);

onlinePlayer.sendMessage("You have been teleported to the nearest town due to the beginning of the Seal Validation period.");

}

}

else

{

if(!onlinePlayer.isGM() && onlinePlayer.isIn7sDungeon() && !currPlayer.getString("cabal").equals(""))

{

onlinePlayer.teleToLocation(MapRegionTable.TeleportWhereType.Town);

onlinePlayer.setIsIn7sDungeon(false);

onlinePlayer.sendMessage("You have been teleported to the nearest town because you have not signed for any cabal.");

}

}

currPlayer = null;

}

}



/**

* The primary controller of period change of the Seven Signs system. This runs all related tasks depending on the

* period that is about to begin.

* 

* @author Tempy

*/

protected class SevenSignsPeriodChange implements Runnable

{



/* (non-Javadoc)

* @see java.lang.Runnable#run()

*/

@Override

public void run()

{

/*

* Remember the period check here refers to the period just ENDED!

*/

final int periodEnded = getCurrentPeriod();

_activePeriod++;



switch(periodEnded)

{

case PERIOD_COMP_RECRUITING: // Initialization



// Start the Festival of Darkness cycle.

SevenSignsFestival.getInstance().startFestivalManager();



// Send message that Competition has begun.

sendMessageToAll(SystemMessageId.QUEST_EVENT_PERIOD_BEGUN);

break;

case PERIOD_COMPETITION: // Results Calculation



// Send message that Competition has ended.

sendMessageToAll(SystemMessageId.QUEST_EVENT_PERIOD_ENDED);



int compWinner = getCabalHighestScore();



// Schedule a stop of the festival engine.

SevenSignsFestival.getInstance().getFestivalManagerSchedule().cancel(false);



calcNewSealOwners();



switch(compWinner)

{

case CABAL_DAWN:

sendMessageToAll(SystemMessageId.DAWN_WON);

break;

case CABAL_DUSK:

sendMessageToAll(SystemMessageId.DUSK_WON);

break;

}



_previousWinner = compWinner;

break;

case PERIOD_COMP_RESULTS: // Seal Validation



// Perform initial Seal Validation set up.

initializeSeals();



// Send message that Seal Validation has begun.

sendMessageToAll(SystemMessageId.SEAL_VALIDATION_PERIOD_BEGUN);



_log.info("SevenSigns: The " + getCabalName(_previousWinner) + " have won the competition with " + getCurrentScore(_previousWinner) + " points!");

break;

case PERIOD_SEAL_VALIDATION: // Reset for New Cycle



SevenSignsFestival.getInstance().rewardHighRanked();



// Ensure a cycle restart when this period ends.

_activePeriod = PERIOD_COMP_RECRUITING;



// Send message that Seal Validation has ended.

sendMessageToAll(SystemMessageId.SEAL_VALIDATION_PERIOD_ENDED);



// Reset all data

resetPlayerData();

resetSeals();



// Reset all Festival-related data and remove any unused blood offerings.

// NOTE: A full update of Festival data in the database is also performed.

SevenSignsFestival.getInstance().resetFestivalData(false);



_dawnStoneScore = 0;

_duskStoneScore = 0;



_dawnFestivalScore = 0;

_duskFestivalScore = 0;



_currentCycle++;



break;

}



// Make sure all Seven Signs data is saved for future use.

saveSevenSignsData(null, true);



teleLosingCabalFromDungeons(getCabalShortName(getCabalHighestScore()));



SignsSky ss = new SignsSky();



for(L2PcInstance player : L2World.getInstance().getAllPlayers())

{

player.sendPacket(ss);

}



ss = null;



spawnSevenSignsNPC();



_log.info("SevenSigns: The " + getCurrentPeriodName() + " period has begun!");



setCalendarForNextPeriodChange();



SevenSignsPeriodChange sspc = new SevenSignsPeriodChange();

ThreadPoolManager.getInstance().scheduleGeneral(sspc, getMilliToPeriodChange());

sspc = null;

}

}

}

Edited March 26, 2016 by EloBoost

EloBoost · March 26, 2016

SevenSignsPriestInstance



/*

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2, or (at your option)

 * any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA

 * 02111-1307, USA.

 *

 * http://www.gnu.org/copyleft/gpl.html

 */

package com.l2jfrozen.gameserver.model.actor.instance;



import java.util.StringTokenizer;



import javolution.text.TextBuilder;



import com.l2jfrozen.Config;

import com.l2jfrozen.gameserver.cache.HtmCache;

import com.l2jfrozen.gameserver.datatables.sql.ClanTable;

import com.l2jfrozen.gameserver.model.L2Clan;

import com.l2jfrozen.gameserver.model.entity.sevensigns.SevenSigns;

import com.l2jfrozen.gameserver.network.SystemMessageId;

import com.l2jfrozen.gameserver.network.serverpackets.InventoryUpdate;

import com.l2jfrozen.gameserver.network.serverpackets.NpcHtmlMessage;

import com.l2jfrozen.gameserver.network.serverpackets.StatusUpdate;

import com.l2jfrozen.gameserver.network.serverpackets.SystemMessage;

import com.l2jfrozen.gameserver.templates.L2NpcTemplate;



/**

 * Dawn/Dusk Seven Signs Priest Instance

 * 

 * @author Tempy

 */

public class L2SignsPriestInstance extends L2FolkInstance

{

//private static Logger _log = Logger.getLogger(L2SignsPriestInstance.class.getName());



public L2SignsPriestInstance(int objectId, L2NpcTemplate template)

{

super(objectId, template);

}



@Override

public void onBypassFeedback(L2PcInstance player, String command)

{

if(command.startsWith("SevenSignsDesc"))

{

int val = Integer.parseInt(command.substring(15));

showChatWindow(player, val, null, true);

}

else if(command.startsWith("SevenSigns"))

{

SystemMessage sm;

InventoryUpdate iu;

StatusUpdate su;

String path;

int cabal = SevenSigns.CABAL_NULL;

int stoneType = 0;

L2ItemInstance ancientAdena = player.getInventory().getItemByItemId(SevenSigns.ANCIENT_ADENA_ID);

int ancientAdenaAmount = ancientAdena == null ? 0 : ancientAdena.getCount();

int val = Integer.parseInt(command.substring(11, 12).trim());



if(command.length() > 12)

{

val = Integer.parseInt(command.substring(11, 13).trim());

}



if(command.length() > 13)

{

try

{

cabal = Integer.parseInt(command.substring(14, 15).trim());

}

catch(Exception e)

{

if(Config.ENABLE_ALL_EXCEPTIONS)

e.printStackTrace();



try

{

cabal = Integer.parseInt(command.substring(13, 14).trim());

}

catch(Exception e2)

{

if(Config.ENABLE_ALL_EXCEPTIONS)

e2.printStackTrace();



try

{

StringTokenizer st = new StringTokenizer(command.trim());

st.nextToken();

cabal = Integer.parseInt(st.nextToken());

st = null;

}

catch(Exception e3)

{

if(Config.ENABLE_ALL_EXCEPTIONS)

e3.printStackTrace();



_log.warning("Failed to retrieve cabal from bypass command. NpcId: " + getNpcId() + "; Command: " + command);

}

}

}

}



switch(val)

{

case 2: // Purchase Record of the Seven Signs

if(!player.getInventory().validateCapacity(1))

{

player.sendPacket(new SystemMessage(SystemMessageId.INVENTORY_VOLUME));

break;

}



//L2ItemInstance adenaItem = player.getInventory().getAdenaInstance(); 

if(!player.reduceAdena("SevenSigns", SevenSigns.RECORD_SEVEN_SIGNS_COST, this, false))

{

String filename = "data/html/seven_signs/noadena.htm";                  

NpcHtmlMessage html = new NpcHtmlMessage(getObjectId());

html.setFile(filename);

html.replace("%objectId%", String.valueOf(getObjectId()));

player.sendPacket(html);

break;

}



player.addItem("SevenSigns", SevenSigns.RECORD_SEVEN_SIGNS_ID, 1, player, true);



// Update current load as well

su = new StatusUpdate(player.getObjectId());

su.addAttribute(StatusUpdate.CUR_LOAD, player.getCurrentLoad());

sendPacket(su);



//adenaItem = null;

break;

case 3: // Join Cabal Intro 1

case 8: // Festival of Darkness Intro - SevenSigns x [0]1

case 10: // Teleport Locations List

showChatWindow(player, val, SevenSigns.getCabalShortName(cabal), false);

break;

case 4: // Join a Cabal - SevenSigns 4 [0]1 x

int newSeal = Integer.parseInt(command.substring(15));

int oldCabal = SevenSigns.getInstance().getPlayerCabal(player);



if(oldCabal != SevenSigns.CABAL_NULL)

{

player.sendMessage("You are already a member of the " + SevenSigns.getCabalName(cabal) + ".");

return;

}



if(player.getClassId().level() == 0)

{

player.sendMessage("You must have already completed your first class transfer.");

break;

}

else if(player.getClassId().level() >= 2)

{

if(Config.ALT_GAME_REQUIRE_CASTLE_DAWN)

{

if(getPlayerAllyHasCastle(player))

{

if(cabal == SevenSigns.CABAL_DUSK)

{

player.sendMessage("You must not be a member of a castle-owning clan to join the Revolutionaries of Dusk.");

return;

}

}

//TODO

if(!getPlayerAllyHasCastle(player))

{

if(cabal == SevenSigns.CABAL_DAWN)

{

player.sendMessage("You must be a member of a castle-owning clan to join the Lords Of Dawn.");

return;

}

}



else

{

/*

* If the player is trying to join the Lords of Dawn, check if they are

* carrying a Lord's certificate.

*

* If not then try to take the required amount of adena instead.

*/

if(cabal == SevenSigns.CABAL_DAWN)

{

boolean allowJoinDawn = false;



if(player.destroyItemByItemId("SevenSigns", SevenSigns.CERTIFICATE_OF_APPROVAL_ID, 1, this, false))

{

sm = new SystemMessage(SystemMessageId.DISSAPEARED_ITEM);

sm.addNumber(1);

sm.addItemName(SevenSigns.CERTIFICATE_OF_APPROVAL_ID);

player.sendPacket(sm);

allowJoinDawn = true;

}

else if(player.reduceAdena("SevenSigns", SevenSigns.ADENA_JOIN_DAWN_COST, this, false))

{

sm = new SystemMessage(SystemMessageId.DISSAPEARED_ADENA);

sm.addNumber(SevenSigns.ADENA_JOIN_DAWN_COST);

player.sendPacket(sm);

allowJoinDawn = true;

}



if(!allowJoinDawn)

{

player.sendMessage("You must be a member of a castle-owning clan, have a Certificate of Lord's Approval, or pay 50000 adena to join the Lords of Dawn.");

return;

}

}

}

}

}



SevenSigns.getInstance().setPlayerInfo(player, cabal, newSeal);



// Joined Dawn

if(cabal == SevenSigns.CABAL_DAWN)

{

player.sendPacket(new SystemMessage(SystemMessageId.SEVENSIGNS_PARTECIPATION_DAWN));

}

else

{

player.sendPacket(new SystemMessage(SystemMessageId.SEVENSIGNS_PARTECIPATION_DUSK)); // Joined Dusk

}



// Show a confirmation message to the user, indicating which seal they chose.

switch(newSeal)

{

case SevenSigns.SEAL_AVARICE:

player.sendPacket(new SystemMessage(SystemMessageId.FIGHT_FOR_AVARICE));

break;

case SevenSigns.SEAL_GNOSIS:

player.sendPacket(new SystemMessage(SystemMessageId.FIGHT_FOR_GNOSIS));

break;

case SevenSigns.SEAL_STRIFE:

player.sendPacket(new SystemMessage(SystemMessageId.FIGHT_FOR_STRIFE));

break;

}



showChatWindow(player, 4, SevenSigns.getCabalShortName(cabal), false);

break;

case 6: // Contribute Seal Stones - SevenSigns 6 x

stoneType = Integer.parseInt(command.substring(13));

L2ItemInstance redStones = player.getInventory().getItemByItemId(SevenSigns.SEAL_STONE_RED_ID);

int redStoneCount = redStones == null ? 0 : redStones.getCount();

L2ItemInstance greenStones = player.getInventory().getItemByItemId(SevenSigns.SEAL_STONE_GREEN_ID);

int greenStoneCount = greenStones == null ? 0 : greenStones.getCount();

L2ItemInstance blueStones = player.getInventory().getItemByItemId(SevenSigns.SEAL_STONE_BLUE_ID);

int blueStoneCount = blueStones == null ? 0 : blueStones.getCount();

int contribScore = SevenSigns.getInstance().getPlayerContribScore(player);

boolean stonesFound = false;



if(contribScore == Config.ALT_MAXIMUM_PLAYER_CONTRIB)

{

player.sendPacket(new SystemMessage(SystemMessageId.CONTRIB_SCORE_EXCEEDED));

break;

}



int redContribCount = 0;

int greenContribCount = 0;

int blueContribCount = 0;



switch(stoneType)

{

case 1:

blueContribCount = (Config.ALT_MAXIMUM_PLAYER_CONTRIB - contribScore) / SevenSigns.BLUE_CONTRIB_POINTS;

if(blueContribCount > blueStoneCount)

{

blueContribCount = blueStoneCount;

}

break;

case 2:

greenContribCount = (Config.ALT_MAXIMUM_PLAYER_CONTRIB - contribScore) / SevenSigns.GREEN_CONTRIB_POINTS;

if(greenContribCount > greenStoneCount)

{

greenContribCount = greenStoneCount;

}

break;

case 3:

redContribCount = (Config.ALT_MAXIMUM_PLAYER_CONTRIB - contribScore) / SevenSigns.RED_CONTRIB_POINTS;

if(redContribCount > redStoneCount)

{

redContribCount = redStoneCount;

}

break;

case 4:

int tempContribScore = contribScore;

redContribCount = (Config.ALT_MAXIMUM_PLAYER_CONTRIB - tempContribScore) / SevenSigns.RED_CONTRIB_POINTS;

if(redContribCount > redStoneCount)

{

redContribCount = redStoneCount;

}

tempContribScore += redContribCount * SevenSigns.RED_CONTRIB_POINTS;

greenContribCount = (Config.ALT_MAXIMUM_PLAYER_CONTRIB - tempContribScore) / SevenSigns.GREEN_CONTRIB_POINTS;

if(greenContribCount > greenStoneCount)

{

greenContribCount = greenStoneCount;

}

tempContribScore += greenContribCount * SevenSigns.GREEN_CONTRIB_POINTS;

blueContribCount = (Config.ALT_MAXIMUM_PLAYER_CONTRIB - tempContribScore) / SevenSigns.BLUE_CONTRIB_POINTS;

if(blueContribCount > blueStoneCount)

{

blueContribCount = blueStoneCount;

}

break;

}

if(redContribCount > 0)

{

if(player.destroyItemByItemId("SevenSigns", SevenSigns.SEAL_STONE_RED_ID, redContribCount, this, false))

{

stonesFound = true;

}

}

if(greenContribCount > 0)

{

if(player.destroyItemByItemId("SevenSigns", SevenSigns.SEAL_STONE_GREEN_ID, greenContribCount, this, false))

{

stonesFound = true;

}

}

if(blueContribCount > 0)

{

if(player.destroyItemByItemId("SevenSigns", SevenSigns.SEAL_STONE_BLUE_ID, blueContribCount, this, false))

{

stonesFound = true;

}

}



if(!stonesFound)

{

player.sendMessage("You do not have any seal stones of that type.");

break;

}



contribScore = SevenSigns.getInstance().addPlayerStoneContrib(player, blueContribCount, greenContribCount, redContribCount);



sm = new SystemMessage(SystemMessageId.CONTRIB_SCORE_INCREASED);

sm.addNumber(contribScore);

player.sendPacket(sm);



showChatWindow(player, 6, null, false);

redStones = null;

greenStones = null;

blueStones = null;

break;

case 7: // Exchange Ancient Adena for Adena - SevenSigns 7 xxxxxxx

int ancientAdenaConvert = 0;



try

{

ancientAdenaConvert = Integer.parseInt(command.substring(13).trim());

}

catch(NumberFormatException e)

{

if(Config.ENABLE_ALL_EXCEPTIONS)

e.printStackTrace();



showChatWindow(player, SevenSigns.SEVEN_SIGNS_HTML_PATH + "blkmrkt_3.htm");

break;

}

catch(StringIndexOutOfBoundsException e)

{

if(Config.ENABLE_ALL_EXCEPTIONS)

e.printStackTrace();



showChatWindow(player, SevenSigns.SEVEN_SIGNS_HTML_PATH + "blkmrkt_3.htm");

break;

}



if(ancientAdenaConvert < 1)

{

showChatWindow(player, SevenSigns.SEVEN_SIGNS_HTML_PATH + "blkmrkt_3.htm");

break;

}



if(ancientAdenaAmount < ancientAdenaConvert)

{

showChatWindow(player, SevenSigns.SEVEN_SIGNS_HTML_PATH + "blkmrkt_4.htm");

break;

}



player.reduceAncientAdena("SevenSigns", ancientAdenaConvert, this, true);

player.addAdena("SevenSigns", ancientAdenaConvert, this, true);



iu = new InventoryUpdate();

iu.addModifiedItem(player.getInventory().getAncientAdenaInstance());

iu.addModifiedItem(player.getInventory().getAdenaInstance());

player.sendPacket(iu);

break;

case 9: // Receive Contribution Rewards

int playerCabal = SevenSigns.getInstance().getPlayerCabal(player);

int winningCabal = SevenSigns.getInstance().getCabalHighestScore();



if(SevenSigns.getInstance().isSealValidationPeriod() && playerCabal == winningCabal)

{

int ancientAdenaReward = SevenSigns.getInstance().getAncientAdenaReward(player, true);



if(ancientAdenaReward < 3)

{

showChatWindow(player, 9, "b", false);

break;

}



player.addAncientAdena("SevenSigns", ancientAdenaReward, this, true);



// Send inventory update packet

iu = new InventoryUpdate();

iu.addModifiedItem(player.getInventory().getAncientAdenaInstance());

sendPacket(iu);



// Update current load as well

su = new StatusUpdate(player.getObjectId());

su.addAttribute(StatusUpdate.CUR_LOAD, player.getCurrentLoad());

sendPacket(su);



showChatWindow(player, 9, "a", false);

}

break;

case 11: // Teleport to Hunting Grounds

try

{

String portInfo = command.substring(14).trim();



StringTokenizer st = new StringTokenizer(portInfo);

int x = Integer.parseInt(st.nextToken());

int y = Integer.parseInt(st.nextToken());

int z = Integer.parseInt(st.nextToken());

int ancientAdenaCost = Integer.parseInt(st.nextToken());



if(ancientAdenaCost > 0)

{

if(!player.reduceAncientAdena("SevenSigns", ancientAdenaCost, this, true))

{

break;

}

}



portInfo = null;

st = null;

player.teleToLocation(x, y, z, true);

}

catch(Exception e)

{

if(Config.ENABLE_ALL_EXCEPTIONS)

e.printStackTrace();



_log.warning("SevenSigns: Error occurred while teleporting player: " + e);

}

break;

case 17: // Exchange Seal Stones for Ancient Adena (Type Choice) - SevenSigns 17 x

stoneType = Integer.parseInt(command.substring(14));

int stoneId = 0;

int stoneCount = 0;

int stoneValue = 0;

String stoneColor = null;

String content;



switch(stoneType)

{

case 1:

stoneColor = "blue";

stoneId = SevenSigns.SEAL_STONE_BLUE_ID;

stoneValue = SevenSigns.SEAL_STONE_BLUE_VALUE;

break;

case 2:

stoneColor = "green";

stoneId = SevenSigns.SEAL_STONE_GREEN_ID;

stoneValue = SevenSigns.SEAL_STONE_GREEN_VALUE;

break;

case 3:

stoneColor = "red";

stoneId = SevenSigns.SEAL_STONE_RED_ID;

stoneValue = SevenSigns.SEAL_STONE_RED_VALUE;

break;

}



L2ItemInstance stoneInstance = player.getInventory().getItemByItemId(stoneId);



if(stoneInstance != null)

{

stoneCount = stoneInstance.getCount();

}



path = SevenSigns.SEVEN_SIGNS_HTML_PATH + "signs_17.htm";

content = HtmCache.getInstance().getHtm(path);



if(content != null)

{

content = content.replaceAll("%stoneColor%", stoneColor);

content = content.replaceAll("%stoneValue%", String.valueOf(stoneValue));

content = content.replaceAll("%stoneCount%", String.valueOf(stoneCount));

content = content.replaceAll("%stoneItemId%", String.valueOf(stoneId));

content = content.replaceAll("%objectId%", String.valueOf(getObjectId()));



NpcHtmlMessage html = new NpcHtmlMessage(getObjectId());

html.setHtml(content);

player.sendPacket(html);

html = null;

}

else

{

_log.warning("Problem with HTML text " + SevenSigns.SEVEN_SIGNS_HTML_PATH + "signs_17.htm: " + path);

}



stoneInstance = null;

stoneColor = null;

content = null;

break;

case 18: // Exchange Seal Stones for Ancient Adena - SevenSigns 18 xxxx xxxxxx

int convertStoneId = Integer.parseInt(command.substring(14, 18));

int convertCount = 0;



try

{

convertCount = Integer.parseInt(command.substring(19).trim());

}

catch(Exception NumberFormatException)

{

if(Config.ENABLE_ALL_EXCEPTIONS)

NumberFormatException.printStackTrace();



player.sendMessage("You must enter an integer amount.");

break;

}



L2ItemInstance convertItem = player.getInventory().getItemByItemId(convertStoneId);



if(convertItem == null)

{

player.sendMessage("You do not have any seal stones of that type.");

break;

}



int totalCount = convertItem.getCount();

int ancientAdenaReward = 0;



if(convertCount <= totalCount && convertCount > 0)

{

switch(convertStoneId)

{

case SevenSigns.SEAL_STONE_BLUE_ID:

ancientAdenaReward = SevenSigns.calcAncientAdenaReward(convertCount, 0, 0);

break;

case SevenSigns.SEAL_STONE_GREEN_ID:

ancientAdenaReward = SevenSigns.calcAncientAdenaReward(0, convertCount, 0);

break;

case SevenSigns.SEAL_STONE_RED_ID:

ancientAdenaReward = SevenSigns.calcAncientAdenaReward(0, 0, convertCount);

break;

}



if(player.destroyItemByItemId("SevenSigns", convertStoneId, convertCount, this, true))

{

player.addAncientAdena("SevenSigns", ancientAdenaReward, this, true);



// Send inventory update packet

iu = new InventoryUpdate();

iu.addModifiedItem(player.getInventory().getAncientAdenaInstance());

iu.addModifiedItem(convertItem);

sendPacket(iu);



// Update current load as well

su = new StatusUpdate(player.getObjectId());

su.addAttribute(StatusUpdate.CUR_LOAD, player.getCurrentLoad());

sendPacket(su);

}

}

else

{

player.sendMessage("You do not have that many seal stones.");

}

convertItem = null;

break;

case 19: // Seal Information (for when joining a cabal)

int chosenSeal = Integer.parseInt(command.substring(16));

String fileSuffix = SevenSigns.getSealName(chosenSeal, true) + "_" + SevenSigns.getCabalShortName(cabal);



showChatWindow(player, val, fileSuffix, false);

fileSuffix = null;

break;

case 20: // Seal Status (for when joining a cabal)

TextBuilder contentBuffer = new TextBuilder("<html><body><font color=\"LEVEL\">[ Seal Status ]</font><br>");



for(int i = 1; i < 4; i++)

{

int sealOwner = SevenSigns.getInstance().getSealOwner(i);



if(sealOwner != SevenSigns.CABAL_NULL)

{

contentBuffer.append("[" + SevenSigns.getSealName(i, false) + ": " + SevenSigns.getCabalName(sealOwner) + "]<br>");

}

else

{

contentBuffer.append("[" + SevenSigns.getSealName(i, false) + ": Nothingness]<br>");

}

}



contentBuffer.append("<a action=\"bypass -h npc_" + getObjectId() + "_SevenSigns 3 " + cabal + "\">Go back.</a></body></html>");



NpcHtmlMessage html = new NpcHtmlMessage(getObjectId());

html.setHtml(contentBuffer.toString());

player.sendPacket(html);

contentBuffer = null;

html = null;

break;

default:

// 1 = Purchase Record Intro

// 5 = Contrib Seal Stones Intro

// 16 = Choose Type of Seal Stones to Convert



showChatWindow(player, val, null, false);

break;



}

sm = null;

iu = null;

su = null;

path = null;

ancientAdena = null;

}

else

{

super.onBypassFeedback(player, command);

}

}



private final boolean getPlayerAllyHasCastle(L2PcInstance player)

{

L2Clan playerClan = player.getClan();



// The player is not in a clan, so return false.

if(playerClan == null)

return false;



// If castle ownage check is clan-based rather than ally-based,

// check if the player's clan has a castle and return the result.

if(!Config.ALT_GAME_REQUIRE_CLAN_CASTLE)

{

int allyId = playerClan.getAllyId();



// The player's clan is not in an alliance, so return false.

if(allyId != 0)

{

// Check if another clan in the same alliance owns a castle,

// by traversing the list of clans and act accordingly.

L2Clan[] clanList = ClanTable.getInstance().getClans();



for(L2Clan clan : clanList)

if(clan.getAllyId() == allyId && clan.getHasCastle() > 0)

return true;



clanList = null;

}

}



return playerClan.getHasCastle() > 0;

}



private void showChatWindow(L2PcInstance player, int val, String suffix, boolean isDescription)

{

String filename = SevenSigns.SEVEN_SIGNS_HTML_PATH;



filename += isDescription ? "desc_" + val : "signs_" + val;

filename += suffix != null ? "_" + suffix + ".htm" : ".htm";



showChatWindow(player, filename);

filename = null;

}

}

Edited March 26, 2016 by EloBoost

EloBoost · March 26, 2016

SevenSignFestival.java



package com.l2jfrozen.gameserver.model.entity.sevensigns;



import java.sql.Connection;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.List;

import java.util.Map;

import java.util.concurrent.ScheduledFuture;

import java.util.logging.Logger;



import javolution.util.FastList;

import javolution.util.FastMap;



import com.l2jfrozen.Config;

import com.l2jfrozen.gameserver.ai.CtrlIntention;

import com.l2jfrozen.gameserver.datatables.csv.MapRegionTable;

import com.l2jfrozen.gameserver.datatables.sql.ClanTable;

import com.l2jfrozen.gameserver.datatables.sql.NpcTable;

import com.l2jfrozen.gameserver.datatables.sql.SpawnTable;

import com.l2jfrozen.gameserver.datatables.xml.ExperienceData;

import com.l2jfrozen.gameserver.model.L2Clan;

import com.l2jfrozen.gameserver.model.L2Party;

import com.l2jfrozen.gameserver.model.L2World;

import com.l2jfrozen.gameserver.model.actor.instance.L2FestivalMonsterInstance;

import com.l2jfrozen.gameserver.model.actor.instance.L2ItemInstance;

import com.l2jfrozen.gameserver.model.actor.instance.L2NpcInstance;

import com.l2jfrozen.gameserver.model.actor.instance.L2PcInstance;

import com.l2jfrozen.gameserver.model.actor.position.L2CharPosition;

import com.l2jfrozen.gameserver.model.spawn.L2Spawn;

import com.l2jfrozen.gameserver.model.spawn.SpawnListener;

import com.l2jfrozen.gameserver.network.SystemMessageId;

import com.l2jfrozen.gameserver.network.serverpackets.CreatureSay;

import com.l2jfrozen.gameserver.network.serverpackets.MagicSkillUser;

import com.l2jfrozen.gameserver.network.serverpackets.PledgeShowInfoUpdate;

import com.l2jfrozen.gameserver.network.serverpackets.SystemMessage;

import com.l2jfrozen.gameserver.templates.L2NpcTemplate;

import com.l2jfrozen.gameserver.templates.StatsSet;

import com.l2jfrozen.gameserver.thread.ThreadPoolManager;

import com.l2jfrozen.gameserver.util.Util;

import com.l2jfrozen.util.CloseUtil;

import com.l2jfrozen.util.database.L2DatabaseFactory;

import com.l2jfrozen.util.random.Rnd;



public class SevenSignsFestival implements SpawnListener

{



/** The Constant _log. */

protected static final Logger _log = Logger.getLogger(SevenSignsFestival.class.getName());



/** The _instance. */

private static SevenSignsFestival _instance;



/** The Constant GET_CLAN_NAME. */

private static final String GET_CLAN_NAME = "SELECT clan_name FROM clan_data WHERE clan_id = (SELECT clanid FROM characters WHERE char_name = ?)";



public static final long FESTIVAL_SIGNUP_TIME = Config.ALT_FESTIVAL_CYCLE_LENGTH - Config.ALT_FESTIVAL_LENGTH - 60000;



// Key Constants \\

/** The Constant FESTIVAL_MAX_OFFSET_X. */

private static final int FESTIVAL_MAX_OFFSET_X = 230;



/** The Constant FESTIVAL_MAX_OFFSET_Y. */

private static final int FESTIVAL_MAX_OFFSET_Y = 230;



/** The Constant FESTIVAL_DEFAULT_RESPAWN. */

private static final int FESTIVAL_DEFAULT_RESPAWN = 60; // Specify in seconds!



/** The Constant FESTIVAL_COUNT. */

public static final int FESTIVAL_COUNT = 5;



/** The Constant FESTIVAL_LEVEL_MAX_FOR_31. */

public static final int FESTIVAL_LEVEL_MAX_FOR_31 = 0;



/** The Constant FESTIVAL_LEVEL_MAX_FOR_42. */

public static final int FESTIVAL_LEVEL_MAX_FOR_42 = 1;



/** The Constant FESTIVAL_LEVEL_MAX_FOR_53. */

public static final int FESTIVAL_LEVEL_MAX_FOR_53 = 2;



/** The Constant FESTIVAL_LEVEL_MAX_FOR_64. */

public static final int FESTIVAL_LEVEL_MAX_FOR_64 = 3;



/** The Constant FESTIVAL_LEVEL_MAX_FOR_NONE. */

public static final int FESTIVAL_LEVEL_MAX_FOR_NONE = 4;



/** The Constant FESTIVAL_LEVEL_SCORES. */

public static final int[] FESTIVAL_LEVEL_SCORES =

{

60, 70, 100, 120, 150

}; // 500 maximum possible score



/** The Constant FESTIVAL_OFFERING_ID. */

public static final int FESTIVAL_OFFERING_ID = 5901;



/** The Constant FESTIVAL_OFFERING_VALUE. */

public static final int FESTIVAL_OFFERING_VALUE = 5;



public static final int[][] FESTIVAL_DAWN_PLAYER_SPAWNS =

{

{

-79187, 113186, -4895, 0

}, // 31 and below

{

-75918, 110137, -4895, 0

}, // 42 and below

{

-73835, 111969, -4895, 0

}, // 53 and below

{

-76170, 113804, -4895, 0

}, // 64 and below

{

-78927, 109528, -4895, 0

}

// No level limit

};



/** The Constant FESTIVAL_DUSK_PLAYER_SPAWNS. */

public static final int[][] FESTIVAL_DUSK_PLAYER_SPAWNS =

{

{

-77200, 88966, -5151, 0

}, // 31 and below

{

-76941, 85307, -5151, 0

}, // 42 and below

{

-74855, 87135, -5151, 0

}, // 53 and below

{

-80208, 88222, -5151, 0

}, // 64 and below

{

-79954, 84697, -5151, 0

}

// No level limit

};



/** The Constant FESTIVAL_DAWN_WITCH_SPAWNS. */

protected static final int[][] FESTIVAL_DAWN_WITCH_SPAWNS =

{

{

-79183, 113052, -4891, 0, 31132

}, // 31 and below

{

-75916, 110270, -4891, 0, 31133

}, // 42 and below

{

-73979, 111970, -4891, 0, 31134

}, // 53 and below

{

-76174, 113663, -4891, 0, 31135

}, // 64 and below

{

-78930, 109664, -4891, 0, 31136

}

// No level limit

};



/** The Constant FESTIVAL_DUSK_WITCH_SPAWNS. */

protected static final int[][] FESTIVAL_DUSK_WITCH_SPAWNS =

{

{

-77199, 88830, -5147, 0, 31142

}, // 31 and below

{

-76942, 85438, -5147, 0, 31143

}, // 42 and below

{

-74990, 87135, -5147, 0, 31144

}, // 53 and below

{

-80207, 88222, -5147, 0, 31145

}, // 64 and below

{

-79952, 84833, -5147, 0, 31146

}

// No level limit

};



/** The Constant FESTIVAL_DAWN_PRIMARY_SPAWNS. */

protected static final int[][][] FESTIVAL_DAWN_PRIMARY_SPAWNS =

{

{

/* Level 31 and Below - Offering of the Branded */

{

-78537, 113839, -4895, -1, 18009

},

{

-78466, 113852, -4895, -1, 18010

},

{

-78509, 113899, -4895, -1, 18010

},



{

-78481, 112557, -4895, -1, 18009

},

{

-78559, 112504, -4895, -1, 18010

},

{

-78489, 112494, -4895, -1, 18010

},



{

-79803, 112543, -4895, -1, 18012

},

{

-79854, 112492, -4895, -1, 18013

},

{

-79886, 112557, -4895, -1, 18014

},



{

-79821, 113811, -4895, -1, 18015

},

{

-79857, 113896, -4895, -1, 18017

},

{

-79878, 113816, -4895, -1, 18018

},



// Archers and Marksmen \\

{

-79190, 113660, -4895, -1, 18011

},

{

-78710, 113188, -4895, -1, 18011

},

{

-79190, 112730, -4895, -1, 18016

},

{

-79656, 113188, -4895, -1, 18016

}

},

{

/* Level 42 and Below - Apostate Offering */

{

-76558, 110784, -4895, -1, 18019

},

{

-76607, 110815, -4895, -1, 18020

}, // South West

{

-76559, 110820, -4895, -1, 18020

},



{

-75277, 110792, -4895, -1, 18019

},

{

-75225, 110801, -4895, -1, 18020

}, // South East

{

-75262, 110832, -4895, -1, 18020

},



{

-75249, 109441, -4895, -1, 18022

},

{

-75278, 109495, -4895, -1, 18023

}, // North East

{

-75223, 109489, -4895, -1, 18024

},



{

-76556, 109490, -4895, -1, 18025

},

{

-76607, 109469, -4895, -1, 18027

}, // North West

{

-76561, 109450, -4895, -1, 18028

},



// Archers and Marksmen \\

{

-76399, 110144, -4895, -1, 18021

},

{

-75912, 110606, -4895, -1, 18021

},

{

-75444, 110144, -4895, -1, 18026

},

{

-75930, 109665, -4895, -1, 18026

}

},

{

/* Level 53 and Below - Witch's Offering */

{

-73184, 111319, -4895, -1, 18029

},

{

-73135, 111294, -4895, -1, 18030

}, // South West

{

-73185, 111281, -4895, -1, 18030

},



{

-74477, 111321, -4895, -1, 18029

},

{

-74523, 111293, -4895, -1, 18030

}, // South East

{

-74481, 111280, -4895, -1, 18030

},



{

-74489, 112604, -4895, -1, 18032

},

{

-74491, 112660, -4895, -1, 18033

}, // North East

{

-74527, 112629, -4895, -1, 18034

},



{

-73197, 112621, -4895, -1, 18035

},

{

-73142, 112631, -4895, -1, 18037

}, // North West

{

-73182, 112656, -4895, -1, 18038

},



// Archers and Marksmen \\

{

-73834, 112430, -4895, -1, 18031

},

{

-74299, 111959, -4895, -1, 18031

},

{

-73841, 111491, -4895, -1, 18036

},

{

-73363, 111959, -4895, -1, 18036

}

},

{

/* Level 64 and Below - Dark Omen Offering */

{

-75543, 114461, -4895, -1, 18039

},

{

-75514, 114493, -4895, -1, 18040

}, // South West

{

-75488, 114456, -4895, -1, 18040

},



{

-75521, 113158, -4895, -1, 18039

},

{

-75504, 113110, -4895, -1, 18040

}, // South East

{

-75489, 113142, -4895, -1, 18040

},



{

-76809, 113143, -4895, -1, 18042

},

{

-76860, 113138, -4895, -1, 18043

}, // North East

{

-76831, 113112, -4895, -1, 18044

},



{

-76831, 114441, -4895, -1, 18045

},

{

-76840, 114490, -4895, -1, 18047

}, // North West

{

-76864, 114455, -4895, -1, 18048

},



// Archers and Marksmen \\

{

-75703, 113797, -4895, -1, 18041

},

{

-76180, 114263, -4895, -1, 18041

},

{

-76639, 113797, -4895, -1, 18046

},

{

-76180, 113337, -4895, -1, 18046

}

},

{

/* No Level Limit - Offering of Forbidden Path */

{

-79576, 108881, -4895, -1, 18049

},

{

-79592, 108835, -4895, -1, 18050

}, // South West

{

-79614, 108871, -4895, -1, 18050

},



{

-79586, 110171, -4895, -1, 18049

},

{

-79589, 110216, -4895, -1, 18050

}, // South East

{

-79620, 110177, -4895, -1, 18050

},



{

-78825, 110182, -4895, -1, 18052

},

{

-78238, 110182, -4895, -1, 18053

}, // North East

{

-78266, 110218, -4895, -1, 18054

},



{

-78275, 108883, -4895, -1, 18055

},

{

-78267, 108839, -4895, -1, 18057

}, // North West

{

-78241, 108871, -4895, -1, 18058

},



// Archers and Marksmen \\

{

-79394, 109538, -4895, -1, 18051

},

{

-78929, 109992, -4895, -1, 18051

},

{

-78454, 109538, -4895, -1, 18056

},

{

-78929, 109053, -4895, -1, 18056

}

}

};



/** The Constant FESTIVAL_DUSK_PRIMARY_SPAWNS. */

protected static final int[][][] FESTIVAL_DUSK_PRIMARY_SPAWNS =

{

{

/* Level 31 and Below - Offering of the Branded */

{

-76542, 89653, -5151, -1, 18009

},

{

-76509, 89637, -5151, -1, 18010

},

{

-76548, 89614, -5151, -1, 18010

},



{

-76539, 88326, -5151, -1, 18009

},

{

-76512, 88289, -5151, -1, 18010

},

{

-76546, 88287, -5151, -1, 18010

},



{

-77879, 88308, -5151, -1, 18012

},

{

-77886, 88310, -5151, -1, 18013

},

{

-77879, 88278, -5151, -1, 18014

},



{

-77857, 89605, -5151, -1, 18015

},

{

-77858, 89658, -5151, -1, 18017

},

{

-77891, 89633, -5151, -1, 18018

},



// Archers and Marksmen \\

{

-76728, 88962, -5151, -1, 18011

},

{

-77194, 88494, -5151, -1, 18011

},

{

-77660, 88896, -5151, -1, 18016

},

{

-77195, 89438, -5151, -1, 18016

}

},

{

/* Level 42 and Below - Apostate's Offering */

{

-77585, 84650, -5151, -1, 18019

},

{

-77628, 84643, -5151, -1, 18020

},

{

-77607, 84613, -5151, -1, 18020

},



{

-76603, 85946, -5151, -1, 18019

},

{

-77606, 85994, -5151, -1, 18020

},

{

-77638, 85959, -5151, -1, 18020

},



{

-76301, 85960, -5151, -1, 18022

},

{

-76257, 85972, -5151, -1, 18023

},

{

-76286, 85992, -5151, -1, 18024

},



{

-76281, 84667, -5151, -1, 18025

},

{

-76291, 84611, -5151, -1, 18027

},

{

-76257, 84616, -5151, -1, 18028

},



// Archers and Marksmen \\

{

-77419, 85307, -5151, -1, 18021

},

{

-76952, 85768, -5151, -1, 18021

},

{

-76477, 85312, -5151, -1, 18026

},

{

-76942, 84832, -5151, -1, 18026

}

},

{

/* Level 53 and Below - Witch's Offering */

{

-74211, 86494, -5151, -1, 18029

},

{

-74200, 86449, -5151, -1, 18030

},

{

-74167, 86464, -5151, -1, 18030

},



{

-75495, 86482, -5151, -1, 18029

},

{

-75540, 86473, -5151, -1, 18030

},

{

-75509, 86445, -5151, -1, 18030

},



{

-75509, 87775, -5151, -1, 18032

},

{

-75518, 87826, -5151, -1, 18033

},

{

-75542, 87780, -5151, -1, 18034

},



{

-74214, 87789, -5151, -1, 18035

},

{

-74169, 87801, -5151, -1, 18037

},

{

-74198, 87827, -5151, -1, 18038

},



// Archers and Marksmen \\

{

-75324, 87135, -5151, -1, 18031

},

{

-74852, 87606, -5151, -1, 18031

},

{

-74388, 87146, -5151, -1, 18036

},

{

-74856, 86663, -5151, -1, 18036

}

},

{

/* Level 64 and Below - Dark Omen Offering */

{

-79560, 89007, -5151, -1, 18039

},

{

-79521, 89016, -5151, -1, 18040

},

{

-79544, 89047, -5151, -1, 18040

},



{

-79552, 87717, -5151, -1, 18039

},

{

-79552, 87673, -5151, -1, 18040

},

{

-79510, 87702, -5151, -1, 18040

},



{

-80866, 87719, -5151, -1, 18042

},

{

-80897, 87689, -5151, -1, 18043

},

{

-80850, 87685, -5151, -1, 18044

},



{

-80848, 89013, -5151, -1, 18045

},

{

-80887, 89051, -5151, -1, 18047

},

{

-80891, 89004, -5151, -1, 18048

},



// Archers and Marksmen \\

{

-80205, 87895, -5151, -1, 18041

},

{

-80674, 88350, -5151, -1, 18041

},

{

-80209, 88833, -5151, -1, 18046

},

{

-79743, 88364, -5151, -1, 18046

}

},

{

/* No Level Limit - Offering of Forbidden Path */

{

-80624, 84060, -5151, -1, 18049

},

{

-80621, 84007, -5151, -1, 18050

},

{

-80590, 84039, -5151, -1, 18050

},



{

-80605, 85349, -5151, -1, 18049

},

{

-80639, 85363, -5151, -1, 18050

},

{

-80611, 85385, -5151, -1, 18050

},



{

-79311, 85353, -5151, -1, 18052

},

{

-79277, 85384, -5151, -1, 18053

},

{

-79273, 85539, -5151, -1, 18054

},



{

-79297, 84054, -5151, -1, 18055

},

{

-79285, 84006, -5151, -1, 18057

},

{

-79260, 84040, -5151, -1, 18058

},



// Archers and Marksmen \\

{

-79945, 85171, -5151, -1, 18051

},

{

-79489, 84707, -5151, -1, 18051

},

{

-79952, 84222, -5151, -1, 18056

},

{

-80423, 84703, -5151, -1, 18056

}

}

};



/** The Constant FESTIVAL_DAWN_SECONDARY_SPAWNS. */

protected static final int[][][] FESTIVAL_DAWN_SECONDARY_SPAWNS =

{

{

/* 31 and Below */

{

-78757, 112834, -4895, -1, 18016

},

{

-78581, 112834, -4895, -1, 18016

},



{

-78822, 112526, -4895, -1, 18011

},

{

-78822, 113702, -4895, -1, 18011

},

{

-78822, 113874, -4895, -1, 18011

},



{

-79524, 113546, -4895, -1, 18011

},

{

-79693, 113546, -4895, -1, 18011

},

{

-79858, 113546, -4895, -1, 18011

},



{

-79545, 112757, -4895, -1, 18016

},

{

-79545, 112586, -4895, -1, 18016

},

},

{

/* 42 and Below */

{

-75565, 110580, -4895, -1, 18026

},

{

-75565, 110740, -4895, -1, 18026

},



{

-75577, 109776, -4895, -1, 18021

},

{

-75413, 109776, -4895, -1, 18021

},

{

-75237, 109776, -4895, -1, 18021

},



{

-76274, 109468, -4895, -1, 18021

},

{

-76274, 109635, -4895, -1, 18021

},

{

-76274, 109795, -4895, -1, 18021

},



{

-76351, 110500, -4895, -1, 18056

},

{

-76528, 110500, -4895, -1, 18056

},

},

{

/* 53 and Below */

{

-74191, 111527, -4895, -1, 18036

},

{

-74191, 111362, -4895, -1, 18036

},



{

-73495, 111611, -4895, -1, 18031

},

{

-73327, 111611, -4895, -1, 18031

},

{

-73154, 111611, -4895, -1, 18031

},



{

-73473, 112301, -4895, -1, 18031

},

{

-73473, 112475, -4895, -1, 18031

},

{

-73473, 112649, -4895, -1, 18031

},



{

-74270, 112326, -4895, -1, 18036

},

{

-74443, 112326, -4895, -1, 18036

},

},

{

/* 64 and Below */

{

-75738, 113439, -4895, -1, 18046

},

{

-75571, 113439, -4895, -1, 18046

},



{

-75824, 114141, -4895, -1, 18041

},

{

-75824, 114309, -4895, -1, 18041

},

{

-75824, 114477, -4895, -1, 18041

},



{

-76513, 114158, -4895, -1, 18041

},

{

-76683, 114158, -4895, -1, 18041

},

{

-76857, 114158, -4895, -1, 18041

},



{

-76535, 113357, -4895, -1, 18056

},

{

-76535, 113190, -4895, -1, 18056

},

},

{

/* No Level Limit */

{

-79350, 109894, -4895, -1, 18056

},

{

-79534, 109894, -4895, -1, 18056

},



{

-79285, 109187, -4895, -1, 18051

},

{

-79285, 109019, -4895, -1, 18051

},

{

-79285, 108860, -4895, -1, 18051

},



{

-78587, 109172, -4895, -1, 18051

},

{

-78415, 109172, -4895, -1, 18051

},

{

-78249, 109172, -4895, -1, 18051

},



{

-78575, 109961, -4895, -1, 18056

},

{

-78575, 110130, -4895, -1, 18056

},

}

};



/** The Constant FESTIVAL_DUSK_SECONDARY_SPAWNS. */

protected static final int[][][] FESTIVAL_DUSK_SECONDARY_SPAWNS =

{

{

/* 31 and Below */

{

-76844, 89304, -5151, -1, 18011

},

{

-76844, 89479, -5151, -1, 18011

},

{

-76844, 89649, -5151, -1, 18011

},



{

-77544, 89326, -5151, -1, 18011

},

{

-77716, 89326, -5151, -1, 18011

},

{

-77881, 89326, -5151, -1, 18011

},



{

-77561, 88530, -5151, -1, 18016

},

{

-77561, 88364, -5151, -1, 18016

},



{

-76762, 88615, -5151, -1, 18016

},

{

-76594, 88615, -5151, -1, 18016

},

},

{

/* 42 and Below */

{

-77307, 84969, -5151, -1, 18021

},

{

-77307, 84795, -5151, -1, 18021

},

{

-77307, 84623, -5151, -1, 18021

},



{

-76614, 84944, -5151, -1, 18021

},

{

-76433, 84944, -5151, -1, 18021

},

{

-7626 - 1, 84944, -5151, -1, 18021

},



{

-76594, 85745, -5151, -1, 18026

},

{

-76594, 85910, -5151, -1, 18026

},



{

-77384, 85660, -5151, -1, 18026

},

{

-77555, 85660, -5151, -1, 18026

},

},

{

/* 53 and Below */

{

-74517, 86782, -5151, -1, 18031

},

{

-74344, 86782, -5151, -1, 18031

},

{

-74185, 86782, -5151, -1, 18031

},



{

-74496, 87464, -5151, -1, 18031

},

{

-74496, 87636, -5151, -1, 18031

},

{

-74496, 87815, -5151, -1, 18031

},



{

-75298, 87497, -5151, -1, 18036

},

{

-75460, 87497, -5151, -1, 18036

},



{

-75219, 86712, -5151, -1, 18036

},

{

-75219, 86531, -5151, -1, 18036

},

},

{

/* 64 and Below */

{

-79851, 88703, -5151, -1, 18041

},

{

-79851, 88868, -5151, -1, 18041

},

{

-79851, 89040, -5151, -1, 18041

},



{

-80548, 88722, -5151, -1, 18041

},

{

-80711, 88722, -5151, -1, 18041

},

{

-80883, 88722, -5151, -1, 18041

},



{

-80565, 87916, -5151, -1, 18046

},

{

-80565, 87752, -5151, -1, 18046

},



{

-79779, 87996, -5151, -1, 18046

},

{

-79613, 87996, -5151, -1, 18046

},

},

{

/* No Level Limit */

{

-79271, 84330, -5151, -1, 18051

},

{

-79448, 84330, -5151, -1, 18051

},

{

-79601, 84330, -5151, -1, 18051

},



{

-80311, 84367, -5151, -1, 18051

},

{

-80311, 84196, -5151, -1, 18051

},

{

-80311, 84015, -5151, -1, 18051

},



{

-80556, 85049, -5151, -1, 18056

},

{

-80384, 85049, -5151, -1, 18056

},



{

-79598, 85127, -5151, -1, 18056

},

{

-79598, 85303, -5151, -1, 18056

},

}

};



/** The Constant FESTIVAL_DAWN_CHEST_SPAWNS. */

protected static final int[][][] FESTIVAL_DAWN_CHEST_SPAWNS =

{

{

/* Level 31 and Below */

{

-78999, 112957, -4927, -1, 18109

},

{

-79153, 112873, -4927, -1, 18109

},

{

-79256, 112873, -4927, -1, 18109

},

{

-79368, 112957, -4927, -1, 18109

},



{

-79481, 113124, -4927, -1, 18109

},

{

-79481, 113275, -4927, -1, 18109

},



{

-79364, 113398, -4927, -1, 18109

},

{

-79213, 113500, -4927, -1, 18109

},

{

-79099, 113500, -4927, -1, 18109

},

{

-78960, 113398, -4927, -1, 18109

},



{

-78882, 113235, -4927, -1, 18109

},

{

-78882, 113099, -4927, -1, 18109

},

},

{

/* Level 42 and Below */

{

-76119, 110383, -4927, -1, 18110

},

{

-75980, 110442, -4927, -1, 18110

},

{

-75848, 110442, -4927, -1, 18110

},

{

-75720, 110383, -4927, -1, 18110

},



{

-75625, 110195, -4927, -1, 18110

},

{

-75625, 110063, -4927, -1, 18110

},



{

-75722, 109908, -4927, -1, 18110

},

{

-75863, 109832, -4927, -1, 18110

},

{

-75989, 109832, -4927, -1, 18110

},

{

-76130, 109908, -4927, -1, 18110

},



{

-76230, 110079, -4927, -1, 18110

},

{

-76230, 110215, -4927, -1, 18110

},

},

{

/* Level 53 and Below */

{

-74055, 111781, -4927, -1, 18111

},

{

-74144, 111938, -4927, -1, 18111

},

{

-74144, 112075, -4927, -1, 18111

},

{

-74055, 112173, -4927, -1, 18111

},



{

-73885, 112289, -4927, -1, 18111

},

{

-73756, 112289, -4927, -1, 18111

},



{

-73574, 112141, -4927, -1, 18111

},

{

-73511, 112040, -4927, -1, 18111

},

{

-73511, 111912, -4927, -1, 18111

},

{

-73574, 111772, -4927, -1, 18111

},



{

-73767, 111669, -4927, -1, 18111

},

{

-73899, 111669, -4927, -1, 18111

},

},

{

/* Level 64 and Below */

{

-76008, 113566, -4927, -1, 18112

},

{

-76159, 113485, -4927, -1, 18112

},

{

-76267, 113485, -4927, -1, 18112

},

{

-76386, 113566, -4927, -1, 18112

},



{

-76482, 113748, -4927, -1, 18112

},

{

-76482, 113885, -4927, -1, 18112

},



{

-76371, 114029, -4927, -1, 18112

},

{

-76220, 114118, -4927, -1, 18112

},

{

-76092, 114118, -4927, -1, 18112

},

{

-75975, 114029, -4927, -1, 18112

},



{

-75861, 11385 - 1, -4927, -1, 18112

},

{

-75861, 113713, -4927, -1, 18112

},

},

{

/* No Level Limit */

{

-79100, 109782, -4927, -1, 18113

},

{

-78962, 109853, -4927, -1, 18113

},

{

-78851, 109853, -4927, -1, 18113

},

{

-78721, 109782, -4927, -1, 18113

},



{

-78615, 109596, -4927, -1, 18113

},

{

-78615, 109453, -4927, -1, 18113

},



{

-78746, 109300, -4927, -1, 18113

},

{

-78881, 109203, -4927, -1, 18113

},

{

-79027, 109203, -4927, -1, 18113

},

{

-79159, 109300, -4927, -1, 18113

},



{

-79240, 109480, -4927, -1, 18113

},

{

-79240, 109615, -4927, -1, 18113

},

}

};



/** The Constant FESTIVAL_DUSK_CHEST_SPAWNS. */

protected static final int[][][] FESTIVAL_DUSK_CHEST_SPAWNS =

{

{

/* Level 31 and Below */

{

-77016, 88726, -5183, -1, 18114

},

{

-77136, 88646, -5183, -1, 18114

},

{

-77247, 88646, -5183, -1, 18114

},

{

-77380, 88726, -5183, -1, 18114

},



{

-77512, 88883, -5183, -1, 18114

},

{

-77512, 89053, -5183, -1, 18114

},



{

-77378, 89287, -5183, -1, 18114

},

{

-77254, 89238, -5183, -1, 18114

},

{

-77095, 89238, -5183, -1, 18114

},

{

-76996, 89287, -5183, -1, 18114

},



{

-76901, 89025, -5183, -1, 18114

},

{

-76901, 88891, -5183, -1, 18114

},

},

{

/* Level 42 and Below */

{

-77128, 85553, -5183, -1, 18115

},

{

-77036, 85594, -5183, -1, 18115

},

{

-76919, 85594, -5183, -1, 18115

},

{

-76755, 85553, -5183, -1, 18115

},



{

-76635, 85392, -5183, -1, 18115

},

{

-76635, 85216, -5183, -1, 18115

},



{

-76761, 85025, -5183, -1, 18115

},

{

-76908, 85004, -5183, -1, 18115

},

{

-77041, 85004, -5183, -1, 18115

},

{

-77138, 85025, -5183, -1, 18115

},



{

-77268, 85219, -5183, -1, 18115

},

{

-77268, 85410, -5183, -1, 18115

},

},

{

/* Level 53 and Below */

{

-75150, 87303, -5183, -1, 18116

},

{

-75150, 87175, -5183, -1, 18116

},

{

-75150, 87175, -5183, -1, 18116

},

{

-75150, 87303, -5183, -1, 18116

},



{

-74943, 87433, -5183, -1, 18116

},

{

-74767, 87433, -5183, -1, 18116

},



{

-74556, 87306, -5183, -1, 18116

},

{

-74556, 87184, -5183, -1, 18116

},

{

-74556, 87184, -5183, -1, 18116

},

{

-74556, 87306, -5183, -1, 18116

},



{

-74757, 86830, -5183, -1, 18116

},

{

-74927, 86830, -5183, -1, 18116

},

},

{

/* Level 64 and Below */

{

-80010, 88128, -5183, -1, 18117

},

{

-80113, 88066, -5183, -1, 18117

},

{

-80220, 88066, -5183, -1, 18117

},

{

-80359, 88128, -5183, -1, 18117

},



{

-80467, 88267, -5183, -1, 18117

},

{

-80467, 88436, -5183, -1, 18117

},



{

-80381, 88639, -5183, -1, 18117

},

{

-80278, 88577, -5183, -1, 18117

},

{

-80142, 88577, -5183, -1, 18117

},

{

-80028, 88639, -5183, -1, 18117

},



{

-79915, 88466, -5183, -1, 18117

},

{

-79915, 88322, -5183, -1, 18117

},

},

{

/* No Level Limit */

{

-80153, 84947, -5183, -1, 18118

},

{

-80003, 84962, -5183, -1, 18118

},

{

-79848, 84962, -5183, -1, 18118

},

{

-79742, 84947, -5183, -1, 18118

},



{

-79668, 84772, -5183, -1, 18118

},

{

-79668, 84619, -5183, -1, 18118

},



{

-79772, 84471, -5183, -1, 18118

},

{

-79888, 84414, -5183, -1, 18118

},

{

-80023, 84414, -5183, -1, 18118

},

{

-80166, 84471, -5183, -1, 18118

},



{

-80253, 84600, -5183, -1, 18118

},

{

-80253, 84780, -5183, -1, 18118

},

}

};



//////////////////////// \\\\\\\\\\\\\\\\\\\\\\\\\\



/** The _manager instance. */

protected FestivalManager _managerInstance;



/** The _manager scheduled task. */

protected ScheduledFuture<?> _managerScheduledTask;



/** The _signs cycle. */

protected int _signsCycle = SevenSigns.getInstance().getCurrentCycle();



/** The _festival cycle. */

protected int _festivalCycle;



/** The _next festival cycle start. */

protected long _nextFestivalCycleStart;



/** The _next festival start. */

protected long _nextFestivalStart;



/** The _festival initialized. */

protected boolean _festivalInitialized;



/** The _festival in progress. */

protected boolean _festivalInProgress;



/** The _accumulated bonuses. */

protected List<Integer> _accumulatedBonuses; // The total bonus available (in Ancient Adena)



/** The _dawn chat guide. */

private L2NpcInstance _dawnChatGuide;



/** The _dusk chat guide. */

private L2NpcInstance _duskChatGuide;



/** The _dawn festival participants. */

protected Map<Integer, List<L2PcInstance>> _dawnFestivalParticipants;



/** The _dusk festival participants. */

protected Map<Integer, List<L2PcInstance>> _duskFestivalParticipants;



/** The _dawn previous participants. */

protected Map<Integer, List<L2PcInstance>> _dawnPreviousParticipants;



/** The _dusk previous participants. */

protected Map<Integer, List<L2PcInstance>> _duskPreviousParticipants;



/** The _dawn festival scores. */

private Map<Integer, Integer> _dawnFestivalScores;



/** The _dusk festival scores. */

private Map<Integer, Integer> _duskFestivalScores;



/**

* _festivalData is essentially an instance of the seven_signs_festival table and should be treated as such. Data is

* initially accessed by the related Seven Signs cycle, with _signsCycle representing data for the current round of

* Festivals. The actual table data is stored as a series of StatsSet constructs. These are accessed by the use of

* an offset based on the number of festivals, thus: offset = FESTIVAL_COUNT + festivalId (Data for Dawn is always

* accessed by offset > FESTIVAL_COUNT)

*/

private Map<Integer, Map<Integer, StatsSet>> _festivalData;



/**

* Instantiates a new seven signs festival.

*/

@SuppressWarnings("unused")

public SevenSignsFestival()

{

_accumulatedBonuses = new FastList<Integer>();



_dawnFestivalParticipants = new FastMap<Integer, List<L2PcInstance>>();

_dawnPreviousParticipants = new FastMap<Integer, List<L2PcInstance>>();

_dawnFestivalScores = new FastMap<Integer, Integer>();



_duskFestivalParticipants = new FastMap<Integer, List<L2PcInstance>>();

_duskPreviousParticipants = new FastMap<Integer, List<L2PcInstance>>();

_duskFestivalScores = new FastMap<Integer, Integer>();



_festivalData = new FastMap<Integer, Map<Integer, StatsSet>>();



restoreFestivalData();

ThreadPoolManager.getInstance().scheduleGeneralAtFixedRate(new RestoreStatus(), 7200000, 10800000);



if(SevenSigns.getInstance().isSealValidationPeriod())

{

_log.info("SevenSignsFestival: Initialization bypassed due to Seal Validation in effect.");

return;

}



L2Spawn.addSpawnListener(this);

startFestivalManager();

}



/**

* Gets the single instance of SevenSignsFestival.

*

* @return single instance of SevenSignsFestival

*/

public static SevenSignsFestival getInstance()

{

if(_instance == null)

{

_instance = new SevenSignsFestival();

}



return _instance;

}



/**

* Returns the associated name (level range) to a given festival ID.

*

* @param festivalID the festival id

* @return String festivalName

*/

public static final String getFestivalName(int festivalID)

{

String festivalName;



switch(festivalID)

{

case FESTIVAL_LEVEL_MAX_FOR_31:

festivalName = "Level 31 or lower";

break;

case FESTIVAL_LEVEL_MAX_FOR_42:

festivalName = "Level 42 or lower";

break;

case FESTIVAL_LEVEL_MAX_FOR_53:

festivalName = "Level 53 or lower";

break;

case FESTIVAL_LEVEL_MAX_FOR_64:

festivalName = "Level 64 or lower";

break;

default:

festivalName = "No Level Limit";

break;

}



return festivalName;

}



/**

* Returns the maximum allowed player level for the given festival type.

*

* @param festivalId the festival id

* @return int maxLevel

*/

public static final int getMaxLevelForFestival(int festivalId)

{

int maxLevel = ExperienceData.getInstance().getMaxLevel() - 1;



switch(festivalId)

{

case SevenSignsFestival.FESTIVAL_LEVEL_MAX_FOR_31:

maxLevel = 31;

break;

case SevenSignsFestival.FESTIVAL_LEVEL_MAX_FOR_42:

maxLevel = 42;

break;

case SevenSignsFestival.FESTIVAL_LEVEL_MAX_FOR_53:

maxLevel = 53;

break;

case SevenSignsFestival.FESTIVAL_LEVEL_MAX_FOR_64:

maxLevel = 64;

break;

}



return maxLevel;

}



/**

* Returns true if the monster ID given is of an archer/marksman type.

*

* @param npcId the npc id

* @return boolean isArcher

*/

protected static final boolean isFestivalArcher(int npcId)

{

if(npcId < 18009 || npcId > 18108)

return false;



int identifier = npcId % 10;

return identifier == 4 || identifier == 9;

}



/**

* Returns true if the monster ID given is a festival chest.

*

* @param npcId the npc id

* @return boolean isChest

*/

protected static final boolean isFestivalChest(int npcId)

{

return npcId < 18109 || npcId > 18118;

}



/**

* Primarily used to terminate the Festival Manager, when the Seven Signs period changes.

* 

* @return ScheduledFuture festManagerScheduler

*/

protected final ScheduledFuture<?> getFestivalManagerSchedule()

{

if(_managerScheduledTask == null)

{

startFestivalManager();

}



return _managerScheduledTask;

}



/**

* Used to start the Festival Manager, if the current period is not Seal Validation.

*/

protected void startFestivalManager()

{

// Start the Festival Manager for the first time after the server has started

// at the specified time, then invoke it automatically after every cycle.

FestivalManager fm = new FestivalManager();

setNextFestivalStart(Config.ALT_FESTIVAL_MANAGER_START + FESTIVAL_SIGNUP_TIME);

_managerScheduledTask = ThreadPoolManager.getInstance().scheduleGeneralAtFixedRate(fm, Config.ALT_FESTIVAL_MANAGER_START, Config.ALT_FESTIVAL_CYCLE_LENGTH);



fm = null;

_log.info("SevenSignsFestival: The first Festival of Darkness cycle begins in " + Config.ALT_FESTIVAL_MANAGER_START / 60000 + " minute(s).");

}



/**

* Restores saved festival data, basic settings from the properties file and past high score data from the database.

*

*/

@SuppressWarnings("unused")

protected void restoreFestivalData()

{

Connection con = null;



if(Config.DEBUG)

{

_log.info("SevenSignsFestival: Restoring festival data. Current SS Cycle: " + _signsCycle);

}



try

{

con = L2DatabaseFactory.getInstance().getConnection(false);

PreparedStatement statement = con.prepareStatement("SELECT festivalId, cabal, cycle, date, score, members FROM seven_signs_festival");

ResultSet rset = statement.executeQuery();



while(rset.next())

{

int festivalCycle = rset.getInt("cycle");

int festivalId = rset.getInt("festivalId");

String cabal = rset.getString("cabal");



StatsSet festivalDat = new StatsSet();

festivalDat.set("festivalId", festivalId);

festivalDat.set("cabal", cabal);

festivalDat.set("cycle", festivalCycle);

festivalDat.set("date", rset.getString("date"));

festivalDat.set("score", rset.getInt("score"));

festivalDat.set("members", rset.getString("members"));



if(Config.DEBUG)

{

_log.info("SevenSignsFestival: Loaded data from DB for (Cycle = " + festivalCycle + ", Oracle = " + cabal + ", Festival = " + getFestivalName(festivalId));

}



if(cabal.equals("dawn"))

{

festivalId += FESTIVAL_COUNT;

}



cabal = null;



Map<Integer, StatsSet> tempData = _festivalData.get(festivalCycle);



if(tempData == null)

{

tempData = new FastMap<Integer, StatsSet>();

}



tempData.put(festivalId, festivalDat);

_festivalData.put(festivalCycle, tempData);

tempData = null;

}



rset.close();

statement.close();



rset = null;

statement = null;



String query = "SELECT festival_cycle, ";



for(int i = 0; i < FESTIVAL_COUNT - 1; i++)

{

query += "accumulated_bonus" + String.valueOf(i) + ", ";

}

query += "accumulated_bonus" + String.valueOf(FESTIVAL_COUNT - 1) + " ";

query += "FROM seven_signs_status WHERE id=0";



statement = con.prepareStatement(query);

rset = statement.executeQuery();



while(rset.next())

{

_festivalCycle = rset.getInt("festival_cycle");



for(int i = 0; i < FESTIVAL_COUNT; i++)

{

_accumulatedBonuses.add(i, rset.getInt("accumulated_bonus" + String.valueOf(i)));

}

}



query = null;



if(Config.DEBUG)

{

_log.info("SevenSignsFestival: Loaded data from database.");

}



rset.close();

statement.close();

rset = null;

statement = null;

}

catch(SQLException e)

{

if(Config.ENABLE_ALL_EXCEPTIONS)

e.printStackTrace();



_log.severe("SevenSignsFestival: Failed to load configuration: " + e);

}

finally

{

CloseUtil.close(con);

con = null;

}

}



/**

* Stores current festival data, basic settings to the properties file and past high score data to the database. If

* updateSettings = true, then all Seven Signs data is updated in the database.

*

* @param updateSettings the update settings

*/

public void saveFestivalData(boolean updateSettings)

{

Connection con = null;



if(Config.DEBUG)

{

_log.info("SevenSignsFestival: Saving festival data to disk.");

}



try

{

con = L2DatabaseFactory.getInstance().getConnection(false);

PreparedStatement statement = null;



for(Map<Integer, StatsSet> currCycleData : _festivalData.values())

{

for(StatsSet festivalDat : currCycleData.values())

{

int festivalCycle = festivalDat.getInteger("cycle");

int festivalId = festivalDat.getInteger("festivalId");

String cabal = festivalDat.getString("cabal");



// Try to update an existing record.

statement = con.prepareStatement("UPDATE seven_signs_festival SET date=?, score=?, members=? WHERE cycle=? AND cabal=? AND festivalId=?");

statement.setLong(1, Long.valueOf(festivalDat.getString("date")));

statement.setInt(2, festivalDat.getInteger("score"));

statement.setString(3, festivalDat.getString("members"));

statement.setInt(4, festivalCycle);

statement.setString(5, cabal);

statement.setInt(6, festivalId);



// If there was no record to update, assume it doesn't exist and add a new one,

// otherwise continue with the next record to store.

if(statement.executeUpdate() > 0)

{

if(Config.DEBUG)

{

_log.info("SevenSignsFestival: Updated data in DB (Cycle = " + festivalCycle + ", Cabal = " + cabal + ", FestID = " + festivalId + ")");

}



statement.close();

continue;

}



statement.close();



statement = con.prepareStatement("INSERT INTO seven_signs_festival (festivalId, cabal, cycle, date, score, members) VALUES (?,?,?,?,?,?)");

statement.setInt(1, festivalId);

statement.setString(2, cabal);

statement.setInt(3, festivalCycle);

statement.setLong(4, Long.valueOf(festivalDat.getString("date")));

statement.setInt(5, festivalDat.getInteger("score"));

statement.setString(6, festivalDat.getString("members"));

statement.execute();

statement.close();

statement = null;



if(Config.DEBUG)

{

_log.info("SevenSignsFestival: Inserted data in DB (Cycle = " + festivalCycle + ", Cabal = " + cabal + ", FestID = " + festivalId + ")");

}

cabal = null;

}

}



// Updates Seven Signs DB data also, so call only if really necessary.

if(updateSettings)

{

SevenSigns.getInstance().saveSevenSignsData(null, true);

}

}

catch(SQLException e)

{

if(Config.ENABLE_ALL_EXCEPTIONS)

e.printStackTrace();



_log.severe("SevenSignsFestival: Failed to save configuration: " + e);

}

finally

{

CloseUtil.close(con);

con = null;

}

}



/**

* If a clan member is a member of the highest-ranked party in the Festival of Darkness, 100 points are added per

* member.

*/

protected void rewardHighRanked()

{

String[] partyMembers;

StatsSet overallData = getOverallHighestScoreData(FESTIVAL_LEVEL_MAX_FOR_31);

if(overallData != null)

{

partyMembers = overallData.getString("members").split(",");

for(String partyMemberName : partyMembers)

{

addReputationPointsForPartyMemberClan(partyMemberName);

}

partyMembers = null;

}



overallData = getOverallHighestScoreData(FESTIVAL_LEVEL_MAX_FOR_42);

if(overallData != null)

{

partyMembers = overallData.getString("members").split(",");

for(String partyMemberName : partyMembers)

{

addReputationPointsForPartyMemberClan(partyMemberName);

}

partyMembers = null;

}



overallData = getOverallHighestScoreData(FESTIVAL_LEVEL_MAX_FOR_53);

if(overallData != null)

{

partyMembers = overallData.getString("members").split(",");

for(String partyMemberName : partyMembers)

{

addReputationPointsForPartyMemberClan(partyMemberName);

}

partyMembers = null;

}



overallData = getOverallHighestScoreData(FESTIVAL_LEVEL_MAX_FOR_64);

if(overallData != null)

{

partyMembers = overallData.getString("members").split(",");

for(String partyMemberName : partyMembers)

{

addReputationPointsForPartyMemberClan(partyMemberName);

}

partyMembers = null;

}



overallData = getOverallHighestScoreData(FESTIVAL_LEVEL_MAX_FOR_NONE);

if(overallData != null)

{

partyMembers = overallData.getString("members").split(",");

for(String partyMemberName : partyMembers)

{

addReputationPointsForPartyMemberClan(partyMemberName);

}

partyMembers = null;

}

overallData = null;

partyMembers = null;

}



/**

* Adds the reputation points for party member clan.

*

* @param partyMemberName the party member name

*/

private void addReputationPointsForPartyMemberClan(String partyMemberName)

{

L2PcInstance player = L2World.getInstance().getPlayer(partyMemberName);

if(player != null)

{

if(player.getClan() != null)

{

player.getClan().setReputationScore(player.getClan().getReputationScore() + 100, true);

player.getClan().broadcastToOnlineMembers(new PledgeShowInfoUpdate(player.getClan()));

SystemMessage sm = new SystemMessage(SystemMessageId.CLAN_MEMBER_S1_WAS_IN_HIGHEST_RANKED_PARTY_IN_FESTIVAL_OF_DARKNESS_AND_GAINED_S2_REPUTATION);

sm.addString(partyMemberName);

sm.addNumber(100);

player.getClan().broadcastToOnlineMembers(sm);

sm = null;

}

}

else

{

Connection con = null;



try

{

con = L2DatabaseFactory.getInstance().getConnection(false);

PreparedStatement statement = con.prepareStatement(GET_CLAN_NAME);

statement.setString(1, partyMemberName);

ResultSet rset = statement.executeQuery();

if(rset.next())

{

String clanName = rset.getString("clan_name");

if(clanName != null)

{

L2Clan clan = ClanTable.getInstance().getClanByName(clanName);

if(clan != null)

{

clan.setReputationScore(clan.getReputationScore() + 100, true);

clan.broadcastToOnlineMembers(new PledgeShowInfoUpdate(clan));

SystemMessage sm = new SystemMessage(SystemMessageId.CLAN_MEMBER_S1_WAS_IN_HIGHEST_RANKED_PARTY_IN_FESTIVAL_OF_DARKNESS_AND_GAINED_S2_REPUTATION);

sm.addString(partyMemberName);

sm.addNumber(100);

clan.broadcastToOnlineMembers(sm);

sm = null;

}

clan = null;

}

clanName = null;

}



rset.close();

statement.close();



rset = null;

statement = null;

}

catch(Exception e)

{

if(Config.ENABLE_ALL_EXCEPTIONS)

e.printStackTrace();



_log.warning("could not get clan name of " + partyMemberName + ": " + e);

}

finally

{

CloseUtil.close(con);

con = null;

}

}

}



/**

* Used to reset all festival data at the beginning of a new quest event period.

*

* @param updateSettings the update settings

*/

protected void resetFestivalData(boolean updateSettings)

{

_festivalCycle = 0;

_signsCycle = SevenSigns.getInstance().getCurrentCycle();



// Set all accumulated bonuses back to 0.

for(int i = 0; i < FESTIVAL_COUNT; i++)

{

_accumulatedBonuses.set(i, 0);

}



_dawnFestivalParticipants.clear();

_dawnPreviousParticipants.clear();

_dawnFestivalScores.clear();



_duskFestivalParticipants.clear();

_duskPreviousParticipants.clear();

_duskFestivalScores.clear();



// Set up a new data set for the current cycle of festivals

Map<Integer, StatsSet> newData = new FastMap<Integer, StatsSet>();



for(int i = 0; i < FESTIVAL_COUNT * 2; i++)

{

int festivalId = i;



if(i >= FESTIVAL_COUNT)

{

festivalId -= FESTIVAL_COUNT;

}



// Create a new StatsSet with "default" data for Dusk

StatsSet tempStats = new StatsSet();

tempStats.set("festivalId", festivalId);

tempStats.set("cycle", _signsCycle);

tempStats.set("date", "0");

tempStats.set("score", 0);

tempStats.set("members", "");



if(i >= FESTIVAL_COUNT)

{

tempStats.set("cabal", SevenSigns.getCabalShortName(SevenSigns.CABAL_DAWN));

}

else

{

tempStats.set("cabal", SevenSigns.getCabalShortName(SevenSigns.CABAL_DUSK));

}



newData.put(i, tempStats);

}



// Add the newly created cycle data to the existing festival data, and

// subsequently save it to the database.

_festivalData.put(_signsCycle, newData);



newData = null;



saveFestivalData(updateSettings);



// Remove any unused blood offerings from online players.

for(L2PcInstance onlinePlayer : L2World.getInstance().getAllPlayers())

{

try

{

L2ItemInstance bloodOfferings = onlinePlayer.getInventory().getItemByItemId(FESTIVAL_OFFERING_ID);



if(bloodOfferings != null)

{

onlinePlayer.destroyItem("SevenSigns", bloodOfferings, null, false);

}

bloodOfferings = null;

}

catch(NullPointerException e)

{

if(Config.ENABLE_ALL_EXCEPTIONS)

e.printStackTrace();

}

}



_log.info("SevenSignsFestival: Reinitialized engine for next competition period.");

}



/**

* Gets the current festival cycle.

*

* @return the current festival cycle

*/

public final int getCurrentFestivalCycle()

{

return _festivalCycle;

}



/**

* Checks if is festival initialized.

*

* @return true, if is festival initialized

*/

public final boolean isFestivalInitialized()

{

return _festivalInitialized;

}



/**

* Checks if is festival in progress.

*

* @return true, if is festival in progress

*/

public final boolean isFestivalInProgress()

{

return _festivalInProgress;

}



/**

* Sets the next cycle start.

*/

public void setNextCycleStart()

{

_nextFestivalCycleStart = System.currentTimeMillis() + Config.ALT_FESTIVAL_CYCLE_LENGTH;

}



/**

* Sets the next festival start.

*

* @param milliFromNow the new next festival start

*/

public void setNextFestivalStart(long milliFromNow)

{

_nextFestivalStart = System.currentTimeMillis() + milliFromNow;

}



/**

* Gets the mins to next cycle.

*

* @return the mins to next cycle

*/

public final int getMinsToNextCycle()

{

if(SevenSigns.getInstance().isSealValidationPeriod())

return -1;



return Math.round((_nextFestivalCycleStart - System.currentTimeMillis()) / 60000);

}



/**

* Gets the mins to next festival.

*

* @return the mins to next festival

*/

public final int getMinsToNextFestival()

{

if(SevenSigns.getInstance().isSealValidationPeriod())

return -1;



return Math.round((_nextFestivalStart - System.currentTimeMillis()) / 60000) + 1;

}



/**

* Gets the time to next festival start.

*

* @return the time to next festival start

*/

public final String getTimeToNextFestivalStart()

{

if(SevenSigns.getInstance().isSealValidationPeriod())

return "<font color=\"FF0000\">This is the Seal Validation period. Festivals will resume next week.</font>";



return "<font color=\"FF0000\">The next festival will begin in " + getMinsToNextFestival() + " minute(s).</font>";

}



/**

* Returns the current festival ID and oracle ID that the specified player is in, but will return the default of

* {-1, -1} if the player is not found as a participant.

*

* @param player the player

* @return int[] playerFestivalInfo

*/

public final int[] getFestivalForPlayer(L2PcInstance player)

{

int[] playerFestivalInfo =

{

-1, -1

};

int festivalId = 0;



while(festivalId < FESTIVAL_COUNT)

{

List<L2PcInstance> participants = _dawnFestivalParticipants.get(festivalId);



// If there are no participants in this festival, move on to the next.

if(participants != null && participants.contains(player))

{

playerFestivalInfo[0] = SevenSigns.CABAL_DAWN;

playerFestivalInfo[1] = festivalId;



return playerFestivalInfo;

}



festivalId++;



participants = _duskFestivalParticipants.get(festivalId);



if(participants != null && participants.contains(player))

{

playerFestivalInfo[0] = SevenSigns.CABAL_DUSK;

playerFestivalInfo[1] = festivalId;



return playerFestivalInfo;

}

participants = null;



festivalId++;

}



// Return default data if the player is not found as a participant.

return playerFestivalInfo;

}



/**

* Checks if is player participant.

*

* @param player the player

* @return true, if is player participant

*/

public final boolean isPlayerParticipant(L2PcInstance player)

{

if(SevenSigns.getInstance().isSealValidationPeriod())

return false;



if(_managerInstance == null)

return false;



for(List<L2PcInstance> participants : _dawnFestivalParticipants.values())

if(participants.contains(player))

return true;



for(List<L2PcInstance> participants : _duskFestivalParticipants.values())

if(participants.contains(player))

return true;



return false;

}



/**

* Gets the participants.

*

* @param oracle the oracle

* @param festivalId the festival id

* @return the participants

*/

public final List<L2PcInstance> getParticipants(int oracle, int festivalId)

{

if(oracle == SevenSigns.CABAL_DAWN)

return _dawnFestivalParticipants.get(festivalId);



return _duskFestivalParticipants.get(festivalId);

}



/**

* Gets the previous participants.

*

* @param oracle the oracle

* @param festivalId the festival id

* @return the previous participants

*/

public final List<L2PcInstance> getPreviousParticipants(int oracle, int festivalId)

{

if(oracle == SevenSigns.CABAL_DAWN)

return _dawnPreviousParticipants.get(festivalId);



return _duskPreviousParticipants.get(festivalId);

}



/**

* Sets the participants.

*

* @param oracle the oracle

* @param festivalId the festival id

* @param festivalParty the festival party

*/

public void setParticipants(int oracle, int festivalId, L2Party festivalParty)

{

List<L2PcInstance> participants = new FastList<L2PcInstance>();



if(festivalParty != null)

{

participants = festivalParty.getPartyMembers();



if(Config.DEBUG)

{

_log.info("SevenSignsFestival: " + festivalParty.getPartyMembers().toString() + " have signed up to the " + SevenSigns.getCabalShortName(oracle) + " " + getFestivalName(festivalId) + " festival.");

}

}



if(oracle == SevenSigns.CABAL_DAWN)

{

_dawnFestivalParticipants.put(festivalId, participants);

}

else

{

_duskFestivalParticipants.put(festivalId, participants);

}



participants = null;

}



/**

* Update participants.

*

* @param player the player

* @param festivalParty the festival party

*/

public void updateParticipants(L2PcInstance player, L2Party festivalParty)

{

if(!isPlayerParticipant(player))

return;



final int[] playerFestInfo = getFestivalForPlayer(player);

final int oracle = playerFestInfo[0];

final int festivalId = playerFestInfo[1];



if(festivalId > -1)

{

if(_festivalInitialized)

{

L2DarknessFestival festivalInst = _managerInstance.getFestivalInstance(oracle, festivalId);



if(festivalParty == null)

{

for(L2PcInstance partyMember : getParticipants(oracle, festivalId))

{

festivalInst.relocatePlayer(partyMember, true);

}

}

else

{

festivalInst.relocatePlayer(player, true);

}



festivalInst = null;

}



setParticipants(oracle, festivalId, festivalParty);

}

}



/**

* Gets the final score.

*

* @param oracle the oracle

* @param festivalId the festival id

* @return the final score

*/

public final int getFinalScore(int oracle, int festivalId)

{

if(oracle == SevenSigns.CABAL_DAWN)

return _dawnFestivalScores.get(festivalId);



return _duskFestivalScores.get(festivalId);

}



/**

* Gets the highest score.

*

* @param oracle the oracle

* @param festivalId the festival id

* @return the highest score

*/

public final int getHighestScore(int oracle, int festivalId)

{

return getHighestScoreData(oracle, festivalId).getInteger("score");

}



/**

* Returns a stats set containing the highest score <b>this cycle</b> for the the specified cabal and associated

* festival ID.

*

* @param oracle the oracle

* @param festivalId the festival id

* @return StatsSet festivalDat

*/

public final StatsSet getHighestScoreData(int oracle, int festivalId)

{

int offsetId = festivalId;



if(oracle == SevenSigns.CABAL_DAWN)

{

offsetId += 5;

}



// Attempt to retrieve existing score data (if found), otherwise create a

// new blank data set and display a console warning.

StatsSet currData = null;



if(_festivalData!=null && _festivalData.get(_signsCycle)!=null){

currData = _festivalData.get(_signsCycle).get(offsetId);

}else{

currData = new StatsSet();

currData.set("score", 0);

currData.set("members", "");



if(Config.DEBUG)

{

_log.info("SevenSignsFestival: Data missing for " + SevenSigns.getCabalName(oracle) + ", FestivalID = " + festivalId + " (Current Cycle " + _signsCycle + ")");

}

}



return currData;

}



/**

* Returns a stats set containing the highest ever recorded score data for the specified festival.

*

* @param festivalId the festival id

* @return StatsSet result

*/

public final StatsSet getOverallHighestScoreData(int festivalId)

{

StatsSet result = null;

int highestScore = 0;



for(Map<Integer, StatsSet> currCycleData : _festivalData.values())

{

for(StatsSet currFestData : currCycleData.values())

{

int currFestID = currFestData.getInteger("festivalId");

int festivalScore = currFestData.getInteger("score");



if(currFestID != festivalId)

{

continue;

}



if(festivalScore > highestScore)

{

highestScore = festivalScore;

result = currFestData;

}

}

}



return result;

}



/**

* Set the final score details for the last participants of the specified festival data. Returns <b>true</b> if the

* score is higher than that previously recorded <b>this cycle</b>.

*

* @param player the player

* @param oracle the oracle

* @param festivalId the festival id

* @param offeringScore the offering score

* @return boolean isHighestScore

*/

public boolean setFinalScore(L2PcInstance player, int oracle, int festivalId, int offeringScore)

{

List<String> partyMembers;



int currDawnHighScore = getHighestScore(SevenSigns.CABAL_DAWN, festivalId);

int currDuskHighScore = getHighestScore(SevenSigns.CABAL_DUSK, festivalId);



int thisCabalHighScore = 0;

int otherCabalHighScore = 0;



if(oracle == SevenSigns.CABAL_DAWN)

{

thisCabalHighScore = currDawnHighScore;

otherCabalHighScore = currDuskHighScore;



_dawnFestivalScores.put(festivalId, offeringScore);

}

else

{

thisCabalHighScore = currDuskHighScore;

otherCabalHighScore = currDawnHighScore;



_duskFestivalScores.put(festivalId, offeringScore);

}



StatsSet currFestData = getHighestScoreData(oracle, festivalId);



// Check if this is the highest score for this level range so far for the player's cabal.

if(offeringScore > thisCabalHighScore)

{

// If the current score is greater than that for the other cabal,

// then they already have the points from this festival.

if(thisCabalHighScore > otherCabalHighScore)

return false;



partyMembers = new FastList<String>();

List<L2PcInstance> prevParticipants = getPreviousParticipants(oracle, festivalId);



// Record a string list of the party members involved.

for(L2PcInstance partyMember : prevParticipants)

{

try

{

partyMembers.add(partyMember.getName());

}

catch(NullPointerException e)

{

if(Config.ENABLE_ALL_EXCEPTIONS)

e.printStackTrace();

}

}

prevParticipants = null;



// Update the highest scores and party list.

currFestData.set("date", String.valueOf(System.currentTimeMillis()));

currFestData.set("score", offeringScore);

currFestData.set("members", Util.implodeString(partyMembers, ","));

partyMembers = null;



if(Config.DEBUG)

{

_log.info("SevenSignsFestival: " + player.getName() + "'s party has the highest score (" + offeringScore + ") so far for " + SevenSigns.getCabalName(oracle) + " in " + getFestivalName(festivalId));

}



// Only add the score to the cabal's overall if it's higher than the other cabal's score.

if(offeringScore > otherCabalHighScore)

{

int contribPoints = FESTIVAL_LEVEL_SCORES[festivalId];



// Give this cabal the festival points, while deducting them from the other.

SevenSigns.getInstance().addFestivalScore(oracle, contribPoints);



//if (Config.DEBUG)

_log.info("SevenSignsFestival: This is the highest score overall so far for the " + getFestivalName(festivalId) + " festival!");

}



saveFestivalData(true);



return true;

}



return false;

}



/**

* Gets the accumulated bonus.

*

* @param festivalId the festival id

* @return the accumulated bonus

*/

public final int getAccumulatedBonus(int festivalId)

{

return _accumulatedBonuses.get(festivalId);

}



/**

* Gets the total accumulated bonus.

*

* @return the total accumulated bonus

*/

public final int getTotalAccumulatedBonus()

{

int totalAccumBonus = 0;



for(int accumBonus : _accumulatedBonuses)

{

totalAccumBonus += accumBonus;

}



return totalAccumBonus;

}



/**

* Adds the accumulated bonus.

*

* @param festivalId the festival id

* @param stoneType the stone type

* @param stoneAmount the stone amount

*/

public void addAccumulatedBonus(int festivalId, int stoneType, int stoneAmount)

{

int eachStoneBonus = 0;



switch(stoneType)

{

case SevenSigns.SEAL_STONE_BLUE_ID:

eachStoneBonus = SevenSigns.SEAL_STONE_BLUE_VALUE;

break;

case SevenSigns.SEAL_STONE_GREEN_ID:

eachStoneBonus = SevenSigns.SEAL_STONE_GREEN_VALUE;

break;

case SevenSigns.SEAL_STONE_RED_ID:

eachStoneBonus = SevenSigns.SEAL_STONE_RED_VALUE;

break;

}



int newTotalBonus = _accumulatedBonuses.get(festivalId) + stoneAmount * eachStoneBonus;

_accumulatedBonuses.set(festivalId, newTotalBonus);

}



/**

* Calculate and return the proportion of the accumulated bonus for the festival where the player was in the winning

* party, if the winning party's cabal won the event. The accumulated bonus is then updated, with the player's share

* deducted.

*

* @param player the player

* @return playerBonus (the share of the bonus for the party)

*/

public final int distribAccumulatedBonus(L2PcInstance player)

{

int playerBonus = 0;

String playerName = player.getName();

int playerCabal = SevenSigns.getInstance().getPlayerCabal(player);



if(playerCabal != SevenSigns.getInstance().getCabalHighestScore())

return 0;



if(_festivalData.get(_signsCycle) != null)

{

for(StatsSet festivalData : _festivalData.get(_signsCycle).values())

{

if(festivalData.getString("members").indexOf(playerName) > -1)

{

int festivalId = festivalData.getInteger("festivalId");

int numPartyMembers = festivalData.getString("members").split(",").length;

int totalAccumBonus = _accumulatedBonuses.get(festivalId);



playerBonus = totalAccumBonus / numPartyMembers;

_accumulatedBonuses.set(festivalId, totalAccumBonus - playerBonus);

playerName = null;

break;

}

}

}

return playerBonus;

}



/**

* Used to send a "shout" message to all players currently present in an Oracle. Primarily used for Festival Guide

* and Witch related speech.

*

* @param senderName the sender name

* @param message the message

*/

public void sendMessageToAll(String senderName, String message)

{

if(_dawnChatGuide == null || _duskChatGuide == null)

return;



CreatureSay cs = new CreatureSay(_dawnChatGuide.getObjectId(), 1, senderName, message);

_dawnChatGuide.broadcastPacket(cs);

cs = null;



cs = new CreatureSay(_duskChatGuide.getObjectId(), 1, senderName, message);

_duskChatGuide.broadcastPacket(cs);

cs = null;

}



/**

* Basically a wrapper-call to signal to increase the challenge of the specified festival.

*

* @param oracle the oracle

* @param festivalId the festival id

* @return boolean isChalIncreased

*/

public final boolean increaseChallenge(int oracle, int festivalId)

{

L2DarknessFestival festivalInst = _managerInstance.getFestivalInstance(oracle, festivalId);



return festivalInst.increaseChallenge();

}



/**

* The Class RestoreStatus.

*/

protected class RestoreStatus implements Runnable

{



/* (non-Javadoc)

* @see java.lang.Runnable#run()

*/

@Override

public void run()

{



}

}



/**

* Used with the SpawnListener, to update the required "chat guide" instances, for use with announcements in the

* oracles.

*

* @param npc the npc

*/

@Override

public void npcSpawned(L2NpcInstance npc)

{

if(npc == null)

return;



int npcId = npc.getNpcId();



// If the spawned NPC ID matches the ones we need, assign their instances.

if(npcId == 31127)

{

if(Config.DEBUG)

{

_log.config("SevenSignsFestival: Instance found for NPC ID 31127 (" + npc.getObjectId() + ").");

}



_dawnChatGuide = npc;

}



if(npcId == 31137)

{

if(Config.DEBUG)

{

_log.config("SevenSignsFestival: Instance found for NPC ID 31137 (" + npc.getObjectId() + ").");

}



_duskChatGuide = npc;

}

}



/**

* The FestivalManager class is the main runner of all the festivals. It is used for easier integration and

* management of all running festivals.

* 

* @author Tempy

*/

private class FestivalManager implements Runnable

{



/** The _festival instances. */

protected Map<Integer, L2DarknessFestival> _festivalInstances;



/**

* Instantiates a new festival manager.

*/

public FestivalManager()

{

_festivalInstances = new FastMap<Integer, L2DarknessFestival>();

_managerInstance = this;



// Increment the cycle counter.

_festivalCycle++;



// Set the next start timers.

setNextCycleStart();

setNextFestivalStart(Config.ALT_FESTIVAL_CYCLE_LENGTH - FESTIVAL_SIGNUP_TIME);

}



/* (non-Javadoc)

* @see java.lang.Runnable#run()

*/

@Override

public synchronized void run()

{

// The manager shouldn't be running if Seal Validation is in effect.

if(SevenSigns.getInstance().isSealValidationPeriod())

return;



// If the next period is due to start before the end of this

// festival cycle, then don't run it.

if(SevenSigns.getInstance().getMilliToPeriodChange() < Config.ALT_FESTIVAL_CYCLE_LENGTH)

return;



if(Config.DEBUG)

{

_log.info("SevenSignsFestival: Festival manager initialized. Those wishing to participate have " + getMinsToNextFestival() + " minute(s) to sign up.");

}



sendMessageToAll("Festival Guide", "The main event will start in " + getMinsToNextFestival() + " minutes. Please register now.");



// Stand by until the allowed signup period has elapsed.

try

{

wait(FESTIVAL_SIGNUP_TIME);

}

catch(InterruptedException e)

{

if(Config.ENABLE_ALL_EXCEPTIONS)

e.printStackTrace();

}



// Clear past participants, they can no longer register their score if not done so already.

_dawnPreviousParticipants.clear();

_duskPreviousParticipants.clear();



// Get rid of random monsters that avoided deletion after last festival

for(L2DarknessFestival festivalInst : _festivalInstances.values())

{

festivalInst.unspawnMobs();

}



/* INITIATION */

// Set the festival timer to 0, as it is just beginning.

long elapsedTime = 0;



// Create the instances for the festivals in both Oracles,

// but only if they have participants signed up for them.

for(int i = 0; i < FESTIVAL_COUNT; i++)

{

if(_duskFestivalParticipants.get(i) != null)

{

_festivalInstances.put(10 + i, new L2DarknessFestival(SevenSigns.CABAL_DUSK, i));

}



if(_dawnFestivalParticipants.get(i) != null)

{

_festivalInstances.put(20 + i, new L2DarknessFestival(SevenSigns.CABAL_DAWN, i));

}

}



// Prevent future signups while festival is in progress.

_festivalInitialized = true;



setNextFestivalStart(Config.ALT_FESTIVAL_CYCLE_LENGTH);

sendMessageToAll("Festival Guide", "The main event is now starting.");



if(Config.DEBUG)

{

_log.info("SevenSignsFestival: The current set of festivals will begin in " + Config.ALT_FESTIVAL_FIRST_SPAWN / 60000 + " minute(s).");

}



// Stand by for a short length of time before starting the festival.

try

{

wait(Config.ALT_FESTIVAL_FIRST_SPAWN);

}

catch(InterruptedException e)

{

if(Config.ENABLE_ALL_EXCEPTIONS)

e.printStackTrace();

}



elapsedTime = Config.ALT_FESTIVAL_FIRST_SPAWN;



// Participants can now opt to increase the challenge, if desired.

_festivalInProgress = true;



/* PROPOGATION */

// Sequentially set all festivals to begin, spawn the Festival Witch and notify participants.

for(L2DarknessFestival festivalInst : _festivalInstances.values())

{

festivalInst.festivalStart();

festivalInst.sendMessageToParticipants("The festival is about to begin!");

}



if(Config.DEBUG)

{

_log.info("SevenSignsFestival: Each of the festivals will end in " + Config.ALT_FESTIVAL_LENGTH / 60000 + " minutes. New participants can signup then.");

}



// After a short time period, move all idle spawns to the center of the arena.

try

{

wait(Config.ALT_FESTIVAL_FIRST_SWARM - Config.ALT_FESTIVAL_FIRST_SPAWN);

}

catch(InterruptedException e)

{

if(Config.ENABLE_ALL_EXCEPTIONS)

e.printStackTrace();

}



elapsedTime += Config.ALT_FESTIVAL_FIRST_SWARM - Config.ALT_FESTIVAL_FIRST_SPAWN;



for(L2DarknessFestival festivalInst : _festivalInstances.values())

{

festivalInst.moveMonstersToCenter();

}



// Stand by until the time comes for the second spawn.

try

{

wait(Config.ALT_FESTIVAL_SECOND_SPAWN - Config.ALT_FESTIVAL_FIRST_SWARM);

}

catch(InterruptedException e)

{

if(Config.ENABLE_ALL_EXCEPTIONS)

e.printStackTrace();

}



// Spawn an extra set of monsters (archers) on the free platforms with

// a faster respawn when killed.

for(L2DarknessFestival festivalInst : _festivalInstances.values())

{

festivalInst.spawnFestivalMonsters(FESTIVAL_DEFAULT_RESPAWN / 2, 2);

festivalInst.sendMessageToParticipants("The festival will end in " + (Config.ALT_FESTIVAL_LENGTH - Config.ALT_FESTIVAL_SECOND_SPAWN) / 60000 + " minute(s).");

}



elapsedTime += Config.ALT_FESTIVAL_SECOND_SPAWN - Config.ALT_FESTIVAL_FIRST_SWARM;



// After another short time period, again move all idle spawns to the center of the arena.

try

{

wait(Config.ALT_FESTIVAL_SECOND_SWARM - Config.ALT_FESTIVAL_SECOND_SPAWN);

}

catch(InterruptedException e)

{

if(Config.ENABLE_ALL_EXCEPTIONS)

e.printStackTrace();

}



for(L2DarknessFestival festivalInst : _festivalInstances.values())

{

festivalInst.moveMonstersToCenter();

}



elapsedTime += Config.ALT_FESTIVAL_SECOND_SWARM - Config.ALT_FESTIVAL_SECOND_SPAWN;



// Stand by until the time comes for the chests to be spawned.

try

{

wait(Config.ALT_FESTIVAL_CHEST_SPAWN - Config.ALT_FESTIVAL_SECOND_SWARM);

}

catch(InterruptedException e)

{

if(Config.ENABLE_ALL_EXCEPTIONS)

e.printStackTrace();

}



// Spawn the festival chests, which enable the team to gain greater rewards

// for each chest they kill.

for(L2DarknessFestival festivalInst : _festivalInstances.values())

{

festivalInst.spawnFestivalMonsters(FESTIVAL_DEFAULT_RESPAWN, 3);

festivalInst.sendMessageToParticipants("The chests have spawned! Be quick, the festival will end soon.");

}



elapsedTime += Config.ALT_FESTIVAL_CHEST_SPAWN - Config.ALT_FESTIVAL_SECOND_SWARM;



// Stand by and wait until it's time to end the festival.

try

{

wait(Config.ALT_FESTIVAL_LENGTH - elapsedTime);

}

catch(InterruptedException e)

{

if(Config.ENABLE_ALL_EXCEPTIONS)

e.printStackTrace();

}



// Participants can no longer opt to increase the challenge, as the festival will soon close.

_festivalInProgress = false;



/* TERMINATION */

// Sequentially begin the ending sequence for all running festivals.

for(L2DarknessFestival festivalInst : _festivalInstances.values())

{

festivalInst.festivalEnd();

}



// Clear the participants list for the next round of signups.

_dawnFestivalParticipants.clear();

_duskFestivalParticipants.clear();



// Allow signups for the next festival cycle.

_festivalInitialized = false;



sendMessageToAll("Festival Witch", "That will do! I'll move you to the outside soon.");



if(Config.DEBUG)

{

_log.info("SevenSignsFestival: The next set of festivals begin in " + getMinsToNextFestival() + " minute(s).");

}

}



/**

* Returns the running instance of a festival for the given Oracle and festivalID. <BR>

* A <B>null</B> value is returned if there are no participants in that festival.

*

* @param oracle the oracle

* @param festivalId the festival id

* @return L2DarknessFestival festivalInst

*/

public final L2DarknessFestival getFestivalInstance(int oracle, int festivalId)

{

if(!isFestivalInitialized())

return null;



/* Compute the offset if a Dusk instance is required.

*

* ID:      0   1   2   3   4

* Dusk 1:  10  11  12  13  14

* Dawn 2:  20  21  22  23  24

*/



festivalId += oracle == SevenSigns.CABAL_DUSK ? 10 : 20;

return _festivalInstances.get(festivalId);

}



/**

* Returns the number of currently running festivals <b>WITH</b> participants.

* 

* @return int Count

*/

/*public final int getInstanceCount()

{

   return _festivalInstances.size();

}*/

}



/**

* Each running festival is represented by an L2DarknessFestival class. It contains all the spawn information and

* data for the running festival. All festivals are managed by the FestivalManager class, which must be initialized

* first.

* 

* @author Tempy

*/

private class L2DarknessFestival

{



/** The _cabal. */

protected final int _cabal;



/** The _level range. */

protected final int _levelRange;



/** The _challenge increased. */

protected boolean _challengeIncreased;



/** The _start location. */

private FestivalSpawn _startLocation;



/** The _witch spawn. */

private FestivalSpawn _witchSpawn;



/** The _witch inst. */

private L2NpcInstance _witchInst;



/** The _npc insts. */

private List<L2FestivalMonsterInstance> _npcInsts;



/** The _participants. */

private List<L2PcInstance> _participants;



/** The _original locations. */

private Map<L2PcInstance, FestivalSpawn> _originalLocations;



/**

* Instantiates a new l2 darkness festival.

*

* @param cabal the cabal

* @param levelRange the level range

*/

protected L2DarknessFestival(int cabal, int levelRange)

{

_cabal = cabal;

_levelRange = levelRange;

_originalLocations = new FastMap<L2PcInstance, FestivalSpawn>();

_npcInsts = new FastList<L2FestivalMonsterInstance>();



if(cabal == SevenSigns.CABAL_DAWN)

{

_participants = _dawnFestivalParticipants.get(levelRange);

_witchSpawn = new FestivalSpawn(FESTIVAL_DAWN_WITCH_SPAWNS[levelRange]);

_startLocation = new FestivalSpawn(FESTIVAL_DAWN_PLAYER_SPAWNS[levelRange]);

}

else

{

_participants = _duskFestivalParticipants.get(levelRange);

_witchSpawn = new FestivalSpawn(FESTIVAL_DUSK_WITCH_SPAWNS[levelRange]);

_startLocation = new FestivalSpawn(FESTIVAL_DUSK_PLAYER_SPAWNS[levelRange]);

}



// FOR TESTING!

if(_participants == null)

{

_participants = new FastList<L2PcInstance>();

}



festivalInit();

}



/**

* Festival init.

*/

protected void festivalInit()

{

boolean isPositive;



if(Config.DEBUG)

{

_log.info("SevenSignsFestival: Initializing festival for " + SevenSigns.getCabalShortName(_cabal) + " (" + getFestivalName(_levelRange) + ")");

}



// Teleport all players to arena and notify them.

if(_participants.size() > 0)

{

try

{

for(L2PcInstance participant : _participants)

{

_originalLocations.put(participant, new FestivalSpawn(participant.getX(), participant.getY(), participant.getZ(), participant.getHeading()));



// Randomize the spawn point around the specific centerpoint for each player.

int x = _startLocation._x;

int y = _startLocation._y;



isPositive = Rnd.nextInt(2) == 1;



if(isPositive)

{

x += Rnd.nextInt(FESTIVAL_MAX_OFFSET_X);

y += Rnd.nextInt(FESTIVAL_MAX_OFFSET_Y);

}

else

{

x -= Rnd.nextInt(FESTIVAL_MAX_OFFSET_X);

y -= Rnd.nextInt(FESTIVAL_MAX_OFFSET_Y);

}



participant.getAI().setIntention(CtrlIntention.AI_INTENTION_IDLE);

participant.teleToLocation(x, y, _startLocation._z, true);



// Remove all buffs from all participants on entry. Works like the skill Cancel.

participant.stopAllEffects();



// Remove any stray blood offerings in inventory

L2ItemInstance bloodOfferings = participant.getInventory().getItemByItemId(FESTIVAL_OFFERING_ID);

if(bloodOfferings != null)

{

participant.destroyItem("SevenSigns", bloodOfferings, null, true);

}

}

}

catch(NullPointerException e)

{

// deleteMe handling should teleport party out in case of disconnect

if(Config.ENABLE_ALL_EXCEPTIONS)

e.printStackTrace();

}

}



L2NpcTemplate witchTemplate = NpcTable.getInstance().getTemplate(_witchSpawn._npcId);



// Spawn the festival witch for this arena

try

{

L2Spawn npcSpawn = new L2Spawn(witchTemplate);



npcSpawn.setLocx(_witchSpawn._x);

npcSpawn.setLocy(_witchSpawn._y);

npcSpawn.setLocz(_witchSpawn._z);

npcSpawn.setHeading(_witchSpawn._heading);

npcSpawn.setAmount(1);

npcSpawn.setRespawnDelay(1);



// Needed as doSpawn() is required to be called also for the NpcInstance it returns.

npcSpawn.startRespawn();



SpawnTable.getInstance().addNewSpawn(npcSpawn, false);

_witchInst = npcSpawn.doSpawn();



if(Config.DEBUG)

{

_log.fine("SevenSignsFestival: Spawned the Festival Witch " + npcSpawn.getNpcid() + " at " + _witchSpawn._x + " " + _witchSpawn._y + " " + _witchSpawn._z);

}



npcSpawn = null;

}

catch(Exception e)

{

if(Config.ENABLE_ALL_EXCEPTIONS)

e.printStackTrace();



_log.warning("SevenSignsFestival: Error while spawning Festival Witch ID " + _witchSpawn._npcId + ": " + e);

}



// Make it appear as though the Witch has apparated there.

MagicSkillUser msu = new MagicSkillUser(_witchInst, _witchInst, 2003, 1, 1, 0);

_witchInst.broadcastPacket(msu);

msu = null;



// And another one... :D

msu = new MagicSkillUser(_witchInst, _witchInst, 2133, 1, 1, 0);

_witchInst.broadcastPacket(msu);

msu = null;



// Send a message to all participants from the witch.

sendMessageToParticipants("The festival will begin in 2 minutes.");

}



/**

* Festival start.

*/

protected void festivalStart()

{

if(Config.DEBUG)

{

_log.info("SevenSignsFestival: Starting festival for " + SevenSigns.getCabalShortName(_cabal) + " (" + getFestivalName(_levelRange) + ")");

}



spawnFestivalMonsters(FESTIVAL_DEFAULT_RESPAWN, 0);

}



/**

* Move monsters to center.

*/

protected void moveMonstersToCenter()

{

boolean isPositive;



if(Config.DEBUG)

{

_log.info("SevenSignsFestival: Moving spawns to arena center for festival " + SevenSigns.getCabalShortName(_cabal) + " (" + getFestivalName(_levelRange) + ")");

}



for(L2FestivalMonsterInstance festivalMob : _npcInsts)

{

if(festivalMob.isDead())

{

continue;

}



// Only move monsters that are idle or doing their usual functions.

CtrlIntention currIntention = festivalMob.getAI().getIntention();



if(currIntention != CtrlIntention.AI_INTENTION_IDLE && currIntention != CtrlIntention.AI_INTENTION_ACTIVE)

{

continue;

}



int x = _startLocation._x;

int y = _startLocation._y;



/*

* Random X and Y coords around the player start location, up to half of the

* maximum allowed offset are generated to prevent the mobs from all moving

* to the exact same place.

*/

isPositive = Rnd.nextInt(2) == 1;



if(isPositive)

{

x += Rnd.nextInt(FESTIVAL_MAX_OFFSET_X);

y += Rnd.nextInt(FESTIVAL_MAX_OFFSET_Y);

}

else

{

x -= Rnd.nextInt(FESTIVAL_MAX_OFFSET_X);

y -= Rnd.nextInt(FESTIVAL_MAX_OFFSET_Y);

}



L2CharPosition moveTo = new L2CharPosition(x, y, _startLocation._z, Rnd.nextInt(65536));



festivalMob.setRunning();

festivalMob.getAI().setIntention(CtrlIntention.AI_INTENTION_MOVE_TO, moveTo);

moveTo = null;

}

}



/*public void setSpawnRate(int respawnDelay)

{

   if (Config.DEBUG)

       _log.info("SevenSignsFestival: Modifying spawn rate of festival mobs to " + respawnDelay + " ms for festival " + SevenSigns.getCabalShortName(_cabal) + " (" + getFestivalName(_levelRange) + ")");



   for (L2FestivalMonsterInstance monsterInst : _npcInsts)

       monsterInst.getSpawn().setRespawnDelay(respawnDelay);

}*/



/**

* Used to spawn monsters unique to the festival. <BR>

* Valid SpawnTypes:<BR>

* 0 - All Primary Monsters (starting monsters) <BR>

* 1 - Same as 0, but without archers/marksmen. (used for challenge increase) <BR>

* 2 - Secondary Monsters (archers) <BR>

* 3 - Festival Chests

*

* @param respawnDelay the respawn delay

* @param spawnType the spawn type

*/

protected void spawnFestivalMonsters(int respawnDelay, int spawnType)

{

int[][] _npcSpawns = null;



switch(spawnType)

{

case 0:

case 1:

_npcSpawns = _cabal == SevenSigns.CABAL_DAWN ? FESTIVAL_DAWN_PRIMARY_SPAWNS[_levelRange] : FESTIVAL_DUSK_PRIMARY_SPAWNS[_levelRange];

break;

case 2:

_npcSpawns = _cabal == SevenSigns.CABAL_DAWN ? FESTIVAL_DAWN_SECONDARY_SPAWNS[_levelRange] : FESTIVAL_DUSK_SECONDARY_SPAWNS[_levelRange];

break;

case 3:

_npcSpawns = _cabal == SevenSigns.CABAL_DAWN ? FESTIVAL_DAWN_CHEST_SPAWNS[_levelRange] : FESTIVAL_DUSK_CHEST_SPAWNS[_levelRange];

break;

default:

return;

}



for(int[] npcSpawn2 : _npcSpawns)

{

FestivalSpawn currSpawn = new FestivalSpawn(npcSpawn2);



// Only spawn archers/marksmen if specified to do so.

if(spawnType == 1 && isFestivalArcher(currSpawn._npcId))

{

continue;

}



L2NpcTemplate npcTemplate = NpcTable.getInstance().getTemplate(currSpawn._npcId);



try

{

L2Spawn npcSpawn = new L2Spawn(npcTemplate);



npcSpawn.setLocx(currSpawn._x);

npcSpawn.setLocy(currSpawn._y);

npcSpawn.setLocz(currSpawn._z);

npcSpawn.setHeading(Rnd.nextInt(65536));

npcSpawn.setAmount(1);

npcSpawn.setRespawnDelay(respawnDelay);



// Needed as doSpawn() is required to be called also for the NpcInstance it returns.

npcSpawn.startRespawn();



SpawnTable.getInstance().addNewSpawn(npcSpawn, false);

L2FestivalMonsterInstance festivalMob = (L2FestivalMonsterInstance) npcSpawn.doSpawn();



// Set the offering bonus to 2x or 5x the amount per kill,

// if this spawn is part of an increased challenge or is a festival chest.

if(spawnType == 1)

{

festivalMob.setOfferingBonus(2);

}

else if(spawnType == 3)

{

festivalMob.setOfferingBonus(5);

}



_npcInsts.add(festivalMob);



if(Config.DEBUG)

{

_log.fine("SevenSignsFestival: Spawned NPC ID " + currSpawn._npcId + " at " + currSpawn._x + " " + currSpawn._y + " " + currSpawn._z);

}

}

catch(Exception e)

{

if(Config.ENABLE_ALL_EXCEPTIONS)

e.printStackTrace();



_log.warning("SevenSignsFestival: Error while spawning NPC ID " + currSpawn._npcId + ": " + e);

}

}

}



/**

* Increase challenge.

*

* @return true, if successful

*/

protected boolean increaseChallenge()

{

if(_challengeIncreased)

return false;



// Set this flag to true to make sure that this can only be done once.

_challengeIncreased = true;



if(Config.DEBUG)

{

_log.info("SevenSignsFestival: " + _participants.get(0).getName() + "'s team have opted to increase the festival challenge!");

}



// Spawn more festival monsters, but this time with a twist.

spawnFestivalMonsters(FESTIVAL_DEFAULT_RESPAWN, 1);

return true;

}



/**

* Send message to participants.

*

* @param message the message

*/

public void sendMessageToParticipants(String message)

{

if(_participants.size() > 0)

{

CreatureSay cs = new CreatureSay(_witchInst.getObjectId(), 0, "Festival Witch", message);



for(L2PcInstance participant : _participants)

{

try

{

participant.sendPacket(cs);

cs = null;

}

catch(NullPointerException e)

{

if(Config.ENABLE_ALL_EXCEPTIONS)

e.printStackTrace();

}

}

}

}



/**

* Festival end.

*/

protected void festivalEnd()

{

if(Config.DEBUG)

{

_log.info("SevenSignsFestival: Ending festival for " + SevenSigns.getCabalShortName(_cabal) + " (" + getFestivalName(_levelRange) + ")");

}



if(_participants.size() > 0)

{

for(L2PcInstance participant : _participants)

{

try

{

relocatePlayer(participant, false);

participant.sendMessage("The festival has ended. Your party leader must now register your score before the next festival takes place.");

}

catch(NullPointerException e)

{

if(Config.ENABLE_ALL_EXCEPTIONS)

e.printStackTrace();

}

}



if(_cabal == SevenSigns.CABAL_DAWN)

{

_dawnPreviousParticipants.put(_levelRange, _participants);

}

else

{

_duskPreviousParticipants.put(_levelRange, _participants);

}

}

_participants = null;



unspawnMobs();

}



/**

* Unspawn mobs.

*/

protected void unspawnMobs()

{

// Delete all the NPCs in the current festival arena.

if(_witchInst != null)

{

_witchInst.deleteMe();

}



if(_npcInsts != null)

{

for(L2FestivalMonsterInstance monsterInst : _npcInsts)

if(monsterInst != null)

{

monsterInst.deleteMe();

}

}

}



/**

* Relocate player.

*

* @param participant the participant

* @param isRemoving the is removing

*/

public void relocatePlayer(L2PcInstance participant, boolean isRemoving)

{

try

{

FestivalSpawn origPosition = _originalLocations.get(participant);



if(isRemoving)

{

_originalLocations.remove(participant);

}



participant.getAI().setIntention(CtrlIntention.AI_INTENTION_IDLE);

participant.teleToLocation(origPosition._x, origPosition._y, origPosition._z, true);

origPosition = null;

participant.sendMessage("You have been removed from the festival arena.");

}

catch(Exception e)

{

if(Config.ENABLE_ALL_EXCEPTIONS)

e.printStackTrace();



// If an exception occurs, just move the player to the nearest town.

try

{

participant.teleToLocation(MapRegionTable.TeleportWhereType.Town);

participant.sendMessage("You have been removed from the festival arena.");

}

catch(NullPointerException e2)

{

if(Config.ENABLE_ALL_EXCEPTIONS)

e2.printStackTrace();

}

}

}

}



/**

* The Class FestivalSpawn.

*/

private class FestivalSpawn

{



/** The _x. */

protected final int _x;



/** The _y. */

protected final int _y;



/** The _z. */

protected final int _z;



/** The _heading. */

protected final int _heading;



/** The _npc id. */

protected final int _npcId;



/**

* Instantiates a new festival spawn.

*

* @param x the x

* @param y the y

* @param z the z

* @param heading the heading

*/

protected FestivalSpawn(int x, int y, int z, int heading)

{

_x = x;

_y = y;

_z = z;



// Generate a random heading if no positive one given.

_heading = heading < 0 ? Rnd.nextInt(65536) : heading;



_npcId = -1;

}



/**

* Instantiates a new festival spawn.

*

* @param spawnData the spawn data

*/

protected FestivalSpawn(int[] spawnData)

{

_x = spawnData[0];

_y = spawnData[1];

_z = spawnData[2];



_heading = spawnData[3] < 0 ? Rnd.nextInt(65536) : spawnData[3];



if(spawnData.length > 4)

{

_npcId = spawnData[4];

}

else

{

_npcId = -1;

}

}

}

}

SweeTs · March 27, 2016

No one is gonna help you with this.

EloBoost · March 27, 2016

Why mate?

Help Seven Sign

Question

EloBoost

5 answers to this question

Recommended Posts

EloBoost

EloBoost

EloBoost

SweeTs

EloBoost

Create an account or sign in to comment

Create an account

Sign in

Posts

Topics

Browse

Activity

Store

Important Information