Нельзя бить персонажей на эвенте Last Hero

Статус
В этой теме нельзя размещать новые ответы.

deadly4283

Свой человек
Пользователь
Сообщения
17
Розыгрыши
0
Репутация
0
Реакции
1
Баллы
525
Хроники
  1. Chaotic Throne: High Five
Исходники
Присутствуют
Сборка
EmuRT rev 10
Добрый день форумчане. Может кто-то сталкивался, или есть идея? сборка EmuRT rev. 10, при регистрации на Ласт Хиро все норм, телепортирует, парализует, дает время забафаться, но после снятия паралича и начала собственно драки можно бить только скилами. Автоатакой когда пытаешься бить ничего не выходит. Проверял зоны, проверял много чего, сузил круг подозрений до параметра "TeamType":
При этапе подготовки (во время паралича, когда можно бафаться) если снять с себя паралич админом, автоатакой можно бить. При этапе сражения, когда всем персонажам добавляется синяя аура, бить нельзя. При удалении ауры вовсе, как таковой, бить можно, но эвент не воспринимает нас как участников, убил всех - победу не засчитали просто спустя время "Эвент Last Hero завершен". Подозреваю что это расценивается будто все персонажи в одной команде. Но это только догадки. Если кто посмотрит и выдаст свои предположения, а может и сразу фиксы, буду безумно благодарен. Спасибо!
package events.lastHero;

