Raidboss spawn


1. 

   Atsijungęs

   Jeppi

   Pranešimai: 0

   Sveiki, gal kas zino kur cia beda, jog raidboss resspawn_time nepakeicia i 0? Uzmusus rb i duom baze suvedami visi teisingi respawn time skaiciai, kai rb atsispauwnina skaiciai nedingsta lieka tie patys, o turetu but 0.

   
   
   
   package com.l2jfrozen.gameserver.managers;
   
   /**
    @author godson
    **/
   
   import java.sql.Connection;
   import java.sql.PreparedStatement;
   import java.sql.ResultSet;
   import java.sql.SQLException;
   import java.util.Calendar;
   import java.util.Map;
   import java.util.concurrent.ScheduledFuture;
   import java.util.logging.Logger;
   
   import javolution.util.FastMap;
   
   import com.l2jfrozen.Config;
   import com.l2jfrozen.gameserver.datatables.GmListTable;
   import com.l2jfrozen.gameserver.datatables.sql.NpcTable;
   import com.l2jfrozen.gameserver.datatables.sql.SpawnTable;
   import com.l2jfrozen.gameserver.model.actor.instance.L2RaidBossInstance;
   import com.l2jfrozen.gameserver.model.entity.Announcements;
   import com.l2jfrozen.gameserver.model.spawn.L2Spawn;
   import com.l2jfrozen.gameserver.templates.L2NpcTemplate;
   import com.l2jfrozen.gameserver.templates.StatsSet;
   import com.l2jfrozen.gameserver.thread.ThreadPoolManager;
   import com.l2jfrozen.util.CloseUtil;
   import com.l2jfrozen.util.database.L2DatabaseFactory;
   import com.l2jfrozen.util.random.Rnd;
   
   public class RaidBossSpawnManager
   {
   
   	private static Logger _log = Logger.getLogger(RaidBossSpawnManager.class.getName());
   
   	private static RaidBossSpawnManager _instance;
   	protected static Map<Integer, L2RaidBossInstance> _bosses;
   	protected static Map<Integer, L2Spawn> _spawns;
   	protected static Map<Integer, StatsSet> _storedInfo;
   	protected static Map<Integer, ScheduledFuture<?>> _schedules;
   
   	public static enum StatusEnum
   	{
   		ALIVE,
   		DEAD,
   		UNDEFINED
   	}
   
   	public RaidBossSpawnManager()
   	{
   		init();
   	}
   
   	public static RaidBossSpawnManager getInstance()
   	{
   		if(_instance == null)
   		{
   			_instance = new RaidBossSpawnManager();
   		}
   
   		return _instance;
   	}
   
   	private void init()
   	{
   		_bosses = new FastMap<Integer, L2RaidBossInstance>();
   		_schedules = new FastMap<Integer, ScheduledFuture<?>>();
   		_storedInfo = new FastMap<Integer, StatsSet>();
   		_spawns = new FastMap<Integer, L2Spawn>();
   
   		Connection con = null;
   
   		try
   		{
   			con = L2DatabaseFactory.getInstance().getConnection(false);
   
   			PreparedStatement statement = con.prepareStatement("SELECT * from raidboss_spawnlist ORDER BY boss_id");
   			ResultSet rset = statement.executeQuery();
   
   			L2Spawn spawnDat;
   			L2NpcTemplate template;
   			long respawnTime;
   			while(rset.next())
   			{
   				template = getValidTemplate(rset.getInt("boss_id"));
   				if(template != null)
   				{
   					spawnDat = new L2Spawn(template);
   					spawnDat.setLocx(rset.getInt("loc_x"));
   					spawnDat.setLocy(rset.getInt("loc_y"));
   					spawnDat.setLocz(rset.getInt("loc_z"));
   					spawnDat.setAmount(rset.getInt("amount"));
   					spawnDat.setHeading(rset.getInt("heading"));
   					spawnDat.setRespawnMinDelay(rset.getInt("respawn_min_delay"));
   					spawnDat.setRespawnMaxDelay(rset.getInt("respawn_max_delay"));
   					respawnTime = rset.getLong("respawn_time");
   
   					StatsSet info = new StatsSet();
   					info.set("respawnTime", respawnTime);
   					_storedInfo.put(rset.getInt("boss_id"), info);
   					
   					addNewSpawn(spawnDat, respawnTime, rset.getDouble("currentHP"), rset.getDouble("currentMP"), false);
   
   					spawnDat = null;
   					template = null;
   				}
   				else
   				{
   					_log.warning("RaidBossSpawnManager: Could not load raidboss #" + rset.getInt("boss_id") + " from DB");
   				}
   			}
   
   			_log.info("RaidBossSpawnManager: Loaded " + _bosses.size() + " Instances");
   			_log.info("RaidBossSpawnManager: Scheduled " + _schedules.size() + " Instances");
   
   			rset.close();
   			statement.close();
   			statement = null;
   			rset = null;
   		}
   		catch(SQLException e)
   		{
   			if(Config.ENABLE_ALL_EXCEPTIONS)
   				e.printStackTrace();
   			
   			_log.warning("RaidBossSpawnManager: Couldnt load raidboss_spawnlist table");
   		}
   		catch(Exception e)
   		{
   			e.printStackTrace();
   		}
   		finally
   		{
   			CloseUtil.close(con);
   			con = null;
   		}
   	}
   
   	private class spawnSchedule implements Runnable
   	{
   		private int bossId;
   
   		public spawnSchedule(int npcId)
   		{
   			bossId = npcId;
   		}
   
   		@Override
   		public void run()
   		{
   			L2RaidBossInstance raidboss = null;
   
   			if(bossId == 25328)
   			{
   				raidboss = DayNightSpawnManager.getInstance().handleBoss(_spawns.get(bossId));
   			}
   			else
   			{
   				raidboss = (L2RaidBossInstance) _spawns.get(bossId).doSpawn();
   			}
   
   			if(raidboss != null)
   			{
   				raidboss.setRaidStatus(StatusEnum.ALIVE);
   
   				StatsSet info = new StatsSet();
   				info.set("currentHP", raidboss.getCurrentHp());
   				info.set("currentMP", raidboss.getCurrentMp());
   				info.set("respawnTime", 0L);
   
   				_storedInfo.put(bossId, info);
   				info = null;
   
   				GmListTable.broadcastMessageToGMs("Spawning Raid Boss " + raidboss.getName());
   				if(Config.ANNOUNCE_TO_ALL_SPAWN_RB)
   				{
   					Announcements.getInstance().announceToAll("Raid boss " + raidboss.getName() + " spawned in world.");
   				}
   				_bosses.put(bossId, raidboss);
   			}
   
   			_schedules.remove(bossId);
   		}
   	}
   
   	public void updateStatus(L2RaidBossInstance boss, boolean isBossDead)
   	{
   		if(!_storedInfo.containsKey(boss.getNpcId()))
   			return;
   
   		StatsSet info = _storedInfo.get(boss.getNpcId());
   
   		if(isBossDead)
   		{
   			boss.setRaidStatus(StatusEnum.DEAD);
   
   			long respawnTime;
   			int RespawnMinDelay = boss.getSpawn().getRespawnMinDelay();
   			int RespawnMaxDelay = boss.getSpawn().getRespawnMaxDelay();
   			long respawn_delay = Rnd.get((int) (RespawnMinDelay * 1000 * Config.RAID_MIN_RESPAWN_MULTIPLIER), (int) (RespawnMaxDelay * 1000 * Config.RAID_MAX_RESPAWN_MULTIPLIER));
   			respawnTime = Calendar.getInstance().getTimeInMillis() + respawn_delay;
   
   			info.set("currentHP", boss.getMaxHp());
   			info.set("currentMP", boss.getMaxMp());
   			info.set("respawnTime", respawnTime);
   
   			_log.info("RaidBossSpawnManager: Updated " + boss.getName() + " respawn time to " + respawnTime);
   
   			ScheduledFuture<?> futureSpawn;
   			futureSpawn = ThreadPoolManager.getInstance().scheduleGeneral(new spawnSchedule(boss.getNpcId()), respawn_delay);
   
   			_schedules.put(boss.getNpcId(), futureSpawn);
   			futureSpawn = null;
   			if(Config.SAVE_RAIDBOSS_STATUS_INTO_DB)
   			{
   				updateDb();
   			}
   		}
   		else
   		{
   			boss.setRaidStatus(StatusEnum.ALIVE);
   
   			info.set("currentHP", boss.getCurrentHp());
   			info.set("currentMP", boss.getCurrentMp());
   			info.set("respawnTime", 0L);
   		}
   
   		_storedInfo.remove(boss.getNpcId());
   		_storedInfo.put(boss.getNpcId(), info);
   
   		info = null;
   	}
   
   	public void addNewSpawn(L2Spawn spawnDat, long respawnTime, double currentHP, double currentMP, boolean storeInDb)
   	{
   		if(spawnDat == null)
   			return;
   
   		if(_spawns.containsKey(spawnDat.getNpcid()))
   			return;
   
   		int bossId = spawnDat.getNpcid();
   		long time = Calendar.getInstance().getTimeInMillis();
   
   		SpawnTable.getInstance().addNewSpawn(spawnDat, false);
   
   		if(respawnTime == 0L || time > respawnTime)
   		{
   			L2RaidBossInstance raidboss = null;
   
   			if(bossId == 25328)
   			{
   				raidboss = DayNightSpawnManager.getInstance().handleBoss(spawnDat);
   			}
   			else
   			{
   				raidboss = (L2RaidBossInstance) spawnDat.doSpawn();
   			}
   
   			if(raidboss != null)
   			{
   				raidboss.setCurrentHp(currentHP);
   				raidboss.setCurrentMp(currentMP);
   				raidboss.setRaidStatus(StatusEnum.ALIVE);
   
   				_bosses.put(bossId, raidboss);
   
   				StatsSet info = new StatsSet();
   				info.set("currentHP", currentHP);
   				info.set("currentMP", currentMP);
   				info.set("respawnTime", 0L);
   
   				_storedInfo.put(bossId, info);
   
   				raidboss = null;
   			}
   		}
   		else
   		{
   			ScheduledFuture<?> futureSpawn;
   			long spawnTime = respawnTime - Calendar.getInstance().getTimeInMillis();
   
   			futureSpawn = ThreadPoolManager.getInstance().scheduleGeneral(new spawnSchedule(bossId), spawnTime);
   
   			_schedules.put(bossId, futureSpawn);
   
   			futureSpawn = null;
   		}
   
   		_spawns.put(bossId, spawnDat);
   
   		if(storeInDb)
   		{
   			Connection con = null;
   
   			try
   			{
   				con = L2DatabaseFactory.getInstance().getConnection(false);
   				PreparedStatement statement = con.prepareStatement("INSERT INTO raidboss_spawnlist (boss_id,amount,loc_x,loc_y,loc_z,heading,respawn_time,currentHp,currentMp) values(?,?,?,?,?,?,?,?,?)");
   				statement.setInt(1, spawnDat.getNpcid());
   				statement.setInt(2, spawnDat.getAmount());
   				statement.setInt(3, spawnDat.getLocx());
   				statement.setInt(4, spawnDat.getLocy());
   				statement.setInt(5, spawnDat.getLocz());
   				statement.setInt(6, spawnDat.getHeading());
   				statement.setLong(7, respawnTime);
   				statement.setDouble(8, currentHP);
   				statement.setDouble(9, currentMP);
   				statement.execute();
   				statement.close();
   				statement = null;
   			}
   			catch(Exception e)
   			{
   				if(Config.ENABLE_ALL_EXCEPTIONS)
   					e.printStackTrace();
   				
   				// problem with storing spawn
   				_log.warning("RaidBossSpawnManager: Could not store raidboss #" + bossId + " in the DB:" + e);
   			}
   			finally
   			{
   				CloseUtil.close(con);
   				con = null;
   			}
   		}
   	}
   
   	public void deleteSpawn(L2Spawn spawnDat, boolean updateDb)
   	{
   		if(spawnDat == null)
   			return;
   
   		if(!_spawns.containsKey(spawnDat.getNpcid()))
   			return;
   
   		int bossId = spawnDat.getNpcid();
   
   		SpawnTable.getInstance().deleteSpawn(spawnDat, false);
   		_spawns.remove(bossId);
   
   		if(_bosses.containsKey(bossId))
   		{
   			_bosses.remove(bossId);
   		}
   
   		if(_schedules.containsKey(bossId))
   		{
   			ScheduledFuture<?> f = _schedules.get(bossId);
   			f.cancel(true);
   			_schedules.remove(bossId);
   		}
   
   		if(_storedInfo.containsKey(bossId))
   		{
   			_storedInfo.remove(bossId);
   		}
   
   		if(updateDb)
   		{
   			Connection con = null;
   
   			try
   			{
   				con = L2DatabaseFactory.getInstance().getConnection(false);
   				PreparedStatement statement = con.prepareStatement("DELETE FROM raidboss_spawnlist WHERE boss_id=?");
   				statement.setInt(1, bossId);
   				statement.execute();
   				statement.close();
   				statement = null;
   			}
   			catch(Exception e)
   			{
   				if(Config.ENABLE_ALL_EXCEPTIONS)
   					e.printStackTrace();
   				
   				// problem with deleting spawn
   				_log.warning("RaidBossSpawnManager: Could not remove raidboss #" + bossId + " from DB: " + e);
   			}
   			finally
   			{
   				CloseUtil.close(con);
   				con = null;
   			}
   		}
   	}
   
   	private void updateDb()
   	{
   		for(Integer bossId : _storedInfo.keySet())
   		{
   			Connection con = null;
   
   			try
   			{
   				con = L2DatabaseFactory.getInstance().getConnection(false);
   
   				L2RaidBossInstance boss = _bosses.get(bossId);
   				if(boss != null)
   				{
   					if(boss.getRaidStatus().equals(StatusEnum.ALIVE))
   					{
   						updateStatus(boss, false);
   					}
   
   					boss = null;
   
   					StatsSet info = _storedInfo.get(bossId);
   					if(info != null)
   					{
   						PreparedStatement statement = con.prepareStatement("UPDATE raidboss_spawnlist set respawn_time = ?, currentHP = ?, currentMP = ? where boss_id = ?");
   						statement.setLong(1, info.getLong("respawnTime"));
   						statement.setDouble(2, info.getDouble("currentHP"));
   						statement.setDouble(3, info.getDouble("currentMP"));
   						statement.setInt(4, bossId);
   						statement.execute();
   
   						statement.close();
   						statement = null;
   						info = null;
   					}
   
   				}
   			}
   			catch(SQLException e)
   			{
   				if(Config.ENABLE_ALL_EXCEPTIONS)
   					e.printStackTrace();
   				
   				_log.warning("RaidBossSpawnManager: Couldnt update raidboss_spawnlist table");
   			}
   			finally
   			{
   				CloseUtil.close(con);
   				con = null;
   			}
   		}
   	}
   
   	public String[] getAllRaidBossStatus()
   	{
   		String[] msg = new String[_bosses == null ? 0 : _bosses.size()];
   
   		if(_bosses == null)
   		{
   			msg[0] = "None";
   			return msg;
   		}
   
   		int index = 0;
   
   		for(int i : _bosses.keySet())
   		{
   			L2RaidBossInstance boss = _bosses.get(i);
   
   			msg[index] = boss.getName() + ": " + boss.getRaidStatus().name();
   			index++;
   
   			boss = null;
   		}
   
   		return msg;
   	}
   
   	public String getRaidBossStatus(int bossId)
   	{
   		String msg = "RaidBoss Status....\n";
   
   		if(_bosses == null)
   		{
   			msg += "None";
   			return msg;
   		}
   
   		if(_bosses.containsKey(bossId))
   		{
   			L2RaidBossInstance boss = _bosses.get(bossId);
   
   			msg += boss.getName() + ": " + boss.getRaidStatus().name();
   		}
   
   		return msg;
   	}
   
   	public StatusEnum getRaidBossStatusId(int bossId)
   	{
   		if(_bosses.containsKey(bossId))
   			return _bosses.get(bossId).getRaidStatus();
   		else if(_schedules.containsKey(bossId))
   			return StatusEnum.DEAD;
   		else
   			return StatusEnum.UNDEFINED;
   	}
   
   	public L2NpcTemplate getValidTemplate(int bossId)
   	{
   		L2NpcTemplate template = NpcTable.getInstance().getTemplate(bossId);
   		if(template == null)
   			return null;
   
   		if(!template.type.equalsIgnoreCase("L2RaidBoss"))
   			return null;
   
   		return template;
   	}
   
   	public void notifySpawnNightBoss(L2RaidBossInstance raidboss)
   	{
   		StatsSet info = new StatsSet();
   		info.set("currentHP", raidboss.getCurrentHp());
   		info.set("currentMP", raidboss.getCurrentMp());
   		info.set("respawnTime", 0L);
   
   		raidboss.setRaidStatus(StatusEnum.ALIVE);
   
   		_storedInfo.put(raidboss.getNpcId(), info);
   
   		info = null;
   
   		GmListTable.broadcastMessageToGMs("Spawning Raid Boss " + raidboss.getName());
   
   		_bosses.put(raidboss.getNpcId(), raidboss);
   	}
   
   	public boolean isDefined(int bossId)
   	{
   		return _spawns.containsKey(bossId);
   	}
   
   	public Map<Integer, L2RaidBossInstance> getBosses()
   	{
   		return _bosses;
   	}
   
   	public Map<Integer, L2Spawn> getSpawns()
   	{
   		return _spawns;
   	}
   
   	public void reloadBosses()
   	{
   		init();
   	}
   
   	/**
   	 * Saves all raidboss status and then clears all info from memory, including all schedules.
   	 */
   
   	public void cleanUp()
   	{
   		updateDb();
   
   		_bosses.clear();
   
   		if(_schedules != null)
   		{
   			for(Integer bossId : _schedules.keySet())
   			{
   				ScheduledFuture<?> f = _schedules.get(bossId);
   				f.cancel(true);
   			}
   		}
   
   		_schedules.clear();
   		_storedInfo.clear();
   		_spawns.clear();
   	}
   	
   	public StatsSet getStatsSet(int bossId)
   	{
   		return _storedInfo.get(bossId);
   	}
   	
   	public L2RaidBossInstance getBoss(int bossId){
   		return _bosses.get(bossId);
   	}
   }
   
   
   
   
   27 Gruodžio 2013 - 22:40 / #1