Evento Deathmatch Engine by Intrepid

[Swarlog]

Código [Seleccionar] Expandir

/*
 * 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 com.azaria.events;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.concurrent.ScheduledFuture;
import java.util.logging.Level;
import java.util.logging.Logger;

import javolution.util.FastMap;

import com.l2jserver.Config;
import com.l2jserver.L2DatabaseFactory;
import com.l2jserver.gameserver.Announcements;
import com.l2jserver.gameserver.ThreadPoolManager;
import com.l2jserver.gameserver.model.L2ItemInstance;
import com.l2jserver.gameserver.model.actor.L2Character;
import com.l2jserver.gameserver.model.actor.instance.L2CubicInstance;
import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
import com.l2jserver.gameserver.network.SystemMessageId;
import com.l2jserver.gameserver.network.serverpackets.SystemMessage;
import com.l2jserver.gameserver.util.Broadcast;
import com.l2jserver.tools.random.Rnd;

/**
 * @author Intrepid
 *
 */
public class DeathMatch
{
	// declare logger
	private static final Logger _log = Logger.getLogger(DeathMatch.class.getName());
	
	// event name
	private static final String _eventName = "DeathMatch";
	
	// event finished and not started yet
	private static final int STATUS_NOT_IN_PROGRESS = 0;
	
	// event registration allowed
	private static final int STATUS_REGISTRATION = 1;
	
	// event registration ended and combat not started yet
	private static final int STATUS_PREPARATION = 2;
	
	// event players teleported to the event and combat starter
	private static final int STATUS_COMBAT = 3;
	
	// event combat ended wait setup for next event
	private static final int STATUS_NEXT_EVENT = 4;
	
	private static final String REMOVE_DISCONNECTED = "UPDATE characters SET heading=?,x=?,y=?,z=? WHERE charId=?";
	
	/**
	 * Initialize new/Returns the one and only instance<br><br>
	 *
	 * @return DeathMatch<br>
	 */
	public static DeathMatch getInstance()
	{
		return SingletonHolder._instance;
	}
	
	private static class SingletonHolder
	{
		protected static final DeathMatch _instance = new DeathMatch();
	}
	
	private final ThreadPoolManager				tpm;
	
	private final autoEventTask					task;
	private final reviveTask					taskDuring;
	private ScheduledFuture<?>					reviver;
	private ScheduledFuture<?>					event;
	private int									announced;
	
	private static FastMap<Integer,L2PcInstance>	players;
	
	private volatile int						status;
	private volatile boolean					active;
	
	/**
	 * private constructor
	 */
	private DeathMatch()
	{
		tpm = ThreadPoolManager.getInstance();
		status = STATUS_NOT_IN_PROGRESS;
		announced = 0;
		players = new FastMap<Integer,L2PcInstance>(Config.DM_MAX_PARTICIPANT);
		task = new autoEventTask();
		taskDuring = new reviveTask();
		reviver = null;
		active = Config.DM_ALLOWED;
		if (active)
		{
			tpm.scheduleGeneral(task, Config.DM_DELAY_INITIAL_REGISTRATION);
			_log.info("DeathMatch: Initialized event enabled.");
		}
		else
			_log.info("DeathMatch: Initialized but not enabled.");
	}
	
	private class autoEventTask implements Runnable
	{
		@Override
		public void run()
		{
			switch (status)
			{
				case STATUS_NOT_IN_PROGRESS:
					if (Config.DM_ALLOWED)
						registrationStart();
					else
						active = false;
					break;
				case STATUS_REGISTRATION:
					if (announced < (Config.DM_REGISTRATION_ANNOUNCEMENT_COUNT + 2))
						registrationAnnounce();
					else
						registrationEnd();
					break;
				case STATUS_PREPARATION:
					startEvent();
					break;
				case STATUS_COMBAT:
					endEvent();
					break;
				case STATUS_NEXT_EVENT:
					status = STATUS_NOT_IN_PROGRESS;
					tpm.scheduleGeneral(task, Config.DM_DELAY_BETWEEN_EVENTS);
					break;
				default:
					_log.severe("Incorrect status set in Automated " + _eventName + ", terminating the event!");
			}
		}
	}
	
	private class reviveTask implements Runnable
	{
		@Override
		public void run()
		{
			L2PcInstance player;
			for (L2PcInstance p : players.values())
			{
				player = p.getActingPlayer();
				if (player != null && player.isDead())
					revive(player);
			}
		}
	}
	