import java.util.ArrayList;
import java.util.Calendar;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.ScheduledFuture;
import l2p.commons.threading.RunnableImpl;
import l2p.gameserver.Announcements;
import l2p.gameserver.Config;
import l2p.gameserver.ThreadPoolManager;
import l2p.gameserver.data.xml.holder.ResidenceHolder;
import l2p.gameserver.instancemanager.ReflectionManager;
import l2p.gameserver.instancemanager.ServerVariables;
import l2p.gameserver.listener.actor.OnDeathListener;
import l2p.gameserver.listener.actor.player.OnPlayerExitListener;
import l2p.gameserver.listener.actor.player.OnTeleportListener;
import l2p.gameserver.listener.zone.OnZoneEnterLeaveListener;
import l2p.gameserver.model.Creature;
import l2p.gameserver.model.GameObject;
import l2p.gameserver.model.GameObjectsStorage;
import l2p.gameserver.model.Player;
import l2p.gameserver.model.Skill;
import l2p.gameserver.model.Zone;
import l2p.gameserver.model.actor.listener.CharListenerList;
import l2p.gameserver.model.base.TeamType;
import l2p.gameserver.model.entity.Hero;
import l2p.gameserver.model.entity.Reflection;
import l2p.gameserver.model.entity.events.impl.DuelEvent;
import l2p.gameserver.model.entity.olympiad.Olympiad;
import l2p.gameserver.model.entity.residence.Castle;
import l2p.gameserver.model.entity.residence.Residence;
import l2p.gameserver.model.instances.DoorInstance;
import l2p.gameserver.model.items.LockType;
import l2p.gameserver.serverpackets.L2GameServerPacket;
import l2p.gameserver.serverpackets.Revive;
import l2p.gameserver.serverpackets.components.ChatType;
import l2p.gameserver.serverpackets.components.CustomMessage;
import l2p.gameserver.scripts.Functions;
import l2p.gameserver.scripts.ScriptFile;
import l2p.gameserver.serverpackets.SkillList;
import l2p.gameserver.serverpackets.SocialAction;
import l2p.gameserver.tables.SkillTable;
import l2p.gameserver.templates.DoorTemplate;
import l2p.gameserver.templates.ZoneTemplate;
import l2p.gameserver.utils.Location;
import l2p.gameserver.utils.PositionUtils;
import l2p.gameserver.utils.ReflectionUtils;
import org.napile.primitive.maps.IntObjectMap;
import org.napile.primitive.maps.impl.HashIntObjectMap;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class LastHero extends Functions
implements ScriptFile, OnDeathListener, OnTeleportListener, OnPlayerExitListener {

private static final Logger _log = LoggerFactory.getLogger(LastHero.class);
private static final int[] doors = {24190001, 24190002, 24190003, 24190004};
private static ScheduledFuture<?> _startTask;
private static List<Long> players_list = new CopyOnWriteArrayList();
private static List<Long> live_list = new CopyOnWriteArrayList();
private static int[][] mage_buffs;
private static int[][] fighter_buffs;
private static Map<Long, Location> playerRestoreCoord = new LinkedHashMap();
private static Map<Long, String> boxes = new LinkedHashMap();
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 boolean _active = false;
private static Skill buff;
private static ScheduledFuture<?> _endTask;
private static Reflection reflection = ReflectionManager.LAST_HERO;
private static Map<String, ZoneTemplate> _zones = new HashMap();
private static IntObjectMap<DoorTemplate> _doors = new HashIntObjectMap();
private static Zone _zone;
private static ZoneListener _zoneListener = new ZoneListener();
private static final Location _enter = new Location(149505, 46719, -3417);

@Override
public void onLoad() {
CharListenerList.addGlobal(this);

_zones.put("[colosseum_battle]", ReflectionUtils.getZone("[colosseum_battle]").getTemplate());
for (int doorId : doors) {
_doors.put(doorId, ReflectionUtils.getDoor(doorId).getTemplate());
}
reflection.init(_doors, _zones);
_zone = reflection.getZone("[colosseum_battle]");
_zone.addListener(_zoneListener);

_active = ServerVariables.getString("LastHero", "off").equalsIgnoreCase("on");

if (isActive()) {
scheduleEventStart();
}
if ((Config.EVENT_LastHeroBuffPlayers) && (Config.EVENT_LastHeroMageBuffs.length > 0)) {
mage_buffs = new int[Config.EVENT_LastHeroMageBuffs.length][2];
}
if ((Config.EVENT_LastHeroBuffPlayers) && (Config.EVENT_LastHeroFighterBuffs.length > 0)) {
fighter_buffs = new int[Config.EVENT_LastHeroFighterBuffs.length][2];
}
int i = 0;

if ((Config.EVENT_LastHeroBuffPlayers) && (Config.EVENT_LastHeroMageBuffs.length > 0)) {
for (String skill : Config.EVENT_LastHeroMageBuffs) {
String[] splitSkill = skill.split(",");
mage_buffs[0] = Integer.parseInt(splitSkill[0]);
mage_buffs[1] = Integer.parseInt(splitSkill[1]);
i++;
}
}
i = 0;

if ((Config.EVENT_LastHeroBuffPlayers) && (Config.EVENT_LastHeroMageBuffs.length != 0)) {
for (String skill : Config.EVENT_LastHeroFighterBuffs) {
String[] splitSkill = skill.split(",");
fighter_buffs[0] = Integer.parseInt(splitSkill[0]);
fighter_buffs[1] = Integer.parseInt(splitSkill[1]);
i++;
}
}
_log.info("Loaded Event: Last Hero");
}

@Override
public void onReload() {
_zone.removeListener(_zoneListener);
if (_startTask != null) {
_startTask.cancel(false);
_startTask = null;
}
}

@Override
public void onShutdown() {
onReload();
}

private static boolean isActive() {
return _active;
}

public void activateEvent() {
Player player = getSelf();
if (!player.getPlayerAccess().IsEventGm) {
return;
}
if (!isActive()) {
if (_startTask == null) {
scheduleEventStart();
}
ServerVariables.set("LastHero", "on");
_log.info("Event 'Last Hero' activated.");
Announcements.getInstance().announceByCustomMessage("scripts.events.LastHero.AnnounceEventStarted", null);
} else {
player.sendMessage("Event 'Last Hero' already active.");
}
_active = true;

show("admin/events/events.htm", player);
}

public void teleportPlayers() {
for (Player player : getPlayers(players_list)) {
if ((player == null) || (!playerRestoreCoord.containsKey(player.getStoredId()))) {
continue;
}
player.setIsInLastHero(false);
player.teleToLocation((Location) playerRestoreCoord.get(player.getStoredId()), ReflectionManager.DEFAULT);
}
playerRestoreCoord.clear();
}

public void deactivateEvent() {
Player player = getSelf();
if (!player.getPlayerAccess().IsEventGm) {
return;
}
if (isActive()) {
if (_startTask != null) {
_startTask.cancel(false);
_startTask = null;
}
ServerVariables.unset("LastHero");
_log.info("Event 'Last Hero' deactivated.");
Announcements.getInstance().announceByCustomMessage("scripts.events.LastHero.AnnounceEventStoped", null);
} else {
player.sendMessage("Event 'LastHero' not active.");
}
_active = false;

show("admin/events/events.htm", player);
}

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

public static int getMinLevelForCategory(int category) {
switch (category) {
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 category) {
switch (category) {
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 level) {
if ((level >= 20) && (level <= 29)) {
return 1;
}
if ((level >= 30) && (level <= 39)) {
return 2;
}
if ((level >= 40) && (level <= 51)) {
return 3;
}
if ((level >= 52) && (level <= 61)) {
return 4;
}
if ((level >= 62) && (level <= 75)) {
return 5;
}
if (level >= 76) {
return 6;
}
return 0;
}

public void start(String[] var) {
Player player = getSelf();
if (var.length != 2) {
show(new CustomMessage("common.Error", player, new Object[0]), 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, new Object[0]), player);
return;
}

_category = category.intValue();
_autoContinue = autoContinue.intValue();

if (_category == -1) {
_minLevel = 1;
_maxLevel = 85;
} else {
_minLevel = getMinLevelForCategory(_category);
_maxLevel = getMaxLevelForCategory(_category);
}

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

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

players_list = new CopyOnWriteArrayList();
live_list = new CopyOnWriteArrayList();
playerRestoreCoord = new LinkedHashMap();
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], 10000L);
executeTask("events.lastHero.LastHero", "announce", new Object[0], 60000L);
}

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

