Парочка скриптов(эвенты)

package events.bountyhunters;

import java.util.ArrayList;
import l2d.ext.scripts.Functions;
import l2d.ext.scripts.ScriptFile;
import l2d.game.Announcements;
import l2d.game.instancemanager.ServerVariables;
import l2d.game.model.L2Object;
import l2d.game.model.L2Player;
import l2d.game.model.L2Spawn;
import l2d.game.tables.NpcTable;
import l2d.game.templates.L2NpcTemplate;
import l2d.util.Files;

// Эвент SiegeMob
public class SiegeMob extends Functions implements ScriptFile
{
public static L2Object self;
public static L2Object npc;
private static int EVENT_MANAGER_ID = 22424;
private static ArrayList<L2Spawn> _spawns = new ArrayList<L2Spawn>();

public static boolean _active = false;

private void spawnEventManagers()
{
final int EVENT_MANAGERS[][] = {
{ 22088, 252537, -2042, 10970 }, //1
{ 22023, 252477, -2044, 337 }, //1
{ 21053, 254730, -2040, 16167 }, //2
{ 20812, 254829, -2040, 39721 }, //2
{ 19023, 254869, -2037, 7038 }, //3
{ 18822, 254742, -2046, 49152 }, //3
{ 17309, 254019, -2043, 7038 }, //4
{ 17319, 253760, -2047, 49152 }, //4
{ 17618, 252120, -2047, 7038 }, //5
{ 17794, 251935, -2044, 49152 }, //5
{ 19552, 251848, -2036, 7038 }, //6
{ 19811, 251982, -2044, 49152 }, //6
{ 19850, 251942, -2044, 49152 } //3
};

L2NpcTemplate template = NpcTable.getTemplate(EVENT_MANAGER_ID);
for(int[] element : EVENT_MANAGERS)
try
{
L2Spawn sp = new L2Spawn(template);
sp.setLocx(element[0]);
sp.setLocy(element[1]);
sp.setLocz(element[2]);
sp.setAmount(1);
sp.setHeading(element[3]);
sp.setRespawnDelay(0);
sp.init();
_spawns.add(sp);
}
catch(ClassNotFoundException e)
{
e.printStackTrace();
}
}

private void unSpawnEventManagers()
{
for(L2Spawn sp : _spawns)
{
sp.stopRespawn();
sp.getLastSpawn().deleteMe();
}
_spawns.clear();
}

private static boolean isActive()
{
return ServerVariables.getString("SiegeMob", "off").equalsIgnoreCase("on");
}

public void startEvent()
{
L2Player player = (L2Player) self;
if(!player.getPlayerAccess().IsEventGm)
return;

if(!isActive())
{
ServerVariables.set("SiegeMob", "on");
spawnEventManagers();
System.out.println("Event: 'SiegeMob' started.");

}
else
player.sendMessage("Event 'SiegeMob' already started.");

_active = true;

show(Files.read("data/html/admin/events/SiegeCV.htm", player), player);
}

public void stopEvent()
{
L2Player player = (L2Player) self;
if(!player.getPlayerAccess().IsEventGm)
return;
if(isActive())
{
ServerVariables.unset("SiegeMob");
unSpawnEventManagers();
System.out.println("Event: SiegeMob stopped.");

}
else
player.sendMessage("Event 'SiegeMob' not started.");

_active = false;
show(Files.read("data/html/admin/events/SiegeCV.htm", player), player);
}

public void onLoad()
{
if(isActive())
{
_active = true;
spawnEventManagers();
System.out.println("Loaded Event: SiegeMob [state: activated]");
}
else
System.out.println("Loaded Event: SiegeMob [state: deactivated]");
}

public void onReload()
{
unSpawnEventManagers();
}

public void onShutdown()
{
unSpawnEventManagers();
}
}

package events.lasthero;

import static l2d.game.model.L2Zone.ZoneType.OlympiadStadia;

import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.ScheduledFuture;