	public void registerPlayer(L2PcInstance player)
	{
		if (!active)
			return;
		
		if (status != STATUS_REGISTRATION || players.size() >= Config.DM_MAX_PARTICIPANT)
			player.sendPacket(SystemMessageId.REGISTRATION_PERIOD_OVER);
		else if(!players.containsValue(player))
		{
			if (!canJoin(player))
			{
				player.sendMessage("You can't join to the" + _eventName + " because you dont meet with the requirements!");
				return;
			}
			players.put(player.getObjectId(), player);
			player.sendMessage("You are successfully registered to: " + _eventName);
			if (Config.DM_REG_CANCEL)
				player.sendMessage("If you decide to cancel your registration use .leavedm!");
		}
		else
			player.sendMessage("You are alredy registered");
	}
	
	public void cancelRegistration(L2PcInstance player)
	{
		if (!active)
			return;
		
		if (status != STATUS_REGISTRATION)
			player.sendPacket(SystemMessageId.REGISTRATION_PERIOD_OVER);
		else if (players.containsValue(player))
		{
			players.remove(player);
			player.sendMessage("You successfully cancelled your registration in " + _eventName);
		}
		else
			player.sendMessage("You are not a participant in" + _eventName);
	}

	public void registrationStart()
	{
		status = STATUS_REGISTRATION;
		Announcements.getInstance().announceToAll(new SystemMessage(SystemMessageId.REGISTRATION_PERIOD));
		SystemMessage time = new SystemMessage(SystemMessageId.REGISTRATION_TIME_S1_S2_S3);
		long timeLeft = Config.DM_REGISTRATION_LENGHT/ 1000;
		time.addNumber((int) (timeLeft / 3600));
		time.addNumber((int) (timeLeft % 3600 / 60));
		time.addNumber((int) (timeLeft % 3600 % 60));
		Broadcast.toAllOnlinePlayers(time);
		Announcements.getInstance().announceToAll("To join the " + _eventName + " you must type .joindm");
		tpm.scheduleGeneral(task, Config.DM_REGISTRATION_LENGHT / (Config.DM_REGISTRATION_ANNOUNCEMENT_COUNT + 2));
	}

	public void registrationAnnounce()
	{
		SystemMessage time = new SystemMessage(SystemMessageId.REGISTRATION_TIME_S1_S2_S3);
		long timeLeft = Config.DM_REGISTRATION_LENGHT;
		long elapsed = timeLeft / (Config.DM_REGISTRATION_ANNOUNCEMENT_COUNT + 2) * announced;
		timeLeft -= elapsed;
		timeLeft /= 1000;
		time.addNumber((int) (timeLeft / 3600));
		time.addNumber((int) (timeLeft % 3600 / 60));
		time.addNumber((int) (timeLeft % 3600 % 60));
		Broadcast.toAllOnlinePlayers(time);
		Announcements.getInstance().announceToAll("To join the " + _eventName + " you must type .joindm");
		announced++;
		tpm.scheduleGeneral(task, Config.DM_REGISTRATION_LENGHT / (Config.DM_REGISTRATION_ANNOUNCEMENT_COUNT + 2));
	}
	