public static void question() {
for (Player player : GameObjectsStorage.getAllPlayersForIterate()) {
if ((player != null) && (!player.isDead()) && (player.getLevel() >= _minLevel) && (player.getLevel() <= _maxLevel) && (player.getReflection().isDefault()) && (!player.isInOlympiadMode()) && (!player.isInObserverMode())) {
player.scriptRequest(new CustomMessage("scripts.events.LastHero.AskPlayer", player, new Object[0]).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], 10000L);
return;
}

if (_time_to_start > 1) {
_time_to_start -= 1;
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], 60000L);
} else {
_status = 1;
_isRegistrationActive = false;
sayToAll("scripts.events.LastHero.AnnounceEventStarting", null);
executeTask("events.lastHero.LastHero", "prepare", new Object[0], 5000L);
}
}

public void addPlayer() {
Player player = getSelf();
if ((player == null) || (!checkPlayer(player, true)) || (!checkDualBox(player))) {
return;
}
players_list.add(player.getStoredId());
live_list.add(player.getStoredId());

show(new CustomMessage("scripts.events.LastHero.Registered", player, new Object[0]), player);
}

public static boolean checkPlayer(Player player, boolean first) {
if ((first) && ((!_isRegistrationActive) || (player.isDead()))) {
show(new CustomMessage("scripts.events.Late", player, new Object[0]), player);
return false;
}

if ((first) && (players_list.contains(player.getStoredId()))) {
show(new CustomMessage("scripts.events.LastHero.Cancelled", player, new Object[0]), player);
if (players_list.contains(player.getStoredId())) {
players_list.remove(player.getStoredId());
}
if (live_list.contains(player.getStoredId())) {
live_list.remove(player.getStoredId());
}
if (boxes.containsKey(player.getStoredId())) {
boxes.remove(player.getStoredId());
}
return false;
}

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

if (player.isMounted()) {
show(new CustomMessage("scripts.events.LastHero.Cancelled", player, new Object[0]), player);
return false;
}

if (player.isCursedWeaponEquipped()) {
show(new CustomMessage("scripts.events.CaptureTheFlag.Cancelled", player, new Object[0]), player);
return false;
}

if (player.isInDuel()) {
show(new CustomMessage("scripts.events.LastHero.CancelledDuel", player, new Object[0]), player);
return false;
}

if ((player.getTeam() != TeamType.NONE) || (player.isInPvPEvent())) {
show(new CustomMessage("scripts.events.CaptureTheFlag.CancelledOtherEvent", player, new Object[0]), player);
return false;
}

if ((player.getOlympiadGame() != null) || ((first) && (Olympiad.isRegistered(player)))) {
show(new CustomMessage("scripts.events.LastHero.CancelledOlympiad", player, new Object[0]), player);
return false;
}

if ((player.isInParty()) && (player.getParty().isInDimensionalRift())) {
show(new CustomMessage("scripts.events.LastHero.CancelledOtherEvent", player, new Object[0]), player);
return false;
}

if (player.isTeleporting()) {
show(new CustomMessage("scripts.events.LastHero.CancelledTeleport", player, new Object[0]), player);
return false;
}

if (player.isInObserverMode()) {
show(new CustomMessage("scripts.event.DeathMatch.CancelledObserver", player, new Object[0]), player);
return false;
}

return true;
}

