lineage2/l2j_mobius
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Handy's Block Checker Event adjustments and removals.

Browse Source
This commit is contained in:
MobiusDevelopment
2022-12-28 09:41:04 +00:00
parent b3374a719a
commit 158e063fd3
309 changed files with 173 additions and 27147 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
L2J_Mobius_Classic_1.0/java/org/l2jmobius/Config.java
View File

@ -603,9 +603,6 @@ public class Config
public static boolean CUSTOM_MULTISELL_LOAD;
public static boolean CUSTOM_BUYLIST_LOAD;
public static int BOOKMARK_CONSUME_ITEM_ID;
public static boolean ENABLE_BLOCK_CHECKER_EVENT;
public static int MIN_BLOCK_CHECKER_TEAM_MEMBERS;
public static boolean HBCE_FAIR_PLAY;
public static int PLAYER_MOVEMENT_BLOCK_TIME;
public static int ABILITY_MAX_POINTS;
public static long ABILITY_POINTS_RESET_ADENA;
@ -2039,17 +2036,6 @@ public class Config
CUSTOM_MULTISELL_LOAD = generalConfig.getBoolean("CustomMultisellLoad", false);
CUSTOM_BUYLIST_LOAD = generalConfig.getBoolean("CustomBuyListLoad", false);
BOOKMARK_CONSUME_ITEM_ID = generalConfig.getInt("BookmarkConsumeItemId", -1);
ENABLE_BLOCK_CHECKER_EVENT = generalConfig.getBoolean("EnableBlockCheckerEvent", false);
MIN_BLOCK_CHECKER_TEAM_MEMBERS = generalConfig.getInt("BlockCheckerMinTeamMembers", 2);
if (MIN_BLOCK_CHECKER_TEAM_MEMBERS < 1)
{
MIN_BLOCK_CHECKER_TEAM_MEMBERS = 1;
}
else if (MIN_BLOCK_CHECKER_TEAM_MEMBERS > 6)
{
MIN_BLOCK_CHECKER_TEAM_MEMBERS = 6;
}
HBCE_FAIR_PLAY = generalConfig.getBoolean("HBCEFairPlay", false);
BOTREPORT_ENABLE = generalConfig.getBoolean("EnableBotReportButton", false);
BOTREPORT_RESETPOINT_HOUR = generalConfig.getString("BotReportPointsResetHour", "00:00").split(":");
BOTREPORT_REPORT_DELAY = generalConfig.getInt("BotReportDelay", 30) * 60000;

1
L2J_Mobius_Classic_1.0/java/org/l2jmobius/gameserver/enums/InstanceType.java
View File

@ -42,7 +42,6 @@ public enum InstanceType
Attackable(Npc),
Guard(Attackable),
Monster(Attackable),
Block(Attackable),
Chest(Monster),
ControllableMob(Monster),
FeedableBeast(Monster),

375
L2J_Mobius_Classic_1.0/java/org/l2jmobius/gameserver/instancemanager/HandysBlockCheckerManager.java
View File