	public void registrationEnd()
	{
		announced = 0;
		status = STATUS_PREPARATION;
		
		for (L2PcInstance p : players.values())
		{
			if (p == null)
				continue;
			if (!canJoin(p))
			{
				p.sendMessage("You can't join to the" + _eventName + " because you dont meet with the requirements!");
				players.remove(p);
			}
		}
		
		if (players.size() <= Config.DM_MIN_PLAYER)
		{
			Announcements.getInstance().announceToAll(_eventName + "aborted not enough players!");
			players.clear();
			status = STATUS_NOT_IN_PROGRESS;
			tpm.scheduleGeneral(task, Config.DM_DELAY_BETWEEN_EVENTS);
			return;
		}
		
		SystemMessage time = new SystemMessage(SystemMessageId.BATTLE_BEGINS_S1_S2_S3);
		long timeLeft = Config.DM_PREPARATION_LENGHT / 1000;
		time.addNumber((int) (timeLeft / 3600));
		time.addNumber((int) (timeLeft % 3600 / 60));
		time.addNumber((int) (timeLeft % 3600 % 60));
		
		for (L2PcInstance p : players.values())
		{
			if (p == null)
				continue;
			
			p.setIsParalyzed(true);
			p.sendPacket(time);
			checkEquipment(p);
			if (Config.DM_CANCEL_PARTY_ONSTART && p.getParty() != null)
				p.getParty().removePartyMember(p);
			if (Config.DM_CANCEL_BUFF_ONSTART)
				p.stopAllEffects();
			if (Config.DM_CANCEL_CUBIC_ONSTART && !p.getCubics().isEmpty())
			{
				for (L2CubicInstance cubic : p.getCubics().values())
				{
					cubic.stopAction();
					cubic.cancelDisappear();
				}
				p.getCubics().clear();
			}
			if (Config.DM_UNSUMMON_PET_ONSTART && p.getPet() != null)
				p.getPet().unSummon(p);
			if (Config.DM_CANCEL_TRANSFORM_ONSTART && p.isTransformed())
				p.untransform();
			if (p.isDead())
				p.setIsPendingRevive(true);
			
			int spawn = Rnd.get(2);
			if (spawn == 0)
				p.teleToLocation(Config.DM_LOCX1,Config.DM_LOCY1,Config.DM_LOCZ1);
			if (spawn == 1)
				p.teleToLocation(Config.DM_LOCX2,Config.DM_LOCY2,Config.DM_LOCZ2);
			
			if (Config.DM_RECOVER_ONSTART && p.getCurrentCp() != p.getMaxCp() || p.getCurrentHp() != p.getMaxHp() || p.getCurrentMp() != p.getMaxMp())
			{
				p.getStatus().setCurrentCp(p.getMaxCp());
				p.getStatus().setCurrentHpMp(p.getMaxHp(), p.getMaxMp());
			}
		}
		tpm.scheduleGeneral(task, Config.DM_PREPARATION_LENGHT);
	}
	
	public void startEvent()
	{
		status = STATUS_COMBAT;
		SystemMessage time = new SystemMessage(SystemMessageId.BATTLE_ENDS_S1_S2_S3);
		long timeLeft = Config.DM_EVENT_LENGHT / 1000;
		time.addNumber((int) (timeLeft / 3600));
		time.addNumber((int) (timeLeft % 3600 / 60));
		time.addNumber((int) (timeLeft % 3600 % 60));
		L2PcInstance player;
		for (L2PcInstance p : players.values())
		{
			player = p.getActingPlayer();
			if (player == null)
				continue;
			player.setIsParalyzed(false);
			player.sendPacket(time);
		}
		reviver = tpm.scheduleGeneralAtFixedRate(taskDuring, Config.DM_REVIVE_DELAY, Config.DM_REVIVE_DELAY);
		event = tpm.scheduleGeneral(task, Config.DM_EVENT_LENGHT);
	}
	
	public void endEvent()
	{
		if (status != STATUS_COMBAT)
			return;
		status = STATUS_NEXT_EVENT;
		reviver.cancel(true);
		if (!event.cancel(false))
			return;
		
		Announcements.getInstance().announceToAll(_eventName + " is finished!");
		
		L2PcInstance player;
		for (L2PcInstance p : players.values())
		{
			player = p.getActingPlayer();
			if (player == null)
			{
				removeDisconnected(p.getObjectId(), p);
				continue;
			}
			removeFromEvent(player);
		}
		players.clear();
		tpm.scheduleGeneral(task, Config.DM_ENDING_LENGHT);
	}
	
	private void revive(L2PcInstance player)
	{
		player.setIsPendingRevive(true);
		int teleTo = Rnd.get(1);
		if (teleTo == 1)
			player.teleToLocation(Config.DM_RANDOM_RESPAWN1_X, Config.DM_RANDOM_RESPAWN1_Y, Config.DM_RANDOM_RESPAWN1_Z);
		if (teleTo == 2)
			player.teleToLocation(Config.DM_RANDOM_RESPAWN2_X, Config.DM_RANDOM_RESPAWN2_Y, Config.DM_RANDOM_RESPAWN2_Z);
	}
	
