package l2s.extensions.scripts;

import l2s.game.model.L2Object;
import l2s.game.model.actor.L2Player;

public final class Events
{
    public static boolean onAction(final L2Player player, final L2Object obj, final boolean shift)
    {
        if(shift && player.getVarB("noShift"))
            return false;

        final Iterable scripts = Scripts.getInstance().getEventScripts(ScriptEventType.ON_ACTION);
        for(final EventScript script : scripts)
            if(script.notifyAction(player, obj, shift))
                return true;

        return false;
    }
}

package l2s.extensions.scripts;

import l2s.game.event.L2EventType;
import l2s.game.model.L2Object;
import l2s.game.model.L2Zone;
import l2s.game.model.actor.L2Character;
import l2s.game.model.actor.L2Player;
import l2s.game.network.serverpackets.SystemMessage;

public class EventScript extends Functions
{
    private final String _name;

    public EventScript()
    {
        _name = getClass().getSimpleName();
    }

    public final void addEventId(final ScriptEventType eventType)
    {
        Scripts.getInstance().addScriptEvent(eventType, this);
    }

    public final void addEventId(final ScriptEventType... types)
    {
        for(final ScriptEventType e : types)
            Scripts.getInstance().addScriptEvent(e, this);
    }

    public final void removeEventId(final ScriptEventType eventType)
    {
        Scripts.getInstance().removeScriptEvent(eventType, this);
    }

    public final void removeEventId(final ScriptEventType... types)
    {
        for(final ScriptEventType e : types)
            Scripts.getInstance().removeScriptEvent(e, this);
    }

    public final void notifyOnDie(final L2Character self, final L2Character killer)
    {
        onDie(self, killer);
    }

    public final void notifyOnEscape(final L2Player player)
    {
        onEscape(player);
    }

    public final void notifyEnterWorld(final L2Player player)
    {
        onEnterWorld(player);
    }

    public final void notifyLevelIncreased(final L2Player player)
    {
        onLevelIncreased(player);
    }

    public final void notifySpawned(final L2Player player)
    {
        onSpawn(player);
    }

    public final void notifyRevive(final L2Player player)
    {
        onRevive(player);
    }

    public final boolean notifyPartyLeaveTry(final L2Player player)
    {
        return onPartyLeave(player);
    }

    public final SystemMessage notifyPartyInviteTry(final L2Player inviter, final L2Player target)
    {
        return onPartyInvite(inviter, target);
    }

    public final boolean notifyAction(final L2Player player, final L2Object target, final boolean shift)
    {
        return onAction(player, target, shift);
    }

    public final boolean notifyIsInEventCheck(final L2Player player, final L2EventType type)
    {
        return isInEvent(player, type);
    }

    public final void notifyDisconnect(final L2Player player)
    {
        onDisconnect(player);
    }

    public final void notifyOnAttack(final L2Character victim, final L2Character attacker)
    {
        onAttack(victim, attacker);
    }

    public final void notifyEnterZone(final L2Player player, final L2Zone zone)
    {
        onEnterZone(player, zone);
    }

    public final void notifyExitZone(final L2Player player, final L2Zone zone)
    {
        onExitZone(player, zone);
    }

    protected void onDie(final L2Character self, final L2Character killer)
    {}

    protected void onEscape(final L2Player player)
    {}

    protected void onLevelIncreased(final L2Player player)
    {}

    protected void onEnterWorld(final L2Player player)
    {}

    protected void onSpawn(final L2Player player)
    {}

    protected void onRevive(final L2Player player)
    {}

    protected boolean onPartyLeave(final L2Player player)
    {
        return true;
    }

    protected SystemMessage onPartyInvite(final L2Player inviter, final L2Player target)
    {
        return null;
    }

    protected boolean onAction(final L2Player player, final L2Object target, final boolean shift)
    {
        return false;
    }

    protected boolean isInEvent(final L2Player player, final L2EventType type)
    {
        return false;
    }

    protected void onDisconnect(final L2Player player)
    {}

    protected void onAttack(final L2Character victim, final L2Character attacker)
    {}

    @Deprecated
    protected void onEnterZone(final L2Player player, final L2Zone zone)
    {}

    @Deprecated
    protected void onExitZone(final L2Player player, final L2Zone zone)
    {}

    public String getName()
    {
        return _name;
    }
}

package l2s.extensions.scripts;

import java.util.HashMap;
import java.util.Map.Entry;
import java.util.concurrent.ScheduledFuture;
import java.util.logging.Level;
import java.util.logging.Logger;