@ -1,375 +0,0 @@
/*
* This file is part of the L2J Mobius project.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.l2jmobius.gameserver.instancemanager;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import org.l2jmobius.Config;
import org.l2jmobius.commons.threads.ThreadPool;
import org.l2jmobius.gameserver.enums.Team;
import org.l2jmobius.gameserver.instancemanager.tasks.PenaltyRemoveTask;
import org.l2jmobius.gameserver.model.ArenaParticipantsHolder;
import org.l2jmobius.gameserver.model.actor.Player;
import org.l2jmobius.gameserver.model.itemcontainer.PlayerInventory;
import org.l2jmobius.gameserver.model.olympiad.OlympiadManager;
import org.l2jmobius.gameserver.model.zone.ZoneId;
import org.l2jmobius.gameserver.network.SystemMessageId;
import org.l2jmobius.gameserver.network.serverpackets.ExCubeGameAddPlayer;
import org.l2jmobius.gameserver.network.serverpackets.ExCubeGameChangeTeam;
import org.l2jmobius.gameserver.network.serverpackets.ExCubeGameRemovePlayer;
import org.l2jmobius.gameserver.network.serverpackets.SystemMessage;
/**
* This class manage the player add/remove, team change and event arena status,<br>
* as the clearance of the participants list or liberate the arena.
* @author BiggBoss
*/
public class HandysBlockCheckerManager
{
// All the participants and their team classified by arena
private static final ArenaParticipantsHolder[] _arenaPlayers = new ArenaParticipantsHolder[4];
// Arena votes to start the game
private static final Map<Integer, Integer> _arenaVotes = new HashMap<>();
// Arena Status, True = is being used, otherwise, False
private static final Map<Integer, Boolean> _arenaStatus = new HashMap<>();
// Registration request penalty (10 seconds)
protected static Set<Integer> _registrationPenalty = Collections.synchronizedSet(new HashSet<>());
/**
* Return the number of event-start votes for the specified arena id
* @param arenaId
* @return int (number of votes)
*/
public synchronized int getArenaVotes(int arenaId)
{
return _arenaVotes.get(arenaId);
}
/**
* Add a new vote to start the event for the specified arena id
* @param arena
*/
public synchronized void increaseArenaVotes(int arena)
{
final int newVotes = _arenaVotes.get(arena) + 1;
final ArenaParticipantsHolder holder = _arenaPlayers[arena];
if ((newVotes > (holder.getAllPlayers().size() / 2)) && !holder.getEvent().isStarted())
{
clearArenaVotes(arena);
if ((holder.getBlueTeamSize() == 0) || (holder.getRedTeamSize() == 0))
{
return;
}
if (Config.HBCE_FAIR_PLAY)
{
holder.checkAndShuffle();
}
ThreadPool.execute(holder.getEvent().new StartEvent());
}
else
{
_arenaVotes.put(arena, newVotes);
}
}
/**
* Will clear the votes queue (of event start) for the specified arena id
* @param arena
*/
public synchronized void clearArenaVotes(int arena)
{
_arenaVotes.put(arena, 0);
}
protected HandysBlockCheckerManager()
{
// Initialize arena status
_arenaStatus.put(0, false);
_arenaStatus.put(1, false);
_arenaStatus.put(2, false);
_arenaStatus.put(3, false);
// Initialize arena votes
_arenaVotes.put(0, 0);
_arenaVotes.put(1, 0);
_arenaVotes.put(2, 0);
_arenaVotes.put(3, 0);
}
/**
* Returns the players holder
* @param arena
* @return ArenaParticipantsHolder
*/
public ArenaParticipantsHolder getHolder(int arena)
{
return _arenaPlayers[arena];
}
/**
* Initializes the participants holder
*/
public void startUpParticipantsQueue()
{
for (int i = 0; i < 4; ++i)
{
_arenaPlayers[i] = new ArenaParticipantsHolder(i);
}
}
/**
* Add the player to the specified arena (through the specified arena manager) and send the needed server -> client packets
* @param player
* @param arenaId
* @return
*/
public boolean addPlayerToArena(Player player, int arenaId)
{
final ArenaParticipantsHolder holder = _arenaPlayers[arenaId];
synchronized (holder)
{
boolean isRed;
for (int i = 0; i < 4; i++)
{
if (_arenaPlayers[i].getAllPlayers().contains(player))
{
final SystemMessage msg = new SystemMessage(SystemMessageId.C1_IS_ALREADY_REGISTERED_ON_THE_MATCH_WAITING_LIST);
msg.addString(player.getName());
player.sendPacket(msg);
return false;
}
}
if (player.isCursedWeaponEquipped())
{
player.sendPacket(SystemMessageId.YOU_CANNOT_REGISTER_WHILE_IN_POSSESSION_OF_A_CURSED_WEAPON);
return false;
}
if (player.isRegisteredOnEvent() || player.isInOlympiadMode())
{
player.sendMessage("Couldnt register you due other event participation.");
return false;
}
if (OlympiadManager.getInstance().isRegistered(player))
{
OlympiadManager.getInstance().unRegisterNoble(player);
player.sendPacket(SystemMessageId.APPLICANTS_FOR_THE_OLYMPIAD_UNDERGROUND_COLISEUM_OR_KRATEI_S_CUBE_MATCHES_CANNOT_REGISTER);
}
// if(UnderGroundColiseum.getInstance().isRegisteredPlayer(player))
// {
// UngerGroundColiseum.getInstance().removeParticipant(player);
// player.sendPacket(SystemMessageId.APPLICANTS_FOR_THE_OLYMPIAD_UNDERGROUND_COLISEUM_OR_KRATEI_S_CUBE_MATCHES_CANNOT_REGISTER));
// }
// if(KrateiCubeManager.getInstance().isRegisteredPlayer(player))
// {
// KrateiCubeManager.getInstance().removeParticipant(player);
// player.sendPacket(SystemMessageId.APPLICANTS_FOR_THE_OLYMPIAD_UNDERGROUND_COLISEUM_OR_KRATEI_S_CUBE_MATCHES_CANNOT_REGISTER));
// }
if (_registrationPenalty.contains(player.getObjectId()))
{
player.sendPacket(SystemMessageId.YOU_MUST_WAIT_10_SECONDS_BEFORE_ATTEMPTING_TO_REGISTER_AGAIN);
return false;
}
if (holder.getBlueTeamSize() < holder.getRedTeamSize())
{
holder.addPlayer(player, 1);
isRed = false;
}
else
{
holder.addPlayer(player, 0);
isRed = true;
}
holder.broadCastPacketToTeam(new ExCubeGameAddPlayer(player, isRed));
return true;
}
}
/**
* Will remove the specified player from the specified team and arena and will send the needed packet to all his team mates / enemy team mates
* @param player
* @param arenaId
* @param team
*/
public void removePlayer(Player player, int arenaId, int team)
{
final ArenaParticipantsHolder holder = _arenaPlayers[arenaId];
synchronized (holder)
{
final boolean isRed = team == 0;
holder.removePlayer(player, team);
holder.broadCastPacketToTeam(new ExCubeGameRemovePlayer(player, isRed));
// End event if theres an empty team
final int teamSize = isRed ? holder.getRedTeamSize() : holder.getBlueTeamSize();
if (teamSize == 0)
{
holder.getEvent().endEventAbnormally();
}
_registrationPenalty.add(player.getObjectId());
schedulePenaltyRemoval(player.getObjectId());
}
}
/**
* Will change the player from one team to other (if possible) and will send the needed packets
* @param player
* @param arena
*/
public void changePlayerToTeam(Player player, int arena)
{
final ArenaParticipantsHolder holder = _arenaPlayers[arena];
synchronized (holder)
{
final boolean isFromRed = holder.getRedPlayers().contains(player);
if (isFromRed && (holder.getBlueTeamSize() == 6))
{
player.sendMessage("The team is full");
return;
}
else if (!isFromRed && (holder.getRedTeamSize() == 6))
{
player.sendMessage("The team is full");
return;
}
final int futureTeam = isFromRed ? 1 : 0;
holder.addPlayer(player, futureTeam);
if (isFromRed)
{
holder.removePlayer(player, 0);
}
else
{
holder.removePlayer(player, 1);
}
holder.broadCastPacketToTeam(new ExCubeGameChangeTeam(player, isFromRed));
}
}
/**
* Will erase all participants from the specified holder
* @param arenaId
*/
public synchronized void clearPaticipantQueueByArenaId(int arenaId)
{
_arenaPlayers[arenaId].clearPlayers();
}
/**
* Returns true if arena is holding an event at this momment
* @param arenaId
* @return boolean
*/
public boolean arenaIsBeingUsed(int arenaId)
{
if ((arenaId < 0) || (arenaId > 3))
{
return false;
}
return _arenaStatus.get(arenaId);
}
/**
* Set the specified arena as being used
* @param arenaId
*/
public void setArenaBeingUsed(int arenaId)
{
_arenaStatus.put(arenaId, true);
}
/**
* Set as free the specified arena for future events
* @param arenaId
*/
public void setArenaFree(int arenaId)
{
_arenaStatus.put(arenaId, false);
}
/**
* Called when played logs out while participating in Block Checker Event
* @param player
*/
public void onDisconnect(Player player)
{
final int arena = player.getBlockCheckerArena();
final int team = getHolder(arena).getPlayerTeam(player);
getInstance().removePlayer(player, arena, team);
if (player.getTeam() != Team.NONE)
{
player.stopAllEffects();
// Remove team aura
player.setTeam(Team.NONE);
// Remove the event items
final PlayerInventory inv = player.getInventory();
if (inv.getItemByItemId(13787) != null)
{
final long count = inv.getInventoryItemCount(13787, 0);
inv.destroyItemByItemId("Handys Block Checker", 13787, count, player, player);
}
if (inv.getItemByItemId(13788) != null)
{
final long count = inv.getInventoryItemCount(13788, 0);
inv.destroyItemByItemId("Handys Block Checker", 13788, count, player, player);
}
player.setInsideZone(ZoneId.PVP, false);
// Teleport Back
player.teleToLocation(-57478, -60367, -2370);
}
}
public void removePenalty(int objectId)
{
_registrationPenalty.remove(objectId);
}
private void schedulePenaltyRemoval(int objId)
{
ThreadPool.schedule(new PenaltyRemoveTask(objId), 10000);
}
/**
* Gets the single instance of {@code HandysBlockCheckerManager}.
* @return single instance of {@code HandysBlockCheckerManager}
*/
public static HandysBlockCheckerManager getInstance()
{
return SingletonHolder.INSTANCE;
}
private static class SingletonHolder
{
protected static final HandysBlockCheckerManager INSTANCE = new HandysBlockCheckerManager();
}
}