	private boolean canJoin(L2PcInstance player)
	{
		// level restriction
		boolean can = player.getLevel() <= Config.DM_MAX_LVL;
		can &= player.getLevel() >= Config.DM_MIN_LVL;
		// hero restriction
		if (!Config.DM_HERO_JOIN)
			can &= !player.isHero();
		// cw owner restriction
		if (Config.DM_CWOWNER_JOIN)
			can &= !player.isCursedWeaponEquipped();
		return can;
	}
	
	private final void checkEquipment(L2PcInstance player)
	{
		L2ItemInstance item;
		for (int i = 0; i < 25; i++)
		{
			synchronized (player.getInventory())
			{
				item = player.getInventory().getPaperdollItem(i);
				if (item != null && !canUse(item.getItemId()))
					player.useEquippableItem(item, true);
			}
		}
	}
	
	public static final boolean canUse(int itemId)
	{
		for (int id : Config.DM_DISALLOWED_ITEMS)
			if (itemId == id)
				return false;
		return true;
	}
	
	private void removeFromEvent(L2PcInstance player)
	{
		if (!player.isDead())
		{
			player.getStatus().setCurrentCp(player.getMaxCp());
			player.getStatus().setCurrentHpMp(player.getMaxHp(), player.getMaxMp());
		}
		else
			player.setIsPendingRevive(true);
		player.teleToLocation(Config.DM_TELE_BACK_X, Config.DM_TELE_BACK_Y, Config.DM_TELE_BACK_Z);
	}
	
	public final void removeDisconnected(int objID,L2PcInstance player)
	{
		Connection con = null;
		try
		{
			con = L2DatabaseFactory.getInstance().getConnection();
			PreparedStatement ps = con.prepareStatement(REMOVE_DISCONNECTED);
			ps.setInt(1, player.getHeading());
			ps.setInt(2, Config.DM_TELE_BACK_X);
			ps.setInt(3, Config.DM_TELE_BACK_Y);
			ps.setInt(4, Config.DM_TELE_BACK_Z);
			ps.setInt(5, objID);
			ps.executeUpdate();
			ps.close();
		}
		catch (SQLException e)
		{
			_log.log(Level.WARNING,"Could not remove a disconnected DM player!", e);
		}
		finally
		{
			L2DatabaseFactory.close(con);
		}
	}
	
	public final void addDisconnected(L2PcInstance participant)
	{
		switch (status)
		{
			case STATUS_REGISTRATION:
				if (Config.DM_REGISTER_AFTER_RELOG && !players.containsValue(participant))
					registerPlayer(participant);
				break;
			case STATUS_COMBAT:
				L2PcInstance p = players.get(participant.getObjectId());
				if (p == null)
					break;
				players.put(participant.getObjectId(), participant);
				checkEquipment(participant);
				int spawn = Rnd.get(2);
				if (spawn == 0)
					participant.teleToLocation(Config.DM_LOCX1,Config.DM_LOCY1,Config.DM_LOCZ1);
				if (spawn == 1)
					participant.teleToLocation(Config.DM_LOCX2,Config.DM_LOCY2,Config.DM_LOCZ2);
				break;
		}
	}
	
	public final void onKill(L2Character killer,L2PcInstance killed)
	{
		if (status != STATUS_COMBAT)
			return;
		
		((L2PcInstance) killer).addItem("DEATHMACH", Config.DM_REWARD_ID, Config.DM_REWARD_COUNT, killer, false);
		killer.sendMessage(killer + "killed: " + killed);
		killed.sendMessage(killed + "killed by: " + killer);
	}
	
	
	public static final boolean isInProgress()
	{
		switch (getInstance().status)
		{
		case STATUS_PREPARATION:
		case STATUS_COMBAT:
			return true;
		default:
			return false;
		}
	}
	
	public static final boolean isPlaying(L2PcInstance player)
	{
		return isInProgress() && isMember(player);
	}
	
	public static final boolean isMember(L2PcInstance player)
	{
		if (player == null)
			return false;
		
		switch (getInstance().status)
		{
			case STATUS_NOT_IN_PROGRESS:
				return false;
			case STATUS_REGISTRATION:
				return players.containsValue(player);
			case STATUS_PREPARATION:
				return players.containsValue(player) || isMember(player.getObjectId());
			case STATUS_COMBAT:
			case STATUS_NEXT_EVENT:
				return isMember(player.getObjectId());
			default:
				return false;
		}
	}
	
	private final static boolean isMember(int oID)
	{
		return players.get(oID) != null;
	}
}