/*
* 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 2, 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
* 02111-1307, USA.
*
* http://www.gnu.org/copyleft/gpl.html
*/
package net.sf.l2j.gameserver;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.ScheduledFuture;
import java.util.logging.Logger;
import javolution.util.FastList;
import net.sf.l2j.gameserver.ai.CtrlEvent;
import net.sf.l2j.gameserver.instancemanager.DayNightSpawnManager;
import net.sf.l2j.gameserver.model.L2Character;
import java.util.concurrent.locks.*;
/**
* This class ...
*
* @version $Revision: 1.1.4.8 $ $Date: 2005/04/06 16:13:24 $
*/
public class GameTimeController
{
static final Logger _log = Logger.getLogger(GameTimeController.class.getName());
public static final int TICKS_PER_SECOND = 10;
public static final int MILLIS_IN_TICK = 1000 / TICKS_PER_SECOND;
private static GameTimeController _instance = new GameTimeController();
protected static int _gameTicks;
protected static long _gameStartTime;
protected static boolean _isNight = false;
private static FastList<L2Character> _movingObjects = new FastList<L2Character>();
protected static TimerThread _timer;
protected static MoveObjectsThread _mover;
private ScheduledFuture _timerWatcher;
public final Lock lock = new ReentrantLock();
public final Condition tickCondition = lock.newCondition();
/**
* one ingame day is 240 real minutes
*/
public static GameTimeController getInstance()
{
return _instance;
}
private GameTimeController()
{
_gameStartTime = System.currentTimeMillis() - 3600000; // offset so that the server starts a day begin
_gameTicks = 3600000 / MILLIS_IN_TICK; // offset so that the server starts a day begin
_timer = new TimerThread();
_timer.start();
_mover = new MoveObjectsThread(_movingObjects);
_mover.start();
_timerWatcher = ThreadPoolManager.getInstance().scheduleGeneralAtFixedRate(new TimerWatcher(), 0, 1000);
ThreadPoolManager.getInstance().scheduleGeneralAtFixedRate(new BroadcastSunState(), 0, 600000);
}
public boolean isNowNight()
{
return _isNight;
}
public int getGameTime()
{
return (_gameTicks / (TICKS_PER_SECOND * 10));
}
public static int getGameTicks()
{
return _gameTicks;
}
/**
* Add a L2Character to movingObjects of GameTimeController.<BR><BR>
*
* <B><U> Concept</U> :</B><BR><BR>
* All L2Character in movement are identified in <B>movingObjects</B> of GameTimeController.<BR><BR>
*
* @param cha The L2Character to add to movingObjects of GameTimeController
*
*/
public void registerMovingObject(L2Character cha)
{
if(cha == null) return;
synchronized(_movingObjects) {
if (!_movingObjects.contains(cha)) _movingObjects.add(cha);
}
}
/**
* Move all L2Characters contained in movingObjects of GameTimeController.<BR><BR>
*
* <B><U> Concept</U> :</B><BR><BR>
* All L2Character in movement are identified in <B>movingObjects</B> of GameTimeController.<BR><BR>
*
* <B><U> Actions</U> :</B><BR><BR>
* <li>Update the position of each L2Character </li>
* <li>If movement is finished, the L2Character is removed from movingObjects </li>
* <li>Create a task to update the _knownObject and _knowPlayers of each L2Character that finished its movement and of their already known L2Object then notify AI with EVT_ARRIVED </li><BR><BR>
*
*/
class MoveObjectsThread extends Thread {
private final FastList<L2Character> chars;
private int oldticks;
public MoveObjectsThread(FastList<L2Character> _chars)
{
chars = _chars;
}
public void run()
{
L2Character cha;
for (;;) {
lock.lock();
try
{
while (oldticks == _gameTicks || chars.isEmpty())
{
if (oldticks != _gameTicks) oldticks = _gameTicks;
tickCondition.await();
}
} catch (InterruptedException e) { return; }
finally {lock.unlock();}
for (FastList.Node<L2Character> e = chars.head(), end = chars.tail(); e!=end; e = e.getNext())
{
cha = e.getValue();
if (cha.updatePosition(_gameTicks))
{
synchronized (chars) { chars.remove(cha); }
ThreadPoolManager.getInstance().executeTask(new MovingObjectArrived(cha));
}
}
oldticks = _gameTicks;
}
}
}
public void stopTimer()
{
_timerWatcher.cancel(true);
_timer.interrupt();
_mover.interrupt();
}
class TimerThread extends Thread
{
protected Exception _error;
public TimerThread()
{
super("GameTimeController");
setDaemon(true);
setPriority(MAX_PRIORITY);
_error = null;
}
@Override
public void run()
{
try
{
for (;;)
{
lock.lock();
int _oldTicks=_gameTicks; // save old ticks value to avoid moving objects 2x in same tick
long runtime = System.currentTimeMillis() - _gameStartTime; // from server boot to now
_gameTicks = (int) (runtime / MILLIS_IN_TICK); // new ticks value (ticks now)
if (_oldTicks != _gameTicks) tickCondition.signalAll();
runtime = (System.currentTimeMillis() - _gameStartTime) - runtime;
// calculate sleep time... time needed to next tick minus time it takes to call moveObjects()
int sleepTime = 1 + MILLIS_IN_TICK - ((int) runtime) % MILLIS_IN_TICK;
lock.unlock();
sleep(sleepTime);
}
}
catch (Exception e)
{
lock.unlock();
_error = e;
}
}
}
class TimerWatcher implements Runnable
{
public void run()
{
if (!_timer.isAlive())
{
String time = (new SimpleDateFormat("HH:mm:ss")).format(new Date());
_log.warning(time + " TimerThread stop with following error. restart it.");
if (_timer._error != null) _timer._error.printStackTrace();
_timer = new TimerThread();
_timer.start();
}
}
}
/**
* Update the _knownObject and _knowPlayers of each L2Character that finished its movement and of their already known L2Object then notify AI with EVT_ARRIVED.<BR><BR>
*/
class MovingObjectArrived implements Runnable
{
private final L2Character _ended;
MovingObjectArrived(L2Character ended)
{
_ended = ended;
}
public void run()
{
_ended.getKnownList().updateKnownObjects();
if (_ended.hasAI())
_ended.getAI().notifyEvent(CtrlEvent.EVT_ARRIVED);
}
}
/**
* @param rise
*/
class BroadcastSunState implements Runnable
{
public void run()
{
int h = (getGameTime() / 60) % 24; // Time in hour
boolean tempIsNight = (h < 6);
if (tempIsNight != _isNight) { // If diff day/night state
_isNight = tempIsNight; // Set current day/night varible to value of temp varible
DayNightSpawnManager.getInstance().notifyChangeMode();
}
}
}
}