Evento Biohazard

[Swarlog]

Código [Seleccionar] Expandir

### Eclipse Workspace Patch 1.0
#P L2J_Server
Index: java/com/l2jserver/Config.java
===================================================================
--- java/com/l2jserver/Config.java	(revision 4767)
+++ java/com/l2jserver/Config.java	(working copy)
@@ -56,6 +56,7 @@
 	//--------------------------------------------------
 	// L2J Property File Definitions
 	//--------------------------------------------------
+	public static final String BIO_CONFIG_FILE = "./config/biohazard.properties";
 	public static final String CHARACTER_CONFIG_FILE = "./config/Character.properties";
 	public static final String FEATURE_CONFIG_FILE = "./config/Feature.properties";
 	public static final String FORTSIEGE_CONFIGURATION_FILE = "./config/fortsiege.properties";
@@ -86,6 +87,19 @@
 	
 	
 	//--------------------------------------------------
+	// Biohazard Config
+	//--------------------------------------------------
+	public static boolean BIOHAZARD_EVENT_ENABLED;
+	public static String[] BIOHAZARD_EVENT_INTERVAL;
+	public static boolean ALLOWPVPPKBIO;
+	public static int BIOHAZARDMINPLAYERS;
+	public static int BIOHAZARD_X;
+	public static int BIOHAZARD_Y;
+	public static int BIOHAZARD_Z;
+	public static int BIOHAZARDREWARDID;
+	public static int BIOHAZARDREWARDAMOUNT;
+	
+	//--------------------------------------------------
 	// L2J Variable Definitions
 	//--------------------------------------------------
 	public static int MASTERACCESS_LEVEL;