762
L2J_Mobius_Classic_1.0/java/org/l2jmobius/gameserver/instancemanager/games/BlockChecker.java
View File

@ -1,762 +0,0 @@
/*
* This file is part of the L2J Mobius project.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.l2jmobius.gameserver.instancemanager.games;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ScheduledFuture;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.l2jmobius.commons.threads.ThreadPool;
import org.l2jmobius.commons.util.Rnd;
import org.l2jmobius.gameserver.data.SpawnTable;
import org.l2jmobius.gameserver.data.xml.NpcData;
import org.l2jmobius.gameserver.data.xml.SkillData;
import org.l2jmobius.gameserver.enums.Team;
import org.l2jmobius.gameserver.instancemanager.HandysBlockCheckerManager;
import org.l2jmobius.gameserver.model.ArenaParticipantsHolder;
import org.l2jmobius.gameserver.model.Spawn;
import org.l2jmobius.gameserver.model.actor.Player;
import org.l2jmobius.gameserver.model.actor.Summon;
import org.l2jmobius.gameserver.model.actor.instance.Block;
import org.l2jmobius.gameserver.model.actor.templates.NpcTemplate;
import org.l2jmobius.gameserver.model.item.instance.Item;
import org.l2jmobius.gameserver.model.itemcontainer.PlayerInventory;
import org.l2jmobius.gameserver.model.skill.Skill;
import org.l2jmobius.gameserver.model.zone.ZoneId;
import org.l2jmobius.gameserver.network.SystemMessageId;
import org.l2jmobius.gameserver.network.serverpackets.ActionFailed;
import org.l2jmobius.gameserver.network.serverpackets.ExBasicActionList;
import org.l2jmobius.gameserver.network.serverpackets.ExCubeGameChangePoints;
import org.l2jmobius.gameserver.network.serverpackets.ExCubeGameCloseUI;
import org.l2jmobius.gameserver.network.serverpackets.ExCubeGameEnd;
import org.l2jmobius.gameserver.network.serverpackets.ExCubeGameExtendedChangePoints;
import org.l2jmobius.gameserver.network.serverpackets.RelationChanged;
import org.l2jmobius.gameserver.network.serverpackets.SystemMessage;
/**
* @author BiggBoss
*/
public class BlockChecker
{
protected static final Logger LOGGER = Logger.getLogger(BlockChecker.class.getName());
// The object which holds all basic members info
protected ArenaParticipantsHolder _holder;
// Maps to hold player of each team and his points
protected Map<Player, Integer> _redTeamPoints = new ConcurrentHashMap<>();
protected Map<Player, Integer> _blueTeamPoints = new ConcurrentHashMap<>();
// The initial points of the event
protected int _redPoints = 15;
protected int _bluePoints = 15;
// Current used arena
protected int _arena = -1;
// All blocks
protected Set<Spawn> _spawns = ConcurrentHashMap.newKeySet();
// Sets if the red team won the event at the end of this (used for packets)
protected boolean _isRedWinner;
// Time when the event starts. Used on packet sending
protected long _startedTime;
// The needed arena coordinates
// Arena X: team1X, team1Y, team2X, team2Y, ArenaCenterX, ArenaCenterY
protected static final int[][] _arenaCoordinates =
{
// Arena 0 - Team 1 XY, Team 2 XY - CENTER XY
{
-58368,
-62745,
-57751,
-62131,
-58053,
-62417
},
// Arena 1 - Team 1 XY, Team 2 XY - CENTER XY
{
-58350,
-63853,
-57756,
-63266,
-58053,
-63551
},
// Arena 2 - Team 1 XY, Team 2 XY - CENTER XY
{
-57194,
-63861,
-56580,
-63249,
-56886,
-63551
},
// Arena 3 - Team 1 XY, Team 2 XY - CENTER XY
{
-57200,
-62727,
-56584,
-62115,
-56850,
-62391
}
};
// Common z coordinate
private static final int Z_COORD = -2405;
// List of dropped items in event (for later deletion)
protected Set<Item> _drops = ConcurrentHashMap.newKeySet();
// Default arena
private static final byte DEFAULT_ARENA = -1;
// Event is started
protected boolean _isStarted = false;
// Event end
protected ScheduledFuture<?> _task;
// Preserve from exploit reward by logging out
protected boolean _abnormalEnd = false;
public BlockChecker(ArenaParticipantsHolder holder, int arena)
{
_holder = holder;
if ((arena > -1) && (arena < 4))
{
_arena = arena;
}
for (Player player : holder.getRedPlayers())
{
_redTeamPoints.put(player, 0);
}
for (Player player : holder.getBluePlayers())
{
_blueTeamPoints.put(player, 0);
}
}
/**
* Updates the player holder before the event starts to synchronize all info
* @param holder
*/
public void updatePlayersOnStart(ArenaParticipantsHolder holder)
{
_holder = holder;
}
/**
* Returns the current holder object of this object engine
* @return HandysBlockCheckerManager.ArenaParticipantsHolder
*/
public ArenaParticipantsHolder getHolder()
{
return _holder;
}
/**
* Will return the id of the arena used by this event
* @return false;
*/
public int getArena()
{
return _arena;
}
/**
* Returns the time when the event started
* @return long
*/
public long getStarterTime()
{
return _startedTime;
}
/**
* Returns the current red team points
* @return int
*/
public int getRedPoints()
{
synchronized (this)
{
return _redPoints;
}
}
/**
* Returns the current blue team points
* @return int
*/
public int getBluePoints()
{
synchronized (this)
{
return _bluePoints;
}
}
/**
* Returns the player points
* @param player
* @param isRed
* @return int
*/
public int getPlayerPoints(Player player, boolean isRed)
{
if (!_redTeamPoints.containsKey(player) && !_blueTeamPoints.containsKey(player))
{
return 0;
}
if (isRed)
{
return _redTeamPoints.get(player);
}
return _blueTeamPoints.get(player);
}
/**
* Increases player points for his teams
* @param player
* @param team
*/
public synchronized void increasePlayerPoints(Player player, int team)
{
if (player == null)
{
return;
}
if (team == 0)
{
final int points = _redTeamPoints.get(player) + 1;
_redTeamPoints.put(player, points);
_redPoints++;
_bluePoints--;
}
else
{
final int points = _blueTeamPoints.get(player) + 1;
_blueTeamPoints.put(player, points);
_bluePoints++;
_redPoints--;
}
}
/**
* Will add a new drop into the list of dropped items
* @param item
*/
public void addNewDrop(Item item)
{
if (item != null)
{
_drops.add(item);
}
}
/**
* Will return true if the event is already started
* @return boolean
*/
public boolean isStarted()
{
return _isStarted;
}
/**
* Will send all packets for the event members with the relation info
* @param plr
*/
protected void broadcastRelationChanged(Player plr)
{
for (Player p : _holder.getAllPlayers())
{
p.sendPacket(new RelationChanged(plr, plr.getRelation(p), plr.isAutoAttackable(p)));
}
}
/**
* Called when a there is an empty team. The event will end.
*/
public void endEventAbnormally()
{
try
{
synchronized (this)
{
_isStarted = false;
if (_task != null)
{
_task.cancel(true);
}
_abnormalEnd = true;
ThreadPool.execute(new EndEvent());
}
}
catch (Exception e)
{
LOGGER.log(Level.SEVERE, "Couldnt end Block Checker event at " + _arena, e);
}
}
/**
* This inner class set ups all player and arena parameters to start the event
*/
public class StartEvent implements Runnable
{
// In event used skills
private final Skill _freeze;
private final Skill _transformationRed;
private final Skill _transformationBlue;
// Common and unparametizer packet
private final ExCubeGameCloseUI _closeUserInterface = ExCubeGameCloseUI.STATIC_PACKET;
public StartEvent()
{
// Initialize all used skills
_freeze = SkillData.getInstance().getSkill(6034, 1);
_transformationRed = SkillData.getInstance().getSkill(6035, 1);
_transformationBlue = SkillData.getInstance().getSkill(6036, 1);
}
/**
* Will set up all player parameters and port them to their respective location based on their teams
*/
private void setUpPlayers()
{
// Set current arena as being used
HandysBlockCheckerManager.getInstance().setArenaBeingUsed(_arena);
// Initialize packets avoiding create a new one per player
_redPoints = _spawns.size() / 2;
_bluePoints = _spawns.size() / 2;
final ExCubeGameChangePoints initialPoints = new ExCubeGameChangePoints(300, _bluePoints, _redPoints);
ExCubeGameExtendedChangePoints clientSetUp;
for (Player player : _holder.getAllPlayers())
{
if (player == null)
{
continue;
}
// Send the secret client packet set up
final boolean isRed = _holder.getRedPlayers().contains(player);
clientSetUp = new ExCubeGameExtendedChangePoints(300, _bluePoints, _redPoints, isRed, player, 0);
player.sendPacket(clientSetUp);
player.sendPacket(ActionFailed.STATIC_PACKET);
// Teleport Player - Array access
// Team 0 * 2 = 0; 0 = 0, 0 + 1 = 1.
// Team 1 * 2 = 2; 2 = 2, 2 + 1 = 3
final int tc = _holder.getPlayerTeam(player) * 2;
// Get x and y coordinates
final int x = _arenaCoordinates[_arena][tc];
final int y = _arenaCoordinates[_arena][tc + 1];
player.teleToLocation(x, y, Z_COORD);
// Set the player team
if (isRed)
{
_redTeamPoints.put(player, 0);
player.setTeam(Team.RED);
}
else
{
_blueTeamPoints.put(player, 0);
player.setTeam(Team.BLUE);
}
player.stopAllEffects();
final Summon pet = player.getPet();
if (pet != null)
{
pet.unSummon(player);
}
player.getServitors().values().forEach(s -> s.unSummon(player));
// Give the player start up effects
// Freeze
_freeze.applyEffects(player, player);
// Transformation
if (_holder.getPlayerTeam(player) == 0)
{
_transformationRed.applyEffects(player, player);
}
else
{
_transformationBlue.applyEffects(player, player);
}
// Set the current player arena
player.setBlockCheckerArena((byte) _arena);
player.setInsideZone(ZoneId.PVP, true);
// Send needed packets
player.sendPacket(initialPoints);
player.sendPacket(_closeUserInterface);
// ExBasicActionList
player.sendPacket(ExBasicActionList.STATIC_PACKET);
broadcastRelationChanged(player);
}
}
@Override
public void run()
{
// Wrong arena passed, stop event
if (_arena == -1)
{
LOGGER.severe("Couldnt set up the arena Id for the Block Checker event, cancelling event...");
return;
}
_isStarted = true;
// Spawn the blocks
ThreadPool.execute(new SpawnRound(16, 1));
// Start up player parameters
setUpPlayers();
// Set the started time
_startedTime = System.currentTimeMillis() + 300000;
}
}
/**
* This class spawns the second round of boxes and schedules the event end
*/
private class SpawnRound implements Runnable
{
int _numOfBoxes;
int _round;
SpawnRound(int numberOfBoxes, int round)
{
_numOfBoxes = numberOfBoxes;
_round = round;
}
@Override
public void run()
{
if (!_isStarted)
{
return;
}
switch (_round)
{
case 1: // Schedule second spawn round
{
_task = ThreadPool.schedule(new SpawnRound(20, 2), 60000);
break;
}
case 2: // Schedule third spawn round
{
_task = ThreadPool.schedule(new SpawnRound(14, 3), 60000);
break;
}
case 3: // Schedule Event End Count Down
{
_task = ThreadPool.schedule(new EndEvent(), 180000);
break;
}
}
// random % 2, if == 0 will spawn a red block
// if != 0, will spawn a blue block
byte random = 2;
// common template
final NpcTemplate template = NpcData.getInstance().getTemplate(18672);
// Spawn blocks
try
{
// Creates 50 new blocks
for (int i = 0; i < _numOfBoxes; i++)
{
final Spawn spawn = new Spawn(template);
spawn.setXYZ(_arenaCoordinates[_arena][4] + Rnd.get(-400, 400), _arenaCoordinates[_arena][5] + Rnd.get(-400, 400), Z_COORD);
spawn.setAmount(1);
spawn.setHeading(1);
spawn.setRespawnDelay(1);
SpawnTable.getInstance().addNewSpawn(spawn, false);
spawn.init();
final Block block = (Block) spawn.getLastSpawn();
// switch color
block.setRed((random % 2) == 0);
block.disableCoreAI(true);
_spawns.add(spawn);
random++;
}
}
catch (Exception e)
{
LOGGER.warning(getClass().getSimpleName() + ": " + e.getMessage());
}
// Spawn the block carrying girl
if ((_round == 1) || (_round == 2))
{
try
{
final Spawn girlSpawn = new Spawn(18676);
girlSpawn.setXYZ(_arenaCoordinates[_arena][4] + Rnd.get(-400, 400), _arenaCoordinates[_arena][5] + Rnd.get(-400, 400), Z_COORD);
girlSpawn.setAmount(1);
girlSpawn.setHeading(1);
girlSpawn.setRespawnDelay(1);
SpawnTable.getInstance().addNewSpawn(girlSpawn, false);
girlSpawn.init();
// Schedule his deletion after 9 secs of spawn
ThreadPool.schedule(new CarryingGirlUnspawn(girlSpawn), 9000);
}
catch (Exception e)
{
LOGGER.warning("Couldnt Spawn Block Checker NPCs! Wrong instance type at npc table?");
LOGGER.warning(getClass().getSimpleName() + ": " + e.getMessage());
}
}
_redPoints += _numOfBoxes / 2;
_bluePoints += _numOfBoxes / 2;
final int timeLeft = (int) ((_startedTime - System.currentTimeMillis()) / 1000);
final ExCubeGameChangePoints changePoints = new ExCubeGameChangePoints(timeLeft, getBluePoints(), getRedPoints());
_holder.broadCastPacketToTeam(changePoints);
}
}
private class CarryingGirlUnspawn implements Runnable
{
private final Spawn _spawn;
protected CarryingGirlUnspawn(Spawn spawn)
{
_spawn = spawn;
}
@Override
public void run()
{
if (_spawn == null)
{
LOGGER.warning("HBCE: Block Carrying Girl is null");
return;
}
SpawnTable.getInstance().deleteSpawn(_spawn, false);
_spawn.stopRespawn();
_spawn.getLastSpawn().deleteMe();
}
}
/*
* private class CountDown implements Runnable {
* @Override public void run() { _holder.broadCastPacketToTeam(new SystemMessage(SystemMessageId.BLOCK_CHECKER_ENDS_5)); ThreadPoolManager.schedule(new EndEvent(), 5000); } }
*/
/**
* This class erase all event parameters on player and port them back near Handy. Also, unspawn blocks, runs a garbage collector and set as free the used arena
*/
protected class EndEvent implements Runnable
{
// Garbage collector and arena free setter
private void clearMe()
{
HandysBlockCheckerManager.getInstance().clearPaticipantQueueByArenaId(_arena);
_holder.clearPlayers();
_blueTeamPoints.clear();
_redTeamPoints.clear();
HandysBlockCheckerManager.getInstance().setArenaFree(_arena);
for (Spawn spawn : _spawns)
{
spawn.stopRespawn();
spawn.getLastSpawn().deleteMe();
SpawnTable.getInstance().deleteSpawn(spawn, false);
}
_spawns.clear();
for (Item item : _drops)
{
// npe
if (item == null)
{
continue;
}
// a player has it, it will be deleted later
if (!item.isSpawned() || (item.getOwnerId() != 0))
{
continue;
}
item.decayMe();
}
_drops.clear();
}
/**
* Reward players after event. Tie - No Reward
*/
private void rewardPlayers()
{
if (_redPoints == _bluePoints)
{
return;
}
_isRedWinner = _redPoints > _bluePoints;
if (_isRedWinner)
{
rewardAsWinner(true);
rewardAsLooser(false);
final SystemMessage msg = new SystemMessage(SystemMessageId.THE_C1_TEAM_HAS_WON);
msg.addString("Red Team");
_holder.broadCastPacketToTeam(msg);
}
else if (_bluePoints > _redPoints)
{
rewardAsWinner(false);
rewardAsLooser(true);
final SystemMessage msg = new SystemMessage(SystemMessageId.THE_C1_TEAM_HAS_WON);
msg.addString("Blue Team");
_holder.broadCastPacketToTeam(msg);
}
else
{
rewardAsLooser(true);
rewardAsLooser(false);
}
}
/**
* Reward the specified team as a winner team 1) Higher score - 8 extra 2) Higher score - 5 extra
* @param isRed
*/
private void rewardAsWinner(boolean isRed)
{
final Map<Player, Integer> tempPoints = isRed ? _redTeamPoints : _blueTeamPoints;
// Main give
for (Entry<Player, Integer> points : tempPoints.entrySet())
{
if (points.getKey() == null)
{
continue;
}
if (points.getValue() >= 10)
{
points.getKey().addItem("Block Checker", 13067, 2, points.getKey(), true);
}
else
{
tempPoints.remove(points.getKey());
}
}
int first = 0;
int second = 0;
Player winner1 = null;
Player winner2 = null;
for (Entry<Player, Integer> entry : tempPoints.entrySet())
{
final Player pc = entry.getKey();
final int pcPoints = entry.getValue();
if (pcPoints > first)
{
// Move old data
second = first;
winner2 = winner1;
// Set new data
first = pcPoints;
winner1 = pc;
}
else if (pcPoints > second)
{
second = pcPoints;
winner2 = pc;
}
}
if (winner1 != null)
{
winner1.addItem("Block Checker", 13067, 8, winner1, true);
}
if (winner2 != null)
{
winner2.addItem("Block Checker", 13067, 5, winner2, true);
}
}
/**
* Will reward the looser team with the predefined rewards Player got >= 10 points: 2 coins Player got < 10 points: 0 coins
* @param isRed
*/
private void rewardAsLooser(boolean isRed)
{
for (Entry<Player, Integer> entry : (isRed ? _redTeamPoints : _blueTeamPoints).entrySet())
{
final Player player = entry.getKey();
if ((player != null) && (entry.getValue() >= 10))
{
player.addItem("Block Checker", 13067, 2, player, true);
}
}
}
/**
* Teleport players back, give status back and send final packet
*/
private void setPlayersBack()
{
final ExCubeGameEnd end = new ExCubeGameEnd(_isRedWinner);
for (Player player : _holder.getAllPlayers())
{
if (player == null)
{
continue;
}
player.stopAllEffects();
// Remove team aura
player.setTeam(Team.NONE);
// Set default arena
player.setBlockCheckerArena(DEFAULT_ARENA);
// Remove the event items
final PlayerInventory inv = player.getInventory();
if (inv.getItemByItemId(13787) != null)
{
inv.destroyItemByItemId("Handys Block Checker", 13787, inv.getInventoryItemCount(13787, 0), player, player);
}
if (inv.getItemByItemId(13788) != null)
{
inv.destroyItemByItemId("Handys Block Checker", 13788, inv.getInventoryItemCount(13788, 0), player, player);
}
broadcastRelationChanged(player);
// Teleport Back
player.teleToLocation(-57478, -60367, -2370);
player.setInsideZone(ZoneId.PVP, false);
// Send end packet
player.sendPacket(end);
player.broadcastUserInfo();
}
}
@Override
public void run()
{
if (!_abnormalEnd)
{
rewardPlayers();
}
setPlayersBack();
clearMe();
_isStarted = false;
_abnormalEnd = false;
}
}
}

