Как выдать "одноразовый хиро" игроку после Ласт Хиро

[duhnochi]

Здравствуйте, уважаемые посетители данного форума.
У меня такая проблемка: Ивент Last Hero не выдает статус Hero победителю. Я смотрел исходники других исходников LH, но они меня ни к чему не привели.
Rebillion

Код ивента:

PHP код:

package l2r.scripts.events.lastHero;

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.concurrent.ScheduledFuture;
import java.util.logging.Logger;
import l2r.Config;
import l2r.common.ThreadPoolManager;
import l2r.extensions.B.C;
import l2r.extensions.listeners.C.B;
import l2r.extensions.listeners.L2ZoneEnterLeaveListener;
import l2r.extensions.scripts.Functions;
import l2r.extensions.scripts.ScriptFile;
import l2r.gameserver.B.A;
import l2r.gameserver.B.L;
import l2r.gameserver.B.O;
import l2r.gameserver.D;
import l2r.gameserver.D.C.B;
import l2r.gameserver.H.C;
import l2r.gameserver.model.EffectList;
import l2r.gameserver.model.L2Character;
import l2r.gameserver.model.L2Object;
import l2r.gameserver.model.L2ObjectsStorage;
import l2r.gameserver.model.L2Party;
import l2r.gameserver.model.L2Player;
import l2r.gameserver.model.L2Skill;
import l2r.gameserver.model.L2Summon;
import l2r.gameserver.model.L2Zone;
import l2r.gameserver.model.L2Zone.ZoneType;
import l2r.gameserver.model.Reflection;
import l2r.gameserver.model.base.PlayerAccess;
import l2r.gameserver.model.entity.olympiad.Olympiad;
import l2r.gameserver.model.entity.residence.Castle;
import l2r.gameserver.model.entity.siege.castle.CastleSiege;
import l2r.gameserver.model.entity.siege.territory.TerritorySiege;
import l2r.gameserver.model.instances.L2DoorInstance;
import l2r.gameserver.network.serverpackets.L2GameServerPacket;
import l2r.gameserver.network.serverpackets.Revive;
import l2r.util.Files;
import l2r.util.GArray;
import l2r.util.GCSArray;
import l2r.util.Location;
import l2r.util.Rnd;
import l2r.util.Util;