@@ -1110,6 +1124,29 @@
 			{
 				try
 				{
+					L2Properties BIOSettings = new L2Properties();
+					is = new FileInputStream(new File(BIO_CONFIG_FILE));
+					BIOSettings.load(is);
+					
+					BIOHAZARD_EVENT_ENABLED = Boolean.parseBoolean(BIOSettings.getProperty("BiohazardEventEnabled", "false"));
+					BIOHAZARD_EVENT_INTERVAL = BIOSettings.getProperty("BiohazardEventInterval", "20:00").split(",");
+					ALLOWPVPPKBIO =  Boolean.parseBoolean(BIOSettings.getProperty("BiohazardAllowPvPPkCount", "false"));
+					BIOHAZARDMINPLAYERS = Integer.parseInt(BIOSettings.getProperty("Biohazardminplayers", "2"));
+					BIOHAZARD_X = Integer.parseInt(BIOSettings.getProperty("setX", "-17507"));
+					BIOHAZARD_Y = Integer.parseInt(BIOSettings.getProperty("setY", "143206"));
+					BIOHAZARD_Z = Integer.parseInt(BIOSettings.getProperty("setZ", "-3911"));
+					BIOHAZARDREWARDID = Integer.parseInt(BIOSettings.getProperty("BiohazardRewardId", "57"));
+					BIOHAZARDREWARDAMOUNT = Integer.parseInt(BIOSettings.getProperty("BiohazardRewardAmount", "1000"));
+				
+				}
+				catch (Exception e)
+				{
+					e.printStackTrace();
+					throw new Error("Failed to Load "+BIO_CONFIG_FILE+" File.");
+				}
+				
+				try
+				{
 					L2Properties serverSettings = new L2Properties();
 					is = new FileInputStream(new File(CONFIGURATION_FILE));
 					serverSettings.load(is);
Index: java/config/biohazard.properties
===================================================================
--- java/config/biohazard.properties	(revision 0)
+++ java/config/biohazard.properties	(revision 0)
@@ -0,0 +1,23 @@
+# ---------------------------------------------------------------------------
+# Biohazard Event Engine
+# ---------------------------------------------------------------------------
+# Enable/Disable BiohazardEvent System
+BiohazardEventEnabled = False
+ 
+# Times Biohazard will occur (24h format).
+BiohazardEventInterval = 9:00,15:00,21:00,3:00
+
+# set True to allow PvP PK points
+BiohazardAllowPvPPkCount = False
+
+# Min amount of players allowed in the event.
+Biohazardminplayers = 2
+
+# Set Location x,y,z for this event.
+setX = -17507
+setY = 143206
+setZ = -3911
+
+# Reward for winning team.
+BiohazardRewardId = 57
+BiohazardRewardAmount = 1000
\ No newline at end of file
Index: java/com/l2jserver/gameserver/model/entity/Biohazard.java
===================================================================
--- java/com/l2jserver/gameserver/model/entity/Biohazard.java	(revision 0)
+++ java/com/l2jserver/gameserver/model/entity/Biohazard.java	(revision 0)
@@ -0,0 +1,310 @@
+/*
+ * 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.l2jserver.gameserver.model.entity;
+ 
+ 
+import java.util.Random;
+import javolution.util.FastSet;
+ 
+import com.l2jserver.Config;
+import com.l2jserver.gameserver.Announcements;
+import com.l2jserver.gameserver.instancemanager.TransformationManager;
+import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
+import com.l2jserver.gameserver.model.olympiad.OlympiadManager;
+import com.l2jserver.util.Rnd;
+ 
+public class Biohazard
+{
+   enum EventState
+   {
+      INACTIVE,
+      INACTIVATING,
+      REGISTERING,
+      STARTED,
+      REWARDING
+   }
+ 
+    private static EventState _state = EventState.INACTIVE;
+   
+   public static FastSet<L2PcInstance> _participants = new FastSet<L2PcInstance>();
+   public static FastSet<L2PcInstance> _infected = new FastSet<L2PcInstance>();
+   public static FastSet<L2PcInstance> _notInfected = new FastSet<L2PcInstance>();
+   
+   public static boolean isStarted()
+   {
+      if (_state == EventState.STARTED)
+         return true;
+      return false;
+   }
+   
+   public static boolean isRegistering()
+   {
+      if (_state == EventState.REGISTERING)
+         return true;
+      return false;
+   }
+   
+   public static void startRegistering()
+   {
+      if (_state == EventState.REGISTERING || _state == EventState.STARTED)
+         return;
+      Announcements.getInstance().announceToAll("Biohazard: Registration is open.");
+      Announcements.getInstance().announceToAll("Biohazard: Type \".bhreg\" to register to event.");
+      Announcements.getInstance().announceToAll("Biohazard: Type \".bhunreg\" to unregister from event.");
+      _state = EventState.REGISTERING;
+      int step = 0;
+      int after = 0;
+      for (int i = 40; i > 0; i-=10)
+      {
+         switch(i)
+         {
+            case 40:
+               step = 5;
+               after = 15;
+               break;
+            case 30:
+               step = 5;
+               after = 10;
+               break;
+            case 20:
+               step = 4;
+               after = 5;
+               break;
+            case 10:
+               step = 1;
+               after = 1;
+               break;
+         }
+         if (_state == EventState.INACTIVE)
+            return;
+         Announcements.getInstance().announceToAll("Biohazard: Registration will be closed in " + after + " minute(s).");
+         try{Thread.sleep(step*60000);}catch (Exception e){}
+      }
+      //sound = "";
+      try{Thread.sleep(10000);}catch (Exception e){}
+      if (_state == EventState.INACTIVE)
+         return;
+      if (_participants.size() >= Config.BIOHAZARDMINPLAYERS)
+      {
+         Announcements.getInstance().announceToAll("Biohazard: Teleporting players in 15 seconds.");
+         try{Thread.sleep(15000);}catch (Exception e){}
+         _state = EventState.STARTED;
+         startEventAndTelePl();
+      }
+      else
+         Announcements.getInstance().announceToAll("Biohazard: Event aborted due to lack of participants.");
+   }
+   
+   public static void addParticipant(L2PcInstance player)
+   {
+      if (OlympiadManager.getInstance().isRegistered(player) || TvTEvent.isPlayerParticipant(player.getObjectId()))
+      {
+         player.sendMessage("You cannot register because of registration in another event");
+         return;
+      }
+      if (_state == EventState.REGISTERING && !_participants.contains(player))
+      {
+         _participants.add(player);
+         player.sendMessage("You have successfully registered to this event");
+      }
+      else
+         player.sendMessage("You are already registered or it's not registration time.");
+   }
+   
+   public static void removeParticipant(L2PcInstance player)
+   {
+      if (_state == EventState.REGISTERING)
+      {
+         if (_participants.contains(player))
+         {
+            _participants.remove(player);
+         	player.sendMessage("You have unregistered to this event.");
+         }
+         else
+            player.sendMessage("You aren't registered in this event.");
+         player.setIsInBiohazard(false);
+      }
+      else
+         player.sendMessage("It's not registration time.");
+   }
+   
+   public static void startEventAndTelePl()
+   {
+	   int time;
+	   Random r = new Random();
+	   time = r.nextInt(35000); // 35000 = 35 Seconds
+	   
+	   if (_state == EventState.INACTIVE)
+         return;
+      synchronized(_participants)
+      {
+         for (L2PcInstance pl : _participants)
+            if (pl.isOnline())
+            {
+               _notInfected.add(pl);
+               pl.stopAllEffects();
+               pl._oldX = pl.getX();
+               pl._oldY = pl.getY();
+               pl._oldZ = pl.getZ();
+               pl.teleToLocation(Config.BIOHAZARD_X,Config.BIOHAZARD_Y,Config.BIOHAZARD_Z);
+               pl.setTeam(0);
+               pl.setIsInBiohazard(true);
+               pl.untransform();
+            }
+      }
+   Announcements.getInstance().announceToAll("Biohazard: In some seconds a virus will take over anyone and he will become zombie!");
+   try{Thread.sleep(time);}catch (Exception e){}
+   int num = Math.round(Rnd.get(_notInfected.size()-1));
+   L2PcInstance infectFirst = getAllNotInfected()[num];
+   infectPlayer(infectFirst);
+   Announcements.getInstance().announceToAll("Biohazard: Virus took over " + infectFirst.getName() + " body and he wants to infect everybody else!");
+   }
+   
+   public static void infectPlayer(L2PcInstance zombie)
+   {
+      if (_state == EventState.INACTIVE)
+         return;
+      zombie.setIsZombie(true);
+      _notInfected.remove(zombie);
+      _infected.add(zombie);
+      TransformationManager.getInstance().transformPlayer(303, zombie);
+      	zombie.stopAllEffects();
+		zombie.setCurrentHp(zombie.getMaxHp());
+		zombie.setCurrentMp(zombie.getMaxMp());
+		zombie.setCurrentCp(zombie.getMaxCp());
+      if (_notInfected.size() == 0)
+         zombiesWin();
+   }
+   
+   public static void onLogout(L2PcInstance playerInstance)
+   {
+      if (_state == EventState.REGISTERING)
+         removeParticipant(playerInstance);
+      else if (_state == EventState.STARTED)
+      {
+         playerInstance.setXYZ(playerInstance._oldX,playerInstance._oldY,playerInstance._oldZ);
+         if (!playerInstance.isZombie())
+            _notInfected.remove(playerInstance);
+         else if (playerInstance.isZombie())
+            _infected.remove(playerInstance);
+         if (_notInfected.size() == 0)
+            zombiesWin();
+         if (_infected.size() == 0)
+            playersWin();
+      }
+   }
+   
+   public static void zombiesWin()
+   {
+      if (_state == EventState.INACTIVE)
+         return;
+      Announcements.getInstance().announceToAll("Biohazard: Zombies won.");
+      Announcements.getInstance().announceToAll("Biohazard: Rewarding and teleporting participants back to village in 20 seconds.");
+      _state = EventState.REWARDING;
+      try{Thread.sleep(15000);}catch (Exception e){}
+      synchronized(_infected)
+      {
+         for (L2PcInstance pl : _infected)
+            if (pl.isOnline())
+            	pl.addItem("Biohazard", Config.BIOHAZARDREWARDID, Config.BIOHAZARDREWARDAMOUNT, pl, true);
+         		Biohazard.teleport();
+      }
+   }
+   
+   public static void playersWin()
+   {
+      Announcements.getInstance().announceToAll("Biohazard: Players won.");
+      Announcements.getInstance().announceToAll("Biohazard: Rewarding and teleporting participants back to village in 15 seconds.");
+      _state = EventState.REWARDING;
+      try{Thread.sleep(15000);}catch (Exception e){}
+      synchronized(_notInfected)
+      {
+         for (L2PcInstance pl : _notInfected)
+            if (pl.isOnline())
+            	pl.addItem("Biohazard", Config.BIOHAZARDREWARDID, Config.BIOHAZARDREWARDAMOUNT, pl, true);
+         		Biohazard.teleport();
+      }
+   }
+   
+   public static void teleport()
+   {
+	   synchronized(_participants)
+      {
+		  synchronized(_notInfected)
+    	  {
+			  for (L2PcInstance pl : _notInfected)
+    			  if (pl.isOnline())
+    			  {
+    				  pl.stopAllEffects();
+    			  	  pl.setIsInBiohazard(false);
+//   			  if (pl.inWorld() == 1)
+//					  pl.setTeam(pl.getFactionId());
+    			  }
+    	  }
+		  synchronized(_infected)
+    	  {
+    		  for (L2PcInstance pl : _infected)
+    			  if (pl.isOnline())
+    			  {
+    				  	  pl.doRevive();
+    				  	  pl.stopAllEffects();
+    				  if (pl.isTransformed())
+    					  pl.untransform();
+    				  	  pl.setIsZombie(false);
+    				  	  pl.setIsInBiohazard(false);
+//					  if (pl.inWorld() == 1)
+//						  pl.setTeam(pl.getFactionId());
+   		  		  }
+    	  }
+		  try{Thread.sleep(4000);}catch (Exception e){}
+		  for (L2PcInstance pl : _participants)
+		  pl.teleToLocation(pl._oldX,pl._oldY,pl._oldZ);
+      }
+      _participants.clear();
+      _infected.clear();
+      _notInfected.clear();
+      _state = EventState.INACTIVE;
+   }
+   
+   public static L2PcInstance[] getAllNotInfected()
+   {
+      synchronized(_notInfected)
+      {
+         return _notInfected.toArray(new L2PcInstance[_notInfected.size()]);
+      }
+   }
+   
+   public static void abortEvent()
+   {
+      _state = EventState.INACTIVE;
+      _participants.clear();
+      _notInfected.clear();
+      _infected.clear();
+      Announcements.getInstance().announceToAll("Biohazard: Event aborted.");
+   }
+   
+   public static boolean isInactive()
+	{
+		boolean isInactive;
+		
+		synchronized (_state)
+		{
+			isInactive = _state == EventState.INACTIVE;
+		}
+		
+		return isInactive;
+	}
+   
+}
\ No newline at end of file
Index: java/com/l2jserver/gameserver/model/actor/instance/L2PcInstance.java
===================================================================
--- java/com/l2jserver/gameserver/model/actor/instance/L2PcInstance.java	(revision 4767)
+++ java/com/l2jserver/gameserver/model/actor/instance/L2PcInstance.java	(working copy)
@@ -150,6 +150,7 @@
 import com.l2jserver.gameserver.model.base.PlayerClass;
 import com.l2jserver.gameserver.model.base.Race;
 import com.l2jserver.gameserver.model.base.SubClass;
+import com.l2jserver.gameserver.model.entity.Biohazard;
 import com.l2jserver.gameserver.model.entity.Castle;
 import com.l2jserver.gameserver.model.entity.Duel;
 import com.l2jserver.gameserver.model.entity.Fort;
@@ -480,6 +481,26 @@
 		}
 	}
 	
+	/** Biohazard */
+	private static boolean _inBiohazard = false;
+	public boolean _isZombie = false;
+	public void setIsZombie(boolean a)
+	{
+		_isZombie = a;
+	}
+	public boolean isZombie()
+	{
+		return _isZombie;
+	}
+	private boolean inBiohazard() 
+	{
+		return _inBiohazard;
+	}
+	public void setIsInBiohazard(boolean b)
+	{
+		_inBiohazard = b;	
+	}
+	
 	/** Olympiad */
 	private boolean _inOlympiadMode = false;
 	private boolean _OlympiadStart = false;
@@ -4892,6 +4913,10 @@
 	@Override
 	public synchronized void untransform()
 	{
+		// Biohazard
+		if (inBiohazard() && Biohazard.isStarted() && _transformation != null && isZombie())
+			return;
+	
 		if (_transformation != null)
 		{
 			setQueuedSkill(null, false, false);
@@ -5324,6 +5349,23 @@
 		// Kill the L2PcInstance
 		if (!super.doDie(killer))
 			return false;
+			
+		// Biohazard
+		if (killer instanceof L2PcInstance)
+			{
+				L2PcInstance pl = (L2PcInstance) killer;
+				if (inBiohazard() && !isZombie() && pl.inBiohazard() && pl.isZombie() && Biohazard.isStarted())
+				{
+					pl.abortAttack();
+					pl.abortCast();
+					doRevive();
+					Biohazard.infectPlayer(this);
+					stopAllEffects();
+			     	setCurrentHp(getMaxHp());
+			     	setCurrentMp(getMaxMp());
+			     	setCurrentCp(getMaxCp());
+				}
+			}
 		
 		if (isMounted())
 			stopFeed();
@@ -5483,6 +5525,17 @@
 		{
 			reviveRequest(this, null, false);
 		}
+		// Biohazard
+		if (isZombie() && inBiohazard())
+		{
+			if(Biohazard._infected.contains(this))
+			{
+				Biohazard._infected.remove(this);
+				untransform();
+				if (Biohazard._infected.size() == 0)
+					Biohazard.playersWin();
+			}
+		}
 		return true;
 	}
 	
@@ -5677,6 +5730,13 @@
 		if (target instanceof L2PcInstance
 				&& AntiFeedManager.getInstance().check(this, target))
 		{
+			// Add by Biohazard Event
+			if(Config.ALLOWPVPPKBIO)
+			{
+				if (Biohazard.isStarted() && _inBiohazard)
+					return;
+			}
+			
 			// Add karma to attacker and increase its PK counter
 			setPvpKills(getPvpKills() + 1);
 			
@@ -5738,6 +5798,13 @@
 		if (getKarma() > (Integer.MAX_VALUE - newKarma))
 			newKarma = Integer.MAX_VALUE - getKarma();
 		
+		// Add by Biohazard Event
+		if(Config.ALLOWPVPPKBIO)
+		{
+			if (Biohazard.isStarted() && _inBiohazard)
+				return;
+		}
+					
 		// Add karma to attacker and increase its PK counter
 		setKarma(getKarma() + newKarma);
 		if (target instanceof L2PcInstance
@@ -8459,6 +8526,17 @@
 		// Check if the attacker isn't the L2PcInstance Pet
 		if (attacker == this || attacker == getPet())
 			return false;
+			
+		// Biohazard
+		L2PcInstance player = null;
+		if (attacker instanceof L2PcInstance)
+			player = (L2PcInstance) attacker;
+		if (attacker instanceof L2SummonInstance)
+			player = ((L2SummonInstance) attacker).getOwner();
+ 		
+		if (player != null)
+			if (Biohazard.isStarted() && player.inBiohazard() && inBiohazard() && player.isZombie() != isZombie())
+				return true;
 		
 		// TODO: check for friendly mobs
 		// Check if the attacker is a L2MonsterInstance
@@ -8859,6 +8937,10 @@
 			return false;
 		}
 		
+		// Biohazard
+		if (skill.getId() == 619 && inBiohazard() && isZombie())
+			return false;
+		
 		//************************************* Check Skill Type *******************************************
 		
 		// Check if this is offensive magic skill
@@ -8869,6 +8951,25 @@
 				// If L2Character or target is in a peace zone, send a system message TARGET_IN_PEACEZONE a Server->Client packet ActionFailed
 				sendPacket(SystemMessage.getSystemMessage(SystemMessageId.TARGET_IN_PEACEZONE));
 				sendPacket(ActionFailed.STATIC_PACKET);
+				
+				// Biohazard
+				boolean cond = true;
+				L2PcInstance trgtF = null;
+				if (target instanceof L2PcInstance)
+					trgtF = (L2PcInstance)target;
+				else if (target instanceof L2SummonInstance)
+					trgtF = ((L2SummonInstance)target).getOwner();
+				if (trgtF != null)
+					if (Biohazard.isStarted() && trgtF.inBiohazard() && inBiohazard())
+					{
+						if (trgtF.isZombie() != isZombie())
+							cond = true;
+						if (trgtF.isZombie() == isZombie())
+							cond = false;
+					}
+		
+				if (!cond)
+				
 				return false;
 			}
 			
@@ -9294,6 +9395,9 @@
 			SkillDat skilldatpet = getCurrentPetSkill();
 			if(skill.isPvpSkill()) // pvp skill
 			{
+				// Biohazard
+				if (Biohazard.isStarted() && inBiohazard() && ((L2PcInstance)target).inBiohazard() && isZombie() != ((L2PcInstance)target).isZombie())
+					return true;
 				if(getClan() != null && ((L2PcInstance)target).getClan() != null)
 				{
 					if(getClan().isAtWarWith(((L2PcInstance)target).getClan().getClanId()) && ((L2PcInstance)target).getClan().isAtWarWith(getClan().getClanId()))
@@ -11778,6 +11882,15 @@
 			_log.log(Level.SEVERE, "deleteMe()", e);
 		}
 		
+		try
+		{
+			Biohazard.onLogout(this);
+		}
+		catch (Exception e)
+		{
+			_log.log(Level.SEVERE, "deleteMe()", e);
+		}
+		
 		// Update database with items in its inventory and remove them from the world
 		try
 		{
@@ -12985,6 +13098,11 @@
 	private int _eventEffectId = 0;
 	private boolean _isInSiege;
 	
+	// Biohazard
+	public int _oldX;
+	public int _oldY;
+	public int _oldZ;
+	
 	public Collection<TimeStamp> getReuseTimeStamps()
 	{
 		return _reuseTimeStamps.values();
Index: java/com/l2jserver/gameserver/GameServer.java
===================================================================
--- java/com/l2jserver/gameserver/GameServer.java	(revision 4767)
+++ java/com/l2jserver/gameserver/GameServer.java	(working copy)
@@ -119,6 +119,7 @@
 import com.l2jserver.gameserver.model.L2World;
 import com.l2jserver.gameserver.model.PartyMatchRoomList;
 import com.l2jserver.gameserver.model.PartyMatchWaitingList;
+import com.l2jserver.gameserver.model.entity.BiohazardManager;
 import com.l2jserver.gameserver.model.entity.Hero;
 import com.l2jserver.gameserver.model.entity.TvTManager;
 import com.l2jserver.gameserver.model.olympiad.Olympiad;
@@ -399,6 +400,7 @@
 		
 		_log.info("IdFactory: Free ObjectID's remaining: " + IdFactory.getInstance().size());
 		
+		BiohazardManager.getInstance();
 		TvTManager.getInstance();
 		KnownListUpdateTaskManager.getInstance();
 		
Index: java/com/l2jserver/gameserver/model/entity/BiohazardManager.java
===================================================================
--- java/com/l2jserver/gameserver/model/entity/BiohazardManager.java	(revision 0)
+++ java/com/l2jserver/gameserver/model/entity/BiohazardManager.java	(revision 0)
@@ -0,0 +1,146 @@
+/*
+ * 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.l2jserver.gameserver.model.entity;
+
+import java.util.Calendar;
+import java.util.concurrent.ScheduledFuture;
+import java.util.logging.Logger;
+
+import com.l2jserver.Config;
+import com.l2jserver.gameserver.model.entity.Biohazard;
+import com.l2jserver.gameserver.ThreadPoolManager;
+
+
+public class BiohazardManager
+{
+	protected static final Logger _log = Logger.getLogger(BiohazardManager.class.getName());
+		
+	/** Task for event cycles<br> */
+	private BiohazardStartTask _task;
+	
+	/**
+	 * New instance only by getInstance()<br>
+	 */
+	 private BiohazardManager()
+	 {
+		if (Config.BIOHAZARD_EVENT_ENABLED)
+		{
+			this.scheduleEventStart();
+			_log.info("[Biohazard] EventEngine: Engine started.");
+		}
+		else
+		{
+			_log.info("[Biohazard] EventEngine: Engine is disabled.");
+		}
+	}
+
+	public static BiohazardManager getInstance()
+	{
+		return SingletonHolder._instance;
+	}
+	
+	public void scheduleEventStart()
+	{
+		try
+		{
+			final Calendar currentTime = Calendar.getInstance();
+			Calendar nextStartTime = null;
+			Calendar testStartTime = null;
+			for (String timeOfDay : Config.BIOHAZARD_EVENT_INTERVAL)
+			{
+				// Creating a Calendar object from the specified interval value
+				testStartTime = Calendar.getInstance();
+				testStartTime.setLenient(true);
+				String[] splitTimeOfDay = timeOfDay.split(":");
+				testStartTime.set(Calendar.HOUR_OF_DAY, Integer.parseInt(splitTimeOfDay[0]));
+				testStartTime.set(Calendar.MINUTE, Integer.parseInt(splitTimeOfDay[1]));
+				// If the date is in the past, make it the next day (Example: Checking for "1:00", when the time is 23:57.)
+				if (testStartTime.getTimeInMillis() < currentTime.getTimeInMillis())
+					testStartTime.add(Calendar.DAY_OF_MONTH, 1);
+
+				// Check for the test date to be the minimum (smallest in the specified list)
+				if (nextStartTime == null || testStartTime.getTimeInMillis() < nextStartTime.getTimeInMillis())
+					nextStartTime = testStartTime;
+
+			}
+			_task = new BiohazardStartTask(nextStartTime.getTimeInMillis());
+			ThreadPoolManager.getInstance().executeTask(_task);
+		}
+		catch (Exception e)
+		{
+			_log.warning("BiohazardEventEngine[BiohazardManager.scheduleEventStart()]: Error figuring out a start time. Check BiohazardEventInterval in config file.");
+		}
+	}
+
+	public void startEvent()
+	{
+		Biohazard.startRegistering();
+		this.scheduleEventStart();
+
+	}
+
+	public void skipDelay()
+	{
+		if (_task.nextRun.cancel(false))
+		{
+			_task.setStartTime(System.currentTimeMillis());
+			ThreadPoolManager.getInstance().executeTask(_task);
+		}
+	}
+	
+	class BiohazardStartTask implements Runnable
+	{
+		private long _startTime;
+		public ScheduledFuture<?> nextRun;
+		
+		public BiohazardStartTask(long startTime)
+		{
+			_startTime = startTime;
+		}
+		
+		public void setStartTime(long startTime)
+		{
+			_startTime = startTime;
+		}
+		
+		public void run()
+		{
+			final int delay = (int) Math.round((_startTime - System.currentTimeMillis()) / 1000.0);
+			
+			// start
+			if(delay <= 0)
+			{				
+				if (Biohazard.isInactive())
+					startEvent();
+				return;
+			}
+			
+			int nextMsg = 0;
+			if (delay > 0)
+			{
+				nextMsg = delay;
+			}
+
+			nextRun = ThreadPoolManager.getInstance().scheduleGeneral(this, nextMsg * 1000);
+
+		}
+	}
+
+	@SuppressWarnings("synthetic-access")
+	private static class SingletonHolder
+	{
+		protected static final BiohazardManager _instance = new BiohazardManager();
+	}
+}
\ No newline at end of file
#P L2J_DataPack
Index: data/scripts/handlers/usercommandhandlers/Escape.java
===================================================================
--- data/scripts/handlers/usercommandhandlers/Escape.java	(revision 8221)
+++ data/scripts/handlers/usercommandhandlers/Escape.java	(working copy)
@@ -57,6 +57,13 @@
 			return false;
 		}
 		
+		// Biohazard
+		if (activeChar.isinBiohazard())
+		{
+			activeChar.sendPacket(ActionFailed.STATIC_PACKET);
+			return false;
+		}
+		
 		
 		int unstuckTimer = (activeChar.getAccessLevel().isGm() ? 1000 : Config.UNSTUCK_INTERVAL * 1000);
 		
Index: data/scripts/handlers/MasterHandler.java
===================================================================
--- data/scripts/handlers/MasterHandler.java	(revision 8221)
+++ data/scripts/handlers/MasterHandler.java	(working copy)
@@ -244,6 +244,7 @@
 import handlers.usercommandhandlers.PartyInfo;
 import handlers.usercommandhandlers.Time;
 import handlers.voicedcommandhandlers.Banking;
+import handlers.voicedcommandhandlers.biohazard;
 import handlers.voicedcommandhandlers.ChatAdmin;
 import handlers.voicedcommandhandlers.Debug;
 import handlers.voicedcommandhandlers.Lang;
@@ -550,6 +551,7 @@
 	
 	private static void loadVoicedHandlers()
 	{
+		VOICE.registerVoicedCommandHandler(new biohazard());
 		VOICE.registerVoicedCommandHandler(new stats());
 		if (Config.L2JMOD_ALLOW_WEDDING)
 			VOICE.registerVoicedCommandHandler(new Wedding());
Index: data/scripts/handlers/voicedcommandhandlers/biohazard.java
===================================================================
--- data/scripts/handlers/voicedcommandhandlers/biohazard.java	(revision 0)
+++ data/scripts/handlers/voicedcommandhandlers/biohazard.java	(revision 0)
@@ -0,0 +1,38 @@
+/*
+ * 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 handlers.voicedcommandhandlers;
+
+import com.l2jserver.gameserver.handler.IVoicedCommandHandler;
+import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
+import com.l2jserver.gameserver.model.entity.Biohazard;
+
+public class biohazard implements IVoicedCommandHandler
+{
+	private static final String[] VOICED_COMMANDS = { "bhreg", "bhunreg" };
+	
+	public boolean useVoicedCommand(String command, L2PcInstance activeChar, String params)
+	{
+		if (command.equalsIgnoreCase("bhreg"))
+			Biohazard.addParticipant(activeChar);
+		else if (command.equalsIgnoreCase("bhunreg"))
+			Biohazard.removeParticipant(activeChar);
+		return true;
+	}
+	
+	public String[] getVoicedCommandList()
+	{
+		return VOICED_COMMANDS;
+	}
+}
\ No newline at end of file