import l2d.Config;
import l2d.ext.listeners.L2ZoneEnterLeaveListener;
import l2d.ext.multilang.CustomMessage;
import l2d.ext.scripts.Functions;
import l2d.ext.scripts.ScriptFile;
import l2d.game.Announcements;
import l2d.game.ThreadPoolManager;
import l2d.game.instancemanager.ServerVariables;
import l2d.game.instancemanager.ZoneManager;
import l2d.game.model.L2Character;
import l2d.game.model.L2Object;
import l2d.game.model.L2Playable;
import l2d.game.model.L2Player;
import l2d.game.model.L2Skill;
import l2d.game.model.L2World;
import l2d.game.model.L2Zone;
import l2d.game.model.L2Zone.ZoneType;
import l2d.game.model.instances.L2NpcInstance;
import l2d.game.network.serverpackets.Revive;
import l2d.game.tables.SkillTable;
import l2d.util.Files;
import l2d.util.Location;
import l2d.util.Rnd;
import l2d.util.Util;

public class LastHero extends Functions implements ScriptFile
{
public class StartTask implements Runnable
{
public void run()
{
if(_active && !isRunned())
start(new String[] { "1", "1" });
}
}

@SuppressWarnings("unchecked")
private static ScheduledFuture _startTask;

public L2Object self;
public L2NpcInstance npc;

private static ConcurrentLinkedQueue<L2Player> players_list = new ConcurrentLinkedQueue<L2Player>();
private static ConcurrentLinkedQueue<L2Player> live_list = new ConcurrentLinkedQueue<L2Player>();

private static boolean _isRegistrationActive = false;
private static int _status = 0;
private static int _time_to_start;
private static int _category;
private static int _minLevel;
private static int _maxLevel;
private static int _autoContinue = 0;

@SuppressWarnings("unchecked")
private static ScheduledFuture _endTask;

private static L2Zone _zone = ZoneManager.getInstance().getZoneByIndex(ZoneType.battle_zone, 4, true);
ZoneListener _zoneListener = new ZoneListener();

public void onLoad()
{
_zone.getListenerEngine().addMethodInvokedListener(_zoneListener);
_startTask = ThreadPoolManager.getInstance().scheduleGeneralAtFixedRate(new StartTask(), (Config.EVENT_LastHeroAutoTime * 60 * 1000), (Config.EVENT_LastHeroAutoTime * 60 * 1000));
_active = ServerVariables.getString("LastHero", "off").equalsIgnoreCase("on");

System.out.println("Loaded Event: Last Hero");
}

public void onReload()
{
_zone.getListenerEngine().removeMethodInvokedListener(_zoneListener);
_startTask.cancel(true);
}

public void onShutdown()
{
onReload();
}

private static boolean _active = false;

private static boolean isActive()
{
return _active;
}

public void activateEvent()
{
L2Player player = (L2Player) self;
if(!player.getPlayerAccess().IsEventGm)
return;

if(!isActive())
{
if(_startTask == null)
_startTask = ThreadPoolManager.getInstance().scheduleGeneralAtFixedRate(new StartTask(), (Config.EVENT_LastHeroAutoTime * 60 * 1000), (Config.EVENT_LastHeroAutoTime * 60 * 1000));
ServerVariables.set("LastHero", "on");
System.out.println("Event 'Last Hero' activated.");
Announcements.getInstance().announceByCustomMessage("scripts.events.lasthero.AnnounceEventStarted", null);
}
else
player.sendMessage("Event 'Last Hero' already active.");

_active = true;

show(Files.read("data/html/admin/events.htm", player), player);
}

public void deactivateEvent()
{
L2Player player = (L2Player) self;
if(!player.getPlayerAccess().IsEventGm)
return;

if(isActive())
{
if(_startTask != null)
{
_startTask.cancel(true);
_startTask = null;
}
ServerVariables.unset("LastHero");
System.out.println("Event 'Last Hero' deactivated.");
Announcements.getInstance().announceByCustomMessage("scripts.events.lasthero.AnnounceEventStoped", null);
}
else
player.sendMessage("Event 'LastHero' not active.");

_active = false;

show(Files.read("data/html/admin/events.htm", player), player);
}

public static boolean isRunned()
{
return _isRegistrationActive || _status > 0;
}

public String DialogAppend_31225(Integer val)
{
if(val == 0)
{
L2Player player = (L2Player) self;
return Files.read("data/scripts/events/lasthero/31225.html", player);
}
return "";
}

public static int getMinLevelForCategory(int category)
{
switch (category)
{
case 1:
return 85;
case 2:
return 85;
case 3:
return 85;
case 4:
return 85;
case 5:
return 85;
case 6:
return 85;
}
return 0;
}

public static int getMaxLevelForCategory(int category)
{
switch (category)
{
case 1:
return 85;
case 2:
return 85;
case 3:
return 85;
case 4:
return 85;
case 5:
return 85;
case 6:
return 85;
}
return 0;
}

public static int getCategory(int level)
{
if(level >= 85 && level <= 85)
return 1;
else if(level >= 85 && level <= 85)
return 2;
else if(level >= 85 && level <= 85)
return 3;
else if(level >= 85 && level <= 85)
return 4;
else if(level >= 85 && level <= 85)
return 5;
else if(level >= 85)
return 6;
return 0;
}

public void start(String[] var)
{
L2Player player = (L2Player) self;
if(var.length != 2)
{
show(new CustomMessage("common.Error", player), player);
return;
}

Integer category;
Integer autoContinue;
try
{
category = Integer.valueOf(var[0]);
autoContinue = Integer.valueOf(var[1]);
}
catch(Exception e)
{
show(new CustomMessage("common.Error", player), player);
return;
}

_category = category;
_autoContinue = autoContinue;

_minLevel = getMinLevelForCategory(_category);
_maxLevel = getMaxLevelForCategory(_category);

if(_endTask != null)
{
show(new CustomMessage("common.TryLater", player), player);
return;
}

_status = 0;
_isRegistrationActive = true;
_time_to_start = Config.EVENT_LastHeroTime;

players_list = new ConcurrentLinkedQueue<L2Player>();
live_list = new ConcurrentLinkedQueue<L2Player>();

String[] param = {
String.valueOf(_time_to_start),
String.valueOf(_minLevel),
String.valueOf(_maxLevel) };
sayToAll("scripts.events.lasthero.AnnouncePreStart", param);

executeTask("events.lasthero.LastHero", "question", new Object[0], 10000);
executeTask("events.lasthero.LastHero", "announce", new Object[0], 60000);
}

public static void sayToAll(String address, String[] replacements)
{
Announcements.getInstance().announceByCustomMessage(address, replacements);
}

public static void question()
{
for(L2Player player : L2World.getAllPlayers())
if(player != null && player.getLevel() >= _minLevel && player.getLevel() <= _maxLevel)
player.scriptRequest(new CustomMessage("scripts.events.lasthero.AskPlayer", player).toString(), "events.lasthero.LastHero:addPlayer", new Object[0]);
}

public static void announce()
{
if(players_list.size() < 2)
{
sayToAll("scripts.events.lasthero.AnnounceEventCancelled", null);
_isRegistrationActive = false;
_status = 0;
executeTask("events.lasthero.LastHero", "autoContinue", new Object[0], 10000);
return;
}

if(_time_to_start > 1)
{
_time_to_start--;
String[] param = {
String.valueOf(_time_to_start),
String.valueOf(_minLevel),
String.valueOf(_maxLevel) };
sayToAll("scripts.events.lasthero.AnnouncePreStart", param);
executeTask("events.lasthero.LastHero", "announce", new Object[0], 60000);
}
else
{
_status = 1;
_isRegistrationActive = false;
sayToAll("scripts.events.lasthero.AnnounceEventStarting", null);
executeTask("events.lasthero.LastHero", "prepare", new Object[0], 5000);
}
}

public void addPlayer()
{
L2Player player = (L2Player) self;
if(player == null || !checkPlayer(player, true))
return;

players_list.add(player);
live_list.add(player);

show(new CustomMessage("scripts.events.lasthero.Registered", player), player);
}

public static boolean checkPlayer(L2Player player, boolean first)
{
if(first && !_isRegistrationActive)
{
show(new CustomMessage("scripts.events.Late", player), player);
return false;
}

if(first && players_list.contains(player))
{
show(new CustomMessage("scripts.events.lasthero.Cancelled", player), player);
return false;
}

if(player.getLevel() < _minLevel || player.getLevel() > _maxLevel)
{
show(new CustomMessage("scripts.events.lasthero.CancelledLevel", player), player);
return false;
}

if(player.getDuel() != null)
{
show(new CustomMessage("scripts.events.lasthero.CancelledDuel", player), player);
return false;
}

if(player.getTeam() != 0)
{
show(new CustomMessage("scripts.events.lasthero.CancelledOtherEvent", player), player);
return false;
}

if(player.isInZone(OlympiadStadia))
{
show(new CustomMessage("scripts.events.lasthero.CancelledOlympiad", player), player);
return false;
}

if(player.isInParty() && player.getParty().isInDimensionalRift())
{
show(new CustomMessage("scripts.events.lasthero.CancelledOtherEvent", player), player);
return false;
}

if(player.isTeleporting())
{
show(new CustomMessage("scripts.events.lasthero.CancelledTeleport", player), player);
return false;
}

return true;
}

public static void prepare()
{
cleanPlayers();
clearArena();

executeTask("events.lasthero.LastHero", "ressurectPlayers", new Object[0], 1000);
executeTask("events.lasthero.LastHero", "healPlayers", new Object[0], 2000);
executeTask("events.lasthero.LastHero", "saveBackCoords", new Object[0], 3000);
executeTask("events.lasthero.LastHero", "paralyzePlayers", new Object[0], 4000);
executeTask("events.lasthero.LastHero", "teleportPlayersToColiseum", new Object[0], 5000);
executeTask("events.lasthero.LastHero", "go", new Object[0], 60000);

sayToAll("scripts.events.lasthero.AnnounceFinalCountdown", null);
}

public static void go()
{
_status = 2;
upParalyzePlayers();
checkLive();
clearArena();
sayToAll("scripts.events.lasthero.AnnounceFight", null);
_endTask = executeTask("events.lasthero.LastHero", "endBattle", new Object[0], 300000);
}

public static void endBattle()
{
_status = 0;
removeAura();
if(live_list.size() == 1)
for(L2Player player : live_list)
if(player != null)
{
String[] repl = { player.getName() };
sayToAll("scripts.events.lasthero.AnnounceWiner", repl);

if(Config.EVENT_LastHeroRate)
addItem(player, Config.EVENT_LastHeroItemID, player.getLevel() * Config.EVENT_LastHeroItemCOUNT * 5);
else
addItem(player, Config.EVENT_LastHeroItemID, Config.EVENT_LastHeroItemCOUNT * 5);
break;
}
sayToAll("scripts.events.lasthero.AnnounceEnd", null);
executeTask("events.lasthero.LastHero", "end", new Object[0], 60000);
_isRegistrationActive = false;
if(_endTask != null)
{
_endTask.cancel(false);
_endTask = null;
}
}

public static void end()
{
executeTask("events.lasthero.LastHero", "ressurectPlayers", new Object[0], 1000);
executeTask("events.lasthero.LastHero", "healPlayers", new Object[0], 2000);
executeTask("events.lasthero.LastHero", "teleportPlayersToSavedCoords", new Object[0], 3000);
executeTask("events.lasthero.LastHero", "autoContinue", new Object[0], 10000);
}

public void autoContinue()
{
if(_autoContinue > 0)
{
if(_autoContinue >= 6)
{
_autoContinue = 0;
return;
}
start(new String[] {
"" + (_autoContinue + 1),
"" + (_autoContinue + 1) });
}
}

public static void saveBackCoords()
{
for(L2Player player : players_list)
if(player != null)
player.setVar("LastHero_backCoords", player.getX() + " " + player.getY() + " " + player.getZ() + " " + player.getReflection().getId());
}

public static void teleportPlayersToColiseum()
{
for(L2Player player : players_list)
if(player != null)
{
Location pos = Rnd.coordsRandomize(149505, 46719, -3417, 0, 0, 500);
player.teleToLocation(pos, 0);
}
}

public static void teleportPlayersToSavedCoords()
{
for(L2Player player : players_list)
if(player != null)
{
String var = player.getVar("LastHero_backCoords");
if(var == null || var.equals(""))
continue;
String[] coords = var.split(" ");
if(coords.length != 4)
continue;
player.teleToLocation(Integer.parseInt(coords[0]), Integer.parseInt(coords[1]), Integer.parseInt(coords[2]), Integer.parseInt(coords[3]));
player.unsetVar("LastHero_backCoords");
}
}

public static void teleportToColiseumSpawn(L2Character cha)
{
if(cha != null)
cha.teleToLocation(147451, 46728, -3410);
}

public static void paralyzePlayers()
{
L2Skill revengeSkill = SkillTable.getInstance().getInfo(4515, 1);
for(L2Player player : players_list)
if(player != null)
{
revengeSkill.getEffects(player, player, false);
if(player.getPet() != null)
revengeSkill.getEffects(player, player.getPet(), false);
}
}

public static void upParalyzePlayers()
{
for(L2Player player : players_list)
if(player != null)
{
player.stopEffect(4515);
if(player.getPet() != null)
player.getPet().stopEffect(4515);

if(player.getParty() != null)
player.getParty().oustPartyMember(player);
}
}

public static void ressurectPlayers()
{
for(L2Player player : players_list)
if(player != null && player.isDead())
{
player.restoreExp();
player.setCurrentCp(player.getMaxCp());
player.setCurrentHp(player.getMaxHp());
player.setCurrentMp(player.getMaxMp());
player.broadcastPacket(new Revive(player));
}
}

public static void healPlayers()
{
for(L2Player player : players_list)
if(player != null)
{
player.setCurrentHpMp(player.getMaxHp(), player.getMaxMp());
player.setCurrentCp(player.getMaxCp());
}
}

public static void cleanPlayers()
{
for(L2Player player : players_list)
if(!checkPlayer(player, false))
{
players_list.remove(player);
live_list.remove(player);
}
}

public static void checkLive()
{
for(L2Player player : live_list)
if(player != null && player.isInZone(_zone) && !player.isDead() && player.isConnected() && !player.isLogoutStarted())
player.setTeam(2);
else if(player != null)
{
show(new CustomMessage("scripts.events.lasthero.YouLose", player), player);
player.setTeam(0);
live_list.remove(player);
}
if(live_list.size() <= 1)
endBattle();
}

public static void removeAura()
{
for(L2Player player : live_list)
if(player != null)
player.setTeam(0);
}

public static void clearArena()
{
for(L2Object obj : _zone.getObjects())
if(obj != null)
{
L2Player player = obj.getPlayer();
if(player != null && !live_list.contains(player))
teleportToColiseumSpawn(player);
}
}

public static void OnDie(L2Object self, L2Character killer)
{
if(_status > 1 && self != null && self.isPlayer && live_list.contains(self))
{
live_list.remove(self);
((L2Player) self).setTeam(0);
show(new CustomMessage("scripts.events.lasthero.YouLose", self), ((L2Player) self));
checkLive();
if(killer != null && killer.isPlayer)
if(Config.EVENT_LastHeroRate)
addItem((L2Player) killer, Config.EVENT_LastHeroItemID, ((L2Player) self).getLevel() * Config.EVENT_LastHeroItemCOUNT);
else
addItem((L2Player) killer, Config.EVENT_LastHeroItemID, Config.EVENT_LastHeroItemCOUNT);
}
}

public static Location OnEscape(L2Player player)
{
if(_status > 1 && player != null && live_list.contains(player))
{
live_list.remove(player);
player.setTeam(0);
checkLive();
}
return null;
}

public static void OnPlayerExit(L2Player player)
{
// Р’С‹С?ел или вылетел РІРѕ время регистрации
if(_status == 0 && _isRegistrationActive && player != null && live_list.contains(player))
{
live_list.remove(player);
players_list.remove(player);
return;
}

// Р’С‹С?ел или вылетел РІРѕ время телепортации
if(_status == 1 && player != null && live_list.contains(player))
{
live_list.remove(player);
players_list.remove(player);
player.setTeam(0);

String var = player.getVar("LastHero_backCoords");
if(var == null || var.equals(""))
return;
String[] coords = var.split(" ");
if(coords.length != 4)
return;
player.teleToLocation(Integer.parseInt(coords[0]), Integer.parseInt(coords[1]), Integer.parseInt(coords[2]), Integer.parseInt(coords[3]));
player.unsetVar("LastHero_backCoords");
return;
}

// Р’С‹С?ел или вылетел РІРѕ время эвента
if(_status > 1 && player != null && live_list.contains(player))
{
live_list.remove(player);
player.setTeam(0);
checkLive();
}
}

private class ZoneListener extends L2ZoneEnterLeaveListener
{
@Override
public void objectEntered(L2Zone zone, L2Object object)
{
if(_status > 0 && object != null && object.getPlayer() != null && !live_list.contains(object.getPlayer()))
teleportToColiseumSpawn((L2Character) object);
}

@Override
public void objectLeaved(L2Zone zone, L2Object object)
{
L2Player player = object.getPlayer();
if(_status > 1 && player != null && live_list.contains(player))
{
L2Playable playable = (L2Playable) object;
double angle = Util.convertHeadingToDegree(playable.getHeading()); // угол в градусах
double radian = Math.toRadians(angle - 90); // угол в радианах
playable.teleToLocation((int) (playable.getX() + 50 * Math.sin(radian)), (int) (playable.getY() - 50 * Math.cos(radian)), playable.getZ());
}
}
}
}