39
L2J_Mobius_Classic_1.0/java/org/l2jmobius/gameserver/instancemanager/tasks/PenaltyRemoveTask.java
View File

@ -1,39 +0,0 @@
/*
* This file is part of the L2J Mobius project.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.l2jmobius.gameserver.instancemanager.tasks;
import org.l2jmobius.gameserver.instancemanager.HandysBlockCheckerManager;
/**
* Handys Block Checker penalty remove.
* @author xban1x
*/
public class PenaltyRemoveTask implements Runnable
{
private final int _objectId;
public PenaltyRemoveTask(int id)
{
_objectId = id;
}
@Override
public void run()
{
HandysBlockCheckerManager.getInstance().removePenalty(_objectId);
}
}

176
L2J_Mobius_Classic_1.0/java/org/l2jmobius/gameserver/model/ArenaParticipantsHolder.java
View File

@ -1,176 +0,0 @@
/*
* This file is part of the L2J Mobius project.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.l2jmobius.gameserver.model;
import java.util.ArrayList;
import java.util.List;
import org.l2jmobius.gameserver.instancemanager.HandysBlockCheckerManager;
import org.l2jmobius.gameserver.instancemanager.games.BlockChecker;
import org.l2jmobius.gameserver.model.actor.Player;
import org.l2jmobius.gameserver.network.SystemMessageId;
import org.l2jmobius.gameserver.network.serverpackets.ServerPacket;
import org.l2jmobius.gameserver.network.serverpackets.SystemMessage;
/**
* @author xban1x
*/
public class ArenaParticipantsHolder
{
private final int _arena;
private final List<Player> _redPlayers;
private final List<Player> _bluePlayers;
private final BlockChecker _engine;
public ArenaParticipantsHolder(int arena)
{
_arena = arena;
_redPlayers = new ArrayList<>(6);
_bluePlayers = new ArrayList<>(6);
_engine = new BlockChecker(this, _arena);
}
public List<Player> getRedPlayers()
{
return _redPlayers;
}
public List<Player> getBluePlayers()
{
return _bluePlayers;
}
public List<Player> getAllPlayers()
{
final List<Player> all = new ArrayList<>(12);
all.addAll(_redPlayers);
all.addAll(_bluePlayers);
return all;
}
public void addPlayer(Player player, int team)
{
if (team == 0)
{
_redPlayers.add(player);
}
else
{
_bluePlayers.add(player);
}
}
public void removePlayer(Player player, int team)
{
if (team == 0)
{
_redPlayers.remove(player);
}
else
{
_bluePlayers.remove(player);
}
}
public int getPlayerTeam(Player player)
{
if (_redPlayers.contains(player))
{
return 0;
}
else if (_bluePlayers.contains(player))
{
return 1;
}
else
{
return -1;
}
}
public int getRedTeamSize()
{
return _redPlayers.size();
}
public int getBlueTeamSize()
{
return _bluePlayers.size();
}
public void broadCastPacketToTeam(ServerPacket packet)
{
for (Player p : _redPlayers)
{
p.sendPacket(packet);
}
for (Player p : _bluePlayers)
{
p.sendPacket(packet);
}
}
public void clearPlayers()
{
_redPlayers.clear();
_bluePlayers.clear();
}
public BlockChecker getEvent()
{
return _engine;
}
public void updateEvent()
{
_engine.updatePlayersOnStart(this);
}
public void checkAndShuffle()
{
final int redSize = _redPlayers.size();
final int blueSize = _bluePlayers.size();
if (redSize > (blueSize + 1))
{
broadCastPacketToTeam(new SystemMessage(SystemMessageId.TEAM_MEMBERS_WERE_MODIFIED_BECAUSE_THE_TEAMS_WERE_UNBALANCED));
final int needed = redSize - (blueSize + 1);
for (int i = 0; i < (needed + 1); i++)
{
final Player plr = _redPlayers.get(i);
if (plr == null)
{
continue;
}
HandysBlockCheckerManager.getInstance().changePlayerToTeam(plr, _arena);
}
}
else if (blueSize > (redSize + 1))
{
broadCastPacketToTeam(new SystemMessage(SystemMessageId.TEAM_MEMBERS_WERE_MODIFIED_BECAUSE_THE_TEAMS_WERE_UNBALANCED));
final int needed = blueSize - (redSize + 1);
for (int i = 0; i < (needed + 1); i++)
{
final Player plr = _bluePlayers.get(i);
if (plr == null)
{
continue;
}
HandysBlockCheckerManager.getInstance().changePlayerToTeam(plr, _arena);
}
}
}
}

