/*
* 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 3 of the License, 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, see <http://www.gnu.org/licenses/>.
*/
package silentium.gameserver.model.quest;
import java.lang.reflect.Array;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import javolution.util.FastList;
import javolution.util.FastMap;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import silentium.commons.database.DatabaseFactory;
import silentium.commons.utils.Rnd;
import silentium.commons.utils.Util;
import silentium.gameserver.ThreadPoolManager;
import silentium.gameserver.configs.MainConfig;
import silentium.gameserver.configs.PlayersConfig;
import silentium.gameserver.data.html.HtmCache;
import silentium.gameserver.data.html.StaticHtmPath;
import silentium.gameserver.instancemanager.QuestManager;
import silentium.gameserver.instancemanager.ZoneManager;
import silentium.gameserver.model.L2Clan;
import silentium.gameserver.model.L2Object;
import silentium.gameserver.model.L2Party;
import silentium.gameserver.model.L2Skill;
import silentium.gameserver.model.L2Spawn;
import silentium.gameserver.model.actor.L2Character;
import silentium.gameserver.model.actor.L2Npc;
import silentium.gameserver.model.actor.instance.L2MonsterInstance;
import silentium.gameserver.model.actor.instance.L2PcInstance;
import silentium.gameserver.model.zone.L2ZoneType;
import silentium.gameserver.network.clientpackets.Say2;
import silentium.gameserver.network.serverpackets.ActionFailed;
import silentium.gameserver.network.serverpackets.NpcHtmlMessage;
import silentium.gameserver.scripting.ManagedScript;
import silentium.gameserver.scripting.ScriptManager;
import silentium.gameserver.tables.NpcTable;
import silentium.gameserver.templates.chars.L2NpcTemplate;
import silentium.gameserver.utils.MinionList;
/**
* @author Luis Arias
*/
public class Quest extends ManagedScript
{
protected static final Logger _log = LoggerFactory.getLogger(Quest.class.getName());
/**
* HashMap containing events from String value of the event
*/
private static Map<String, Quest> _allEventsS = new FastMap<>();
/**
* HashMap containing lists of timers from the name of the timer
*/
private final Map<String, FastList<QuestTimer>> _allEventTimers = new FastMap<String, FastList<QuestTimer>>().shared();
private final ReentrantReadWriteLock _rwLock = new ReentrantReadWriteLock();
private final int _questId;
private final String _name;
private final String _dname;
private final String _path;
private final byte _initialState = State.CREATED;
protected boolean _onEnterWorld = false;
// NOTE: questItemIds will be overridden by child classes. Ideally, it should be
// protected instead of public. However, quest scripts written in Jython will
// have trouble with protected, as Jython only knows private and public...
// In fact, protected will typically be considered private thus breaking the scripts.
// Leave this as public as a workaround.
public int[] questItemIds = null;
boolean altMethodCall = true;
private static final String DEFAULT_NO_QUEST_MSG = "<html><body>You are either not on a quest that involves this NPC, or you don't meet this NPC's minimum quest requirements.</body></html>";
private static final String DEFAULT_ALREADY_COMPLETED_MSG = "<html><body>This quest has already been completed.</body></html>";
/**
* Return collection view of the values contains in the allEventS
*
* @return Collection<Quest>
*/
public static Collection<Quest> findAllEvents()
{
return _allEventsS.values();
}
/**
* (Constructor)Add values to class variables and put the quest in HashMaps.
*
* @param questId
* : int pointing out the ID of the quest
* @param name
* : String corresponding to the name of the quest
* @param path
* : String for the description of the quest
*/
public Quest(int questId, String name, String dname, String path)
{
_questId = questId;
_name = name;
_dname = dname;
_path = path;
if (questId != 0)
QuestManager.getInstance().addQuest(this);
else
_allEventsS.put(name, this);
init_LoadGlobalData();
}
/**
* The function init_LoadGlobalData is, by default, called by the constructor of all quests. Children of this class can implement this
* function in order to define what variables to load and what structures to save them in. By default, nothing is loaded.
*/
protected void init_LoadGlobalData()
{
}
/**
* The function saveGlobalData is, by default, called at shutdown, for all quests, by the QuestManager. Children of this class can implement
* this function in order to convert their structures into <var, value> tuples and make calls to save them to the database, if needed. By
* default, nothing is saved.
*/
public void saveGlobalData()
{
}
public static enum QuestEventType
{
ON_FIRST_TALK(false), // control the first dialog shown by NPCs when they are clicked (some quests must override the
// default npc action)
QUEST_START(true), // onTalk action from start npcs
ON_TALK(true), // onTalk action from npcs participating in a quest
ON_ATTACK(true), // onAttack action triggered when a mob gets attacked by someone
ON_ATTACK_ACT(true), // onAttackAct event is triggered when a mob attacks someone
ON_KILL(true), // onKill action triggered when a mob gets killed.
ON_SPAWN(true), // onSpawn action triggered when an NPC is spawned or respawned.
ON_SKILL_SEE(true), // NPC or Mob saw a person casting a skill (regardless what the target is).
ON_FACTION_CALL(true), // NPC or Mob saw a person casting a skill (regardless what the target is).
ON_AGGRO_RANGE_ENTER(true), // a person came within the Npc/Mob's range
ON_SPELL_FINISHED(true), // on spell finished action when npc finish casting skill
ON_ENTER_ZONE(true), // on zone enter
ON_EXIT_ZONE(true); // on zone exit
// control whether this event type is allowed for the same npc template in multiple quests
// or if the npc must be registered in at most one quest for the specified event
private boolean _allowMultipleRegistration;
QuestEventType(boolean allowMultipleRegistration)
{
_allowMultipleRegistration = allowMultipleRegistration;
}
public boolean isMultipleRegistrationAllowed()
{
return _allowMultipleRegistration;
}
}
/**
* Return ID of the quest
*
* @return int
*/
public int getQuestIntId()
{
return _questId;
}
/**
* Add a new QuestState to the database and return it.
*
* @param player
* @return QuestState : QuestState created
*/
public QuestState newQuestState(L2PcInstance player)
{
QuestState qs = new QuestState(this, player, getInitialState());
return qs;
}
/**
* Return initial state of the quest
*
* @return State
*/
public byte getInitialState()
{
return _initialState;
}
/**
* Return name of the class
*
* @return String
*/
public String getName()
{
return _name;
}
/**
* Return display name of the class
*
* @return String
*/
public String getDisplayName()
{
return _dname;
}
/**
* Return path of the class
*
* @return String
*/
public String getScriptPath()
{
return _path;
}
/**
* Add a timer to the quest, if it doesn't exist already
*
* @param name
* name of the timer (also passed back as "event" in onAdvEvent)
* @param time
* time in ms for when to fire the timer
*/
public void startQuestTimer(String name, long time)
{
startQuestTimer(name, time, null, null, false);
}
/**
* Add a timer to the quest, if it doesn't exist already
*
* @param name
* name of the timer (also passed back as "event" in onAdvEvent)
* @param time
* time in ms for when to fire the timer
* @param npc
* npc associated with this timer (can be null)
* @param player
* player associated with this timer (can be null)
*/
public void startQuestTimer(String name, long time, L2Npc npc, L2PcInstance player)
{
startQuestTimer(name, time, npc, player, false);
}
/**
* Add a timer to the quest, if it doesn't exist already. If the timer is repeatable, it will auto-fire automatically, at a fixed rate, until
* explicitly canceled.
*
* @param name
* name of the timer (also passed back as "event" in onAdvEvent)
* @param time
* time in ms for when to fire the timer
* @param npc
* npc associated with this timer (can be null)
* @param player
* player associated with this timer (can be null)
* @param repeating
* indicates if the timer is repeatable or one-time.
*/
public void startQuestTimer(String name, long time, L2Npc npc, L2PcInstance player, boolean repeating)
{
// Add quest timer if timer doesn't already exist
FastList<QuestTimer> timers = getQuestTimers(name);
// no timer exists with the same name, at all
if (timers == null)
{
timers = new FastList<>();
timers.add(new QuestTimer(this, name, time, npc, player, repeating));
_allEventTimers.put(name, timers);
}
// a timer with this name exists, but may not be for the same set of npc and player
else
{
// if there exists a timer with this name, allow the timer only if the [npc, player] set is unique
// nulls act as wildcards
if (getQuestTimer(name, npc, player) == null)
{
try
{
_rwLock.writeLock().lock();
timers.add(new QuestTimer(this, name, time, npc, player, repeating));
}
finally
{
_rwLock.writeLock().unlock();
}
}
}
}
public QuestTimer getQuestTimer(String name, L2Npc npc, L2PcInstance player)
{
FastList<QuestTimer> qt = getQuestTimers(name);
if (qt == null || qt.isEmpty())
return null;
try
{
_rwLock.readLock().lock();
for (QuestTimer timer : qt)
{
if (timer != null)
{
if (timer.isMatch(this, name, npc, player))
return timer;
}
}
}
finally
{
_rwLock.readLock().unlock();
}
return null;
}
private FastList<QuestTimer> getQuestTimers(String name)
{
return _allEventTimers.get(name);
}
public void cancelQuestTimers(String name)
{
FastList<QuestTimer> timers = getQuestTimers(name);
if (timers == null)
return;
try
{
_rwLock.writeLock().lock();
for (QuestTimer timer : timers)
{
if (timer != null)
timer.cancel();
}
}
finally
{
_rwLock.writeLock().unlock();
}
}
public void cancelQuestTimer(String name, L2Npc npc, L2PcInstance player)
{
QuestTimer timer = getQuestTimer(name, npc, player);
if (timer != null)
timer.cancel();
}
public void removeQuestTimer(QuestTimer timer)
{
if (timer == null)
return;
FastList<QuestTimer> timers = getQuestTimers(timer.getName());
if (timers == null)
return;
try
{
_rwLock.writeLock().lock();
timers.remove(timer);
}
finally
{
_rwLock.writeLock().unlock();
}
}
// these are methods to call from java
public final boolean notifyAttack(L2Npc npc, L2PcInstance attacker, int damage, boolean isPet)
{
String res = null;
try
{
res = onAttack(npc, attacker, damage, isPet);
}
catch (Exception e)
{
return showError(attacker, e);
}
return showResult(attacker, res);
}
public final boolean notifyAttackAct(L2Npc npc, L2PcInstance victim)
{
String res = null;
try
{
res = onAttackAct(npc, victim);
}
catch (Exception e)
{
return showError(victim, e);
}
return showResult(victim, res);
}
public final boolean notifyDeath(L2Character killer, L2Character victim, QuestState qs)
{
String res = null;
try
{
res = onDeath(killer, victim, qs);
}
catch (Exception e)
{
return showError(qs.getPlayer(), e);
}
return showResult(qs.getPlayer(), res);
}
public final boolean notifySpellFinished(L2Npc instance, L2PcInstance player, L2Skill skill)
{
String res = null;
try
{
res = onSpellFinished(instance, player, skill);
}
catch (Exception e)
{
return showError(player, e);
}
return showResult(player, res);
}
public final boolean notifySpawn(L2Npc npc)
{
try
{
onSpawn(npc);
}
catch (Exception e)
{
_log.warn("Exception on onSpawn() in notifySpawn(): " + e.getMessage(), e);
return true;
}
return false;
}
public final boolean notifyEvent(String event, L2Npc npc, L2PcInstance player)
{
String res = null;
try
{
res = onAdvEvent(event, npc, player);
}
catch (Exception e)
{
return showError(player, e);
}
return showResult(player, res);
}
public final boolean notifyEnterWorld(L2PcInstance player)
{
String res = null;
try
{
res = onEnterWorld(player);
}
catch (Exception e)
{
return showError(player, e);
}
return showResult(player, res);
}
public final boolean notifyKill(L2Npc npc, L2PcInstance killer, boolean isPet)
{
String res = null;
try
{
if (altMethodCall)
{
QuestState st = killer.getQuestState(getName());
if (st != null)
res = onKill(npc, st);
if (res == null || res.equals(""))
res = onKill(npc, killer, isPet);
}
else
res = onKill(npc, killer, isPet);
}
catch (Exception e)
{
return showError(killer, e);
}
return showResult(killer, res);
}
public final boolean notifyTalk(L2Npc npc, QuestState qs)
{
String res = null;
try
{
res = onTalk(npc, qs.getPlayer());
}
catch (Exception e)
{
return showError(qs.getPlayer(), e);
}
qs.getPlayer().setLastQuestNpcObject(npc.getObjectId());
return showResult(qs.getPlayer(), res);
}
// override the default NPC dialogs when a quest defines this for the given NPC
public final boolean notifyFirstTalk(L2Npc npc, L2PcInstance player)
{
String res = null;
try
{
res = onFirstTalk(npc, player);
}
catch (Exception e)
{
return showError(player, e);
}
// if the quest returns text to display, display it.
if (res != null && res.length() > 0)
return showResult(player, res);
player.sendPacket(ActionFailed.STATIC_PACKET);
return true;
}
public final boolean notifyAcquireSkillList(L2Npc npc, L2PcInstance player)
{
String res = null;
try
{
res = onAcquireSkillList(npc, player);
}
catch (Exception e)
{
return showError(player, e);
}
return showResult(player, res);
}
public final boolean notifyAcquireSkillInfo(L2Npc npc, L2PcInstance player, L2Skill skill)
{
String res = null;
try
{
res = onAcquireSkillInfo(npc, player, skill);
}
catch (Exception e)
{
return showError(player, e);
}
return showResult(player, res);
}
public final boolean notifyAcquireSkill(L2Npc npc, L2PcInstance player, L2Skill skill)
{
String res = null;
try
{
res = onAcquireSkill(npc, player, skill);
if (res == "true")
return true;
else if (res == "false")
return false;
}
catch (Exception e)
{
return showError(player, e);
}
return showResult(player, res);
}
public class TmpOnSkillSee implements Runnable
{
private final L2Npc _npc;
private final L2PcInstance _caster;
private final L2Skill _skill;
private final L2Object[] _targets;
private final boolean _isPet;
public TmpOnSkillSee(L2Npc npc, L2PcInstance caster, L2Skill skill, L2Object[] targets, boolean isPet)
{
_npc = npc;
_caster = caster;
_skill = skill;
_targets = targets;
_isPet = isPet;
}
@Override
public void run()
{
String res = null;
try
{
res = onSkillSee(_npc, _caster, _skill, _targets, _isPet);
}
catch (Exception e)
{
showError(_caster, e);
}
showResult(_caster, res);
}
}
public final boolean notifySkillSee(L2Npc npc, L2PcInstance caster, L2Skill skill, L2Object[] targets, boolean isPet)
{
ThreadPoolManager.getInstance().executeAi(new TmpOnSkillSee(npc, caster, skill, targets, isPet));
return true;
}
public final boolean notifyFactionCall(L2Npc npc, L2Npc caller, L2PcInstance attacker, boolean isPet)
{
String res = null;
try
{
res = onFactionCall(npc, caller, attacker, isPet);
}
catch (Exception e)
{
return showError(attacker, e);
}
return showResult(attacker, res);
}
public class TmpOnAggroEnter implements Runnable
{
private final L2Npc _npc;
private final L2PcInstance _pc;
private final boolean _isPet;
public TmpOnAggroEnter(L2Npc npc, L2PcInstance pc, boolean isPet)
{
_npc = npc;
_pc = pc;
_isPet = isPet;
}
@Override
public void run()
{
String res = null;
try
{
res = onAggroRangeEnter(_npc, _pc, _isPet);
}
catch (Exception e)
{
showError(_pc, e);
}
showResult(_pc, res);
}
}
public final boolean notifyAggroRangeEnter(L2Npc npc, L2PcInstance player, boolean isPet)
{
ThreadPoolManager.getInstance().executeAi(new TmpOnAggroEnter(npc, player, isPet));
return true;
}
public final boolean notifyEnterZone(L2Character character, L2ZoneType zone)
{
L2PcInstance player = character.getActingPlayer();
String res = null;
try
{
res = onEnterZone(character, zone);
}
catch (Exception e)
{
if (player != null)
return showError(player, e);
}
if (player != null)
return showResult(player, res);
return true;
}
public final boolean notifyExitZone(L2Character character, L2ZoneType zone)
{
L2PcInstance player = character.getActingPlayer();
String res = null;
try
{
res = onExitZone(character, zone);
}
catch (Exception e)
{
if (player != null)
return showError(player, e);
}
if (player != null)
return showResult(player, res);
return true;
}
// these are methods that java calls to invoke scripts
public String onAttack(L2Npc npc, L2PcInstance attacker, int damage, boolean isPet)
{
return null;
}
public String onAttackAct(L2Npc npc, L2PcInstance victim)
{
return null;
}
public String onDeath(L2Character killer, L2Character victim, QuestState qs)
{
if (killer instanceof L2Npc)
return onAdvEvent("", (L2Npc) killer, qs.getPlayer());
return onAdvEvent("", null, qs.getPlayer());
}
public String onAdvEvent(String event, L2Npc npc, L2PcInstance player)
{
// if not overridden by a subclass, then default to the returned value of the simpler (and older) onEvent override
// if the player has a state, use it as parameter in the next call, else return null
if (player != null)
{
QuestState qs = player.getQuestState(getName());
if (qs != null)
return onEvent(event, qs);
}
return null;
}
public String onEvent(String event, QuestState qs)
{
return null;
}
public String onKill(L2Npc npc, QuestState qs)
{
return null;
}
public String onKill(L2Npc npc, L2PcInstance killer, boolean isPet)
{
return null;
}
public String onTalk(L2Npc npc, L2PcInstance talker)
{
return null;
}
public String onFirstTalk(L2Npc npc, L2PcInstance player)
{
return null;
}
public String onAcquireSkillList(L2Npc npc, L2PcInstance player)
{
return null;
}
public String onAcquireSkillInfo(L2Npc npc, L2PcInstance player, L2Skill skill)
{
return null;
}
public String onAcquireSkill(L2Npc npc, L2PcInstance player, L2Skill skill)
{
return null;
}
public String onSkillSee(L2Npc npc, L2PcInstance caster, L2Skill skill, L2Object[] targets, boolean isPet)
{
return null;
}
public String onSpellFinished(L2Npc npc, L2PcInstance player, L2Skill skill)
{
return null;
}
public String onSpawn(L2Npc npc)
{
return null;
}
public String onFactionCall(L2Npc npc, L2Npc caller, L2PcInstance attacker, boolean isPet)
{
return null;
}
public String onAggroRangeEnter(L2Npc npc, L2PcInstance player, boolean isPet)
{
return null;
}
public String onEnterWorld(L2PcInstance player)
{
return null;
}
public String onEnterZone(L2Character character, L2ZoneType zone)
{
return null;
}
public String onExitZone(L2Character character, L2ZoneType zone)
{
return null;
}
/**
* Show message error to player who has an access level greater than 0
*
* @param player
* : L2PcInstance
* @param t
* : Throwable
* @return boolean
*/
public boolean showError(L2PcInstance player, Throwable t)
{
_log.warn(getScriptFile().getName(), t);
if (t.getMessage() == null)
t.printStackTrace();
if (player != null && player.getAccessLevel().isGm())
{
String res = "<html><body><title>Script error</title>" + Util.getStackTrace(t) + "</body></html>";
return showResult(player, res);
}
return false;
}
/**
* Show a message to player.<BR>
* <BR>
* <U><I>Concept : </I></U><BR>
* 3 cases are managed according to the value of the parameter "res" :<BR>
* <LI><U>"res" ends with string ".html" :</U> an HTML is opened in order to be shown in a dialog box</LI> <LI><U>"res" starts with "<html>"
* :</U> the message hold in "res" is shown in a dialog box</LI> <LI><U>otherwise :</U> the message held in "res" is shown in chat box</LI>
*
* @param player
* : the player.
* @param res
* : String pointing out the message to show at the player
* @return boolean
*/
public boolean showResult(L2PcInstance player, String res)
{
if (res == null || res.isEmpty() || player == null)
return true;
if (res.endsWith(".htm") || res.endsWith(".html"))
{
showHtmlFile(player, res);
}
else if (res.startsWith("<html>"))
{
NpcHtmlMessage npcReply = new NpcHtmlMessage(5);
npcReply.setHtml(res);
npcReply.replace("%playername%", player.getName());
player.sendPacket(npcReply);
player.sendPacket(ActionFailed.STATIC_PACKET);
}
else
{
player.sendMessage(res);
}
return false;
}
/**
* Add quests to the L2PCInstance of the player.<BR>
* <BR>
* <U><I>Action : </U></I><BR>
* Add state of quests, drops and variables for quests in the HashMap _quest of L2PcInstance
*
* @param player
* : Player who is entering the world
*/
public static final void playerEnter(L2PcInstance player)
{
try (Connection con = DatabaseFactory.getConnection())
{
PreparedStatement invalidQuestData = con.prepareStatement("DELETE FROM character_quests WHERE charId=? and name=?");
PreparedStatement invalidQuestDataVar = con.prepareStatement("delete FROM character_quests WHERE charId=? and name=? and var=?");
PreparedStatement statement = con.prepareStatement("SELECT name,value FROM character_quests WHERE charId=? AND var=?");
statement.setInt(1, player.getObjectId());
statement.setString(2, "<state>");
ResultSet rs = statement.executeQuery();
while (rs.next())
{
// Get ID of the quest and ID of its state
String questId = rs.getString("name");
String statename = rs.getString("value");
// Search quest associated with the ID
Quest q = QuestManager.getInstance().getQuest(questId);
if (q == null)
{
_log.warn("Unknown quest " + questId + " for player " + player.getName());
if (MainConfig.AUTODELETE_INVALID_QUEST_DATA)
{
invalidQuestData.setInt(1, player.getObjectId());
invalidQuestData.setString(2, questId);
invalidQuestData.executeUpdate();
}
continue;
}
// Create a new QuestState for the player that will be added to the player's list of quests
new QuestState(q, player, State.getStateId(statename));
}
rs.close();
invalidQuestData.close();
statement.close();
// Get list of quests owned by the player from the DB in order to add variables used in the quest.
statement = con.prepareStatement("SELECT name,var,value FROM character_quests WHERE charId=? AND var<>?");
statement.setInt(1, player.getObjectId());
statement.setString(2, "<state>");
rs = statement.executeQuery();
while (rs.next())
{
String questId = rs.getString("name");
String var = rs.getString("var");
String value = rs.getString("value");
// Get the QuestState saved in the loop before
QuestState qs = player.getQuestState(questId);
if (qs == null)
{
_log.warn("Lost variable " + var + " in quest " + questId + " for player " + player.getName());
if (MainConfig.AUTODELETE_INVALID_QUEST_DATA)
{
invalidQuestDataVar.setInt(1, player.getObjectId());
invalidQuestDataVar.setString(2, questId);
invalidQuestDataVar.setString(3, var);
invalidQuestDataVar.executeUpdate();
}
continue;
}
// Add parameter to the quest
qs.setInternal(var, value);
}
rs.close();
invalidQuestDataVar.close();
statement.close();
}
catch (Exception e)
{
_log.warn("could not insert char quest:", e);
}
// events
for (String name : _allEventsS.keySet())
{
player.processQuestEvent(name, "enter");
}
}
/**
* Insert (or Update) in the database variables that need to stay persistant for this quest after a reboot. This function is for storage of
* values that do not related to a specific player but are global for all characters. For example, if we need to disable a quest-gatekeeper
* until a certain time (as is done with some grand-boss gatekeepers), we can save that time in the DB.
*
* @param var
* : String designating the name of the variable for the quest
* @param value
* : String designating the value of the variable for the quest
*/
public final void saveGlobalQuestVar(String var, String value)
{
try (Connection con = DatabaseFactory.getConnection())
{
PreparedStatement statement = con.prepareStatement("REPLACE INTO quest_global_data (quest_name,var,value) VALUES (?,?,?)");
statement.setString(1, getName());
statement.setString(2, var);
statement.setString(3, value);
statement.executeUpdate();
statement.close();
}
catch (Exception e)
{
_log.warn("could not insert global quest variable:", e);
}
}
/**
* Read from the database a previously saved variable for this quest. Due to performance considerations, this function should best be used
* only when the quest is first loaded. Subclasses of this class can define structures into which these loaded values can be saved. However,
* on-demand usage of this function throughout the script is not prohibited, only not recommended. Values read from this function were
* entered by calls to "saveGlobalQuestVar"
*
* @param var
* : String designating the name of the variable for the quest
* @return String : String representing the loaded value for the passed var, or an empty string if the var was invalid
*/
public final String loadGlobalQuestVar(String var)
{
String result = "";
try (Connection con = DatabaseFactory.getConnection())
{
PreparedStatement statement = con.prepareStatement("SELECT value FROM quest_global_data WHERE quest_name = ? AND var = ?");
statement.setString(1, getName());
statement.setString(2, var);
ResultSet rs = statement.executeQuery();
if (rs.first())
result = rs.getString(1);
rs.close();
statement.close();
}
catch (Exception e)
{
_log.warn("could not load global quest variable:", e);
}
return result;
}
/**
* Permanently delete from the database a global quest variable that was previously saved for this quest.
*
* @param var
* : String designating the name of the variable for the quest
*/
public final void deleteGlobalQuestVar(String var)
{
try (Connection con = DatabaseFactory.getConnection())
{
PreparedStatement statement = con.prepareStatement("DELETE FROM quest_global_data WHERE quest_name = ? AND var = ?");
statement.setString(1, getName());
statement.setString(2, var);
statement.executeUpdate();
statement.close();
}
catch (Exception e)
{
_log.warn("could not delete global quest variable:", e);
}
}
/**
* Permanently delete from the database all global quest variables that was previously saved for this quest.
*/
public final void deleteAllGlobalQuestVars()
{
try (Connection con = DatabaseFactory.getConnection())
{
PreparedStatement statement = con.prepareStatement("DELETE FROM quest_global_data WHERE quest_name = ?");
statement.setString(1, getName());
statement.executeUpdate();
statement.close();
}
catch (Exception e)
{
_log.warn("could not delete global quest variables:", e);
}
}
/**
* Insert in the database the quest for the player.
*
* @param qs
* : QuestState pointing out the state of the quest
* @param var
* : String designating the name of the variable for the quest
* @param value
* : String designating the value of the variable for the quest
*/
public static void createQuestVarInDb(QuestState qs, String var, String value)
{
try (Connection con = DatabaseFactory.getConnection())
{
PreparedStatement statement = con.prepareStatement("INSERT INTO character_quests (charId,name,var,value) VALUES (?,?,?,?) ON DUPLICATE KEY UPDATE value=?");
statement.setInt(1, qs.getPlayer().getObjectId());
statement.setString(2, qs.getQuestName());
statement.setString(3, var);
statement.setString(4, value);
statement.setString(5, value);
statement.executeUpdate();
statement.close();
}
catch (Exception e)
{
_log.warn("could not insert char quest:", e);
}
}
/**
* Update the value of the variable "var" for the quest.<BR>
* <BR>
* <U><I>Actions :</I></U><BR>
* The selection of the right record is made with : <LI>charId = qs.getPlayer().getObjectID()</LI> <LI>name = qs.getQuest().getName()</LI>
* <LI>var = var</LI> <BR>
* <BR>
* The modification made is : <LI>value = parameter value</LI>
*
* @param qs
* : Quest State
* @param var
* : String designating the name of the variable for quest
* @param value
* : String designating the value of the variable for quest
*/
public static void updateQuestVarInDb(QuestState qs, String var, String value)
{
try (Connection con = DatabaseFactory.getConnection())
{
PreparedStatement statement = con.prepareStatement("UPDATE character_quests SET value=? WHERE charId=? AND name=? AND var = ?");
statement.setString(1, value);
statement.setInt(2, qs.getPlayer().getObjectId());
statement.setString(3, qs.getQuestName());
statement.setString(4, var);
statement.executeUpdate();
statement.close();
}
catch (Exception e)
{
_log.warn("could not update char quest:", e);
}
}
/**
* Delete a variable of player's quest from the database.
*
* @param qs
* : object QuestState pointing out the player's quest
* @param var
* : String designating the variable characterizing the quest
*/
public static void deleteQuestVarInDb(QuestState qs, String var)
{
try (Connection con = DatabaseFactory.getConnection())
{
PreparedStatement statement = con.prepareStatement("DELETE FROM character_quests WHERE charId=? AND name=? AND var=?");
statement.setInt(1, qs.getPlayer().getObjectId());
statement.setString(2, qs.getQuestName());
statement.setString(3, var);
statement.executeUpdate();
statement.close();
}
catch (Exception e)
{
_log.warn("could not delete char quest:", e);
}
}
/**
* Delete the player's quest from database.
*
* @param qs
* : QuestState pointing out the player's quest
*/
public static void deleteQuestInDb(QuestState qs)
{
try (Connection con = DatabaseFactory.getConnection())
{
PreparedStatement statement = con.prepareStatement("DELETE FROM character_quests WHERE charId=? AND name=?");
statement.setInt(1, qs.getPlayer().getObjectId());
statement.setString(2, qs.getQuestName());
statement.executeUpdate();
statement.close();
}
catch (Exception e)
{
_log.warn("could not delete char quest:", e);
}
}
/**
* Create a record in database for quest.<BR>
* <BR>
* <U><I>Actions :</I></U><BR>
* Use fucntion createQuestVarInDb() with following parameters :<BR>
* <LI>QuestState : parameter sq that puts in fields of database :
* <UL type="square">
* <LI>charId : ID of the player</LI>
* <LI>name : name of the quest</LI>
* </UL>
* </LI> <LI>var : string "<state>" as the name of the variable for the quest</LI> <LI>val : string corresponding at the ID of the
* state (in fact, initial state)</LI>
*
* @param qs
* : QuestState
*/
public static void createQuestInDb(QuestState qs)
{
createQuestVarInDb(qs, "<state>", State.getStateName(qs.getState()));
}
/**
* Update informations regarding quest in database.<BR>
* <U><I>Actions :</I></U><BR>
* <LI>Get ID state of the quest recorded in object qs</LI> <LI>Test if quest is completed. If true, add a star (*) before the ID state</LI>
* <LI>Save in database the ID state (with or without the star) for the variable called "<state>" of the quest</LI>
*
* @param qs
* : QuestState
*/
public static void updateQuestInDb(QuestState qs)
{
String val = State.getStateName(qs.getState());
updateQuestVarInDb(qs, "<state>", val);
}
/**
* @return default html page "You are either not on a quest that involves this NPC.."
*/
public static String getNoQuestMsg()
{
final String result = HtmCache.getInstance().getHtm(StaticHtmPath.NpcHtmPath + "noquest.htm");
if (result != null && result.length() > 0)
return result;
return DEFAULT_NO_QUEST_MSG;
}
/**
* @return default html page "This quest has already been completed."
*/
public static String getAlreadyCompletedMsg()
{
final String result = HtmCache.getInstance().getHtm(StaticHtmPath.NpcHtmPath + "alreadycompleted.htm");
if (result != null && result.length() > 0)
return result;
return DEFAULT_ALREADY_COMPLETED_MSG;
}
/**
* Add this quest to the list of quests that the passed mob will respond to for the specified Event type.<BR>
* <BR>
*
* @param npcId
* : id of the NPC to register
* @param eventType
* : type of event being registered
* @return L2NpcTemplate : Npc Template corresponding to the npcId, or null if the id is invalid
*/
public L2NpcTemplate addEventId(int npcId, QuestEventType eventType)
{
try
{
L2NpcTemplate t = NpcTable.getInstance().getTemplate(npcId);
if (t != null)
{
t.addQuestEvent(eventType, this);
}
return t;
}
catch (Exception e)
{
_log.warn("Exception on addEventId(): " + e.getMessage(), e);
return null;
}
}
/**
* Add the quest to the NPC's startQuest
*
* @param npcIds
* A serie of ids.
* @return L2NpcTemplate : Start NPC
*/
public L2NpcTemplate[] addStartNpc(int... npcIds)
{
L2NpcTemplate[] value = new L2NpcTemplate[npcIds.length];
int i = 0;
for (int npcId : npcIds)
value[i++] = addEventId(npcId, QuestEventType.QUEST_START);
return value;
}
public L2NpcTemplate addStartNpc(int npcId)
{
return addEventId(npcId, QuestEventType.QUEST_START);
}
/**
* Add the quest to the NPC's first-talk (default action dialog)
*
* @param npcIds
* A serie of ids.
* @return L2NpcTemplate : Start NPC
*/
public L2NpcTemplate[] addFirstTalkId(int... npcIds)
{
L2NpcTemplate[] value = new L2NpcTemplate[npcIds.length];
int i = 0;
for (int npcId : npcIds)
value[i++] = addEventId(npcId, QuestEventType.ON_FIRST_TALK);
return value;
}
public L2NpcTemplate addFirstTalkId(int npcId)
{
return addEventId(npcId, QuestEventType.ON_FIRST_TALK);
}
/**
* Add this quest to the list of quests that the passed mob will respond to for Attack Events.<BR>
* <BR>
*
* @param npcIds
* A serie of ids.
* @return int : attackId
*/
public L2NpcTemplate[] addAttackId(int... npcIds)
{
L2NpcTemplate[] value = new L2NpcTemplate[npcIds.length];
int i = 0;
for (int npcId : npcIds)
value[i++] = addEventId(npcId, QuestEventType.ON_ATTACK);
return value;
}
public L2NpcTemplate addAttackId(int attackId)
{
return addEventId(attackId, QuestEventType.ON_ATTACK);
}
/**
* Add this quest to the list of quests that the passed mob will respond to for AttackAct Events.<BR>
* <BR>
*
* @param npcIds
* A serie of ids.
* @return int : attackId
*/
public L2NpcTemplate[] addAttackActId(int... npcIds)
{
L2NpcTemplate[] value = new L2NpcTemplate[npcIds.length];
int i = 0;
for (int npcId : npcIds)
value[i++] = addEventId(npcId, QuestEventType.ON_ATTACK_ACT);
return value;
}
public L2NpcTemplate addAttackActId(int attackId)
{
return addEventId(attackId, QuestEventType.ON_ATTACK_ACT);
}
/**
* Add this quest to the list of quests that the passed mob will respond to for Kill Events.<BR>
* <BR>
*
* @param killIds
* A serie of ids.
* @return int : killId
*/
public L2NpcTemplate[] addKillId(int... killIds)
{
L2NpcTemplate[] value = new L2NpcTemplate[killIds.length];
int i = 0;
for (int killId : killIds)
value[i++] = addEventId(killId, QuestEventType.ON_KILL);
return value;
}
public L2NpcTemplate addKillId(int killId)
{
return addEventId(killId, QuestEventType.ON_KILL);
}
/**
* Add this quest to the list of quests that the passed npc will respond to for Talk Events.<BR>
* <BR>
*
* @param talkIds
* : A serie of ids.
* @return int : ID of the NPC
*/
public L2NpcTemplate[] addTalkId(int... talkIds)
{
L2NpcTemplate[] value = new L2NpcTemplate[talkIds.length];
int i = 0;
for (int talkId : talkIds)
value[i++] = addEventId(talkId, QuestEventType.ON_TALK);
return value;
}
public L2NpcTemplate addTalkId(int talkId)
{
return addEventId(talkId, QuestEventType.ON_TALK);
}
/**
* Add this quest to the list of quests that the passed npc will respond to for Spawn Events.<BR>
* <BR>
*
* @param npcIds
* : A serie of ids.
* @return int : ID of the NPC
*/
public L2NpcTemplate[] addSpawnId(int... npcIds)
{
L2NpcTemplate[] value = new L2NpcTemplate[npcIds.length];
int i = 0;
for (int npcId : npcIds)
value[i++] = addEventId(npcId, QuestEventType.ON_SPAWN);
return value;
}
public L2NpcTemplate addSpawnId(int npcId)
{
return addEventId(npcId, QuestEventType.ON_SPAWN);
}
/**
* Add this quest to the list of quests that the passed npc will respond to for Skill-See Events.<BR>
* <BR>
*
* @param npcIds
* : A serie of ids.
* @return int : ID of the NPC
*/
public L2NpcTemplate[] addSkillSeeId(int... npcIds)
{
L2NpcTemplate[] value = new L2NpcTemplate[npcIds.length];
int i = 0;
for (int npcId : npcIds)
value[i++] = addEventId(npcId, QuestEventType.ON_SKILL_SEE);
return value;
}
public L2NpcTemplate addSkillSeeId(int npcId)
{
return addEventId(npcId, QuestEventType.ON_SKILL_SEE);
}
public L2NpcTemplate[] addSpellFinishedId(int... npcIds)
{
L2NpcTemplate[] value = new L2NpcTemplate[npcIds.length];
int i = 0;
for (int npcId : npcIds)
value[i++] = addEventId(npcId, QuestEventType.ON_SPELL_FINISHED);
return value;
}
public L2NpcTemplate addSpellFinishedId(int npcId)
{
return addEventId(npcId, QuestEventType.ON_SPELL_FINISHED);
}
/**
* Add this quest to the list of quests that the passed npc will respond to for Faction Call Events.<BR>
* <BR>
*
* @param npcIds
* : A serie of ids.
* @return int : ID of the NPC
*/
public L2NpcTemplate[] addFactionCallId(int... npcIds)
{
L2NpcTemplate[] value = new L2NpcTemplate[npcIds.length];
int i = 0;
for (int npcId : npcIds)
value[i++] = addEventId(npcId, QuestEventType.ON_FACTION_CALL);
return value;
}
public L2NpcTemplate addFactionCallId(int npcId)
{
return addEventId(npcId, QuestEventType.ON_FACTION_CALL);
}
/**
* Add this quest to the list of quests that the passed npc will respond to for Character See Events.<BR>
* <BR>
*
* @param npcIds
* : A serie of ids.
* @return int : ID of the NPC
*/
public L2NpcTemplate[] addAggroRangeEnterId(int... npcIds)
{
L2NpcTemplate[] value = new L2NpcTemplate[npcIds.length];
int i = 0;
for (int npcId : npcIds)
value[i++] = addEventId(npcId, QuestEventType.ON_AGGRO_RANGE_ENTER);
return value;
}
public L2NpcTemplate addAggroRangeEnterId(int npcId)
{
return addEventId(npcId, QuestEventType.ON_AGGRO_RANGE_ENTER);
}
public L2ZoneType[] addEnterZoneId(int... zoneIds)
{
L2ZoneType[] value = new L2ZoneType[zoneIds.length];
int i = 0;
for (int zoneId : zoneIds)
{
try
{
L2ZoneType zone = ZoneManager.getInstance().getZoneById(zoneId);
if (zone != null)
zone.addQuestEvent(QuestEventType.ON_ENTER_ZONE, this);
value[i++] = zone;
}
catch (Exception e)
{
_log.warn("Exception on addEnterZoneId(): " + e.getMessage(), e);
continue;
}
}
return value;
}
public L2ZoneType addEnterZoneId(int zoneId)
{
try
{
L2ZoneType zone = ZoneManager.getInstance().getZoneById(zoneId);
if (zone != null)
zone.addQuestEvent(QuestEventType.ON_ENTER_ZONE, this);
return zone;
}
catch (Exception e)
{
_log.warn("Exception on addEnterZoneId(): " + e.getMessage(), e);
return null;
}
}
public L2ZoneType[] addExitZoneId(int... zoneIds)
{
L2ZoneType[] value = new L2ZoneType[zoneIds.length];
int i = 0;
for (int zoneId : zoneIds)
{
try
{
L2ZoneType zone = ZoneManager.getInstance().getZoneById(zoneId);
if (zone != null)
zone.addQuestEvent(QuestEventType.ON_EXIT_ZONE, this);
value[i++] = zone;
}
catch (Exception e)
{
_log.warn("Exception on addEnterZoneId(): " + e.getMessage(), e);
continue;
}
}
return value;
}
public L2ZoneType addExitZoneId(int zoneId)
{
try
{
L2ZoneType zone = ZoneManager.getInstance().getZoneById(zoneId);
if (zone != null)
zone.addQuestEvent(QuestEventType.ON_EXIT_ZONE, this);
return zone;
}
catch (Exception e)
{
_log.warn("Exception on addExitZoneId(): " + e.getMessage(), e);
return null;
}
}
/**
* @param player
* : The player to make checks on.
* @return A random party member or the passed player if he has no party.
*/
public L2PcInstance getRandomPartyMember(L2PcInstance player)
{
// No valid player instance is passed, there is nothing to check.
if (player == null)
return null;
// No party, return player.
if (!player.isInParty())
return player;
// Player's party.
final L2Party party = player.getParty();
// Random party member.
return party.getPartyMembers().get(Rnd.get(party.getMemberCount()));
}
/**
* Auxiliary function for party quests. Checks the player's condition. Player member must be within 1500 distance from the npc. If npc is
* null, 1500 distance condition from the player itself is applied.
*
* @param player
* : the instance of a player whose party is to be searched
* @param npc
* : the instance of a L2Npc to compare distance
* @param var
* : a tuple specifying a quest condition that must be satisfied for a party member to be considered.
* @param value
* : a tuple specifying a quest condition that must be satisfied for a party member to be considered.
* @return boolean : True if player matches the specified condition. If the var is null, true is returned (i.e. no condition is applied).
*/
public boolean checkPlayerCondition(L2PcInstance player, L2Npc npc, String var, String value)
{
// No valid player instance is passed, there is nothing to check.
if (player == null)
return false;
// Check player's quest conditions.
QuestState st = player.getQuestState(getName());
if (st == null)
return false;
// Condition exists?
if (st.get(var) == null)
return false;
// Condition has correct value?
if (!(st.get(var)).equalsIgnoreCase(value))
return false;
// Player is in range?
return player.isInsideRadius(npc == null ? player : npc, PlayersConfig.ALT_PARTY_RANGE, true, false);
}
/**
* Auxiliary function for party quests. Note: This function is only here because of how commonly it may be used by quest developers. For any
* variations on this function, the quest script can always handle things on its own
*
* @param player
* : the instance of a player whose party is to be searched
* @param npc
* : the instance of a L2Npc to compare distance
* @param var
* : a tuple specifying a quest condition that must be satisfied for a party member to be considered.
* @param value
* : a tuple specifying a quest condition that must be satisfied for a party member to be considered.
* @return List<L2PcInstance> : List of party members that matches the specified condition, empty list if none matches. If the var is null,
* empty list is returned (i.e. no condition is applied). The party member must be within 1500 distance from the npc. If npc is null,
* 1500 distance condition from the player itself is applied.
*/
public List<L2PcInstance> getPartyMembers(L2PcInstance player, L2Npc npc, String var, String value)
{
// No valid player instance is passed, there is nothing to check.
if (player == null)
return null;
// Player is not in a party, there is nothing to check.
if (!player.isInParty())
return null;
// Output list.
List<L2PcInstance> candidates = new ArrayList<>();
// Filter candidates from player's party.
for (L2PcInstance partyMember : player.getParty().getPartyMembers())
{
if (partyMember == null)
continue;
// Check party members' quest condition.
if (checkPlayerCondition(player, npc, var, value))
candidates.add(partyMember);
}
// Check candidates, if empty, nothing to return.
if (candidates.isEmpty())
return null;
return candidates;
}
/**
* Auxiliary function for party quests. Note: This function is only here because of how commonly it may be used by quest developers. For any
* variations on this function, the quest script can always handle things on its own
*
* @param player
* : the instance of a player whose party is to be searched
* @param npc
* : the instance of a L2Npc to compare distance
* @param var
* : a tuple specifying a quest condition that must be satisfied for a party member to be considered.
* @param value
* : a tuple specifying a quest condition that must be satisfied for a party member to be considered.
* @return L2PcInstance : L2PcInstance for a random party member that matches the specified condition, or null if no match. If the var is
* null, null is returned (i.e. no condition is applied). The party member must be within 1500 distance from the npc. If npc is null,
* 1500 distance condition from the player itself is applied.
*/
public L2PcInstance getRandomPartyMember(L2PcInstance player, L2Npc npc, String var, String value)
{
// No valid player instance is passed, there is nothing to check.
if (player == null)
return null;
// Player in party.
if (player.isInParty())
{
// Get all candidates fulfilling the condition.
final List<L2PcInstance> candidates = getPartyMembers(player, npc, var, value);
// No candidate, return.
if (candidates == null)
return null;
// Return random candidate.
return candidates.get(Rnd.get(candidates.size()));
}
// Player alone.
if (checkPlayerCondition(player, npc, var, value))
return player;
return null;
}
/**
* Auxiliary function for party quests. Note: This function is only here because of how commonly it may be used by quest developers. For any
* variations on this function, the quest script can always handle things on its own
*
* @param player
* : the instance of a player whose party is to be searched
* @param npc
* : the instance of a L2Npc to compare distance
* @param value
* : the value of the "cond" variable that must be matched
* @return L2PcInstance : L2PcInstance for a random party member that matches the specified condition, or null if no match.
*/
public L2PcInstance getRandomPartyMember(L2PcInstance player, L2Npc npc, String value)
{
return getRandomPartyMember(player, npc, "cond", value);
}
/**
* Auxiliary function for party quests. Checks the player's condition. Player member must be within 1500 distance from the npc. If npc is
* null, 1500 distance condition from the player itself is applied.
*
* @param player
* : the instance of a player whose party is to be searched
* @param npc
* : the instance of a L2Npc to compare distance
* @param state
* : the state in which the party member's QuestState must be in order to be considered.
* @return boolean : True if player matches the specified conditions.
*/
public boolean checkPlayerState(L2PcInstance player, L2Npc npc, byte state)
{
// No valid player instance is passed, there is nothing to check.
if (player == null)
return false;
// Check player's quest conditions.
QuestState st = player.getQuestState(getName());
if (st == null)
return false;
// State correct?
if (st.getState() != state)
return false;
// Player is in range?
return player.isInsideRadius(npc == null ? player : npc, PlayersConfig.ALT_PARTY_RANGE, true, false);
}
/**
* Auxiliary function for party quests. Note: This function is only here because of how commonly it may be used by quest developers. For any
* variations on this function, the quest script can always handle things on its own
*
* @param player
* : the instance of a player whose party is to be searched
* @param npc
* : the instance of a L2Npc to compare distance
* @param state
* : the state in which the party member's QuestState must be in order to be considered.
* @return List<L2PcInstance> : List of party members that matches the specified condition, or null if no match. If the var is null, any
* random party member is returned (i.e. no condition is applied).
*/
public List<L2PcInstance> getPartyMembersState(L2PcInstance player, L2Npc npc, byte state)
{
// No valid player instance is passed, there is nothing to check.
if (player == null)
return null;
// Player is not in a party, there is nothing to check.
if (!player.isInParty())
return null;
// Output list.
List<L2PcInstance> candidates = new ArrayList<>();
// Filter candidates from player's party.
for (L2PcInstance partyMember : player.getParty().getPartyMembers())
{
if (partyMember == null)
continue;
// Check party members' quest state.
if (checkPlayerState(player, npc, state))
candidates.add(partyMember);
}
// Check candidates, if empty, nothing to return.
if (candidates.isEmpty())
return null;
return candidates;
}
/**
* Auxiliary function for party quests. Note: This function is only here because of how commonly it may be used by quest developers. For any
* variations on this function, the quest script can always handle things on its own
*
* @param player
* : the instance of a player whose party is to be searched
* @param npc
* : the instance of a monster to compare distance
* @param state
* : the state in which the party member's QuestState must be in order to be considered.
* @return L2PcInstance: L2PcInstance for a random party member that matches the specified condition, or null if no match. If the var is
* null, any random party member is returned (i.e. no condition is applied).
*/
public L2PcInstance getRandomPartyMemberState(L2PcInstance player, L2Npc npc, byte state)
{
// No valid player instance is passed, there is nothing to check.
if (player == null)
return null;
// Player is in party.
if (player.isInParty())
{
// Get all candidates fulfilling the condition.
final List<L2PcInstance> candidates = getPartyMembersState(player, npc, state);
// No candidate, return.
if (candidates == null)
return null;
// Return random candidate.
return candidates.get(Rnd.get(candidates.size()));
}
// Player is alone.
if (checkPlayerState(player, npc, state))
return player;
return null;
}
/**
* Retrieves the clan leader quest state.
*
* @param player
* the player to test
* @param radius
* the radius to test
* @return the QuestState of the leader, or null if not found
*/
public QuestState getClanLeaderQuestState(L2PcInstance player, int radius)
{
QuestState qS = null;
// If player is the leader, retrieves directly the qS and bypass others checks
if (player.isClanLeader())
qS = player.getQuestState(getName());
else
{
// Verify if the player got a clan
L2Clan clan = player.getClan();
if (clan != null)
{
// Verify if the leader is online
L2PcInstance leader = clan.getLeader().getPlayerInstance();
if (leader != null)
{
// Verify if the player is on the radius of the leader ; if true, send leader's qS.
if (player.isInsideRadius(leader, radius, true, false))
qS = leader.getQuestState(getName());
}
}
}
return qS;
}
/**
* Show HTML file to client
*
* @param player
* : the receiver.
* @param fileName
* : the filename to send.
* @return String : message sent to client.
*/
public String showHtmlFile(L2PcInstance player, String fileName)
{
boolean questwindow = true;
if (fileName.endsWith(".html"))
questwindow = false;
int questId = getQuestIntId();
// Create handler to file linked to the quest
String content = getHtm(player, fileName);
if (player.getTarget() != null)
content = content.replaceAll("%objectId%", String.valueOf(player.getTarget().getObjectId()));
// Send message to client if message not empty
if (content != null)
{
if (questwindow && questId > 0 && questId < 20000 && questId != 999)
{
NpcHtmlMessage npcReply = new NpcHtmlMessage(5);
npcReply.setHtml(content);
npcReply.replace("%playername%", player.getName());
player.sendPacket(npcReply);
}
else
{
NpcHtmlMessage npcReply = new NpcHtmlMessage(5);
npcReply.setHtml(content);
npcReply.replace("%playername%", player.getName());
player.sendPacket(npcReply);
}
player.sendPacket(ActionFailed.STATIC_PACKET);
}
return content;
}
/**
* Return HTML file contents
*
* @param fileName
* @return
*/
public String getHtm(L2PcInstance player, String fileName)
{
String path = StaticHtmPath.ScriptsHtmPath + getScriptPath().toLowerCase() + "/" + getName() + "/" + fileName;
// Show htmpath in chat (only for gm)
if (player.isGM())
player.sendChatMessage(0, Say2.ALL, "HTML", path);
return HtmCache.getInstance().getHtm(path);
}
/**
* Add a temporary (quest) spawn on the location of a character.
*
* @param npcId
* the NPC template to spawn.
* @param cha
* the position where to spawn it.
* @return instance of the newly spawned npc.
*/
public L2Npc addSpawn(int npcId, L2Character cha)
{
return addSpawn(npcId, cha.getX(), cha.getY(), cha.getZ(), cha.getHeading(), false, 0, false);
}
/**
* Add a temporary (quest) spawn on the location of a character.
*
* @param npcId
* the NPC template to spawn.
* @param cha
* the position where to spawn it.
* @param isSummonSpawn
* if true, spawn with animation (if any exists).
* @return instance of the newly spawned npc with summon animation.
*/
public L2Npc addSpawn(int npcId, L2Character cha, boolean isSummonSpawn)
{
return addSpawn(npcId, cha.getX(), cha.getY(), cha.getZ(), cha.getHeading(), false, 0, isSummonSpawn);
}
public L2Npc addSpawn(int npcId, int x, int y, int z, int heading, boolean randomOffSet, long despawnDelay)
{
return addSpawn(npcId, x, y, z, heading, randomOffSet, despawnDelay, false);
}
public L2Npc addSpawn(int npcId, int x, int y, int z, int heading, boolean randomOffset, long despawnDelay, boolean isSummonSpawn)
{
L2Npc result = null;
try
{
L2NpcTemplate template = NpcTable.getInstance().getTemplate(npcId);
if (template != null)
{
// Sometimes, even if the quest script specifies some xyz (for example npc.getX() etc) by the time the code
// reaches here, xyz have become 0! Also, a questdev might have purposely set xy to 0,0...however,
// the spawn code is coded such that if x=y=0, it looks into location for the spawn loc! This will NOT work
// with quest spawns! For both of the above cases, we need a fail-safe spawn. For this, we use the
// default spawn location, which is at the player's loc.
if ((x == 0) && (y == 0))
{
_log.warn("Failed to adjust bad locks for quest spawn! Spawn aborted!");
return null;
}
if (randomOffset)
{
int offset;
offset = Rnd.get(2); // Get the direction of the offset
if (offset == 0)
{
offset = -1;
} // make offset negative
offset *= Rnd.get(50, 100);
x += offset;
offset = Rnd.get(2); // Get the direction of the offset
if (offset == 0)
{
offset = -1;
} // make offset negative
offset *= Rnd.get(50, 100);
y += offset;
}
L2Spawn spawn = new L2Spawn(template);
spawn.setHeading(heading);
spawn.setLocx(x);
spawn.setLocy(y);
spawn.setLocz(z + 20);
spawn.stopRespawn();
result = spawn.doSpawn(isSummonSpawn);
if (despawnDelay > 0)
result.scheduleDespawn(despawnDelay);
return result;
}
}
catch (Exception e1)
{
_log.warn("Could not spawn Npc " + npcId);
}
return null;
}
public L2Npc addMinion(L2MonsterInstance master, int minionId)
{
return MinionList.spawnMinion(master, minionId);
}
public int[] getRegisteredItemIds()
{
return questItemIds;
}
@Override
public String getScriptName()
{
return getName();
}
@Override
public void setActive(boolean status)
{
// TODO implement me
}
@Override
public ScriptManager<?> getScriptManager()
{
return QuestManager.getInstance();
}
public void setOnEnterWorld(boolean val)
{
_onEnterWorld = val;
}
public boolean getOnEnterWorld()
{
return _onEnterWorld;
}
public static final boolean contains(final Object array, final Object value)
{
return arrayIndexOf(array, value) != -1;
}
public static final int arrayIndexOf(final Object array, final Object value)
{
final int length = Array.getLength(array);
if (value == null)
{
for (int i = 0; i < length; i++)
{
if (Array.get(array, i) == null)
return i;
}
}
else
{
for (int i = 0; i < length; i++)
{
final Object o = Array.get(array, i);
if (value == o || value.equals(o))
return i;
}
}
return -1;
}
public void setAltMethodCall(boolean altMethodCall)
{
this.altMethodCall = altMethodCall;
}
}