import l2s.Config;
import l2s.commons.list.GArray;
import l2s.commons.text.Strings;
import l2s.extensions.multilang.CustomMessage;
import l2s.game.L2GameThreadPools;
import l2s.game.cache.Msg;
import l2s.game.instancemanager.ServerVariables;
import l2s.game.model.L2Object;
import l2s.game.model.L2ObjectsStorage;
import l2s.game.model.L2Spawn;
import l2s.game.model.L2World;
import l2s.game.model.actor.L2Character;
import l2s.game.model.actor.L2Playable;
import l2s.game.model.actor.L2Player;
import l2s.game.model.actor.L2Summon;
import l2s.game.model.instances.L2ItemInstance;
import l2s.game.model.instances.L2NpcInstance;
import l2s.game.model.items.Inventory;
import l2s.game.network.clientpackets.Say2C;
import l2s.game.network.serverpackets.ExShowTrace;
import l2s.game.network.serverpackets.NpcHtmlMessage;
import l2s.game.network.serverpackets.NpcSay;
import l2s.game.network.serverpackets.SystemMessage;
import l2s.game.tables.ItemTable;
import l2s.game.tables.MapRegionTable;
import l2s.game.tables.NpcTable;
import l2s.game.templates.L2NpcTemplate;
import l2s.util.Location;
import l2s.util.Rnd;

public class Functions
{
    protected static final Logger _log = Logger.getLogger(Functions.class.getName());

    public Long self, npc;

    public static final Object[] EMPTY_ARG = new Object[0];

    public L2Object getSelf()
    {
        return L2ObjectsStorage.get(self);
    }
   
    public static void sendDebugMessage(L2Player player, String message)
    {
        if(!player.isGM())
            return;
        player.sendMessage(message);
    }
    public L2Player getSelfPlayer()
    {
        return L2ObjectsStorage.getAsPlayer(self);
    }

    public L2NpcInstance getNpc()
    {
        return L2ObjectsStorage.getAsNpc(npc);
    }

    public static ScheduledFuture executeTask(final L2Object object, final String sClass, final String sMethod, final Object[] args, final HashMap variables, final long delay)
    {
        return L2GameThreadPools.getInstance().scheduleGeneral(new Runnable()
        {
             
            public void run()
            {
                if(object != null)
                    object.callScripts(sClass, sMethod, args, variables);
            }
        }, delay);
    }

    public static ScheduledFuture executeTask(final String sClass, final String sMethod, final Object[] args, final HashMap variables, final long delay)
    {
        return L2GameThreadPools.getInstance().scheduleGeneral(new Runnable()
        {
             
            public void run()
            {
                callScripts(sClass, sMethod, args, variables);
            }
        }, delay);
    }

    public static ScheduledFuture executeTask(final L2Object object, final String sClass, final String sMethod, final Object[] args, final long delay)
    {
        return executeTask(object, sClass, sMethod, args, null, delay);
    }

    public static ScheduledFuture executeTask(final String sClass, final String sMethod, final Object[] args, final long delay)
    {
        return executeTask(sClass, sMethod, args, null, delay);
    }

    public static Object callScripts(final String _class, final String method, final Object[] args)
    {
        return callScripts(_class, method, args, null);
    }

    public static Object callScripts(final String _class, final String method, final Object[] args, final HashMap variables)
    {
        if(Scripts.loading)
            return null;

        final Script scriptClass = Scripts.getInstance().getClasses().get(_class);
        if(scriptClass == null)
            return null;

        ScriptObject o;
        try
        {
            o = scriptClass.newInstance();
        }
        catch(final Exception e)
        {
            _log.log(Level.WARNING, "Error in callScripts class=" + _class + "/method=" + method, e);
            return null;
        }

        if(variables != null)
            for(final Entry obj : variables.entrySet())
                try
                {
                    o.setProperty(obj.getKey(), obj.getValue());
                }
                catch(final Exception e)
                {}

        return o.invokeMethod(method, args);
    }

    public static void show(String text, final L2Player self)
    {
        if(text == null || self == null)
            return;
        NpcHtmlMessage msg;
        if(self.getLastNpc() != null)
            msg = new NpcHtmlMessage(self, self.getLastNpc());
        else
            msg = new NpcHtmlMessage(5);

        if(text.endsWith(".html-ru") || text.endsWith(".htm-ru"))
            text = text.substring(0, text.length() - 3);

        if(text.endsWith(".html") || text.endsWith(".htm"))
            msg.setFile(text);
        else
            msg.setHtml(Strings.bbParse(text));
        self.sendPacket(msg);
    }