public class LastHero extends Functions
  implements ScriptFile
{
  private static Logger _log = Logger.getLogger(LastHero.class.getName());
  private static ScheduledFuture<?> _startTask;
  private static GCSArray<Long> players_list = new GCSArray();
  private static GCSArray<Long> live_list = new GCSArray();
  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;
  private static ScheduledFuture<?> _endTask;
  private static L2Zone _zone = A.B().A(L2Zone.ZoneType.battle_zone, 4, true);
  ZoneListener _zoneListener;
  private static boolean _active = false;

  public LastHero()
  {
    this._zoneListener = new ZoneListener(this, null);
  }

  public void onLoad()
  {
    _zone.getListenerEngine().A(this._zoneListener);
    _startTask = ThreadPoolManager.getInstance().scheduleGeneralAtFixedRate(new StartTask(this), 3600000, 3600000);
    _active = O.A("LastHero", "off").equalsIgnoreCase("on");
    _log.fine("Loaded Event: Last Hero");
  }

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

  public void onShutdown()
  {
    onReload();
  }

  private static boolean isActive()
  {
    return _active;
  }

  public void activateEvent()
  {
    L2Player localL2Player = (L2Player)getSelf();
    if (!(localL2Player.getPlayerAccess().IsEventGm))
      return;
    if (!(isActive()))
    {
      if (_startTask == null)
        _startTask = ThreadPoolManager.getInstance().scheduleGeneralAtFixedRate(new StartTask(this), 3600000, 3600000);
      O.B("LastHero", "on");
      _log.fine("Event 'Last Hero' activated.");
      D.C().A("l2r.scripts.events.LastHero.AnnounceEventStarted", null);
    }
    else
      localL2Player.sendMessage("Ивент 'Last Hero' уже активирован.");
    _active = true;
    show(Files.read("data/html/admin/events.htm", localL2Player), localL2Player);
  }

  public void deactivateEvent()
  {
    L2Player localL2Player = (L2Player)getSelf();
    if (!(localL2Player.getPlayerAccess().IsEventGm))
      return;
    if (isActive())
    {
      if (_startTask != null)
      {
        _startTask.cancel(true);
        _startTask = null;
      }
      O.B("LastHero");
      _log.fine("Event 'Last Hero' dissabled.");
      D.C().A("l2r.scripts.events.LastHero.AnnounceEventStoped", null);
    }
    else
      localL2Player.sendMessage("Ивент 'LastHero' не активен.");
    _active = false;
    show(Files.read("data/html/admin/events.htm", localL2Player), localL2Player);
  }

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

  public String DialogAppend_31225(Integer paramInteger)
  {
    if (paramInteger.intValue() == 0)
    {
      L2Player localL2Player = (L2Player)getSelf();
      return Files.read("data/html/scripts/events/lastHero/31225.html", localL2Player);
    }
    return "";
  }

  public static int getMinLevelForCategory(int paramInt)
  {
    switch (paramInt)
    {
    case 1:
      return 20;
    case 2:
      return 30;
    case 3:
      return 40;
    case 4:
      return 52;
    case 5:
      return 62;
    case 6:
      return 76;
    }
    return 0;
  }

  public static int getMaxLevelForCategory(int paramInt)
  {
    switch (paramInt)
    {
    case 1:
      return 29;
    case 2:
      return 39;
    case 3:
      return 51;
    case 4:
      return 61;
    case 5:
      return 75;
    case 6:
      return 85;
    }
    return 0;
  }

  public static int getCategory(int paramInt)
  {
    if ((paramInt >= 20) && (paramInt <= 29))
      return 1;
    if ((paramInt >= 30) && (paramInt <= 39))
      return 2;
    if ((paramInt >= 40) && (paramInt <= 51))
      return 3;
    if ((paramInt >= 52) && (paramInt <= 61))
      return 4;
    if ((paramInt >= 62) && (paramInt <= 75))
      return 5;
    if (paramInt >= 76)
      return 6;
    return 0;
  }

  public void start(String[] paramArrayOfString)
  {
    Integer localInteger1;
    Integer localInteger2;
    L2Player localL2Player = (L2Player)getSelf();
    if (paramArrayOfString.length != 2)
    {
      show(new C("common.Error", localL2Player, new Object[0]), localL2Player);
      return;
    }
    try
    {
      localInteger1 = Integer.valueOf(paramArrayOfString[0]);
      localInteger2 = Integer.valueOf(paramArrayOfString[1]);
    }
    catch (Exception localObject)
    {
      show(new C("common.Error", localL2Player, new Object[0]), localL2Player);
      return;
    }
    _category = localInteger1.intValue();
    _autoContinue = localInteger2.intValue();
    if (_category == -1)
    {
      _minLevel = 1;
      _maxLevel = 85;
    }
    else
    {
      _minLevel = getMinLevelForCategory(_category);
      _maxLevel = getMaxLevelForCategory(_category);
    }
    if (_endTask != null)
    {
      show(new C("common.TryLater", localL2Player, new Object[0]), localL2Player);
      return;
    }
    _status = 0;
    _isRegistrationActive = true;
    _time_to_start = Config.EVENT_LastHeroTime;
    players_list = new GCSArray();
    live_list = new GCSArray();
    localObject = { String.valueOf(_time_to_start), String.valueOf(_minLevel), String.valueOf(_maxLevel) };
    sayToAll("l2r.scripts.events.LastHero.AnnouncePreStart", localObject);
    executeTask("l2r.scripts.events.lastHero.LastHero", "question", new Object[0], 10000);
    executeTask("l2r.scripts.events.lastHero.LastHero", "announce", new Object[0], 60000);
  }

  public static void sayToAll(String paramString, String[] paramArrayOfString)
  {
    D.C().A(paramString, paramArrayOfString, 18);
  }

  public static void question()
  {
    Iterator localIterator = L2ObjectsStorage.getAllPlayersForIterate().iterator();
    while (localIterator.hasNext())
    {
      L2Player localL2Player = (L2Player)localIterator.next();
      if ((localL2Player != null) && (localL2Player.getLevel() >= _minLevel) && (localL2Player.getLevel() <= _maxLevel) && (!(localL2Player.getReflection().getId() > 0L)) && (!(localL2Player.isInOlympiadMode())))
        localL2Player.scriptRequest(new C("l2r.scripts.events.LastHero.AskPlayer", localL2Player, new Object[0]).toString(), "l2r.scripts.events.lastHero.LastHero:addPlayer", new Object[0]);
    }
  }

  public static void announce()
  {
    if (players_list.size() < 2)
    {
      sayToAll("l2r.scripts.events.LastHero.AnnounceEventCancelled", null);
      _isRegistrationActive = false;
      _status = 0;
      executeTask("l2r.scripts.events.lastHero.LastHero", "autoContinue", new Object[0], 10000);
      return;
    }
    if (_time_to_start > 1)
    {
      _time_to_start = _time_to_start - 1;
      String[] arrayOfString = { String.valueOf(_time_to_start), String.valueOf(_minLevel), String.valueOf(_maxLevel) };
      sayToAll("l2r.scripts.events.LastHero.AnnouncePreStart", arrayOfString);
      executeTask("l2r.scripts.events.lastHero.LastHero", "announce", new Object[0], 60000);
    }
    else
    {
      _status = 1;
      _isRegistrationActive = false;
      sayToAll("l2r.scripts.events.LastHero.AnnounceEventStarting", null);
      executeTask("l2r.scripts.events.lastHero.LastHero", "prepare", new Object[0], 5000);
    }
  }

  public void addPlayer()
  {
    L2Player localL2Player = (L2Player)getSelf();
    if ((localL2Player == null) || (!(checkPlayer(localL2Player, true))))
      return;
    players_list.add(localL2Player.getStoredId());
    live_list.add(localL2Player.getStoredId());
    show(new C("l2r.scripts.events.LastHero.Registered", localL2Player, new Object[0]), localL2Player);
  }

  public static boolean checkPlayer(L2Player paramL2Player, boolean paramBoolean)
  {
    if ((paramBoolean) && (!(_isRegistrationActive)))
    {
      show(new C("l2r.scripts.events.Late", paramL2Player, new Object[0]), paramL2Player);
      return false;
    }
    if ((paramBoolean) && (players_list.contains(paramL2Player.getStoredId())))
    {
      show(new C("l2r.scripts.events.LastHero.Cancelled", paramL2Player, new Object[0]), paramL2Player);
      return false;
    }
    if ((paramL2Player.getLevel() < _minLevel) || (paramL2Player.getLevel() > _maxLevel))
    {
      show(new C("l2r.scripts.events.LastHero.CancelledLevel", paramL2Player, new Object[0]), paramL2Player);
      return false;
    }
    if (paramL2Player.isMounted())
    {
      show(new C("l2r.scripts.events.LastHero.Cancelled", paramL2Player, new Object[0]), paramL2Player);
      return false;
    }
    if (paramL2Player.getDuel() != null)
    {
      show(new C("l2r.scripts.events.LastHero.CancelledDuel", paramL2Player, new Object[0]), paramL2Player);
      return false;
    }
    if (paramL2Player.getTeam() != 0)
    {
      show(new C("l2r.scripts.events.LastHero.CancelledOtherEvent", paramL2Player, new Object[0]), paramL2Player);
      return false;
    }
    if ((paramL2Player.getOlympiadGameId() > 0) || (paramL2Player.isInZoneOlympiad()) || ((paramBoolean) && (Olympiad.isRegistered(paramL2Player))))
    {
      show(new C("l2r.scripts.events.LastHero.CancelledOlympiad", paramL2Player, new Object[0]), paramL2Player);
      return false;
    }
    if ((paramL2Player.isInParty()) && (paramL2Player.getParty().isInDimensionalRift()))
    {
      show(new C("l2r.scripts.events.LastHero.CancelledOtherEvent", paramL2Player, new Object[0]), paramL2Player);
      return false;
    }
    if (paramL2Player.isTeleporting())
    {
      show(new C("l2r.scripts.events.LastHero.CancelledTeleport", paramL2Player, new Object[0]), paramL2Player);
      return false;
    }
    return true;
  }

  public static void prepare()
  {
    B.E().B(Integer.valueOf(24190002)).closeMe();
    B.E().B(Integer.valueOf(24190003)).closeMe();
    cleanPlayers();
    clearArena();
    executeTask("l2r.scripts.events.lastHero.LastHero", "ressurectPlayers", new Object[0], 1000);
    executeTask("l2r.scripts.events.lastHero.LastHero", "healPlayers", new Object[0], 2000);
    executeTask("l2r.scripts.events.lastHero.LastHero", "saveBackCoords", new Object[0], 3000);
    executeTask("l2r.scripts.events.lastHero.LastHero", "paralyzePlayers", new Object[0], 4000);
    executeTask("l2r.scripts.events.lastHero.LastHero", "teleportPlayersToColiseum", new Object[0], 5000);
    executeTask("l2r.scripts.events.lastHero.LastHero", "go", new Object[0], 60000);
    sayToAll("l2r.scripts.events.LastHero.AnnounceFinalCountdown", null);
  }

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

  public static void endBattle()
  {
    B.E().B(Integer.valueOf(24190002)).openMe();
    B.E().B(Integer.valueOf(24190003)).openMe();
    _status = 0;
    removeAura();
    if (live_list.size() == 1)
    {
      Iterator localIterator = getPlayers(live_list).iterator();
      if (localIterator.hasNext())
      {
        L2Player localL2Player = (L2Player)localIterator.next();
        String[] arrayOfString = { localL2Player.getName() };
        sayToAll("l2r.scripts.events.LastHero.AnnounceWiner", arrayOfString);
        addItem(localL2Player, Config.EVENT_LastHeroItemID, Math.round(1F * Config.EVENT_LastHeroItemCOUNTFinal));
      }
    }
    sayToAll("l2r.scripts.events.LastHero.AnnounceEnd", null);
    executeTask("l2r.scripts.events.lastHero.LastHero", "end", new Object[0], 30000);
    _isRegistrationActive = false;
    if (_endTask != null)
    {
      _endTask.cancel(false);
      _endTask = null;
    }
  }

  public static void end()
  {
    executeTask("l2r.scripts.events.lastHero.LastHero", "ressurectPlayers", new Object[0], 1000);
    executeTask("l2r.scripts.events.lastHero.LastHero", "healPlayers", new Object[0], 2000);
    executeTask("l2r.scripts.events.lastHero.LastHero", "teleportPlayersToSavedCoords", new Object[0], 3000);
    executeTask("l2r.scripts.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()
  {
    Iterator localIterator = getPlayers(players_list).iterator();
    while (localIterator.hasNext())
    {
      L2Player localL2Player = (L2Player)localIterator.next();
      localL2Player.setVar("LastHero_backCoords", localL2Player.getX() + " " + localL2Player.getY() + " " + localL2Player.getZ() + " " + localL2Player.getReflection().getId());
    }
  }

  public static void teleportPlayersToColiseum()
  {
    Iterator localIterator = getPlayers(players_list).iterator();
    while (localIterator.hasNext())
    {
      L2Player localL2Player = (L2Player)localIterator.next();
      unRide(localL2Player);
      unSummonPet(localL2Player, true);
      Location localLocation = Rnd.coordsRandomize(149505, 46719, -3417, 0, 0, 500);
      localL2Player.teleToLocation(localLocation, 0L);
    }
  }

  public static void teleportPlayersToSavedCoords()
  {
    Iterator localIterator = getPlayers(players_list).iterator();
    while (localIterator.hasNext())
    {
      L2Player localL2Player = (L2Player)localIterator.next();
      try
      {
        String[] arrayOfString;
        while (true)
        {
          String str;
          while (true)
          {
            str = localL2Player.getVar("LastHero_backCoords");
            if ((str != null) && (!(str.equals(""))))
              break;
          }
          arrayOfString = str.split(" ");
          if (arrayOfString.length == 4)
            break;
        }
        localL2Player.teleToLocation(Integer.parseInt(arrayOfString[0]), Integer.parseInt(arrayOfString[1]), Integer.parseInt(arrayOfString[2]), Long.parseLong(arrayOfString[3]));
        localL2Player.unsetVar("LastHero_backCoords");
      }
      catch (Exception localException)
      {
        localException.printStackTrace();
      }
    }
  }

  public static void paralyzePlayers()
  {
    L2Skill localL2Skill = C.B().A(4515, 1);
    Iterator localIterator = getPlayers(players_list).iterator();
    while (localIterator.hasNext())
    {
      L2Player localL2Player = (L2Player)localIterator.next();
      localL2Player.getEffectList().stopEffect(1411);
      localL2Skill.getEffects(localL2Player, localL2Player, false, false);
      if (localL2Player.getPet() != null)
        localL2Skill.getEffects(localL2Player, localL2Player.getPet(), false, false);
    }
  }

  public static void upParalyzePlayers()
  {
    Iterator localIterator = getPlayers(players_list).iterator();
    while (localIterator.hasNext())
    {
      L2Player localL2Player = (L2Player)localIterator.next();
      localL2Player.getEffectList().stopEffect(4515);
      if (localL2Player.getPet() != null)
        localL2Player.getPet().getEffectList().stopEffect(4515);
      if (localL2Player.getParty() != null)
        localL2Player.getParty().oustPartyMember(localL2Player);
    }
  }

  public static void ressurectPlayers()
  {
    Iterator localIterator = getPlayers(players_list).iterator();
    while (localIterator.hasNext())
    {
      L2Player localL2Player = (L2Player)localIterator.next();
      if (localL2Player.isDead())
      {
        localL2Player.restoreExp();
        localL2Player.setCurrentCp(localL2Player.getMaxCp());
        localL2Player.setCurrentHp(localL2Player.getMaxHp(), true);
        localL2Player.setCurrentMp(localL2Player.getMaxMp());
        localL2Player.broadcastPacket(new L2GameServerPacket[] { new Revive(localL2Player) });
      }
    }
  }

  public static void healPlayers()
  {
    Iterator localIterator = getPlayers(players_list).iterator();
    while (localIterator.hasNext())
    {
      L2Player localL2Player = (L2Player)localIterator.next();
      localL2Player.setCurrentHpMp(localL2Player.getMaxHp(), localL2Player.getMaxMp());
      localL2Player.setCurrentCp(localL2Player.getMaxCp());
    }
  }

  public static void cleanPlayers()
  {
    Iterator localIterator = getPlayers(players_list).iterator();
    while (localIterator.hasNext())
    {
      L2Player localL2Player = (L2Player)localIterator.next();
      if (!(checkPlayer(localL2Player, false)))
        removePlayer(localL2Player);
    }
  }

  public static void checkLive()
  {
    Object localObject;
    GCSArray localGCSArray = new GCSArray();
    Iterator localIterator = live_list.iterator();
    while (localIterator.hasNext())
    {
      localObject = (Long)localIterator.next();
      L2Player localL2Player = L2ObjectsStorage.getAsPlayer(((Long)localObject).longValue());
      if (localL2Player != null)
        localGCSArray.add(localObject);
    }
    live_list = localGCSArray;
    localIterator = getPlayers(live_list).iterator();
    while (localIterator.hasNext())
    {
      localObject = (L2Player)localIterator.next();
      if ((((L2Player)localObject).isInZone(_zone)) && (!(((L2Player)localObject).isDead())) && (((L2Player)localObject).isConnected()) && (!(((L2Player)localObject).isLogoutStarted())))
        ((L2Player)localObject).setTeam(2, false);
      else
        loosePlayer((L2Player)localObject);
    }
    if (live_list.size() <= 1)
      endBattle();
  }

  public static void removeAura()
  {
    Iterator localIterator = getPlayers(live_list).iterator();
    while (localIterator.hasNext())
    {
      L2Player localL2Player = (L2Player)localIterator.next();
      localL2Player.setTeam(0, false);
    }
  }

  public static void clearArena()
  {
    L2Object[] arrayOfL2Object = _zone.getObjects();
    int i = arrayOfL2Object.length;
    for (int j = 0; j < i; ++j)
    {
      L2Object localL2Object = arrayOfL2Object[j];
      if (localL2Object != null)
      {
        L2Player localL2Player = localL2Object.getPlayer();
        if ((localL2Player != null) && (!(live_list.contains(localL2Player.getStoredId()))))
          localL2Player.teleToLocation(147451, 46728, -3410);
      }
    }
  }

  public static void OnDie(L2Character paramL2Character1, L2Character paramL2Character2)
  {
    if ((_status > 1) && (paramL2Character1 != null) && (paramL2Character1.isPlayer()) && (paramL2Character1.getTeam() > 0) && (live_list.contains(paramL2Character1.getStoredId())))
    {
      L2Player localL2Player = (L2Player)paramL2Character1;
      loosePlayer(localL2Player);
      checkLive();
      if ((paramL2Character2 != null) && (paramL2Character2.isPlayer()))
        if (!(paramL2Character2.getPlayer().getIP().equals(localL2Player.getIP())))
        {
          addItem((L2Player)paramL2Character2, Config.EVENT_LastHeroItemID, Math.round(1F * Config.EVENT_LastHeroItemCOUNT));
          paramL2Character2.sendMessage("Награда за убиство выдана.");
        }
        else
          paramL2Character2.sendMessage("Ваш IP равен IP убитого вами, награда не выдана.");
    }
  }

  public static Location OnEscape(L2Player paramL2Player)
  {
    if ((_status > 1) && (paramL2Player != null) && (paramL2Player.getTeam() > 0) && (live_list.contains(paramL2Player.getStoredId())))
    {
      removePlayer(paramL2Player);
      checkLive();
    }
    return null;
  }

  public static void OnPlayerExit(int paramInt)
  {
    L2Player localL2Player = L2ObjectsStorage.getPlayer(paramInt);
    if ((localL2Player == null) || (localL2Player.getTeam() < 1))
      return;
    if ((_status == 0) && (_isRegistrationActive) && (live_list.contains(localL2Player.getStoredId())))
    {
      removePlayer(localL2Player);
      return;
    }
    if ((_status == 1) && (live_list.contains(localL2Player.getStoredId())))
    {
      removePlayer(localL2Player);
      try
      {
        String str = localL2Player.getVar("LastHero_backCoords");
        if ((str == null) || (str.equals("")))
          return;
        String[] arrayOfString = str.split(" ");
        if (arrayOfString.length != 4)
          return;
        localL2Player.teleToLocation(Integer.parseInt(arrayOfString[0]), Integer.parseInt(arrayOfString[1]), Integer.parseInt(arrayOfString[2]), Integer.parseInt(arrayOfString[3]));
        localL2Player.unsetVar("LastHero_backCoords");
      }
      catch (Exception localException)
      {
        localException.printStackTrace();
      }
      return;
    }
    OnEscape(localL2Player);
  }

  private static void loosePlayer(L2Player paramL2Player)
  {
    if (paramL2Player != null)
    {
      live_list.remove(paramL2Player.getStoredId());
      paramL2Player.setTeam(0, false);
      show(new C("l2r.scripts.events.LastHero.YouLose", paramL2Player, new Object[0]), paramL2Player);
    }
  }

  private static void removePlayer(L2Player paramL2Player)
  {
    if (paramL2Player != null)
    {
      live_list.remove(paramL2Player.getStoredId());
      players_list.remove(paramL2Player.getStoredId());
      paramL2Player.setTeam(0, false);
    }
  }

  private static GArray<L2Player> getPlayers(GCSArray<Long> paramGCSArray)
  {
    GArray localGArray = new GArray();
    Iterator localIterator = paramGCSArray.iterator();
    while (localIterator.hasNext())
    {
      Long localLong = (Long)localIterator.next();
      L2Player localL2Player = L2ObjectsStorage.getAsPlayer(localLong.longValue());
      if (localL2Player != null)
        localGArray.add(localL2Player);
    }
    return localGArray;
  }

  public class TeleportTask
  implements Runnable
  {
    Location loc;
    L2Character target;

    public TeleportTask(, L2Character paramL2Character, Location paramLocation)
    {
      this.target = paramL2Character;
      this.loc = paramLocation;
      paramL2Character.startStunning();
    }

    public void run()
    {
      this.target.stopStunning();
      this.target.teleToLocation(this.loc);
    }
  }

  private class ZoneListener extends L2ZoneEnterLeaveListener
  {
    public void objectEntered(, L2Object paramL2Object)
    {
      if (paramL2Object == null)
        return;
      L2Player localL2Player = paramL2Object.getPlayer();
      if ((LastHero.access$300() > 0) && (localL2Player != null) && (!(LastHero.access$400().contains(localL2Player.getStoredId()))))
        ThreadPoolManager.getInstance().scheduleGeneral(new LastHero.TeleportTask(this.this$0, (L2Character)paramL2Object, new Location(147451, 46728, -3410)), 3000);
    }

    public void objectLeaved(, L2Object paramL2Object)
    {
      if (paramL2Object == null)
        return;
      L2Player localL2Player = paramL2Object.getPlayer();
      if ((LastHero.access$300() > 1) && (localL2Player != null) && (localL2Player.getTeam() > 0) && (LastHero.access$400().contains(localL2Player.getStoredId())))
      {
        double d1 = Util.convertHeadingToDegree(paramL2Object.getHeading());
        double d2 = Math.toRadians(d1 - 90.0D);
        int i = (int)(paramL2Object.getX() + 50.0D * Math.sin(d2));
        int j = (int)(paramL2Object.getY() - 50.0D * Math.cos(d2));
        int k = paramL2Object.getZ();
        ThreadPoolManager.getInstance().scheduleGeneral(new LastHero.TeleportTask(this.this$0, (L2Character)paramL2Object, new Location(i, j, k)), 3000);
      }
    }
  }

  public class StartTask
  implements Runnable
  {
    public void run()
    {
      if (!(LastHero.access$000()))
        return;
      if (Functions.isPvPEventStarted())
      {
        LastHero.access$100().info("Ивент Last Hero не стартовал: запущен другой ивент");
        return;
      }
      if (!(Rnd.chance(Config.EVENT_LastHeroChanceToStart)))
      {
        LastHero.access$100().fine("Ивент Last Hero не запущен: chance");
        return;
      }
      if (TerritorySiege.isInProgress())
      {
        LastHero.access$100().fine("Ивент Last Hero не запущен: ведутся Территориальные Войны");
        return;
      }
      Iterator localIterator = L.C().A().values().iterator();
      while (localIterator.hasNext())
      {
        Castle localCastle = (Castle)localIterator.next();
        if ((localCastle.getSiege() != null) && (localCastle.getSiege().isInProgress()))
        {
          LastHero.access$100().fine("Ивент Last Hero не запущен: ведутся Осады Замков");
          return;
        }
      }
      this.this$0.start(new String[] { "1", "1" });
    }
  }
}

Если кто-нибудь может хоть как-то помочь - приму любую помощь.
Также еще одна проблема с олимпом: статус героя игроку (//add_hero) задать можно (ну или даже допустим он выиграл оли), он появляется в списке хиро и может брать хиро оружие и т.д. Но у него не видно (вообще не светится) хиро ауры, при том, что //sethero (одноразовый хиро) дает это свечение