public static void prepare() {
for (DoorInstance door : reflection.getDoors()) {
door.closeMe();
}
for (Zone z : reflection.getZones()) {
z.setType(Zone.ZoneType.peace_zone);
}
cleanPlayers();
clearArena();

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

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

public static void go() {
_status = 2;
blockItems();
upParalyzePlayers();
checkLive();
clearArena();
sayToAll("scripts.events.LastHero.AnnounceFight", null);
for (Zone z : reflection.getZones()) {
z.setType(Zone.ZoneType.battle_zone);
}
_endTask = executeTask("events.lastHero.LastHero", "endBattle", new Object[0], 300000L);
}

public static void endBattle() {
_status = 0;
removeAura();

for (DoorInstance door : reflection.getDoors()) {
door.openMe();
}

for (Zone z : reflection.getZones()) {
z.setType(Zone.ZoneType.peace_zone);
}
boxes.clear();
if (live_list.size() == 1) {
Iterator i$ = getPlayers(live_list).iterator();
if (i$.hasNext()) {
Player player = (Player) i$.next();

String[] repl = {player.getName()};
sayToAll("scripts.events.LastHero.AnnounceWiner", repl);
addItem(player, Config.EVENT_LastHeroItemID, Math.round(Config.EVENT_LastHeroRateFinal ? player.getLevel() * Config.EVENT_LastHeroItemCOUNTFinal : 1.0D * Config.EVENT_LastHeroItemCOUNTFinal));


player.setHero(true);
Hero.addSkills(player);
player.updatePledgeClass();
player.sendPacket(new SkillList(player));
player.broadcastUserInfo(true);
player.setVar("HeroPeriod", String.valueOf(System.currentTimeMillis() + 60 * 1000 * 60 * 24 * 1), -1);
ThreadPoolManager.getInstance().schedule(new EndHero(player), System.currentTimeMillis() + (60 * 1000 * 60 * 24 * 1));
player.broadcastPacket(new SocialAction(player.getObjectId(), 16));



if (Config.EVENT_LAST_HERO_AURA_ENABLE) {
player.setHeroAura(true);
player.broadcastCharInfo();
}
}
}
sayToAll("scripts.events.LastHero.AnnounceEnd", null);
executeTask("events.lastHero.LastHero", "end", new Object[0], 30000L);
_isRegistrationActive = false;
if (_endTask != null) {
_endTask.cancel(false);
_endTask = null;
}
}

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

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

public static void teleportPlayersToColiseum() {
for (Player player : getPlayers(players_list)) {
unRide(player);
if (!Config.EVENT_LastHeroAllowSummons) {
unSummonPet(player, true);
}
DuelEvent duel = (DuelEvent) player.getEvent(DuelEvent.class);
if (duel != null) {
duel.abortDuel(player);
}
playerRestoreCoord.put(player.getStoredId(), new Location(player.getX(), player.getY(), player.getZ()));
player.teleToLocation(Location.findPointToStay(_enter, 150, 500, ReflectionManager.DEFAULT.getGeoIndex()), reflection);
player.setIsInLastHero(true);
}
}

public static void paralyzePlayers() {
for (Player player : getPlayers(players_list)) {
if (player == null) {
continue;
}
player.getEffectList().stopEffect(Skill.SKILL_MYSTIC_IMMUNITY);
if (!player.isParalyzed()) {
player.startParalyzed();
if (player.getPet() != null) {
player.getPet().startParalyzed();
}
}
}
}

public static void upParalyzePlayers() {
for (Player player : getPlayers(players_list)) {
if (player == null) {
continue;
}
if (player.isParalyzed()) {
player.stopParalyzed();
if (player.getPet() != null) {
player.getPet().stopParalyzed();
}
}
}
}

public static void blockItems() {
for (Player player : getPlayers(players_list)) {
if (player == null) {
continue;
}
player.getInventory().lockItems(LockType.INCLUDE, Config.EVENT_LastHeroEventBlockItems);
}
}

public static void unlockItems() {
for (Player player : getPlayers(players_list)) {
if (player == null) {
continue;
}
player.getInventory().unlock();
}
}

public static void ressurectPlayers() {
for (Player player : getPlayers(players_list)) {
if (player.isDead()) {
player.restoreExp();
player.setCurrentCp(player.getMaxCp());
player.setCurrentHp(player.getMaxHp(), true);
player.setCurrentMp(player.getMaxMp());
player.broadcastPacket(new L2GameServerPacket[]{new Revive(player)});
}
}
}

public static void healPlayers() {
for (Player player : getPlayers(players_list)) {
player.setCurrentHpMp(player.getMaxHp(), player.getMaxMp());
player.setCurrentCp(player.getMaxCp());
}
}

public static void cleanPlayers() {
for (Player player : getPlayers(players_list)) {
if (!checkPlayer(player, false)) {
removePlayer(player);
}
}
}

public static void checkLive() {
List new_live_list = new CopyOnWriteArrayList();

for (Long storeId : live_list) {
Player player = GameObjectsStorage.getAsPlayer(storeId.longValue());
if (player != null) {
new_live_list.add(storeId);
}
}
live_list = new_live_list;

for (Player player : getPlayers(live_list)) {
if ((player.isInZone(_zone)) && (!player.isDead()) && (!player.isLogoutStarted())) {
player.setTeam(TeamType.BLUE);
} else {
loosePlayer(player);
}
}
if (live_list.size() <= 1) {
endBattle();
}
}

public static void removeAura() {
for (Player player : getPlayers(live_list)) {
player.setTeam(TeamType.NONE);
player.setIsInLastHero(false);
}
}

public static void clearArena() {
for (GameObject obj : _zone.getObjects()) {
if (obj == null) {
continue;
}
Player player = obj.getPlayer();
if ((player != null) && (!live_list.contains(player.getStoredId()))) {
player.teleToLocation(147451, 46728, -3410, ReflectionManager.DEFAULT);
}
}
}

@Override
public void onDeath(Creature self, Creature killer) {
if ((_status > 1) && (self.isPlayer()) && (self.getTeam() != TeamType.NONE) && (live_list.contains(self.getStoredId()))) {
Player player = (Player) self;
loosePlayer(player);
checkLive();
if ((killer != null) && (killer.isPlayer()) && (killer.getPlayer().getExpertiseIndex() - player.getExpertiseIndex() > 2)) {
addItem((Player) killer, Config.EVENT_LastHeroItemID, Math.round(Config.EVENT_LastHeroRate ? player.getLevel() * Config.EVENT_LastHeroItemCOUNT : 1.0D * Config.EVENT_LastHeroItemCOUNT));
}
// self.getPlayer().setIsInLastHero(false);
}
}

@Override
public void onTeleport(Player player, int x, int y, int z, Reflection reflection) {
if (_zone.checkIfInZone(x, y, z, reflection)) {
return;
}
if ((_status > 1) && (player.getTeam() != TeamType.NONE) && (live_list.contains(player.getStoredId()))) {
removePlayer(player);
checkLive();
}
}

@Override
public void onPlayerExit(Player player) {
if (player.getTeam() == TeamType.NONE) {
return;
}

if ((_status == 0) && (_isRegistrationActive) && (live_list.contains(player.getStoredId()))) {
removePlayer(player);
return;
}

if ((_status == 1) && (live_list.contains(player.getStoredId()))) {
player.teleToLocation((Location) playerRestoreCoord.get(player.getStoredId()), ReflectionManager.DEFAULT);
removePlayer(player);

return;
}

if ((_status > 1) && (player.getTeam() != TeamType.NONE) && (live_list.contains(player.getStoredId()))) {
removePlayer(player);
checkLive();
}
}

private static void loosePlayer(Player player) {
if (player != null) {
live_list.remove(player.getStoredId());
player.setTeam(TeamType.NONE);
show(new CustomMessage("scripts.events.LastHero.YouLose", player, new Object[0]), player);
}
}

private static void removePlayer(Player player) {
if (player != null) {
live_list.remove(player.getStoredId());
players_list.remove(player.getStoredId());
playerRestoreCoord.remove(player.getStoredId());
player.setIsInLastHero(false);

if (!Config.EVENT_LastHeroAllowMultiReg) {
boxes.remove(player.getStoredId());
}
player.setTeam(TeamType.NONE);
player.getInventory().unlock();
}
}

private static List<Player> getPlayers(List<Long> list) {
List result = new ArrayList(list.size());
for (Long storeId : list) {
Player player = GameObjectsStorage.getAsPlayer(storeId.longValue());
if (player != null) {
result.add(player);
}
}
return result;
}

public static void buffPlayers() {
for (Player player : getPlayers(players_list)) {
if (!Config.EVENT_LastHeroAllowBuffs) {
player.getEffectList().stopAllEffects();
if (player.getPet() != null) {
player.getPet().getEffectList().stopAllEffects();
}
}
}

if (!Config.EVENT_LastHeroBuffPlayers) {
return;
}

for (Player player : getPlayers(players_list)) {
if (player.isMageClass()) {
mageBuff(player);
} else {
fighterBuff(player);
}
}
for (Player player : getPlayers(live_list)) {
if (player.isMageClass()) {
mageBuff(player);
} else {
fighterBuff(player);
}
}
}

public void scheduleEventStart() {
try {
Calendar currentTime = Calendar.getInstance();
Calendar nextStartTime = null;
Calendar testStartTime = null;

for (String timeOfDay : Config.EVENT_LastHeroStartTime) {
testStartTime = Calendar.getInstance();
testStartTime.setLenient(true);

String[] splitTimeOfDay = timeOfDay.split(":");

testStartTime.set(11, Integer.parseInt(splitTimeOfDay[0]));
testStartTime.set(12, Integer.parseInt(splitTimeOfDay[1]));

if (testStartTime.getTimeInMillis() < currentTime.getTimeInMillis()) {
testStartTime.add(5, 1);
}
if ((nextStartTime == null) || (testStartTime.getTimeInMillis() < nextStartTime.getTimeInMillis())) {
nextStartTime = testStartTime;
}
if (_startTask != null) {
_startTask.cancel(false);
_startTask = null;
}
_startTask = ThreadPoolManager.getInstance().schedule(new StartTask(), nextStartTime.getTimeInMillis() - System.currentTimeMillis());
}

currentTime = null;
nextStartTime = null;
testStartTime = null;
} catch (Exception e) {
_log.warn("LH: Error figuring out a start time. Check TvTEventInterval in config file.");
}
}

public static void mageBuff(Player player) {
for (int i = 0; i < mage_buffs.length; i++) {
buff = SkillTable.getInstance().getInfo(mage_buffs[0], mage_buffs[1]);

buff.getEffects(player, player, false, false);
}
}

public static void fighterBuff(Player player) {
for (int i = 0; i < fighter_buffs.length; i++) {
buff = SkillTable.getInstance().getInfo(fighter_buffs[0], fighter_buffs[1]);

buff.getEffects(player, player, false, false);
}
}

private static boolean checkDualBox(Player player) {
if (!Config.EVENT_LastHeroAllowMultiReg) {
if ("IP".equalsIgnoreCase(Config.EVENT_LastHeroCheckWindowMethod)) {
if (boxes.containsValue(player.getIP())) {
show(new CustomMessage("scripts.events.LH.CancelledBox", player, new Object[0]), player);
return false;
}

} else if (("HWid".equalsIgnoreCase(Config.EVENT_LastHeroCheckWindowMethod))
&& (boxes.containsValue(player.getNetConnection().getHWID()))) {
show(new CustomMessage("scripts.events.DeathMatch.CancelledBox", player, new Object[0]), player);
return false;
}
}
return true;
}

public class StartTask extends RunnableImpl {

public StartTask() {
}

@Override
public void runImpl() {
if (!LastHero._active) {
return;
}
if (Functions.isPvPEventStarted()) {
_log.info("LH not started: another event is already running");
return;
}

for (Residence c : ResidenceHolder.getInstance().getResidenceList(Castle.class)) {
if ((c.getSiegeEvent() != null) && (c.getSiegeEvent().isInProgress())) {
_log.debug("LH not started: CastleSiege in progress");
return;
}

}

if (Config.EVENT_LastHeroCategories) {
LastHero.this.start(new String[]{"1", "1"});
} else {
LastHero.this.start(new String[]{"-1", "-1"});
}
}
}

private static class ZoneListener
implements OnZoneEnterLeaveListener {

@Override
public void onZoneEnter(Zone zone, Creature cha) {
if (cha == null) {
return;
}
Player player = cha.getPlayer();
if ((LastHero._status > 0) && (player != null) && (!LastHero.live_list.contains(player.getStoredId()))) {
player.teleToLocation(147451, 46728, -3410, ReflectionManager.DEFAULT);
}
}

@Override
public void onZoneLeave(Zone zone, Creature cha) {
if (cha == null) {
return;
}
Player player = cha.getPlayer();
if ((LastHero._status > 1) && (player != null) && (player.getTeam() != TeamType.NONE) && (LastHero.live_list.contains(player.getStoredId()))) {
double angle = PositionUtils.convertHeadingToDegree(cha.getHeading());
double radian = Math.toRadians(angle - 90.0D);
int x = (int) (cha.getX() + 250.0D * Math.sin(radian));
int y = (int) (cha.getY() - 250.0D * Math.cos(radian));
int z = cha.getZ();
player.teleToLocation(x, y, z, LastHero.reflection);
}
}
}

private static class EndHero implements Runnable {
private Player player;

public EndHero(Player player) {
this.player = player;
}

@Override
public void run() {
player.setHero(false);
Hero.removeSkills(player);
player.unsetVar("HeroPeriod");
player.updatePledgeClass();
player.sendPacket(new SkillList(player));
player.broadcastUserInfo(true);
}
}
}

 
Во многих сборках есть проверки в isAttackable/isCtrlAttackable (названия методов зависят от сборки) в кторых проверяется что если у игрока задан TeamType, то он не может бить цели с таким же TeamType.

У меня к примеру такое есть, но доработанное для правильной работы:
Java:
            if (player.getPvPEventMode() > 0 || pcAttacker.getPvPEventMode() > 0)
            {
                if (player.getPvPEventMode() != pcAttacker.getPvPEventMode())
                    return false;

                if (player.getPvPEventMode() == 2 && player.getTeam() == pcAttacker.getTeam())
                    return false;
            }
где getPvPEventMode() возвращает режим проводящегося pvp-эвента, в ктором игрок зарегался и участвует
Java:
    /**
     * Возвращает режим участия в PvP-эвенте
     *
     * @return
     * 0 - нет участия<br>
     * 1 - участие в эвенте без разделения на отряды<br>
     * 2 - участие в эвенте с разделением на отряды
     */
    @Override
    public int getPvPEventMode()
    {
        return _pvpEventMode;
    }
так что или выпиливать тебе эти проверки или дорабатывать
в первом варианте может еще на что-то повлиять, возможно.
 
Большое спасибо, нашел, поправил заработало! Тему можно закрыть
 
Статус
В этой теме нельзя размещать новые ответы.
Назад
Сверху Снизу