/*
* Copyright (C) 2004-2015 L2J Server
*
* This file is part of L2J Server.
*
* L2J Server 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.
*
* L2J Server 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 .
*/
package com.l2jserver.gameserver.model.events;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.logging.Level;
import java.util.logging.Logger;
import javolution.util.FastList;
import javolution.util.FastSet;
import com.l2jserver.Config;
import com.l2jserver.gameserver.GameTimeController;
import com.l2jserver.gameserver.ai.CtrlIntention;
import com.l2jserver.gameserver.data.xml.impl.DoorData;
import com.l2jserver.gameserver.data.xml.impl.NpcData;
import com.l2jserver.gameserver.datatables.ItemTable;
import com.l2jserver.gameserver.enums.QuestSound;
import com.l2jserver.gameserver.instancemanager.CastleManager;
import com.l2jserver.gameserver.instancemanager.FortManager;
import com.l2jserver.gameserver.instancemanager.InstanceManager;
import com.l2jserver.gameserver.instancemanager.ZoneManager;
import com.l2jserver.gameserver.model.L2Spawn;
import com.l2jserver.gameserver.model.Location;
import com.l2jserver.gameserver.model.actor.L2Attackable;
import com.l2jserver.gameserver.model.actor.L2Character;
import com.l2jserver.gameserver.model.actor.L2Npc;
import com.l2jserver.gameserver.model.actor.L2Playable;
import com.l2jserver.gameserver.model.actor.instance.L2DoorInstance;
import com.l2jserver.gameserver.model.actor.instance.L2MonsterInstance;
import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
import com.l2jserver.gameserver.model.actor.instance.L2TrapInstance;
import com.l2jserver.gameserver.model.actor.templates.L2NpcTemplate;
import com.l2jserver.gameserver.model.entity.Castle;
import com.l2jserver.gameserver.model.entity.Fort;
import com.l2jserver.gameserver.model.entity.Instance;
import com.l2jserver.gameserver.model.events.annotations.Id;
import com.l2jserver.gameserver.model.events.annotations.Ids;
import com.l2jserver.gameserver.model.events.annotations.NpcLevelRange;
import com.l2jserver.gameserver.model.events.annotations.NpcLevelRanges;
import com.l2jserver.gameserver.model.events.annotations.Priority;
import com.l2jserver.gameserver.model.events.annotations.Range;
import com.l2jserver.gameserver.model.events.annotations.Ranges;
import com.l2jserver.gameserver.model.events.annotations.RegisterEvent;
import com.l2jserver.gameserver.model.events.annotations.RegisterType;
import com.l2jserver.gameserver.model.events.impl.IBaseEvent;
import com.l2jserver.gameserver.model.events.impl.character.OnCreatureKill;
import com.l2jserver.gameserver.model.events.impl.character.OnCreatureZoneEnter;
import com.l2jserver.gameserver.model.events.impl.character.OnCreatureZoneExit;
import com.l2jserver.gameserver.model.events.impl.character.npc.OnNpcCanBeSeen;
import com.l2jserver.gameserver.model.events.impl.character.npc.OnNpcCreatureSee;
import com.l2jserver.gameserver.model.events.impl.character.npc.OnNpcEventReceived;
import com.l2jserver.gameserver.model.events.impl.character.npc.OnNpcFirstTalk;
import com.l2jserver.gameserver.model.events.impl.character.npc.OnNpcMoveFinished;
import com.l2jserver.gameserver.model.events.impl.character.npc.OnNpcMoveNodeArrived;
import com.l2jserver.gameserver.model.events.impl.character.npc.OnNpcMoveRouteFinished;
import com.l2jserver.gameserver.model.events.impl.character.npc.OnNpcSkillFinished;
import com.l2jserver.gameserver.model.events.impl.character.npc.OnNpcSkillSee;
import com.l2jserver.gameserver.model.events.impl.character.npc.OnNpcSpawn;
import com.l2jserver.gameserver.model.events.impl.character.npc.OnNpcTeleport;
import com.l2jserver.gameserver.model.events.impl.character.npc.attackable.OnAttackableAggroRangeEnter;
import com.l2jserver.gameserver.model.events.impl.character.npc.attackable.OnAttackableAttack;
import com.l2jserver.gameserver.model.events.impl.character.npc.attackable.OnAttackableFactionCall;
import com.l2jserver.gameserver.model.events.impl.character.npc.attackable.OnAttackableHate;
import com.l2jserver.gameserver.model.events.impl.character.npc.attackable.OnAttackableKill;
import com.l2jserver.gameserver.model.events.impl.character.player.OnPlayerLogin;
import com.l2jserver.gameserver.model.events.impl.character.player.OnPlayerLogout;
import com.l2jserver.gameserver.model.events.impl.character.player.OnPlayerProfessionChange;
import com.l2jserver.gameserver.model.events.impl.character.player.OnPlayerSkillLearn;
import com.l2jserver.gameserver.model.events.impl.character.player.OnPlayerSummonSpawn;
import com.l2jserver.gameserver.model.events.impl.character.player.OnPlayerSummonTalk;
import com.l2jserver.gameserver.model.events.impl.character.trap.OnTrapAction;
import com.l2jserver.gameserver.model.events.impl.item.OnItemBypassEvent;
import com.l2jserver.gameserver.model.events.impl.item.OnItemTalk;
import com.l2jserver.gameserver.model.events.impl.olympiad.OnOlympiadMatchResult;
import com.l2jserver.gameserver.model.events.impl.sieges.castle.OnCastleSiegeFinish;
import com.l2jserver.gameserver.model.events.impl.sieges.castle.OnCastleSiegeOwnerChange;
import com.l2jserver.gameserver.model.events.impl.sieges.castle.OnCastleSiegeStart;
import com.l2jserver.gameserver.model.events.listeners.AbstractEventListener;
import com.l2jserver.gameserver.model.events.listeners.AnnotationEventListener;
import com.l2jserver.gameserver.model.events.listeners.ConsumerEventListener;
import com.l2jserver.gameserver.model.events.listeners.DummyEventListener;
import com.l2jserver.gameserver.model.events.listeners.FunctionEventListener;
import com.l2jserver.gameserver.model.events.listeners.RunnableEventListener;
import com.l2jserver.gameserver.model.events.returns.AbstractEventReturn;
import com.l2jserver.gameserver.model.events.returns.TerminateReturn;
import com.l2jserver.gameserver.model.holders.ItemHolder;
import com.l2jserver.gameserver.model.holders.SkillHolder;
import com.l2jserver.gameserver.model.interfaces.IPositionable;
import com.l2jserver.gameserver.model.itemcontainer.Inventory;
import com.l2jserver.gameserver.model.itemcontainer.PcInventory;
import com.l2jserver.gameserver.model.items.L2EtcItem;
import com.l2jserver.gameserver.model.items.L2Item;
import com.l2jserver.gameserver.model.items.instance.L2ItemInstance;
import com.l2jserver.gameserver.model.olympiad.Olympiad;
import com.l2jserver.gameserver.model.skills.Skill;
import com.l2jserver.gameserver.model.stats.Stats;
import com.l2jserver.gameserver.model.zone.L2ZoneType;
import com.l2jserver.gameserver.network.NpcStringId;
import com.l2jserver.gameserver.network.SystemMessageId;
import com.l2jserver.gameserver.network.serverpackets.ExShowScreenMessage;
import com.l2jserver.gameserver.network.serverpackets.InventoryUpdate;
import com.l2jserver.gameserver.network.serverpackets.SpecialCamera;
import com.l2jserver.gameserver.network.serverpackets.StatusUpdate;
import com.l2jserver.gameserver.network.serverpackets.SystemMessage;
import com.l2jserver.gameserver.scripting.ManagedScript;
import com.l2jserver.gameserver.util.MinionList;
import com.l2jserver.util.Rnd;
/**
* @author UnAfraid
*/
public abstract class AbstractScript extends ManagedScript
{
protected static final Logger _log = Logger.getLogger(AbstractScript.class.getName());
private final Map> _registeredIds = new ConcurrentHashMap<>();
private final List _listeners = new FastList().shared();
public AbstractScript()
{
initializeAnnotationListeners();
}
private void initializeAnnotationListeners()
{
final List ids = new ArrayList<>();
for (Method method : getClass().getMethods())
{
if (method.isAnnotationPresent(RegisterEvent.class) && method.isAnnotationPresent(RegisterType.class))
{
final RegisterEvent listener = method.getAnnotation(RegisterEvent.class);
final RegisterType regType = method.getAnnotation(RegisterType.class);
final ListenerRegisterType type = regType.value();
final EventType eventType = listener.value();
if (method.getParameterCount() != 1)
{
_log.log(Level.WARNING, getClass().getSimpleName() + ": Non properly defined annotation listener on method: " + method.getName() + " expected parameter count is 1 but found: " + method.getParameterCount());
continue;
}
else if (!eventType.isEventClass(method.getParameterTypes()[0]))
{
_log.log(Level.WARNING, getClass().getSimpleName() + ": Non properly defined annotation listener on method: " + method.getName() + " expected parameter to be type of: " + eventType.getEventClass().getSimpleName() + " but found: " + method.getParameterTypes()[0].getSimpleName());
continue;
}
else if (!eventType.isReturnClass(method.getReturnType()))
{
_log.log(Level.WARNING, getClass().getSimpleName() + ": Non properly defined annotation listener on method: " + method.getName() + " expected return type to be one of: " + Arrays.toString(eventType.getReturnClasses()) + " but found: " + method.getReturnType().getSimpleName());
continue;
}
int priority = 0;
// Clear the list
ids.clear();
// Scan for possible Id filters
for (Annotation annotation : method.getAnnotations())
{
if (annotation instanceof Id)
{
final Id npc = (Id) annotation;
for (int id : npc.value())
{
ids.add(id);
}
}
else if (annotation instanceof Ids)
{
final Ids npcs = (Ids) annotation;
for (Id npc : npcs.value())
{
for (int id : npc.value())
{
ids.add(id);
}
}
}
else if (annotation instanceof Range)
{
final Range range = (Range) annotation;
if (range.from() > range.to())
{
_log.log(Level.WARNING, getClass().getSimpleName() + ": Wrong " + annotation.getClass().getSimpleName() + " from is higher then to!");
continue;
}
for (int id = range.from(); id <= range.to(); id++)
{
ids.add(id);
}
}
else if (annotation instanceof Ranges)
{
final Ranges ranges = (Ranges) annotation;
for (Range range : ranges.value())
{
if (range.from() > range.to())
{
_log.log(Level.WARNING, getClass().getSimpleName() + ": Wrong " + annotation.getClass().getSimpleName() + " from is higher then to!");
continue;
}
for (int id = range.from(); id <= range.to(); id++)
{
ids.add(id);
}
}
}
else if (annotation instanceof NpcLevelRange)
{
final NpcLevelRange range = (NpcLevelRange) annotation;
if (range.from() > range.to())
{
_log.log(Level.WARNING, getClass().getSimpleName() + ": Wrong " + annotation.getClass().getSimpleName() + " from is higher then to!");
continue;
}
else if (type != ListenerRegisterType.NPC)
{
_log.log(Level.WARNING, getClass().getSimpleName() + ": ListenerRegisterType " + type + " for " + annotation.getClass().getSimpleName() + " NPC is expected!");
continue;
}
for (int level = range.from(); level <= range.to(); level++)
{
final List templates = NpcData.getInstance().getAllOfLevel(level);
templates.forEach(template -> ids.add(template.getId()));
}
}
else if (annotation instanceof NpcLevelRanges)
{
final NpcLevelRanges ranges = (NpcLevelRanges) annotation;
for (NpcLevelRange range : ranges.value())
{
if (range.from() > range.to())
{
_log.log(Level.WARNING, getClass().getSimpleName() + ": Wrong " + annotation.getClass().getSimpleName() + " from is higher then to!");
continue;
}
else if (type != ListenerRegisterType.NPC)
{
_log.log(Level.WARNING, getClass().getSimpleName() + ": ListenerRegisterType " + type + " for " + annotation.getClass().getSimpleName() + " NPC is expected!");
continue;
}
for (int level = range.from(); level <= range.to(); level++)
{
final List templates = NpcData.getInstance().getAllOfLevel(level);
templates.forEach(template -> ids.add(template.getId()));
}
}
}
else if (annotation instanceof Priority)
{
final Priority p = (Priority) annotation;
priority = p.value();
}
}
if (!ids.isEmpty())
{
if (!_registeredIds.containsKey(type))
{
_registeredIds.put(type, new FastSet().shared());
}
_registeredIds.get(type).addAll(ids);
}
registerAnnotation(method, eventType, type, priority, ids);
}
}
}
/**
* Unloads all listeners registered by this class.
*/
@Override
public boolean unload()
{
_listeners.forEach(AbstractEventListener::unregisterMe);
_listeners.clear();
return true;
}
// ---------------------------------------------------------------------------------------------------------------------------
/**
* Provides delayed (Depending on {@link com.l2jserver.gameserver.model.actor.L2Attackable#getOnKillDelay()}) callback operation when L2Attackable dies from a player.
* @param callback
* @param npcIds
* @return
*/
protected final List setAttackableKillId(Consumer callback, int... npcIds)
{
return registerConsumer(callback, EventType.ON_ATTACKABLE_KILL, ListenerRegisterType.NPC, npcIds);
}
/**
* Provides delayed (Depending on {@link com.l2jserver.gameserver.model.actor.L2Attackable#getOnKillDelay()}) callback operation when L2Attackable dies from a player.
* @param callback
* @param npcIds
* @return
*/
protected final List setAttackableKillId(Consumer callback, Collection npcIds)
{
return registerConsumer(callback, EventType.ON_ATTACKABLE_KILL, ListenerRegisterType.NPC, npcIds);
}
// ---------------------------------------------------------------------------------------------------------------------------
/**
* Provides instant callback operation when L2Attackable dies from a player with return type.
* @param callback
* @param npcIds
* @return
*/
protected final List addCreatureKillId(Function callback, int... npcIds)
{
return registerFunction(callback, EventType.ON_CREATURE_KILL, ListenerRegisterType.NPC, npcIds);
}
/**
* Provides instant callback operation when L2Attackable dies from a player.
* @param callback
* @param npcIds
* @return
*/
protected final List setCreatureKillId(Consumer callback, int... npcIds)
{
return registerConsumer(callback, EventType.ON_CREATURE_KILL, ListenerRegisterType.NPC, npcIds);
}
/**
* Provides instant callback operation when {@link L2Attackable} dies from a {@link L2PcInstance}.
* @param callback
* @param npcIds
* @return
*/
protected final List setCreatureKillId(Consumer callback, Collection npcIds)
{
return registerConsumer(callback, EventType.ON_CREATURE_KILL, ListenerRegisterType.NPC, npcIds);
}
// ---------------------------------------------------------------------------------------------------------------------------
/**
* Provides instant callback operation when {@link L2PcInstance} talk to {@link L2Npc} for first time.
* @param callback
* @param npcIds
* @return
*/
protected final List setNpcFirstTalkId(Consumer callback, int... npcIds)
{
return registerConsumer(callback, EventType.ON_NPC_FIRST_TALK, ListenerRegisterType.NPC, npcIds);
}
/**
* Provides instant callback operation when {@link L2PcInstance} talk to {@link L2Npc} for first time.
* @param callback
* @param npcIds
* @return
*/
protected final List setNpcFirstTalkId(Consumer callback, Collection npcIds)
{
return registerConsumer(callback, EventType.ON_NPC_FIRST_TALK, ListenerRegisterType.NPC, npcIds);
}
// ---------------------------------------------------------------------------------------------------------------------------
/**
* Provides instant callback operation when {@link L2PcInstance} talk to {@link L2Npc}.
* @param npcIds
* @return
*/
protected final List setNpcTalkId(Collection npcIds)
{
return registerDummy(EventType.ON_NPC_TALK, ListenerRegisterType.NPC, npcIds);
}
/**
* Provides instant callback operation when {@link L2PcInstance} talk to {@link L2Npc}.
* @param npcIds
* @return
*/
protected final List setNpcTalkId(int... npcIds)
{
return registerDummy(EventType.ON_NPC_TALK, ListenerRegisterType.NPC, npcIds);
}
// ---------------------------------------------------------------------------------------------------------------------------
/**
* Provides instant callback operation when teleport {@link L2Npc}.
* @param callback
* @param npcIds
* @return
*/
protected final List setNpcTeleportId(Consumer callback, Collection npcIds)
{
return registerConsumer(callback, EventType.ON_NPC_TELEPORT, ListenerRegisterType.NPC, npcIds);
}
/**
* Provides instant callback operation when teleport {@link L2Npc}.
* @param callback
* @param npcIds
* @return
*/
protected final List setNpcTeleportId(Consumer callback, int... npcIds)
{
return registerConsumer(callback, EventType.ON_NPC_TELEPORT, ListenerRegisterType.NPC, npcIds);
}
// ---------------------------------------------------------------------------------------------------------------------------
/**
* Provides instant callback operation when {@link L2PcInstance} talk to {@link L2Npc} and must receive quest state.
* @param npcIds
* @return
*/
protected final List setNpcQuestStartId(int... npcIds)
{
return registerDummy(EventType.ON_NPC_QUEST_START, ListenerRegisterType.NPC, npcIds);
}
/**
* Provides instant callback operation when {@link L2PcInstance} talk to {@link L2Npc} and must receive quest state.
* @param npcIds
* @return
*/
protected final List setNpcQuestStartId(Collection npcIds)
{
return registerDummy(EventType.ON_NPC_QUEST_START, ListenerRegisterType.NPC, npcIds);
}
// ---------------------------------------------------------------------------------------------------------------------------
/**
* Provides instant callback operation when L2Npc sees skill from a player.
* @param callback
* @param npcIds
* @return
*/
protected final List setNpcSkillSeeId(Consumer callback, int... npcIds)
{
return registerConsumer(callback, EventType.ON_NPC_SKILL_SEE, ListenerRegisterType.NPC, npcIds);
}
/**
* Provides instant callback operation when L2Npc sees skill from a player.
* @param callback
* @param npcIds
* @return
*/
protected final List setNpcSkillSeeId(Consumer callback, Collection npcIds)
{
return registerConsumer(callback, EventType.ON_NPC_SKILL_SEE, ListenerRegisterType.NPC, npcIds);
}
// ---------------------------------------------------------------------------------------------------------------------------
/**
* Provides instant callback operation when L2Npc casts skill on a player.
* @param callback
* @param npcIds
* @return
*/
protected final List setNpcSkillFinishedId(Consumer callback, int... npcIds)
{
return registerConsumer(callback, EventType.ON_NPC_SKILL_FINISHED, ListenerRegisterType.NPC, npcIds);
}
/**
* Provides instant callback operation when L2Npc casts skill on a player.
* @param callback
* @param npcIds
* @return
*/
protected final List setNpcSkillFinishedId(Consumer callback, Collection npcIds)
{
return registerConsumer(callback, EventType.ON_NPC_SKILL_FINISHED, ListenerRegisterType.NPC, npcIds);
}
// ---------------------------------------------------------------------------------------------------------------------------
/**
* Provides instant callback operation when L2Npc is spawned.
* @param callback
* @param npcIds
* @return
*/
protected final List setNpcSpawnId(Consumer callback, int... npcIds)
{
return registerConsumer(callback, EventType.ON_NPC_SPAWN, ListenerRegisterType.NPC, npcIds);
}
/**
* Provides instant callback operation when L2Npc is spawned.
* @param callback
* @param npcIds
* @return
*/
protected final List setNpcSpawnId(Consumer callback, Collection npcIds)
{
return registerConsumer(callback, EventType.ON_NPC_SPAWN, ListenerRegisterType.NPC, npcIds);
}
// ---------------------------------------------------------------------------------------------------------------------------
/**
* Provides instant callback operation when {@link L2Npc} receives event from another {@link L2Npc}
* @param callback
* @param npcIds
* @return
*/
protected final List setNpcEventReceivedId(Consumer callback, int... npcIds)
{
return registerConsumer(callback, EventType.ON_NPC_EVENT_RECEIVED, ListenerRegisterType.NPC, npcIds);
}
/**
* Provides instant callback operation when {@link L2Npc} receives event from another {@link L2Npc}
* @param callback
* @param npcIds
* @return
*/
protected final List setNpcEventReceivedId(Consumer callback, Collection npcIds)
{
return registerConsumer(callback, EventType.ON_NPC_EVENT_RECEIVED, ListenerRegisterType.NPC, npcIds);
}
// ---------------------------------------------------------------------------------------------------------------------------
/**
* Provides instant callback operation when {@link L2Npc} finishes to move.
* @param callback
* @param npcIds
* @return
*/
protected final List setNpcMoveFinishedId(Consumer callback, int... npcIds)
{
return registerConsumer(callback, EventType.ON_NPC_MOVE_FINISHED, ListenerRegisterType.NPC, npcIds);
}
/**
* Provides instant callback operation when {@link L2Npc} finishes to move.
* @param callback
* @param npcIds
* @return
*/
protected final List setNpcMoveFinishedId(Consumer callback, Collection npcIds)
{
return registerConsumer(callback, EventType.ON_NPC_MOVE_FINISHED, ListenerRegisterType.NPC, npcIds);
}
// ---------------------------------------------------------------------------------------------------------------------------
/**
* Provides instant callback operation when {@link L2Npc} arrive to node of its route
* @param callback
* @param npcIds
* @return
*/
protected final List setNpcMoveNodeArrivedId(Consumer callback, int... npcIds)
{
return registerConsumer(callback, EventType.ON_NPC_MOVE_NODE_ARRIVED, ListenerRegisterType.NPC, npcIds);
}
/**
* Provides instant callback operation when {@link L2Npc} arrive to node of its route
* @param callback
* @param npcIds
* @return
*/
protected final List setNpcMoveNodeArrivedId(Consumer callback, Collection npcIds)
{
return registerConsumer(callback, EventType.ON_NPC_MOVE_NODE_ARRIVED, ListenerRegisterType.NPC, npcIds);
}
// ---------------------------------------------------------------------------------------------------------------------------
/**
* Provides instant callback operation when {@link L2Npc} finishes to move on its route.
* @param callback
* @param npcIds
* @return
*/
protected final List setNpcMoveRouteFinishedId(Consumer callback, int... npcIds)
{
return registerConsumer(callback, EventType.ON_NPC_MOVE_ROUTE_FINISHED, ListenerRegisterType.NPC, npcIds);
}
/**
* Provides instant callback operation when {@link L2Npc} finishes to move on its route.
* @param callback
* @param npcIds
* @return
*/
protected final List setNpcMoveRouteFinishedId(Consumer callback, Collection npcIds)
{
return registerConsumer(callback, EventType.ON_NPC_MOVE_ROUTE_FINISHED, ListenerRegisterType.NPC, npcIds);
}
// ---------------------------------------------------------------------------------------------------------------------------
/**
* Provides instant callback operation when {@link L2Npc} is about to hate and start attacking a creature.
* @param callback
* @param npcIds
* @return
*/
protected final List setNpcHateId(Consumer callback, int... npcIds)
{
return registerConsumer(callback, EventType.ON_NPC_HATE, ListenerRegisterType.NPC, npcIds);
}
/**
* Provides instant callback operation when {@link L2Npc} is about to hate and start attacking a creature.
* @param callback
* @param npcIds
* @return
*/
protected final List setNpcHateId(Consumer callback, Collection npcIds)
{
return registerConsumer(callback, EventType.ON_NPC_HATE, ListenerRegisterType.NPC, npcIds);
}
/**
* Provides instant callback operation when {@link L2Npc} is about to hate and start attacking a creature.
* @param callback
* @param npcIds
* @return
*/
protected final List addNpcHateId(Function callback, int... npcIds)
{
return registerFunction(callback, EventType.ON_NPC_HATE, ListenerRegisterType.NPC, npcIds);
}
/**
* Provides instant callback operation when {@link L2Npc} is about to hate and start attacking a creature.
* @param callback
* @param npcIds
* @return
*/
protected final List addNpcHateId(Function callback, Collection npcIds)
{
return registerFunction(callback, EventType.ON_NPC_HATE, ListenerRegisterType.NPC, npcIds);
}
// ---------------------------------------------------------------------------------------------------------------------------
/**
* Provides instant callback operation when {@link L2Npc} is about to hate and start attacking a creature.
* @param callback
* @param npcIds
* @return
*/
protected final List setNpcCanBeSeenId(Consumer callback, int... npcIds)
{
return registerConsumer(callback, EventType.ON_NPC_CAN_BE_SEEN, ListenerRegisterType.NPC, npcIds);
}
/**
* Provides instant callback operation when {@link L2Npc} is about to hate and start attacking a creature.
* @param callback
* @param npcIds
* @return
*/
protected final List setNpcCanBeSeenId(Consumer callback, Collection npcIds)
{
return registerConsumer(callback, EventType.ON_NPC_CAN_BE_SEEN, ListenerRegisterType.NPC, npcIds);
}
/**
* Provides instant callback operation when {@link L2Npc} is about to hate and start attacking a creature.
* @param callback
* @param npcIds
* @return
*/
protected final List setNpcCanBeSeenId(Function callback, int... npcIds)
{
return registerFunction(callback, EventType.ON_NPC_CAN_BE_SEEN, ListenerRegisterType.NPC, npcIds);
}
/**
* Provides instant callback operation when {@link L2Npc} is about to hate and start attacking a creature.
* @param callback
* @param npcIds
* @return
*/
protected final List setNpcCanBeSeenId(Function callback, Collection npcIds)
{
return registerFunction(callback, EventType.ON_NPC_CAN_BE_SEEN, ListenerRegisterType.NPC, npcIds);
}
// ---------------------------------------------------------------------------------------------------------------------------
/**
* Provides instant callback operation when {@link L2Npc} sees another creature.
* @param callback
* @param npcIds
* @return
*/
protected final List setNpcCreatureSeeId(Consumer callback, int... npcIds)
{
return registerConsumer(callback, EventType.ON_NPC_CREATURE_SEE, ListenerRegisterType.NPC, npcIds);
}
/**
* Provides instant callback operation when {@link L2Npc} sees another creature.
* @param callback
* @param npcIds
* @return
*/
protected final List setNpcCreatureSeeId(Consumer callback, Collection npcIds)
{
return registerConsumer(callback, EventType.ON_NPC_CREATURE_SEE, ListenerRegisterType.NPC, npcIds);
}
// ---------------------------------------------------------------------------------------------------------------------------
/**
* Provides instant callback operation when L2Attackable is under attack to other clan mates.
* @param callback
* @param npcIds
* @return
*/
protected final List setAttackableFactionIdId(Consumer callback, int... npcIds)
{
return registerConsumer(callback, EventType.ON_ATTACKABLE_FACTION_CALL, ListenerRegisterType.NPC, npcIds);
}
/**
* Provides instant callback operation when L2Attackable is under attack to other clan mates.
* @param callback
* @param npcIds
* @return
*/
protected final List setAttackableFactionIdId(Consumer callback, Collection npcIds)
{
return registerConsumer(callback, EventType.ON_ATTACKABLE_FACTION_CALL, ListenerRegisterType.NPC, npcIds);
}
// ---------------------------------------------------------------------------------------------------------------------------
/**
* Provides instant callback operation when L2Attackable is attacked from a player.
* @param callback
* @param npcIds
* @return
*/
protected final List setAttackableAttackId(Consumer callback, int... npcIds)
{
return registerConsumer(callback, EventType.ON_ATTACKABLE_ATTACK, ListenerRegisterType.NPC, npcIds);
}
/**
* Provides instant callback operation when L2Attackable is attacked from a player.
* @param callback
* @param npcIds
* @return
*/
protected final List setAttackableAttackId(Consumer callback, Collection npcIds)
{
return registerConsumer(callback, EventType.ON_ATTACKABLE_ATTACK, ListenerRegisterType.NPC, npcIds);
}
// ---------------------------------------------------------------------------------------------------------------------------
/**
* Provides instant callback operation when {@link L2PcInstance} enters in {@link L2Attackable}'s aggressive range.
* @param callback
* @param npcIds
* @return
*/
protected final List setAttackableAggroRangeEnterId(Consumer callback, int... npcIds)
{
return registerConsumer(callback, EventType.ON_ATTACKABLE_AGGRO_RANGE_ENTER, ListenerRegisterType.NPC, npcIds);
}
/**
* Provides instant callback operation when {@link L2PcInstance} enters in {@link L2Attackable}'s aggressive range.
* @param callback
* @param npcIds
* @return
*/
protected final List setAttackableAggroRangeEnterId(Consumer callback, Collection npcIds)
{
return registerConsumer(callback, EventType.ON_ATTACKABLE_AGGRO_RANGE_ENTER, ListenerRegisterType.NPC, npcIds);
}
// ---------------------------------------------------------------------------------------------------------------------------
/**
* Provides instant callback operation when {@link L2PcInstance} learn's a {@link Skill}.
* @param callback
* @param npcIds
* @return
*/
protected final List setPlayerSkillLearnId(Consumer callback, int... npcIds)
{
return registerConsumer(callback, EventType.ON_PLAYER_SKILL_LEARN, ListenerRegisterType.NPC, npcIds);
}
/**
* Provides instant callback operation when {@link L2PcInstance} learn's a {@link Skill}.
* @param callback
* @param npcIds
* @return
*/
protected final List setPlayerSkillLearnId(Consumer callback, Collection npcIds)
{
return registerConsumer(callback, EventType.ON_PLAYER_SKILL_LEARN, ListenerRegisterType.NPC, npcIds);
}
// ---------------------------------------------------------------------------------------------------------------------------
/**
* Provides instant callback operation when {@link L2PcInstance} summons a servitor or a pet
* @param callback
* @param npcIds
* @return
*/
protected final List setPlayerSummonSpawnId(Consumer callback, int... npcIds)
{
return registerConsumer(callback, EventType.ON_PLAYER_SUMMON_SPAWN, ListenerRegisterType.NPC, npcIds);
}
/**
* Provides instant callback operation when {@link L2PcInstance} summons a servitor or a pet
* @param callback
* @param npcIds
* @return
*/
protected final List setPlayerSummonSpawnId(Consumer callback, Collection npcIds)
{
return registerConsumer(callback, EventType.ON_PLAYER_SUMMON_SPAWN, ListenerRegisterType.NPC, npcIds);
}
// ---------------------------------------------------------------------------------------------------------------------------
/**
* Provides instant callback operation when {@link L2PcInstance} talk with a servitor or a pet
* @param callback
* @param npcIds
* @return
*/
protected final List setPlayerSummonTalkId(Consumer callback, int... npcIds)
{
return registerConsumer(callback, EventType.ON_PLAYER_SUMMON_TALK, ListenerRegisterType.NPC, npcIds);
}
/**
* Provides instant callback operation when {@link L2PcInstance} talk with a servitor or a pet
* @param callback
* @param npcIds
* @return
*/
protected final List setPlayerSummonTalkId(Consumer callback, Collection npcIds)
{
return registerConsumer(callback, EventType.ON_PLAYER_SUMMON_TALK, ListenerRegisterType.NPC, npcIds);
}
// ---------------------------------------------------------------------------------------------------------------------------
/**
* Provides instant callback operation when {@link L2PcInstance} summons a servitor or a pet
* @param callback
* @return
*/
protected final List setPlayerLoginId(Consumer callback)
{
return registerConsumer(callback, EventType.ON_PLAYER_LOGIN, ListenerRegisterType.GLOBAL);
}
// ---------------------------------------------------------------------------------------------------------------------------
/**
* Provides instant callback operation when {@link L2PcInstance} summons a servitor or a pet
* @param callback
* @return
*/
protected final List setPlayerLogoutId(Consumer callback)
{
return registerConsumer(callback, EventType.ON_PLAYER_LOGOUT, ListenerRegisterType.GLOBAL);
}
// ---------------------------------------------------------------------------------------------------------------------------
/**
* Provides instant callback operation when {@link com.l2jserver.gameserver.model.actor.L2Character} Enters on a {@link L2ZoneType}.
* @param callback
* @param npcIds
* @return
*/
protected final List setCreatureZoneEnterId(Consumer callback, int... npcIds)
{
return registerConsumer(callback, EventType.ON_CREATURE_ZONE_ENTER, ListenerRegisterType.ZONE, npcIds);
}
/**
* Provides instant callback operation when {@link com.l2jserver.gameserver.model.actor.L2Character} Enters on a {@link L2ZoneType}.
* @param callback
* @param npcIds
* @return
*/
protected final List setCreatureZoneEnterId(Consumer callback, Collection npcIds)
{
return registerConsumer(callback, EventType.ON_CREATURE_ZONE_ENTER, ListenerRegisterType.ZONE, npcIds);
}
// ---------------------------------------------------------------------------------------------------------------------------
/**
* Provides instant callback operation when {@link com.l2jserver.gameserver.model.actor.L2Character} Exits on a {@link L2ZoneType}.
* @param callback
* @param npcIds
* @return
*/
protected final List setCreatureZoneExitId(Consumer callback, int... npcIds)
{
return registerConsumer(callback, EventType.ON_CREATURE_ZONE_EXIT, ListenerRegisterType.ZONE, npcIds);
}
/**
* Provides instant callback operation when {@link com.l2jserver.gameserver.model.actor.L2Character} Exits on a {@link L2ZoneType}.
* @param callback
* @param npcIds
* @return
*/
protected final List setCreatureZoneExitId(Consumer callback, Collection npcIds)
{
return registerConsumer(callback, EventType.ON_CREATURE_ZONE_EXIT, ListenerRegisterType.ZONE, npcIds);
}
// ---------------------------------------------------------------------------------------------------------------------------
/**
* Provides instant callback operation when {@link com.l2jserver.gameserver.model.actor.instance.L2TrapInstance} acts.
* @param callback
* @param npcIds
* @return
*/
protected final List setTrapActionId(Consumer callback, int... npcIds)
{
return registerConsumer(callback, EventType.ON_TRAP_ACTION, ListenerRegisterType.NPC, npcIds);
}
/**
* Provides instant callback operation when {@link com.l2jserver.gameserver.model.actor.instance.L2TrapInstance} acts.
* @param callback
* @param npcIds
* @return
*/
protected final List setTrapActionId(Consumer callback, Collection npcIds)
{
return registerConsumer(callback, EventType.ON_TRAP_ACTION, ListenerRegisterType.NPC, npcIds);
}
// ---------------------------------------------------------------------------------------------------------------------------
/**
* Provides instant callback operation when {@link L2Item} receives an event from {@link L2PcInstance}.
* @param callback
* @param npcIds
* @return
*/
protected final List setItemBypassEvenId(Consumer callback, int... npcIds)
{
return registerConsumer(callback, EventType.ON_ITEM_BYPASS_EVENT, ListenerRegisterType.ITEM, npcIds);
}
/**
* Provides instant callback operation when {@link L2Item} receives an event from {@link L2PcInstance}.
* @param callback
* @param npcIds
* @return
*/
protected final List setItemBypassEvenId(Consumer callback, Collection npcIds)
{
return registerConsumer(callback, EventType.ON_ITEM_BYPASS_EVENT, ListenerRegisterType.ITEM, npcIds);
}
// ---------------------------------------------------------------------------------------------------------------------------
/**
* Provides instant callback operation when {@link L2PcInstance} talk to {@link L2Item}.
* @param callback
* @param npcIds
* @return
*/
protected final List setItemTalkId(Consumer callback, int... npcIds)
{
return registerConsumer(callback, EventType.ON_ITEM_TALK, ListenerRegisterType.ITEM, npcIds);
}
/**
* Provides instant callback operation when {@link L2PcInstance} talk to {@link L2Item}.
* @param callback
* @param npcIds
* @return
*/
protected final List setItemTalkId(Consumer callback, Collection npcIds)
{
return registerConsumer(callback, EventType.ON_ITEM_TALK, ListenerRegisterType.ITEM, npcIds);
}
// ---------------------------------------------------------------------------------------------------------------------------
/**
* Provides instant callback operation when Olympiad match finishes.
* @param callback
* @return
*/
protected final List setOlympiadMatchResult(Consumer callback)
{
return registerConsumer(callback, EventType.ON_OLYMPIAD_MATCH_RESULT, ListenerRegisterType.OLYMPIAD);
}
// ---------------------------------------------------------------------------------------------------------------------------
/**
* Provides instant callback operation when castle siege begins
* @param callback
* @param castleIds
* @return
*/
protected final List setCastleSiegeStartId(Consumer callback, int... castleIds)
{
return registerConsumer(callback, EventType.ON_CASTLE_SIEGE_START, ListenerRegisterType.CASTLE, castleIds);
}
/**
* Provides instant callback operation when castle siege begins
* @param callback
* @param castleIds
* @return
*/
protected final List setCastleSiegeStartId(Consumer callback, Collection castleIds)
{
return registerConsumer(callback, EventType.ON_CASTLE_SIEGE_START, ListenerRegisterType.CASTLE, castleIds);
}
// ---------------------------------------------------------------------------------------------------------------------------
/**
* Provides instant callback operation when Castle owner has changed during a siege
* @param callback
* @param castleIds
* @return
*/
protected final List setCastleSiegeOwnerChangeId(Consumer callback, int... castleIds)
{
return registerConsumer(callback, EventType.ON_CASTLE_SIEGE_OWNER_CHANGE, ListenerRegisterType.CASTLE, castleIds);
}
/**
* Provides instant callback operation when Castle owner has changed during a siege
* @param callback
* @param castleIds
* @return
*/
protected final List setCastleSiegeOwnerChangeId(Consumer callback, Collection castleIds)
{
return registerConsumer(callback, EventType.ON_CASTLE_SIEGE_OWNER_CHANGE, ListenerRegisterType.CASTLE, castleIds);
}
// ---------------------------------------------------------------------------------------------------------------------------
/**
* Provides instant callback operation when castle siege ends
* @param callback
* @param castleIds
* @return
*/
protected final List setCastleSiegeFinishId(Consumer callback, int... castleIds)
{
return registerConsumer(callback, EventType.ON_CASTLE_SIEGE_FINISH, ListenerRegisterType.CASTLE, castleIds);
}
/**
* Provides instant callback operation when castle siege ends
* @param callback
* @param castleIds
* @return
*/
protected final List setCastleSiegeFinishId(Consumer callback, Collection castleIds)
{
return registerConsumer(callback, EventType.ON_CASTLE_SIEGE_FINISH, ListenerRegisterType.CASTLE, castleIds);
}
// ---------------------------------------------------------------------------------------------------------------------------
/**
* Provides instant callback operation when player's profession has change
* @param callback
* @return
*/
protected final List setPlayerProfessionChangeId(Consumer callback)
{
return registerConsumer(callback, EventType.ON_PLAYER_PROFESSION_CHANGE, ListenerRegisterType.GLOBAL);
}
// --------------------------------------------------------------------------------------------------
// --------------------------------Default listener register methods---------------------------------
// --------------------------------------------------------------------------------------------------
/**
* Method that registers Function type of listeners (Listeners that need parameters but doesn't return objects)
* @param callback
* @param type
* @param registerType
* @param npcIds
* @return
*/
protected final List registerConsumer(Consumer callback, EventType type, ListenerRegisterType registerType, int... npcIds)
{
return registerListener((container) -> new ConsumerEventListener(container, type, callback, this), registerType, npcIds);
}
/**
* Method that registers Function type of listeners (Listeners that need parameters but doesn't return objects)
* @param callback
* @param type
* @param registerType
* @param npcIds
* @return
*/
protected final List registerConsumer(Consumer callback, EventType type, ListenerRegisterType registerType, Collection npcIds)
{
return registerListener((container) -> new ConsumerEventListener(container, type, callback, this), registerType, npcIds);
}
/**
* Method that registers Function type of listeners (Listeners that need parameters and return objects)
* @param callback
* @param type
* @param registerType
* @param npcIds
* @return
*/
protected final List registerFunction(Function callback, EventType type, ListenerRegisterType registerType, int... npcIds)
{
return registerListener((container) -> new FunctionEventListener(container, type, callback, this), registerType, npcIds);
}
/**
* Method that registers Function type of listeners (Listeners that need parameters and return objects)
* @param callback
* @param type
* @param registerType
* @param npcIds
* @return
*/
protected final List registerFunction(Function callback, EventType type, ListenerRegisterType registerType, Collection npcIds)
{
return registerListener((container) -> new FunctionEventListener(container, type, callback, this), registerType, npcIds);
}
/**
* Method that registers runnable type of listeners (Listeners that doesn't needs parameters or return objects)
* @param callback
* @param type
* @param registerType
* @param npcIds
* @return
*/
protected final List registerRunnable(Runnable callback, EventType type, ListenerRegisterType registerType, int... npcIds)
{
return registerListener((container) -> new RunnableEventListener(container, type, callback, this), registerType, npcIds);
}
/**
* Method that registers runnable type of listeners (Listeners that doesn't needs parameters or return objects)
* @param callback
* @param type
* @param registerType
* @param npcIds
* @return
*/
protected final List registerRunnable(Runnable callback, EventType type, ListenerRegisterType registerType, Collection npcIds)
{
return registerListener((container) -> new RunnableEventListener(container, type, callback, this), registerType, npcIds);
}
/**
* Method that registers runnable type of listeners (Listeners that doesn't needs parameters or return objects)
* @param callback
* @param type
* @param registerType
* @param priority
* @param npcIds
* @return
*/
protected final List registerAnnotation(Method callback, EventType type, ListenerRegisterType registerType, int priority, int... npcIds)
{
return registerListener((container) -> new AnnotationEventListener(container, type, callback, this, priority), registerType, npcIds);
}
/**
* Method that registers runnable type of listeners (Listeners that doesn't needs parameters or return objects)
* @param callback
* @param type
* @param registerType
* @param priority
* @param npcIds
* @return
*/
protected final List registerAnnotation(Method callback, EventType type, ListenerRegisterType registerType, int priority, Collection npcIds)
{
return registerListener((container) -> new AnnotationEventListener(container, type, callback, this, priority), registerType, npcIds);
}
/**
* Method that registers dummy type of listeners (Listeners doesn't gets notification but just used to check if their type present or not)
* @param type
* @param registerType
* @param npcIds
* @return
*/
protected final List registerDummy(EventType type, ListenerRegisterType registerType, int... npcIds)
{
return registerListener((container) -> new DummyEventListener(container, type, this), registerType, npcIds);
}
/**
* Method that registers dummy type of listeners (Listeners doesn't gets notification but just used to check if their type present or not)
* @param type
* @param registerType
* @param npcIds
* @return
*/
protected final List registerDummy(EventType type, ListenerRegisterType registerType, Collection npcIds)
{
return registerListener((container) -> new DummyEventListener(container, type, this), registerType, npcIds);
}
// --------------------------------------------------------------------------------------------------
// --------------------------------------Register methods--------------------------------------------
// --------------------------------------------------------------------------------------------------
/**
* Generic listener register method
* @param action
* @param registerType
* @param ids
* @return
*/
protected final List registerListener(Function action, ListenerRegisterType registerType, int... ids)
{
final List listeners = new ArrayList<>(ids.length > 0 ? ids.length : 1);
if (ids.length > 0)
{
for (int id : ids)
{
switch (registerType)
{
case NPC:
{
final L2NpcTemplate template = NpcData.getInstance().getTemplate(id);
if (template != null)
{
listeners.add(template.addListener(action.apply(template)));
}
break;
}
case ZONE:
{
final L2ZoneType template = ZoneManager.getInstance().getZoneById(id);
if (template != null)
{
listeners.add(template.addListener(action.apply(template)));
}
break;
}
case ITEM:
{
final L2Item template = ItemTable.getInstance().getTemplate(id);
if (template != null)
{
listeners.add(template.addListener(action.apply(template)));
}
break;
}
case CASTLE:
{
final Castle template = CastleManager.getInstance().getCastleById(id);
if (template != null)
{
listeners.add(template.addListener(action.apply(template)));
}
break;
}
case FORTRESS:
{
final Fort template = FortManager.getInstance().getFortById(id);
if (template != null)
{
listeners.add(template.addListener(action.apply(template)));
}
break;
}
default:
{
_log.log(Level.WARNING, getClass().getSimpleName() + ": Unhandled register type: " + registerType);
}
}
if (!_registeredIds.containsKey(registerType))
{
_registeredIds.put(registerType, new FastSet().shared());
}
_registeredIds.get(registerType).add(id);
}
}
else
{
switch (registerType)
{
case OLYMPIAD:
{
final Olympiad template = Olympiad.getInstance();
listeners.add(template.addListener(action.apply(template)));
break;
}
case GLOBAL: // Global Listener
{
final ListenersContainer template = Containers.Global();
listeners.add(template.addListener(action.apply(template)));
break;
}
case GLOBAL_NPCS: // Global Npcs Listener
{
final ListenersContainer template = Containers.Npcs();
listeners.add(template.addListener(action.apply(template)));
break;
}
case GLOBAL_MONSTERS: // Global Monsters Listener
{
final ListenersContainer template = Containers.Monsters();
listeners.add(template.addListener(action.apply(template)));
break;
}
case GLOBAL_PLAYERS: // Global Players Listener
{
final ListenersContainer template = Containers.Players();
listeners.add(template.addListener(action.apply(template)));
break;
}
}
}
_listeners.addAll(listeners);
return listeners;
}
/**
* Generic listener register method
* @param action
* @param registerType
* @param ids
* @return
*/
protected final List registerListener(Function action, ListenerRegisterType registerType, Collection ids)
{
final List listeners = new ArrayList<>(!ids.isEmpty() ? ids.size() : 1);
if (!ids.isEmpty())
{
for (int id : ids)
{
switch (registerType)
{
case NPC:
{
final L2NpcTemplate template = NpcData.getInstance().getTemplate(id);
if (template != null)
{
listeners.add(template.addListener(action.apply(template)));
}
break;
}
case ZONE:
{
final L2ZoneType template = ZoneManager.getInstance().getZoneById(id);
if (template != null)
{
listeners.add(template.addListener(action.apply(template)));
}
break;
}
case ITEM:
{
final L2Item template = ItemTable.getInstance().getTemplate(id);
if (template != null)
{
listeners.add(template.addListener(action.apply(template)));
}
break;
}
case CASTLE:
{
final Castle template = CastleManager.getInstance().getCastleById(id);
if (template != null)
{
listeners.add(template.addListener(action.apply(template)));
}
break;
}
case FORTRESS:
{
final Fort template = FortManager.getInstance().getFortById(id);
if (template != null)
{
listeners.add(template.addListener(action.apply(template)));
}
break;
}
default:
{
_log.log(Level.WARNING, getClass().getSimpleName() + ": Unhandled register type: " + registerType);
}
}
}
if (!_registeredIds.containsKey(registerType))
{
_registeredIds.put(registerType, new FastSet().shared());
}
_registeredIds.get(registerType).addAll(ids);
}
else
{
switch (registerType)
{
case OLYMPIAD:
{
final Olympiad template = Olympiad.getInstance();
listeners.add(template.addListener(action.apply(template)));
break;
}
case GLOBAL: // Global Listener
{
final ListenersContainer template = Containers.Global();
listeners.add(template.addListener(action.apply(template)));
break;
}
case GLOBAL_NPCS: // Global Npcs Listener
{
final ListenersContainer template = Containers.Npcs();
listeners.add(template.addListener(action.apply(template)));
break;
}
case GLOBAL_MONSTERS: // Global Monsters Listener
{
final ListenersContainer template = Containers.Monsters();
listeners.add(template.addListener(action.apply(template)));
break;
}
case GLOBAL_PLAYERS: // Global Players Listener
{
final ListenersContainer template = Containers.Players();
listeners.add(template.addListener(action.apply(template)));
break;
}
}
}
_listeners.addAll(listeners);
return listeners;
}
public Set getRegisteredIds(ListenerRegisterType type)
{
return _registeredIds.containsKey(type) ? _registeredIds.get(type) : Collections.emptySet();
}
public List getListeners()
{
return _listeners;
}
/**
* -------------------------------------------------------------------------------------------------------
*/
/**
* Show an on screen message to the player.
* @param player the player to display the message to
* @param text the message to display
* @param time the duration of the message in milliseconds
*/
public static void showOnScreenMsg(L2PcInstance player, String text, int time)
{
player.sendPacket(new ExShowScreenMessage(text, time));
}
/**
* Show an on screen message to the player.
* @param player the player to display the message to
* @param npcString the NPC string to display
* @param position the position of the message on the screen
* @param time the duration of the message in milliseconds
* @param params values of parameters to replace in the NPC String (like S1, C1 etc.)
*/
public static void showOnScreenMsg(L2PcInstance player, NpcStringId npcString, int position, int time, String... params)
{
player.sendPacket(new ExShowScreenMessage(npcString, position, time, params));
}
/**
* Show an on screen message to the player.
* @param player the player to display the message to
* @param systemMsg the system message to display
* @param position the position of the message on the screen
* @param time the duration of the message in milliseconds
* @param params values of parameters to replace in the system message (like S1, C1 etc.)
*/
public static void showOnScreenMsg(L2PcInstance player, SystemMessageId systemMsg, int position, int time, String... params)
{
player.sendPacket(new ExShowScreenMessage(systemMsg, position, time, params));
}
/**
* Add a temporary spawn of the specified NPC.
* @param npcId the ID of the NPC to spawn
* @param pos the object containing the spawn location coordinates
* @return the {@link L2Npc} object of the newly spawned NPC or {@code null} if the NPC doesn't exist
* @see #addSpawn(int, IPositionable, boolean, long, boolean, int)
* @see #addSpawn(int, int, int, int, int, boolean, long, boolean, int)
*/
public static L2Npc addSpawn(int npcId, IPositionable pos)
{
return addSpawn(npcId, pos.getX(), pos.getY(), pos.getZ(), pos.getHeading(), false, 0, false, 0);
}
/**
* Add a temporary spawn of the specified NPC.
* @param summoner the NPC that requires this spawn
* @param npcId the ID of the NPC to spawn
* @param pos the object containing the spawn location coordinates
* @param randomOffset if {@code true}, adds +/- 50~100 to X/Y coordinates of the spawn location
* @param despawnDelay time in milliseconds till the NPC is despawned (0 - only despawned on server shutdown)
* @return the {@link L2Npc} object of the newly spawned NPC, {@code null} if the NPC doesn't exist
*/
public static L2Npc addSpawn(L2Npc summoner, int npcId, IPositionable pos, boolean randomOffset, long despawnDelay)
{
return addSpawn(summoner, npcId, pos.getX(), pos.getY(), pos.getZ(), pos.getHeading(), randomOffset, despawnDelay, false, 0);
}
/**
* Add a temporary spawn of the specified NPC.
* @param npcId the ID of the NPC to spawn
* @param pos the object containing the spawn location coordinates
* @param isSummonSpawn if {@code true}, displays a summon animation on NPC spawn
* @return the {@link L2Npc} object of the newly spawned NPC or {@code null} if the NPC doesn't exist
* @see #addSpawn(int, IPositionable, boolean, long, boolean, int)
* @see #addSpawn(int, int, int, int, int, boolean, long, boolean, int)
*/
public static L2Npc addSpawn(int npcId, IPositionable pos, boolean isSummonSpawn)
{
return addSpawn(npcId, pos.getX(), pos.getY(), pos.getZ(), pos.getHeading(), false, 0, isSummonSpawn, 0);
}
/**
* Add a temporary spawn of the specified NPC.
* @param npcId the ID of the NPC to spawn
* @param pos the object containing the spawn location coordinates
* @param randomOffset if {@code true}, adds +/- 50~100 to X/Y coordinates of the spawn location
* @param despawnDelay time in milliseconds till the NPC is despawned (0 - only despawned on server shutdown)
* @return the {@link L2Npc} object of the newly spawned NPC or {@code null} if the NPC doesn't exist
* @see #addSpawn(int, IPositionable, boolean, long, boolean, int)
* @see #addSpawn(int, int, int, int, int, boolean, long, boolean, int)
*/
public static L2Npc addSpawn(int npcId, IPositionable pos, boolean randomOffset, long despawnDelay)
{
return addSpawn(npcId, pos.getX(), pos.getY(), pos.getZ(), pos.getHeading(), randomOffset, despawnDelay, false, 0);
}
/**
* Add a temporary spawn of the specified NPC.
* @param npcId the ID of the NPC to spawn
* @param pos the object containing the spawn location coordinates
* @param randomOffset if {@code true}, adds +/- 50~100 to X/Y coordinates of the spawn location
* @param despawnDelay time in milliseconds till the NPC is despawned (0 - only despawned on server shutdown)
* @param isSummonSpawn if {@code true}, displays a summon animation on NPC spawn
* @return the {@link L2Npc} object of the newly spawned NPC or {@code null} if the NPC doesn't exist
* @see #addSpawn(int, IPositionable, boolean, long, boolean, int)
* @see #addSpawn(int, int, int, int, int, boolean, long, boolean, int)
*/
public static L2Npc addSpawn(int npcId, IPositionable pos, boolean randomOffset, long despawnDelay, boolean isSummonSpawn)
{
return addSpawn(npcId, pos.getX(), pos.getY(), pos.getZ(), pos.getHeading(), randomOffset, despawnDelay, isSummonSpawn, 0);
}
/**
* Add a temporary spawn of the specified NPC.
* @param npcId the ID of the NPC to spawn
* @param pos the object containing the spawn location coordinates
* @param randomOffset if {@code true}, adds +/- 50~100 to X/Y coordinates of the spawn location
* @param despawnDelay time in milliseconds till the NPC is despawned (0 - only despawned on server shutdown)
* @param isSummonSpawn if {@code true}, displays a summon animation on NPC spawn
* @param instanceId the ID of the instance to spawn the NPC in (0 - the open world)
* @return the {@link L2Npc} object of the newly spawned NPC or {@code null} if the NPC doesn't exist
* @see #addSpawn(int, IPositionable)
* @see #addSpawn(int, IPositionable, boolean)
* @see #addSpawn(int, IPositionable, boolean, long)
* @see #addSpawn(int, IPositionable, boolean, long, boolean)
* @see #addSpawn(int, int, int, int, int, boolean, long, boolean, int)
*/
public static L2Npc addSpawn(int npcId, IPositionable pos, boolean randomOffset, long despawnDelay, boolean isSummonSpawn, int instanceId)
{
return addSpawn(npcId, pos.getX(), pos.getY(), pos.getZ(), pos.getHeading(), randomOffset, despawnDelay, isSummonSpawn, instanceId);
}
/**
* Add a temporary spawn of the specified NPC.
* @param npcId the ID of the NPC to spawn
* @param x the X coordinate of the spawn location
* @param y the Y coordinate of the spawn location
* @param z the Z coordinate (height) of the spawn location
* @param heading the heading of the NPC
* @param randomOffset if {@code true}, adds +/- 50~100 to X/Y coordinates of the spawn location
* @param despawnDelay time in milliseconds till the NPC is despawned (0 - only despawned on server shutdown)
* @return the {@link L2Npc} object of the newly spawned NPC or {@code null} if the NPC doesn't exist
* @see #addSpawn(int, IPositionable, boolean, long, boolean, int)
* @see #addSpawn(int, int, int, int, int, boolean, long, boolean, int)
*/
public static 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, 0);
}
/**
* Add a temporary spawn of the specified NPC.
* @param npcId the ID of the NPC to spawn
* @param x the X coordinate of the spawn location
* @param y the Y coordinate of the spawn location
* @param z the Z coordinate (height) of the spawn location
* @param heading the heading of the NPC
* @param randomOffset if {@code true}, adds +/- 50~100 to X/Y coordinates of the spawn location
* @param despawnDelay time in milliseconds till the NPC is despawned (0 - only despawned on server shutdown)
* @param isSummonSpawn if {@code true}, displays a summon animation on NPC spawn
* @return the {@link L2Npc} object of the newly spawned NPC or {@code null} if the NPC doesn't exist
* @see #addSpawn(int, IPositionable, boolean, long, boolean, int)
* @see #addSpawn(int, int, int, int, int, boolean, long, boolean, int)
*/
public static L2Npc addSpawn(int npcId, int x, int y, int z, int heading, boolean randomOffset, long despawnDelay, boolean isSummonSpawn)
{
return addSpawn(npcId, x, y, z, heading, randomOffset, despawnDelay, isSummonSpawn, 0);
}
/**
* Add a temporary spawn of the specified NPC.
* @param npcId the ID of the NPC to spawn
* @param x the X coordinate of the spawn location
* @param y the Y coordinate of the spawn location
* @param z the Z coordinate (height) of the spawn location
* @param heading the heading of the NPC
* @param randomOffset if {@code true}, adds +/- 50~100 to X/Y coordinates of the spawn location
* @param despawnDelay time in milliseconds till the NPC is despawned (0 - only despawned on server shutdown)
* @param isSummonSpawn if {@code true}, displays a summon animation on NPC spawn
* @param instanceId the ID of the instance to spawn the NPC in (0 - the open world)
* @return the {@link L2Npc} object of the newly spawned NPC or {@code null} if the NPC doesn't exist
* @see #addSpawn(int, IPositionable, boolean, long, boolean, int)
* @see #addSpawn(int, int, int, int, int, boolean, long)
* @see #addSpawn(int, int, int, int, int, boolean, long, boolean)
*/
public static L2Npc addSpawn(int npcId, int x, int y, int z, int heading, boolean randomOffset, long despawnDelay, boolean isSummonSpawn, int instanceId)
{
return addSpawn(null, npcId, x, y, z, heading, randomOffset, despawnDelay, isSummonSpawn, instanceId);
}
/**
* Add a temporary spawn of the specified NPC.
* @param summoner the NPC that requires this spawn
* @param npcId the ID of the NPC to spawn
* @param x the X coordinate of the spawn location
* @param y the Y coordinate of the spawn location
* @param z the Z coordinate (height) of the spawn location
* @param heading the heading of the NPC
* @param randomOffset if {@code true}, adds +/- 50~100 to X/Y coordinates of the spawn location
* @param despawnDelay time in milliseconds till the NPC is despawned (0 - only despawned on server shutdown)
* @param isSummonSpawn if {@code true}, displays a summon animation on NPC spawn
* @param instanceId the ID of the instance to spawn the NPC in (0 - the open world)
* @return the {@link L2Npc} object of the newly spawned NPC or {@code null} if the NPC doesn't exist
* @see #addSpawn(int, IPositionable, boolean, long, boolean, int)
* @see #addSpawn(int, int, int, int, int, boolean, long)
* @see #addSpawn(int, int, int, int, int, boolean, long, boolean)
*/
public static L2Npc addSpawn(L2Npc summoner, int npcId, int x, int y, int z, int heading, boolean randomOffset, long despawnDelay, boolean isSummonSpawn, int instanceId)
{
try
{
if ((x == 0) && (y == 0))
{
_log.log(Level.SEVERE, "addSpawn(): invalid spawn coordinates for NPC #" + npcId + "!");
return null;
}
if (randomOffset)
{
int offset = Rnd.get(50, 100);
if (Rnd.nextBoolean())
{
offset *= -1;
}
x += offset;
offset = Rnd.get(50, 100);
if (Rnd.nextBoolean())
{
offset *= -1;
}
y += offset;
}
final L2Spawn spawn = new L2Spawn(npcId);
spawn.setInstanceId(instanceId);
spawn.setHeading(heading);
spawn.setX(x);
spawn.setY(y);
spawn.setZ(z);
spawn.stopRespawn();
final L2Npc npc = spawn.spawnOne(isSummonSpawn);
if (despawnDelay > 0)
{
npc.scheduleDespawn(despawnDelay);
}
if (summoner != null)
{
summoner.addSummonedNpc(npc);
}
return npc;
}
catch (Exception e)
{
_log.warning("Could not spawn NPC #" + npcId + "; error: " + e.getMessage());
}
return null;
}
/**
* @param trapId
* @param x
* @param y
* @param z
* @param heading
* @param skill
* @param instanceId
* @return
*/
public L2TrapInstance addTrap(int trapId, int x, int y, int z, int heading, Skill skill, int instanceId)
{
final L2NpcTemplate npcTemplate = NpcData.getInstance().getTemplate(trapId);
L2TrapInstance trap = new L2TrapInstance(npcTemplate, instanceId, -1);
trap.setCurrentHp(trap.getMaxHp());
trap.setCurrentMp(trap.getMaxMp());
trap.setIsInvul(true);
trap.setHeading(heading);
trap.spawnMe(x, y, z);
return trap;
}
/**
* @param master
* @param minionId
* @return
*/
public L2Npc addMinion(L2MonsterInstance master, int minionId)
{
return MinionList.spawnMinion(master, minionId);
}
/**
* Get the amount of an item in player's inventory.
* @param player the player whose inventory to check
* @param itemId the ID of the item whose amount to get
* @return the amount of the specified item in player's inventory
*/
public static long getQuestItemsCount(L2PcInstance player, int itemId)
{
return player.getInventory().getInventoryItemCount(itemId, -1);
}
/**
* Get the total amount of all specified items in player's inventory.
* @param player the player whose inventory to check
* @param itemIds a list of IDs of items whose amount to get
* @return the summary amount of all listed items in player's inventory
*/
public long getQuestItemsCount(L2PcInstance player, int... itemIds)
{
long count = 0;
for (L2ItemInstance item : player.getInventory().getItems())
{
if (item == null)
{
continue;
}
for (int itemId : itemIds)
{
if (item.getId() == itemId)
{
if ((count + item.getCount()) > Long.MAX_VALUE)
{
return Long.MAX_VALUE;
}
count += item.getCount();
}
}
}
return count;
}
/**
* Check if the player has the specified item in his inventory.
* @param player the player whose inventory to check for the specified item
* @param item the {@link ItemHolder} object containing the ID and count of the item to check
* @return {@code true} if the player has the required count of the item
*/
protected static boolean hasItem(L2PcInstance player, ItemHolder item)
{
return hasItem(player, item, true);
}
/**
* Check if the player has the required count of the specified item in his inventory.
* @param player the player whose inventory to check for the specified item
* @param item the {@link ItemHolder} object containing the ID and count of the item to check
* @param checkCount if {@code true}, check if each item is at least of the count specified in the ItemHolder,
* otherwise check only if the player has the item at all
* @return {@code true} if the player has the item
*/
protected static boolean hasItem(L2PcInstance player, ItemHolder item, boolean checkCount)
{
if (item == null)
{
return false;
}
if (checkCount)
{
return (getQuestItemsCount(player, item.getId()) >= item.getCount());
}
return hasQuestItems(player, item.getId());
}
/**
* Check if the player has all the specified items in his inventory and, if necessary, if their count is also as required.
* @param player the player whose inventory to check for the specified item
* @param checkCount if {@code true}, check if each item is at least of the count specified in the ItemHolder,
* otherwise check only if the player has the item at all
* @param itemList a list of {@link ItemHolder} objects containing the IDs of the items to check
* @return {@code true} if the player has all the items from the list
*/
protected static boolean hasAllItems(L2PcInstance player, boolean checkCount, ItemHolder... itemList)
{
if ((itemList == null) || (itemList.length == 0))
{
return false;
}
for (ItemHolder item : itemList)
{
if (!hasItem(player, item, checkCount))
{
return false;
}
}
return true;
}
/**
* Check for an item in player's inventory.
* @param player the player whose inventory to check for quest items
* @param itemId the ID of the item to check for
* @return {@code true} if the item exists in player's inventory, {@code false} otherwise
*/
public static boolean hasQuestItems(L2PcInstance player, int itemId)
{
return (player.getInventory().getItemByItemId(itemId) != null);
}
/**
* Check for multiple items in player's inventory.
* @param player the player whose inventory to check for quest items
* @param itemIds a list of item IDs to check for
* @return {@code true} if all items exist in player's inventory, {@code false} otherwise
*/
public static boolean hasQuestItems(L2PcInstance player, int... itemIds)
{
if ((itemIds == null) || (itemIds.length == 0))
{
return false;
}
final PcInventory inv = player.getInventory();
for (int itemId : itemIds)
{
if (inv.getItemByItemId(itemId) == null)
{
return false;
}
}
return true;
}
/**
* Check for multiple items in player's inventory.
* @param player the player whose inventory to check for quest items
* @param itemIds a list of item IDs to check for
* @return {@code true} if at least one items exist in player's inventory, {@code false} otherwise
*/
public boolean hasAtLeastOneQuestItem(L2PcInstance player, int... itemIds)
{
final PcInventory inv = player.getInventory();
for (int itemId : itemIds)
{
if (inv.getItemByItemId(itemId) != null)
{
return true;
}
}
return false;
}
/**
* Get the enchantment level of an item in player's inventory.
* @param player the player whose item to check
* @param itemId the ID of the item whose enchantment level to get
* @return the enchantment level of the item or 0 if the item was not found
*/
public static int getEnchantLevel(L2PcInstance player, int itemId)
{
final L2ItemInstance enchantedItem = player.getInventory().getItemByItemId(itemId);
if (enchantedItem == null)
{
return 0;
}
return enchantedItem.getEnchantLevel();
}
/**
* Give Adena to the player.
* @param player the player to whom to give the Adena
* @param count the amount of Adena to give
* @param applyRates if {@code true} quest rates will be applied to the amount
*/
public void giveAdena(L2PcInstance player, long count, boolean applyRates)
{
if (applyRates)
{
rewardItems(player, Inventory.ADENA_ID, count);
}
else
{
giveItems(player, Inventory.ADENA_ID, count);
}
}
/**
* Give a reward to player using multipliers.
* @param player the player to whom to give the item
* @param holder
*/
public static void rewardItems(L2PcInstance player, ItemHolder holder)
{
rewardItems(player, holder.getId(), holder.getCount());
}
/**
* Give a reward to player using multipliers.
* @param player the player to whom to give the item
* @param itemId the ID of the item to give
* @param count the amount of items to give
*/
public static void rewardItems(L2PcInstance player, int itemId, long count)
{
if (count <= 0)
{
return;
}
final L2Item item = ItemTable.getInstance().getTemplate(itemId);
if (item == null)
{
return;
}
try
{
if (itemId == Inventory.ADENA_ID)
{
count *= Config.RATE_QUEST_REWARD_ADENA;
}
else if (Config.RATE_QUEST_REWARD_USE_MULTIPLIERS)
{
if (item instanceof L2EtcItem)
{
switch (((L2EtcItem) item).getItemType())
{
case POTION:
count *= Config.RATE_QUEST_REWARD_POTION;
break;
case SCRL_ENCHANT_WP:
case SCRL_ENCHANT_AM:
case SCROLL:
count *= Config.RATE_QUEST_REWARD_SCROLL;
break;
case RECIPE:
count *= Config.RATE_QUEST_REWARD_RECIPE;
break;
case MATERIAL:
count *= Config.RATE_QUEST_REWARD_MATERIAL;
break;
default:
count *= Config.RATE_QUEST_REWARD;
}
}
}
else
{
count *= Config.RATE_QUEST_REWARD;
}
}
catch (Exception e)
{
count = Long.MAX_VALUE;
}
// Add items to player's inventory
final L2ItemInstance itemInstance = player.getInventory().addItem("Quest", itemId, count, player, player.getTarget());
if (itemInstance == null)
{
return;
}
sendItemGetMessage(player, itemInstance, count);
}
/**
* Send the system message and the status update packets to the player.
* @param player the player that has got the item
* @param item the item obtain by the player
* @param count the item count
*/
private static void sendItemGetMessage(L2PcInstance player, L2ItemInstance item, long count)
{
// If item for reward is gold, send message of gold reward to client
if (item.getId() == Inventory.ADENA_ID)
{
SystemMessage smsg = SystemMessage.getSystemMessage(SystemMessageId.EARNED_S1_ADENA);
smsg.addLong(count);
player.sendPacket(smsg);
}
// Otherwise, send message of object reward to client
else
{
if (count > 1)
{
SystemMessage smsg = SystemMessage.getSystemMessage(SystemMessageId.EARNED_S2_S1_S);
smsg.addItemName(item);
smsg.addLong(count);
player.sendPacket(smsg);
}
else
{
SystemMessage smsg = SystemMessage.getSystemMessage(SystemMessageId.EARNED_ITEM_S1);
smsg.addItemName(item);
player.sendPacket(smsg);
}
}
// send packets
StatusUpdate su = new StatusUpdate(player);
su.addAttribute(StatusUpdate.CUR_LOAD, player.getCurrentLoad());
player.sendPacket(su);
}
/**
* Give item/reward to the player
* @param player
* @param itemId
* @param count
*/
public static void giveItems(L2PcInstance player, int itemId, long count)
{
giveItems(player, itemId, count, 0);
}
/**
* Give item/reward to the player
* @param player
* @param holder
*/
protected static void giveItems(L2PcInstance player, ItemHolder holder)
{
giveItems(player, holder.getId(), holder.getCount());
}
/**
* @param player
* @param itemId
* @param count
* @param enchantlevel
*/
public static void giveItems(L2PcInstance player, int itemId, long count, int enchantlevel)
{
if (count <= 0)
{
return;
}
// Add items to player's inventory
final L2ItemInstance item = player.getInventory().addItem("Quest", itemId, count, player, player.getTarget());
if (item == null)
{
return;
}
// set enchant level for item if that item is not adena
if ((enchantlevel > 0) && (itemId != Inventory.ADENA_ID))
{
item.setEnchantLevel(enchantlevel);
}
sendItemGetMessage(player, item, count);
}
/**
* @param player
* @param itemId
* @param count
* @param attributeId
* @param attributeLevel
*/
public static void giveItems(L2PcInstance player, int itemId, long count, byte attributeId, int attributeLevel)
{
if (count <= 0)
{
return;
}
// Add items to player's inventory
final L2ItemInstance item = player.getInventory().addItem("Quest", itemId, count, player, player.getTarget());
if (item == null)
{
return;
}
// set enchant level for item if that item is not adena
if ((attributeId >= 0) && (attributeLevel > 0))
{
item.setElementAttr(attributeId, attributeLevel);
if (item.isEquipped())
{
item.updateElementAttrBonus(player);
}
InventoryUpdate iu = new InventoryUpdate();
iu.addModifiedItem(item);
player.sendPacket(iu);
}
sendItemGetMessage(player, item, count);
}
/**
* Give the specified player a set amount of items if he is lucky enough.
* Not recommended to use this for non-stacking items.
* @param player the player to give the item(s) to
* @param itemId the ID of the item to give
* @param amountToGive the amount of items to give
* @param limit the maximum amount of items the player can have. Won't give more if this limit is reached. 0 - no limit.
* @param dropChance the drop chance as a decimal digit from 0 to 1
* @param playSound if true, plays ItemSound.quest_itemget when items are given and ItemSound.quest_middle when the limit is reached
* @return {@code true} if limit > 0 and the limit was reached or if limit <= 0 and items were given; {@code false} in all other cases
*/
public static boolean giveItemRandomly(L2PcInstance player, int itemId, long amountToGive, long limit, double dropChance, boolean playSound)
{
return giveItemRandomly(player, null, itemId, amountToGive, amountToGive, limit, dropChance, playSound);
}
/**
* Give the specified player a set amount of items if he is lucky enough.
* Not recommended to use this for non-stacking items.
* @param player the player to give the item(s) to
* @param npc the NPC that "dropped" the item (can be null)
* @param itemId the ID of the item to give
* @param amountToGive the amount of items to give
* @param limit the maximum amount of items the player can have. Won't give more if this limit is reached. 0 - no limit.
* @param dropChance the drop chance as a decimal digit from 0 to 1
* @param playSound if true, plays ItemSound.quest_itemget when items are given and ItemSound.quest_middle when the limit is reached
* @return {@code true} if limit > 0 and the limit was reached or if limit <= 0 and items were given; {@code false} in all other cases
*/
public static boolean giveItemRandomly(L2PcInstance player, L2Npc npc, int itemId, long amountToGive, long limit, double dropChance, boolean playSound)
{
return giveItemRandomly(player, npc, itemId, amountToGive, amountToGive, limit, dropChance, playSound);
}
/**
* Give the specified player a random amount of items if he is lucky enough.
* Not recommended to use this for non-stacking items.
* @param player the player to give the item(s) to
* @param npc the NPC that "dropped" the item (can be null)
* @param itemId the ID of the item to give
* @param minAmount the minimum amount of items to give
* @param maxAmount the maximum amount of items to give (will give a random amount between min/maxAmount multiplied by quest rates)
* @param limit the maximum amount of items the player can have. Won't give more if this limit is reached. 0 - no limit.
* @param dropChance the drop chance as a decimal digit from 0 to 1
* @param playSound if true, plays ItemSound.quest_itemget when items are given and ItemSound.quest_middle when the limit is reached
* @return {@code true} if limit > 0 and the limit was reached or if limit <= 0 and items were given; {@code false} in all other cases
*/
public static boolean giveItemRandomly(L2PcInstance player, L2Npc npc, int itemId, long minAmount, long maxAmount, long limit, double dropChance, boolean playSound)
{
final long currentCount = getQuestItemsCount(player, itemId);
if ((limit > 0) && (currentCount >= limit))
{
return true;
}
minAmount *= Config.RATE_QUEST_DROP;
maxAmount *= Config.RATE_QUEST_DROP;
dropChance *= Config.RATE_QUEST_DROP; // TODO separate configs for rate and amount
if ((npc != null) && Config.L2JMOD_CHAMPION_ENABLE && npc.isChampion())
{
dropChance *= Config.L2JMOD_CHAMPION_REWARDS;
if ((itemId == Inventory.ADENA_ID) || (itemId == Inventory.ANCIENT_ADENA_ID))
{
minAmount *= Config.L2JMOD_CHAMPION_ADENAS_REWARDS;
maxAmount *= Config.L2JMOD_CHAMPION_ADENAS_REWARDS;
}
else
{
minAmount *= Config.L2JMOD_CHAMPION_REWARDS;
maxAmount *= Config.L2JMOD_CHAMPION_REWARDS;
}
}
long amountToGive = ((minAmount == maxAmount) ? minAmount : Rnd.get(minAmount, maxAmount));
final double random = Rnd.nextDouble();
// Inventory slot check (almost useless for non-stacking items)
if ((dropChance >= random) && (amountToGive > 0) && player.getInventory().validateCapacityByItemId(itemId))
{
if ((limit > 0) && ((currentCount + amountToGive) > limit))
{
amountToGive = limit - currentCount;
}
// Give the item to player
L2ItemInstance item = player.addItem("Quest", itemId, amountToGive, npc, true);
if (item != null)
{
// limit reached (if there is no limit, this block doesn't execute)
if ((currentCount + amountToGive) == limit)
{
if (playSound)
{
playSound(player, QuestSound.ITEMSOUND_QUEST_MIDDLE);
}
return true;
}
if (playSound)
{
playSound(player, QuestSound.ITEMSOUND_QUEST_ITEMGET);
}
// if there is no limit, return true every time an item is given
if (limit <= 0)
{
return true;
}
}
}
return false;
}
/**
* Take an amount of a specified item from player's inventory.
* @param player the player whose item to take
* @param itemId the ID of the item to take
* @param amount the amount to take
* @return {@code true} if any items were taken, {@code false} otherwise
*/
public static boolean takeItems(L2PcInstance player, int itemId, long amount)
{
// Get object item from player's inventory list
final L2ItemInstance item = player.getInventory().getItemByItemId(itemId);
if (item == null)
{
return false;
}
// Tests on count value in order not to have negative value
if ((amount < 0) || (amount > item.getCount()))
{
amount = item.getCount();
}
// Destroy the quantity of items wanted
if (item.isEquipped())
{
final L2ItemInstance[] unequiped = player.getInventory().unEquipItemInBodySlotAndRecord(item.getItem().getBodyPart());
InventoryUpdate iu = new InventoryUpdate();
for (L2ItemInstance itm : unequiped)
{
iu.addModifiedItem(itm);
}
player.sendPacket(iu);
player.broadcastUserInfo();
}
return player.destroyItemByItemId("Quest", itemId, amount, player, true);
}
/**
* Take a set amount of a specified item from player's inventory.
* @param player the player whose item to take
* @param holder the {@link ItemHolder} object containing the ID and count of the item to take
* @return {@code true} if the item was taken, {@code false} otherwise
*/
protected static boolean takeItem(L2PcInstance player, ItemHolder holder)
{
if (holder == null)
{
return false;
}
return takeItems(player, holder.getId(), holder.getCount());
}
/**
* Take a set amount of all specified items from player's inventory.
* @param player the player whose items to take
* @param itemList the list of {@link ItemHolder} objects containing the IDs and counts of the items to take
* @return {@code true} if all items were taken, {@code false} otherwise
*/
protected static boolean takeAllItems(L2PcInstance player, ItemHolder... itemList)
{
if ((itemList == null) || (itemList.length == 0))
{
return false;
}
// first check if the player has all items to avoid taking half the items from the list
if (!hasAllItems(player, true, itemList))
{
return false;
}
for (ItemHolder item : itemList)
{
// this should never be false, but just in case
if (!takeItem(player, item))
{
return false;
}
}
return true;
}
/**
* Take an amount of all specified items from player's inventory.
* @param player the player whose items to take
* @param amount the amount to take of each item
* @param itemIds a list or an array of IDs of the items to take
* @return {@code true} if all items were taken, {@code false} otherwise
*/
public static boolean takeItems(L2PcInstance player, int amount, int... itemIds)
{
boolean check = true;
if (itemIds != null)
{
for (int item : itemIds)
{
check &= takeItems(player, item, amount);
}
}
return check;
}
/**
* Send a packet in order to play a sound to the player.
* @param player the player whom to send the packet
* @param sound the name of the sound to play
*/
public static void playSound(L2PcInstance player, String sound)
{
player.sendPacket(QuestSound.getSound(sound));
}
/**
* Send a packet in order to play a sound to the player.
* @param player the player whom to send the packet
* @param sound the {@link QuestSound} object of the sound to play
*/
public static void playSound(L2PcInstance player, QuestSound sound)
{
player.sendPacket(sound.getPacket());
}
/**
* Add EXP and SP as quest reward.
* @param player the player whom to reward with the EXP/SP
* @param exp the amount of EXP to give to the player
* @param sp the amount of SP to give to the player
*/
public static void addExpAndSp(L2PcInstance player, long exp, int sp)
{
player.addExpAndSp((long) player.calcStat(Stats.EXPSP_RATE, exp * Config.RATE_QUEST_REWARD_XP, null, null), (int) player.calcStat(Stats.EXPSP_RATE, sp * Config.RATE_QUEST_REWARD_SP, null, null));
}
/**
* Get a random integer from 0 (inclusive) to {@code max} (exclusive).
* Use this method instead of importing {@link com.l2jserver.util.Rnd} utility.
* @param max the maximum value for randomization
* @return a random integer number from 0 to {@code max - 1}
*/
public static int getRandom(int max)
{
return Rnd.get(max);
}
/**
* Get a random integer from {@code min} (inclusive) to {@code max} (inclusive).
* Use this method instead of importing {@link com.l2jserver.util.Rnd} utility.
* @param min the minimum value for randomization
* @param max the maximum value for randomization
* @return a random integer number from {@code min} to {@code max}
*/
public static int getRandom(int min, int max)
{
return Rnd.get(min, max);
}
/**
* Get a random boolean.
* Use this method instead of importing {@link com.l2jserver.util.Rnd} utility.
* @return {@code true} or {@code false} randomly
*/
public static boolean getRandomBoolean()
{
return Rnd.nextBoolean();
}
/**
* Get the ID of the item equipped in the specified inventory slot of the player.
* @param player the player whose inventory to check
* @param slot the location in the player's inventory to check
* @return the ID of the item equipped in the specified inventory slot or 0 if the slot is empty or item is {@code null}.
*/
public static int getItemEquipped(L2PcInstance player, int slot)
{
return player.getInventory().getPaperdollItemId(slot);
}
/**
* @return the number of ticks from the {@link com.l2jserver.gameserver.GameTimeController}.
*/
public static int getGameTicks()
{
return GameTimeController.getInstance().getGameTicks();
}
/**
* Execute a procedure for each player depending on the parameters.
* @param player the player on which the procedure will be executed
* @param npc the related NPC
* @param isSummon {@code true} if the event that called this method was originated by the player's summon, {@code false} otherwise
* @param includeParty if {@code true}, #actionForEachPlayer(L2PcInstance, L2Npc, boolean) will be called with the player's party members
* @param includeCommandChannel if {@code true}, {@link #actionForEachPlayer(L2PcInstance, L2Npc, boolean)} will be called with the player's command channel members
* @see #actionForEachPlayer(L2PcInstance, L2Npc, boolean)
*/
public final void executeForEachPlayer(L2PcInstance player, final L2Npc npc, final boolean isSummon, boolean includeParty, boolean includeCommandChannel)
{
if ((includeParty || includeCommandChannel) && player.isInParty())
{
if (includeCommandChannel && player.getParty().isInCommandChannel())
{
player.getParty().getCommandChannel().forEachMember(member ->
{
actionForEachPlayer(member, npc, isSummon);
return true;
});
}
else if (includeParty)
{
player.getParty().forEachMember(member ->
{
actionForEachPlayer(member, npc, isSummon);
return true;
});
}
}
else
{
actionForEachPlayer(player, npc, isSummon);
}
}
/**
* Overridable method called from {@link #executeForEachPlayer(L2PcInstance, L2Npc, boolean, boolean, boolean)}
* @param player the player on which the action will be run
* @param npc the NPC related to this action
* @param isSummon {@code true} if the event that called this method was originated by the player's summon
*/
public void actionForEachPlayer(L2PcInstance player, L2Npc npc, boolean isSummon)
{
// To be overridden in quest scripts.
}
/**
* Open a door if it is present on the instance and its not open.
* @param doorId the ID of the door to open
* @param instanceId the ID of the instance the door is in (0 if the door is not not inside an instance)
*/
public void openDoor(int doorId, int instanceId)
{
final L2DoorInstance door = getDoor(doorId, instanceId);
if (door == null)
{
_log.log(Level.WARNING, getClass().getSimpleName() + ": called openDoor(" + doorId + ", " + instanceId + "); but door wasnt found!", new NullPointerException());
}
else if (!door.getOpen())
{
door.openMe();
}
}
/**
* Close a door if it is present in a specified the instance and its open.
* @param doorId the ID of the door to close
* @param instanceId the ID of the instance the door is in (0 if the door is not not inside an instance)
*/
public void closeDoor(int doorId, int instanceId)
{
final L2DoorInstance door = getDoor(doorId, instanceId);
if (door == null)
{
_log.log(Level.WARNING, getClass().getSimpleName() + ": called closeDoor(" + doorId + ", " + instanceId + "); but door wasnt found!", new NullPointerException());
}
else if (door.getOpen())
{
door.closeMe();
}
}
/**
* Retrieve a door from an instance or the real world.
* @param doorId the ID of the door to get
* @param instanceId the ID of the instance the door is in (0 if the door is not not inside an instance)
* @return the found door or {@code null} if no door with that ID and instance ID was found
*/
public L2DoorInstance getDoor(int doorId, int instanceId)
{
L2DoorInstance door = null;
if (instanceId <= 0)
{
door = DoorData.getInstance().getDoor(doorId);
}
else
{
final Instance inst = InstanceManager.getInstance().getInstance(instanceId);
if (inst != null)
{
door = inst.getDoor(doorId);
}
}
return door;
}
/**
* Teleport a player into/out of an instance.
* @param player the player to teleport
* @param loc the {@link Location} object containing the destination coordinates
* @param instanceId the ID of the instance to teleport the player to (0 to teleport out of an instance)
*/
public void teleportPlayer(L2PcInstance player, Location loc, int instanceId)
{
teleportPlayer(player, loc, instanceId, true);
}
/**
* Teleport a player into/out of an instance.
* @param player the player to teleport
* @param loc the {@link Location} object containing the destination coordinates
* @param instanceId the ID of the instance to teleport the player to (0 to teleport out of an instance)
* @param allowRandomOffset if {@code true}, will randomize the teleport coordinates by +/-Config.MAX_OFFSET_ON_TELEPORT
*/
public void teleportPlayer(L2PcInstance player, Location loc, int instanceId, boolean allowRandomOffset)
{
loc.setInstanceId(instanceId);
player.teleToLocation(loc, allowRandomOffset);
}
/**
* Monster is running and attacking the playable.
* @param npc the NPC that performs the attack
* @param playable the player
*/
protected void addAttackPlayerDesire(L2Npc npc, L2Playable playable)
{
addAttackPlayerDesire(npc, playable, 999);
}
/**
* Monster is running and attacking the target.
* @param npc the NPC that performs the attack
* @param target the target of the attack
* @param desire the desire to perform the attack
*/
protected void addAttackPlayerDesire(L2Npc npc, L2Playable target, int desire)
{
if (npc instanceof L2Attackable)
{
((L2Attackable) npc).addDamageHate(target, 0, desire);
}
npc.setIsRunning(true);
npc.getAI().setIntention(CtrlIntention.AI_INTENTION_ATTACK, target);
}
/**
* Adds desire to move to the given NPC.
* @param npc the NPC
* @param loc the location
* @param desire the desire
*/
protected void addMoveToDesire(L2Npc npc, Location loc, int desire)
{
npc.getAI().setIntention(CtrlIntention.AI_INTENTION_MOVE_TO, loc);
}
/**
* Instantly cast a skill upon the given target.
* @param npc the caster NPC
* @param target the target of the cast
* @param skill the skill to cast
*/
protected void castSkill(L2Npc npc, L2Playable target, SkillHolder skill)
{
npc.setTarget(target);
npc.doCast(skill.getSkill());
}
/**
* Instantly cast a skill upon the given target.
* @param npc the caster NPC
* @param target the target of the cast
* @param skill the skill to cast
*/
protected void castSkill(L2Npc npc, L2Playable target, Skill skill)
{
npc.setTarget(target);
npc.doCast(skill);
}
/**
* Adds the desire to cast a skill to the given NPC.
* @param npc the NPC whom cast the skill
* @param target the skill target
* @param skill the skill to cast
* @param desire the desire to cast the skill
*/
protected void addSkillCastDesire(L2Npc npc, L2Character target, SkillHolder skill, int desire)
{
addSkillCastDesire(npc, target, skill.getSkill(), desire);
}
/**
* Adds the desire to cast a skill to the given NPC.
* @param npc the NPC whom cast the skill
* @param target the skill target
* @param skill the skill to cast
* @param desire the desire to cast the skill
*/
protected void addSkillCastDesire(L2Npc npc, L2Character target, Skill skill, int desire)
{
if (npc instanceof L2Attackable)
{
((L2Attackable) npc).addDamageHate(target, 0, desire);
}
npc.setTarget(target);
npc.getAI().setIntention(CtrlIntention.AI_INTENTION_CAST, skill, target);
}
/**
* Sends the special camera packet to the player.
* @param player the player
* @param creature the watched creature
* @param force
* @param angle1
* @param angle2
* @param time
* @param range
* @param duration
* @param relYaw
* @param relPitch
* @param isWide
* @param relAngle
*/
public static final void specialCamera(L2PcInstance player, L2Character creature, int force, int angle1, int angle2, int time, int range, int duration, int relYaw, int relPitch, int isWide, int relAngle)
{
player.sendPacket(new SpecialCamera(creature, force, angle1, angle2, time, range, duration, relYaw, relPitch, isWide, relAngle));
}
/**
* Sends the special camera packet to the player.
* @param player
* @param creature
* @param force
* @param angle1
* @param angle2
* @param time
* @param duration
* @param relYaw
* @param relPitch
* @param isWide
* @param relAngle
*/
public static final void specialCameraEx(L2PcInstance player, L2Character creature, int force, int angle1, int angle2, int time, int duration, int relYaw, int relPitch, int isWide, int relAngle)
{
player.sendPacket(new SpecialCamera(creature, player, force, angle1, angle2, time, duration, relYaw, relPitch, isWide, relAngle));
}
/**
* Sends the special camera packet to the player.
* @param player
* @param creature
* @param force
* @param angle1
* @param angle2
* @param time
* @param range
* @param duration
* @param relYaw
* @param relPitch
* @param isWide
* @param relAngle
* @param unk
*/
public static final void specialCamera3(L2PcInstance player, L2Character creature, int force, int angle1, int angle2, int time, int range, int duration, int relYaw, int relPitch, int isWide, int relAngle, int unk)
{
player.sendPacket(new SpecialCamera(creature, force, angle1, angle2, time, range, duration, relYaw, relPitch, isWide, relAngle, unk));
}
/**
* @param player
* @param x
* @param y
* @param z
*/
public static void addRadar(L2PcInstance player, int x, int y, int z)
{
player.getRadar().addMarker(x, y, z);
}
/**
* @param player
* @param x
* @param y
* @param z
*/
public void removeRadar(L2PcInstance player, int x, int y, int z)
{
player.getRadar().removeMarker(x, y, z);
}
/**
* @param player
*/
public void clearRadar(L2PcInstance player)
{
player.getRadar().removeAllMarkers();
}
}