    public static void show(final CustomMessage message, final L2Player self)
    {
        show(message.toString(), self);
    }

    public static void sendMessage(final String text, final L2Player self)
    {
        self.sendMessage(text);
    }

    public static void sendMessage(final CustomMessage message, final L2Player self)
    {
        self.sendMessage(message);
    }

    public static void npcSayInRange(final L2NpcInstance npc, final String text, final int range)
    {
        npcSayInRange(npc, Say2C.LOCAL, text, range);
    }

    public static void npcSayInRange(final L2NpcInstance npc, final int messageType, final String text, final int range)
    {
        if(npc == null)
            return;
        final NpcSay cs = new NpcSay(npc, messageType, text);
        for(final L2Player player : L2World.getAroundPlayers(npc, range, 200))
            if(player != null)
                player.sendPacket(cs);
    }

    public static void npcSay(final L2NpcInstance npc, final String text)
    {
        npcSayInRange(npc, text, 1500);
    }

    public static void npcSayToAll(final L2NpcInstance npc, final String text)
    {
        if(npc == null)
            return;
        final NpcSay cs = new NpcSay(npc, 1, text);
        if(Config.GLOBAL_CHAT  players = npc.getAroundPlayers(range);
        if(players.isEmpty())
            return;
        final L2Player player = players.get(Rnd.get(players.size()));
        if(text.contains("%randomPlayer%"))
            text.replace("%randomPlayer%", player.getName());
        player.sendPacket(cs);
    }

    public static void npcShout(final L2NpcInstance npc, final String text)
    {
        if(npc == null)
            return;
        final NpcSay cs = new NpcSay(npc, 1, text);
        for(final L2Player player : L2World.getAroundPlayers(npc))
            if(player != null)
                player.sendPacket(cs);
    }

    public static void npcShout(final L2NpcInstance npc, final int range, final String text)
    {
        if(npc == null)
            return;
        final NpcSay cs = new NpcSay(npc, 1, text);
        for(final L2Player player : L2World.getAroundPlayers(npc, range, 1500))
            if(player != null)
                player.sendPacket(cs);
    }

    public static void npcSayInRangeCustomMessage(final L2NpcInstance npc, final int range, final String address)
    {
        if(npc == null)
            return;
        for(final L2Player player : L2World.getAroundPlayers(npc, range, 200))
            if(player != null && !player.isBlockAll())
                player.sendPacket(new NpcSay(npc, 0, new CustomMessage(address, player).toString()));
    }

    public static void npcSayInRangeCustomMessage(final L2NpcInstance npc, final int range, final String address, final Object... replacements)
    {
        if(npc == null)
            return;
        for(final L2Player player : L2World.getAroundPlayers(npc, range, 200))
            if(player != null && !player.isBlockAll())
                player.sendPacket(new NpcSay(npc, 0, new CustomMessage(address, player, replacements).toString()));
    }

    public static void npcSayCustomMessage(final L2NpcInstance npc, final String address)
    {
        npcSayInRangeCustomMessage(npc, 1500, address);
    }

    public static void npcSayCustomMessage(final L2NpcInstance npc, final String address, final Object... replacements)
    {
        npcSayInRangeCustomMessage(npc, 1500, address, replacements);
    }

    public static void npcShoutCustomMessage(final L2NpcInstance npc, final String address, final Object... replacements)
    {
        if(npc == null)
            return;

        if(Config.SHOUT_CHAT_MODE == 1)
        {
            for(final L2Player player : L2World.getAroundPlayers(npc, 10000, 1500))
                if(player != null && !player.isBlockAll())
                    player.sendPacket(new NpcSay(npc, 1, new CustomMessage(address, player, replacements).toString()));
        }
        else
        {
            final int mapregion = MapRegionTable.getInstance().getMapRegion(npc.getX(), npc.getY());
            for(final L2Player player : L2ObjectsStorage.getAllPlayersForIterate())
                if(player != null && MapRegionTable.getInstance().getMapRegion(player.getX(), player.getY()) == mapregion && !player.isBlockAll())
                    player.sendPacket(new NpcSay(npc, 1, new CustomMessage(address, player, replacements).toString()));
        }
    }

    public static void addItem(final L2Playable playable, final int item_id, final long count)
    {
        if(playable == null || count  0)
            {
                final long item_count = item.getCount();
                final long rem = count  0)
            player.sendPacket(SystemMessage.removeItems(item_id, removed));
        return removed;
    }

    public static boolean ride(final L2Player player, final int pet)
    {
        if(player.isMounted())
            player.setMount(0, 0);

        if(player.getPet() != null)
        {
            player.sendPacket(Msg.YOU_ALREADY_HAVE_A_PET);
            return false;
        }

        player.setMount(pet, 0);
        return true;
    }

    public static void unRide(final L2Player player)
    {
        if(player.isMounted())
            player.setMount(0, 0);
    }

    public static void unSummonPet(final L2Player player)
    {
        final L2Summon pet = player.getPet();
        if(pet == null)
            return;
        pet.unSummon();
    }

    public static L2NpcInstance spawn(final Location loc, final int npcId)
    {
        return spawn(loc, npcId, 0);
    }

    public static L2NpcInstance spawn(final Location loc, final int npcId, final long refId)
    {
        try
        {
            final L2NpcInstance npc = NpcTable.getTemplate(npcId).getNewInstance();
            npc.setReflection(refId);
            npc.setSpawnedLoc(loc.correctGeoZ());
            npc.onSpawn();
            npc.spawnMe(npc.getSpawnedLoc());
            return npc;
        }
        catch(final Exception e)
        {
            _log.log(Level.WARNING, "Could not spawn Npc " + npcId, e);
        }
        return null;
    }

    public static void spawnNPCs(final int npcId, final int[][] locations, final GArray list)
    {
        final L2NpcTemplate template = NpcTable.getTemplate(npcId);
        if(template == null)
        {
            System.out.println("WARNING! events.Helper.SpawnNPCs template is null for npc: " + npcId);
            Thread.dumpStack();
            return;
        }
        for(final int[] location : locations)
            try
            {
                final L2Spawn sp = new L2Spawn(template);
                sp.setLoc(new Location(location));
                sp.setAmount(1);
                sp.setRespawnDelay(0);
                sp.init();
                if(list != null)
                    list.add(sp);
            }
            catch(final ClassNotFoundException e)
            {
                _log.log(Level.WARNING, "Could not spawn Npc " + npcId, e);
            }
    }

    public static void deSpawnNPCs(final GArray list)
    {
        for(final L2Spawn sp : list)
        {
            sp.stopRespawn();
            if(sp.getLastSpawn() != null)
                sp.getLastSpawn().deleteMe();
        }
        list.clear();
    }

    public static boolean isActive(final String name)
    {
        return ServerVariables.getString(name, "off").equalsIgnoreCase("on");
    }

    public static boolean setActive(final String name, final boolean active)
    {
        if(active == isActive(name))
            return false;
        if(active)
            ServerVariables.set(name, "on");
        else
            ServerVariables.unset(name);
        return true;
    }

    public static boolean SimpleCheckDrop(final L2Character mob, final L2Character killer)
    {
        return mob != null && mob.isMonster() && !mob.isRaid() && killer != null && killer.getPlayer() != null && killer.getLevel() - mob.getLevel()  item_count ? item_count : count;
            player.getInventory().destroyItem(item, removed, true);

            if(item_id == 57)
                player.sendPacket(new SystemMessage(SystemMessage.S1_ADENA_DISAPPEARED).addNumber(removed));
            else if(removed > 1)
                player.sendPacket(new SystemMessage(SystemMessage.S2_S1_HAS_DISAPPEARED).addItemName(item_id).addNumber(removed));
            else
                player.sendPacket(new SystemMessage(SystemMessage.S1_HAS_DISAPPEARED).addItemName(item_id));
        }
    }

    public static String htmlButton(final String value, final String action, final int width)
    {
        return Strings.htmlButton(value, action, width);
    }

    public static String htmlButton(final String value, final String action, final int width, final int height)
    {
        return Strings.htmlButton(value, action, width, height);
    }

    public static ExShowTrace Points2Trace(final GArray points, final int step, final boolean auto_compleate, final boolean maxz)
    {
        final ExShowTrace result = new ExShowTrace();

        int[] prev = null;
        int[] first = null;
        for(final int[] p : points)
        {
            if(first == null)
                first = p;
            if(prev != null)
                result.addLine(prev[0], prev[1], maxz ? prev[3] : prev[2], p[0], p[1], maxz ? p[3] : p[2], step, 60000);
            prev = p;
        }

        if(prev == null || first == null)
            return result;
        if(auto_compleate)
            result.addLine(prev[0], prev[1], maxz ? prev[3] : prev[2], first[0], first[1], maxz ? first[3] : first[2], step, 60000);
        return result;
    }
}

package l2s.extensions.scripts;

public interface ScriptFile
{
    public void onLoad();

    public void onReload();

    public void onShutdown();
}