5
L2J_Mobius_Classic_1.0/java/org/l2jmobius/gameserver/model/actor/Creature.java
View File

@ -4167,11 +4167,6 @@ public abstract class Creature extends WorldObject implements ISkillsHolder, IDe
player.sendPacket(ActionFailed.STATIC_PACKET);
return;
}
if (player.getBlockCheckerArena() != -1)
{
player.sendPacket(ActionFailed.STATIC_PACKET);
return;
}
// Notify AI with AI_INTENTION_ATTACK
player.getAI().setIntention(CtrlIntention.AI_INTENTION_ATTACK, this);
}

40
L2J_Mobius_Classic_1.0/java/org/l2jmobius/gameserver/model/actor/Player.java
View File

@ -114,7 +114,6 @@ import org.l2jmobius.gameserver.instancemanager.CursedWeaponsManager;
import org.l2jmobius.gameserver.instancemanager.DuelManager;
import org.l2jmobius.gameserver.instancemanager.FortManager;
import org.l2jmobius.gameserver.instancemanager.FortSiegeManager;
import org.l2jmobius.gameserver.instancemanager.HandysBlockCheckerManager;
import org.l2jmobius.gameserver.instancemanager.IdManager;
import org.l2jmobius.gameserver.instancemanager.ItemsOnGroundManager;
import org.l2jmobius.gameserver.instancemanager.MatchingRoomManager;
@ -126,7 +125,6 @@ import org.l2jmobius.gameserver.instancemanager.SellBuffsManager;
import org.l2jmobius.gameserver.instancemanager.SiegeManager;
import org.l2jmobius.gameserver.instancemanager.ZoneManager;
import org.l2jmobius.gameserver.model.AccessLevel;
import org.l2jmobius.gameserver.model.ArenaParticipantsHolder;
import org.l2jmobius.gameserver.model.BlockList;
import org.l2jmobius.gameserver.model.CommandChannel;
import org.l2jmobius.gameserver.model.ContactList;
@ -721,8 +719,6 @@ public class Player extends Playable
private boolean _isOnSoloEvent = false;
private boolean _isOnEvent = false;
private byte _handysBlockCheckerEventArena = -1;
/** new race ticket **/
private final int[] _race = new int[2];
@ -1047,20 +1043,6 @@ public class Player extends Playable
}
}
}
if (_handysBlockCheckerEventArena != -1)
{
result |= RelationChanged.RELATION_INSIEGE;
final ArenaParticipantsHolder holder = HandysBlockCheckerManager.getInstance().getHolder(getBlockCheckerArena());
if (holder.getPlayerTeam(this) == 0)
{
result |= RelationChanged.RELATION_ENEMY;
}
else
{
result |= RelationChanged.RELATION_ALLY;
}
result |= RelationChanged.RELATION_ATTACKER;
}
return result;
}
@ -10764,18 +10746,6 @@ public class Player extends Playable
LOGGER.log(Level.SEVERE, "deleteMe()", e);
}
try
{
if (Config.ENABLE_BLOCK_CHECKER_EVENT && (_handysBlockCheckerEventArena != -1))
{
HandysBlockCheckerManager.getInstance().onDisconnect(this);
}
}
catch (Exception e)
{
LOGGER.log(Level.SEVERE, "deleteMe()", e);
}
try
{
_isOnline = false;
@ -13094,16 +13064,6 @@ public class Player extends Playable
return _isOnEvent || isAffected(EffectFlag.PROTECT_DEATH_PENALTY);
}
public void setBlockCheckerArena(byte arena)
{
_handysBlockCheckerEventArena = arena;
}
public int getBlockCheckerArena()
{
return _handysBlockCheckerEventArena;
}
public void setOriginalCpHpMp(double cp, double hp, double mp)
{
_originalCp = cp;

162
L2J_Mobius_Classic_1.0/java/org/l2jmobius/gameserver/model/actor/instance/Block.java
View File

@ -1,162 +0,0 @@
/*
* This file is part of the L2J Mobius project.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.l2jmobius.gameserver.model.actor.instance;
import org.l2jmobius.commons.util.Rnd;
import org.l2jmobius.gameserver.data.ItemTable;
import org.l2jmobius.gameserver.instancemanager.games.BlockChecker;
import org.l2jmobius.gameserver.model.ArenaParticipantsHolder;
import org.l2jmobius.gameserver.model.actor.Creature;
import org.l2jmobius.gameserver.model.actor.Player;
import org.l2jmobius.gameserver.model.actor.templates.NpcTemplate;
import org.l2jmobius.gameserver.model.item.instance.Item;
import org.l2jmobius.gameserver.network.serverpackets.ActionFailed;
import org.l2jmobius.gameserver.network.serverpackets.ExCubeGameChangePoints;
import org.l2jmobius.gameserver.network.serverpackets.ExCubeGameExtendedChangePoints;
import org.l2jmobius.gameserver.network.serverpackets.NpcInfo;
/**
* @author BiggBoss
*/
public class Block extends Monster
{
private int _colorEffect;
public Block(NpcTemplate template)
{
super(template);
}
/**
* Will change the color of the block and update the appearance in the known players clients
* @param attacker
* @param holder
* @param team
*/
public void changeColor(Player attacker, ArenaParticipantsHolder holder, int team)
{
// Do not update color while sending old info
synchronized (this)
{
final BlockChecker event = holder.getEvent();
if (_colorEffect == 0x53)
{
// Change color
_colorEffect = 0x00;
// BroadCast to all known players
broadcastPacket(new NpcInfo(this));
increaseTeamPointsAndSend(attacker, team, event);
}
else
{
// Change color
_colorEffect = 0x53;
// BroadCast to all known players
broadcastPacket(new NpcInfo(this));
increaseTeamPointsAndSend(attacker, team, event);
}
// 30% chance to drop the event items
final int random = Rnd.get(100);
// Bond
if ((random > 69) && (random <= 84))
{
dropItem(13787, event, attacker);
}
else if (random > 84)
{
dropItem(13788, event, attacker);
}
}
}
/**
* Sets if the block is red or blue. Mainly used in block spawn
* @param isRed
*/
public void setRed(boolean isRed)
{
_colorEffect = isRed ? 0x53 : 0x00;
}
/**
* @return {@code true} if the block is red at this moment, {@code false} otherwise
*/
@Override
public int getColorEffect()
{
return _colorEffect;
}
@Override
public boolean isAutoAttackable(Creature attacker)
{
if (attacker.isPlayer())
{
return (attacker.getActingPlayer() != null) && (attacker.getActingPlayer().getBlockCheckerArena() > -1);
}
return true;
}
@Override
public boolean doDie(Creature killer)
{
return false;
}
@Override
public void onAction(Player player, boolean interact)
{
if (!canTarget(player))
{
return;
}
player.setLastFolkNPC(this);
if (player.getTarget() != this)
{
player.setTarget(this);
getAI(); // wake up ai
}
else if (interact)
{
player.sendPacket(ActionFailed.STATIC_PACKET);
}
}
private void increaseTeamPointsAndSend(Player player, int team, BlockChecker eng)
{
eng.increasePlayerPoints(player, team);
final int timeLeft = (int) ((eng.getStarterTime() - System.currentTimeMillis()) / 1000);
final boolean isRed = eng.getHolder().getRedPlayers().contains(player);
final ExCubeGameChangePoints changePoints = new ExCubeGameChangePoints(timeLeft, eng.getBluePoints(), eng.getRedPoints());
final ExCubeGameExtendedChangePoints secretPoints = new ExCubeGameExtendedChangePoints(timeLeft, eng.getBluePoints(), eng.getRedPoints(), isRed, player, eng.getPlayerPoints(player, isRed));
eng.getHolder().broadCastPacketToTeam(changePoints);
eng.getHolder().broadCastPacketToTeam(secretPoints);
}
private void dropItem(int id, BlockChecker eng, Player player)
{
final Item drop = ItemTable.getInstance().createItem("Loot", id, 1, player, this);
final int x = getX() + Rnd.get(50);
final int y = getY() + Rnd.get(50);
final int z = getZ();
drop.dropMe(this, x, y, z);
eng.addNewDrop(drop);
}
}

4
L2J_Mobius_Classic_1.0/java/org/l2jmobius/gameserver/network/ExClientPackets.java
View File

@ -167,9 +167,9 @@ public enum ExClientPackets
REQUEST_EX_JOIN_DOMINION_WAR(0x54, null, ConnectionState.IN_GAME),
REQUEST_EX_DOMINION_INFO(0x55, null, ConnectionState.IN_GAME),
REQUEST_EX_CLEFT_ENTER(0x56, null, ConnectionState.IN_GAME),
REQUEST_EX_CUBE_GAME_CHANGE_TEAM(0x57, RequestExCubeGameChangeTeam::new, ConnectionState.IN_GAME),
REQUEST_EX_CUBE_GAME_CHANGE_TEAM(0x57, null, ConnectionState.IN_GAME),
END_SCENE_PLAYER(0x58, EndScenePlayer::new, ConnectionState.IN_GAME),
REQUEST_EX_CUBE_GAME_READY_ANSWER(0x59, RequestExCubeGameReadyAnswer::new, ConnectionState.IN_GAME),
REQUEST_EX_CUBE_GAME_READY_ANSWER(0x59, null, ConnectionState.IN_GAME),
REQUEST_EX_LIST_MPCC_WAITING(0x5A, RequestExListMpccWaiting::new, ConnectionState.IN_GAME),
REQUEST_EX_MANAGE_MPCC_ROOM(0x5B, RequestExManageMpccRoom::new, ConnectionState.IN_GAME),
REQUEST_EX_JOIN_MPCC_ROOM(0x5C, RequestExJoinMpccRoom::new, ConnectionState.IN_GAME),

82
L2J_Mobius_Classic_1.0/java/org/l2jmobius/gameserver/network/clientpackets/RequestExCubeGameChangeTeam.java
View File

@ -1,82 +0,0 @@
/*
* This file is part of the L2J Mobius project.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.l2jmobius.gameserver.network.clientpackets;
import org.l2jmobius.commons.network.ReadablePacket;
import org.l2jmobius.gameserver.instancemanager.HandysBlockCheckerManager;
import org.l2jmobius.gameserver.model.actor.Player;
import org.l2jmobius.gameserver.network.GameClient;
import org.l2jmobius.gameserver.network.PacketLogger;
/**
* Format: chdd d: Arena d: Team
* @author mrTJO
*/
public class RequestExCubeGameChangeTeam implements ClientPacket
{
private int _arena;
private int _team;
@Override
public void read(ReadablePacket packet)
{
// client sends -1,0,1,2 for arena parameter
_arena = packet.readInt() + 1;
_team = packet.readInt();
}
@Override
public void run(GameClient client)
{
// do not remove players after start
if (HandysBlockCheckerManager.getInstance().arenaIsBeingUsed(_arena))
{
return;
}
final Player player = client.getPlayer();
switch (_team)
{
case 0:
case 1:
{
// Change Player Team
HandysBlockCheckerManager.getInstance().changePlayerToTeam(player, _arena);
break;
}
case -1:
{
// Remove Player (me)
}
{
final int team = HandysBlockCheckerManager.getInstance().getHolder(_arena).getPlayerTeam(player);
// client sends two times this packet if click on exit
// client did not send this packet on restart
if (team > -1)
{
HandysBlockCheckerManager.getInstance().removePlayer(player, _arena, team);
}
break;
}
default:
{
PacketLogger.warning("Wrong Cube Game Team ID: " + _team);
break;
}
}
}
}

72
L2J_Mobius_Classic_1.0/java/org/l2jmobius/gameserver/network/clientpackets/RequestExCubeGameReadyAnswer.java
View File

@ -1,72 +0,0 @@
/*
* This file is part of the L2J Mobius project.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.l2jmobius.gameserver.network.clientpackets;
import org.l2jmobius.commons.network.ReadablePacket;
import org.l2jmobius.gameserver.instancemanager.HandysBlockCheckerManager;
import org.l2jmobius.gameserver.model.actor.Player;
import org.l2jmobius.gameserver.network.GameClient;
import org.l2jmobius.gameserver.network.PacketLogger;
/**
* Format: chddd d: Arena d: Answer
* @author mrTJO
*/
public class RequestExCubeGameReadyAnswer implements ClientPacket
{
private int _arena;
private int _answer;
@Override
public void read(ReadablePacket packet)
{
// client sends -1,0,1,2 for arena parameter
_arena = packet.readInt() + 1;
// client sends 1 if clicked confirm on not clicked, 0 if clicked cancel
_answer = packet.readInt();
}
@Override
public void run(GameClient client)
{
final Player player = client.getPlayer();
if (player == null)
{
return;
}
switch (_answer)
{
case 0:
{
// Cancel - Answer No
break;
}
case 1:
{
// OK or Time Over
HandysBlockCheckerManager.getInstance().increaseArenaVotes(_arena);
break;
}
default:
{
PacketLogger.warning("Unknown Cube Game Answer ID: " + _answer);
break;
}
}
}
}