removed 'application' folder to have everything in the root directory

core/Callbacks/CallbackListener.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace ManiaControl\Callbacks;
+
+/**
+ * Interface for Callback Listener
+ *
+ * @author    ManiaControl Team <mail@maniacontrol.com>
+ * @copyright 2014 ManiaControl Team
+ * @license   http://www.gnu.org/licenses/ GNU General Public License, Version 3
+ */
+interface CallbackListener {
+}

core/Callbacks/CallbackManager.php

@@ -0,0 +1,319 @@
+<?php
+
+namespace ManiaControl\Callbacks;
+
+use ManiaControl\Callbacks\Models\BaseCallback;
+use ManiaControl\ManiaControl;
+
+/**
+ * Class for managing Server and ManiaControl Callbacks
+ *
+ * @author    ManiaControl Team <mail@maniacontrol.com>
+ * @copyright 2014 ManiaControl Team
+ * @license   http://www.gnu.org/licenses/ GNU General Public License, Version 3
+ */
+class CallbackManager {
+	/*
+	 * Constants
+	 */
+	// ManiaPlanet callbacks
+	const CB_MP_SERVERSTART               = 'ManiaPlanet.ServerStart';
+	const CB_MP_SERVERSTOP                = 'ManiaPlanet.ServerStop';
+	const CB_MP_BEGINMATCH                = 'ManiaPlanet.BeginMatch';
+	const CB_MP_ENDMATCH                  = 'ManiaPlanet.EndMatch';
+	const CB_MP_BEGINMAP                  = 'ManiaPlanet.BeginMap';
+	const CB_MP_ENDMAP                    = 'ManiaPlanet.EndMap';
+	const CB_MP_MAPLISTMODIFIED           = 'ManiaPlanet.MapListModified';
+	const CB_MP_ECHO                      = 'ManiaPlanet.Echo';
+	const CB_MP_BILLUPDATED               = 'ManiaPlanet.BillUpdated';
+	const CB_MP_PLAYERCHAT                = 'ManiaPlanet.PlayerChat';
+	const CB_MP_PLAYERCONNECT             = 'ManiaPlanet.PlayerConnect';
+	const CB_MP_PLAYERDISCONNECT          = 'ManiaPlanet.PlayerDisconnect';
+	const CB_MP_PLAYERMANIALINKPAGEANSWER = 'ManiaPlanet.PlayerManialinkPageAnswer';
+	const CB_MP_PLAYERINFOCHANGED         = 'ManiaPlanet.PlayerInfoChanged';
+	const CB_MP_PLAYERALLIESCHANGED       = 'ManiaPlanet.PlayerAlliesChanged';
+	const CB_MP_VOTEUPDATED               = 'ManiaPlanet.VoteUpdated';
+	const CB_MP_STATUSCHANGED             = 'ManiaPlanet.StatusChanged';
+	const CB_MP_MODESCRIPTCALLBACK        = 'ManiaPlanet.ModeScriptCallback';
+	const CB_MP_MODESCRIPTCALLBACKARRAY   = 'ManiaPlanet.ModeScriptCallbackArray';
+	const CB_MP_TUNNELDATARECEIVED        = 'ManiaPlanet.TunnelDataReceived';
+
+	// TrackMania callbacks
+	const CB_TM_PLAYERCHECKPOINT  = 'TrackMania.PlayerCheckpoint';
+	const CB_TM_PLAYERFINISH      = 'TrackMania.PlayerFinish';
+	const CB_TM_PLAYERINCOHERENCE = 'TrackMania.PlayerIncoherence';
+
+	/*
+	 * Public properties
+	 */
+	public $libXmlRpcCallbacks = null;
+	public $shootManiaCallbacks = null;
+	public $trackManiaCallbacks = null;
+
+	/*
+	 * Private properties
+	 */
+	/** @var ManiaControl $maniaControl */
+	private $maniaControl = null;
+	/** @var Listening[][] $callbackListenings */
+	private $callbackListenings = array();
+	/** @var Listening[][] $scriptCallbackListenings */
+	private $scriptCallbackListenings = array();
+
+	/**
+	 * Construct a new callbacks manager instance
+	 *
+	 * @param ManiaControl $maniaControl
+	 */
+	public function __construct(ManiaControl $maniaControl) {
+		$this->maniaControl = $maniaControl;
+
+		$this->libXmlRpcCallbacks  = new LibXmlRpcCallbacks($maniaControl, $this);
+		$this->shootManiaCallbacks = new ShootManiaCallbacks($maniaControl, $this);
+		$this->trackManiaCallbacks = new TrackManiaCallbacks($maniaControl, $this);
+	}
+
+	/**
+	 * Register a new Callback Listener
+	 *
+	 * @param string           $callbackName
+	 * @param CallbackListener $listener
+	 * @param string           $method
+	 * @return bool
+	 */
+	public function registerCallbackListener($callbackName, CallbackListener $listener, $method) {
+		if (is_array($callbackName)) {
+			$success = false;
+			foreach ($callbackName as $callback) {
+				if ($this->registerCallbackListener($callback, $listener, $method)) {
+					$success = true;
+				}
+			}
+			return $success;
+		}
+
+		if (!Listening::checkValidCallback($listener, $method)) {
+			$listenerClass = get_class($listener);
+			trigger_error("Given Listener '{$listenerClass}' can't handle Callback '{$callbackName}': No callable Method '{$method}'!");
+			return false;
+		}
+
+		if (!array_key_exists($callbackName, $this->callbackListenings)) {
+			$this->callbackListenings[$callbackName] = array();
+		}
+
+		$listening = new Listening($listener, $method);
+		array_push($this->callbackListenings[$callbackName], $listening);
+
+		return true;
+	}
+
+	/**
+	 * Register a new Script Callback Listener
+	 *
+	 * @param string           $callbackName
+	 * @param CallbackListener $listener
+	 * @param string           $method
+	 * @return bool
+	 */
+	public function registerScriptCallbackListener($callbackName, CallbackListener $listener, $method) {
+		if (is_array($callbackName)) {
+			$success = false;
+			foreach ($callbackName as $callback) {
+				if ($this->registerScriptCallbackListener($callback, $listener, $method)) {
+					$success = true;
+				}
+			}
+			return $success;
+		}
+
+		if (!Listening::checkValidCallback($listener, $method)) {
+			$listenerClass = get_class($listener);
+			trigger_error("Given Listener '{$listenerClass}' can't handle Script Callback '{$callbackName}': No callable Method '{$method}'!");
+			return false;
+		}
+
+		if (!array_key_exists($callbackName, $this->scriptCallbackListenings)) {
+			$this->scriptCallbackListenings[$callbackName] = array();
+		}
+
+		$listening = new Listening($listener, $method);
+		array_push($this->scriptCallbackListenings[$callbackName], $listening);
+
+		return true;
+	}
+
+	/**
+	 * Unregister a Callback Listener
+	 *
+	 * @param CallbackListener $listener
+	 * @return bool
+	 */
+	public function unregisterCallbackListener(CallbackListener $listener) {
+		return $this->removeCallbackListener($this->callbackListenings, $listener);
+	}
+
+	//TODO better name (used only in customvotesPlugin)
+
+	/**
+	 * Remove the Callback Listener from the given Listeners Array
+	 *
+	 * @param Listening[]      $listeningsArray
+	 * @param CallbackListener $listener
+	 * @return bool
+	 */
+	private function removeCallbackListener(array &$listeningsArray, CallbackListener $listener) {
+		$removed = false;
+		foreach ($listeningsArray as &$listenings) {
+			foreach ($listenings as $key => &$listening) {
+				if ($listening->listener === $listener) {
+					unset($listenings[$key]);
+					$removed = true;
+				}
+			}
+		}
+		return $removed;
+	}
+
+	/**
+	 * Unregister a single Callback Listening from an Callback Listener
+	 *
+	 * @param String           $callbackName
+	 * @param CallbackListener $listener
+	 * @return bool
+	 */
+	public function unregisterCallbackListening($callbackName, CallbackListener $listener) {
+		$removed = false;
+		foreach ($this->callbackListenings as &$listenings) {
+			foreach ($listenings as $key => &$listening) {
+				if ($key === $callbackName && $listening->listener === $listener) {
+					unset($listenings[$key]);
+					$removed = true;
+				}
+			}
+		}
+		return $removed;
+	}
+
+	/**
+	 * Unregister a Script Callback Listener
+	 *
+	 * @param CallbackListener $listener
+	 * @return bool
+	 */
+	public function unregisterScriptCallbackListener(CallbackListener $listener) {
+		return $this->removeCallbackListener($this->scriptCallbackListenings, $listener);
+	}
+
+	/**
+	 * Trigger internal Callbacks and manage Server Callbacks
+	 */
+	public function manageCallbacks() {
+		// Manage Timings
+		$this->maniaControl->getTimerManager()->manageTimings();
+
+		// Server Callbacks
+		if (!$this->maniaControl->getClient()) {
+			return;
+		}
+
+		// Handle callbacks
+		$callbacks = $this->maniaControl->getClient()->executeCallbacks();
+		foreach ($callbacks as $callback) {
+			$this->handleCallback($callback);
+		}
+	}
+
+	/**
+	 * Handle the given Callback
+	 *
+	 * @param array $callback
+	 */
+	private function handleCallback(array $callback) {
+		$callbackName = $callback[0];
+		switch ($callbackName) {
+			case self::CB_MP_BEGINMATCH:
+				$this->triggerCallback($callbackName, $callback);
+				break;
+			case self::CB_MP_BEGINMAP:
+				$this->maniaControl->getMapManager()->handleBeginMap($callback);
+				$this->triggerCallback($callbackName, $callback);
+				break;
+			case self::CB_MP_ENDMATCH:
+				$this->triggerCallback($callbackName, $callback);
+				break;
+			case self::CB_MP_ENDMAP:
+				$this->maniaControl->getMapManager()->handleEndMap($callback);
+				$this->triggerCallback($callbackName, $callback);
+				break;
+			case self::CB_MP_MODESCRIPTCALLBACK:
+				$this->handleScriptCallback($callback);
+				$this->triggerCallback($callbackName, $callback);
+				break;
+			case self::CB_MP_MODESCRIPTCALLBACKARRAY:
+				$this->handleScriptCallback($callback);
+				$this->triggerCallback($callbackName, $callback);
+				break;
+			default:
+				$this->triggerCallback($callbackName, $callback);
+				break;
+		}
+	}
+
+	/**
+	 * Trigger a specific Callback
+	 *
+	 * @param mixed $callback
+	 */
+	public function triggerCallback($callback) {
+		if ($callback instanceof BaseCallback) {
+			$callbackName = $callback->name;
+		} else {
+			$callbackName = $callback;
+		}
+		if (!array_key_exists($callbackName, $this->callbackListenings)) {
+			return;
+		}
+
+		$params = func_get_args();
+		if (!($callback instanceof BaseCallback)) {
+			$params = array_slice($params, 1, null, true);
+		}
+
+		foreach ($this->callbackListenings[$callbackName] as $listening) {
+			/** @var Listening $listening */
+			$listening->triggerCallbackWithParams($params);
+		}
+	}
+
+	/**
+	 * Handle the given Script Callback
+	 *
+	 * @param array $callback
+	 */
+	private function handleScriptCallback(array $callback) {
+		$scriptCallbackData = $callback[1];
+		$scriptCallbackName = $scriptCallbackData[0];
+		$this->triggerScriptCallback($scriptCallbackName, $scriptCallbackData);
+		$this->triggerCallback(Callbacks::SCRIPTCALLBACK, $scriptCallbackName, $scriptCallbackData[1]);
+	}
+
+	/**
+	 * Trigger a specific Script Callback
+	 *
+	 * @param string $callbackName
+	 */
+	public function triggerScriptCallback($callbackName) {
+		if (!array_key_exists($callbackName, $this->scriptCallbackListenings)) {
+			return;
+		}
+
+		$params = func_get_args();
+		$params = array_slice($params, 1, null, true);
+
+		foreach ($this->scriptCallbackListenings[$callbackName] as $listening) {
+			/** @var Listening $listening */
+			$listening->triggerCallbackWithParams($params);
+		}
+	}
+}

core/Callbacks/Callbacks.php

@@ -0,0 +1,100 @@
+<?php
+
+// TODO: method class for all the libxmlrpc get Methods, to fetch the callback asnyc
+
+namespace ManiaControl\Callbacks;
+
+/**
+ * Callbacks Interface
+ *
+ * @author    ManiaControl Team <mail@maniacontrol.com>
+ * @copyright 2014 ManiaControl Team
+ * @license   http://www.gnu.org/licenses/ GNU General Public License, Version 3
+ */
+interface Callbacks {
+	/*
+	 * ManiaControl Callbacks
+	 */
+	const ONINIT     = 'Callbacks.OnInit';
+	const AFTERINIT  = 'Callbacks.AfterInit';
+	const ONSHUTDOWN = 'Callbacks.OnShutdown';
+
+	/** Script Callback: CallbackName, CallbackData */
+	const SCRIPTCALLBACK = 'Callbacks.ScriptCallback';
+
+	/*
+	 * Common Callbacks
+	 */
+	/** BeginMatch Callback: MatchNumber */
+	const BEGINMATCH = 'Callbacks.BeginMatch';
+	/** LoadingMap Callback: MapNumber */
+	const LOADINGMAP = 'Callbacks.LoadingMap';
+	/** BeginMap Callback: Map */
+	const BEGINMAP = 'Callbacks.BeginMap';
+	/** BeginSubMatch Callback: SubmatchNumber */
+	const BEGINSUBMATCH = 'Callbacks.BeginSubmatch';
+	/** BeginRound Callback: RoundNumber */
+	const BEGINROUND = 'Callbacks.BeginRound';
+	/** BeginTurn Callback: TurnNumber */
+	const BEGINTURN = 'Callbacks.BeginTurn';
+	/** BeginPlaying Callback */
+	const BEGINPLAYING = 'Callbacks.BeginPlaying';
+	/** EndPlaying Callback */
+	const ENDPLAYING = 'Callbacks.EndPlaying';
+	/** EndTurn Callback: TurnNumber */
+	const ENDTURN = 'Callbacks.EndTurn';
+	/** EndRound Callback: RoundNumber */
+	const ENDROUND = 'Callbacks.EndRound';
+	/** EndSubmatch Callback: SubmatchNumber */
+	const ENDSUBMATCH = 'Callbacks.EndSubmatch';
+	/** EndMap Callback: Map */
+	const ENDMAP = 'Callbacks.EndMap';
+	/** BeginPodium Callback */
+	const BEGINPODIUM = 'Callbacks.BeginPodium';
+	/** EndPodium Callback */
+	const ENDPODIUM = 'Callbacks.EndPodium';
+	/** UnloadingMap Callback */
+	const UNLOADINGMAP = 'Callbacks.UnloadingMap';
+	/** EndMatch Callback: MatchNumber */
+	const ENDMATCH = 'Callbacks.EndMatch';
+
+	/** BeginWarmup Callback */
+	const BEGINWARMUP = 'Callbacks.BeginWarmUp';
+	/** EndWarmup Callback */
+	const ENDWARMUP = 'Callbacks.EndWarmUp';
+
+	/** PlayerRanking Callback, returned after LibXmlRpc_PlayerRanking
+	 * try to avoid to use this, just use the Get function of the RankingsManager instead
+	 * param1 Player $player
+	 * param2 int $rank
+	 * param3 int $currentPoints
+	 * param4 int AFKStatus */
+	const PLAYERRANKING = 'Callbacks.PlayerRanking';
+
+	/*
+	 * ShootMania Callbacks
+	 */
+	/** RankingsUpdated Callback: SortedRankings */
+	const RANKINGSUPDATED = 'Callbacks.RankingsUpdated';
+	/** Scores Callback (returned after LibXmlRpc_PlayerRanking): Scores */
+	const SCORES = 'Callbacks.Scores';
+
+	/** Returns the AFKStatus of an Player, returned after  param1 Scores */ //returned after TODO
+	const AFKSTATUS = 'Callbacks.AfkStatus';
+	/** Returns if the GameMode has Warmup activated, returned after  param1 Scores */ //returned after TODO
+	const WARMUPSTATUS = 'Callbacks.WarmupStatus';
+
+	/*
+	 * TrackMania Callbacks
+	 */
+	/** OnStartLine Callback */
+	const ONSTARTLINE = 'Callbacks.OnStartLine';
+	/** OnWayPoint Callback */
+	const ONWAYPOINT = 'Callbacks.OnWayPoint';
+	/** OnGiveUp Callback */
+	const ONGIVEUP = 'Callbacks.OnGiveUp';
+	/** OnRespawn Callback */
+	const ONRESPAWN = 'Callbacks.OnRespawn';
+	/** OnStunt Callback */
+	const ONSTUNT = 'Callbacks.OnStunt';
+}

core/Callbacks/LibXmlRpcCallbacks.php

@@ -0,0 +1,128 @@
+<?php
+
+namespace ManiaControl\Callbacks;
+
+use ManiaControl\ManiaControl;
+
+/**
+ * Class converting LibXmlRpc Callbacks
+ *
+ * @author    ManiaControl Team <mail@maniacontrol.com>
+ * @copyright 2014 ManiaControl Team
+ * @license   http://www.gnu.org/licenses/ GNU General Public License, Version 3
+ */
+class LibXmlRpcCallbacks implements CallbackListener {
+	/*
+	 * Private properties
+	 */
+	/** @var ManiaControl $maniaControl */
+	private $maniaControl = null;
+
+	/**
+	 * Create a new LibXmlRpc Callbacks Instance
+	 *
+	 * @param ManiaControl    $maniaControl
+	 * @param CallbackManager $callbackManager
+	 */
+	public function __construct(ManiaControl $maniaControl, CallbackManager $callbackManager) {
+		$this->maniaControl = $maniaControl;
+
+		$callbackManager->registerCallbackListener(Callbacks::SCRIPTCALLBACK, $this, 'handleScriptCallback');
+	}
+
+	/**
+	 * Handle the Script Callback
+	 *
+	 * @param string $name
+	 * @param mixed  $data
+	 */
+	public function handleScriptCallback($name, $data) {
+		switch ($name) {
+			case 'LibXmlRpc_BeginMatch':
+				$this->maniaControl->getCallbackManager()->triggerCallback(Callbacks::BEGINMATCH, $data[0]);
+				break;
+			case 'LibXmlRpc_LoadingMap':
+				$this->maniaControl->getCallbackManager()->triggerCallback(Callbacks::LOADINGMAP, $data[0]);
+				break;
+			case 'BeginMap':
+			case 'LibXmlRpc_BeginMap':
+				if (!isset($data[2])) {
+					$data[2] = 'False';
+				}
+				$this->maniaControl->getMapManager()->handleScriptBeginMap($data[1], $data[2]);
+				break;
+			case 'LibXmlRpc_BeginSubmatch':
+				$this->maniaControl->getCallbackManager()->triggerCallback(Callbacks::BEGINSUBMATCH, $data[0]);
+				break;
+			case 'LibXmlRpc_BeginTurn':
+				$this->maniaControl->getCallbackManager()->triggerCallback(Callbacks::BEGINTURN, $data[0]);
+				break;
+			case 'LibXmlRpc_BeginPlaying':
+				$this->maniaControl->getCallbackManager()->triggerCallback(Callbacks::BEGINPLAYING);
+				break;
+			case 'LibXmlRpc_EndPlaying':
+				$this->maniaControl->getCallbackManager()->triggerCallback(Callbacks::ENDPLAYING);
+				break;
+			case 'LibXmlRpc_EndTurn':
+				$this->maniaControl->getCallbackManager()->triggerCallback(Callbacks::ENDTURN, $data[0]);
+				break;
+			case 'LibXmlRpc_EndRound':
+				$this->maniaControl->getCallbackManager()->triggerCallback(Callbacks::ENDROUND, $data[0]);
+				break;
+			case 'LibXmlRpc_EndSubmatch':
+				$this->maniaControl->getCallbackManager()->triggerCallback(Callbacks::ENDSUBMATCH, $data[0]);
+				break;
+			case 'EndMap':
+			case 'LibXmlRpc_EndMap':
+				$this->maniaControl->getMapManager()->handleScriptEndMap();
+				break;
+			case 'LibXmlRpc_BeginPodium':
+				$this->maniaControl->getCallbackManager()->triggerCallback(Callbacks::BEGINPODIUM);
+				break;
+			case 'LibXmlRpc_EndPodium':
+				$this->maniaControl->getCallbackManager()->triggerCallback(Callbacks::ENDPODIUM);
+				break;
+			case 'LibXmlRpc_UnloadingMap':
+				$this->maniaControl->getCallbackManager()->triggerCallback(Callbacks::UNLOADINGMAP, $data[0]);
+				break;
+			case 'LibXmlRpc_EndMatch':
+				$this->maniaControl->getCallbackManager()->triggerCallback(Callbacks::ENDMATCH, $data[0]);
+				break;
+			case 'LibXmlRpc_BeginWarmUp':
+				$this->maniaControl->getCallbackManager()->triggerCallback(Callbacks::BEGINWARMUP);
+				break;
+			case 'LibXmlRpc_EndWarmUp':
+				$this->maniaControl->getCallbackManager()->triggerCallback(Callbacks::ENDWARMUP);
+				break;
+			case 'LibXmlRpc_PlayerRanking':
+				//TODO really useful? what does it have what RankingsManager not have?
+				$this->triggerPlayerRanking($data[0]);
+				break;
+			case 'LibXmlRpc_OnStartLine':
+				$this->maniaControl->getCallbackManager()->triggerCallback(Callbacks::ONSTARTLINE, $data[0]);
+				break;
+			case 'LibXmlRpc_OnWayPoint':
+				$this->maniaControl->getCallbackManager()->triggerCallback(Callbacks::ONWAYPOINT, $data);
+				break;
+			case 'LibXmlRpc_OnGiveUp':
+				$this->maniaControl->getCallbackManager()->triggerCallback(Callbacks::ONGIVEUP, $data[0]);
+				break;
+			case 'LibXmlRpc_OnRespawn':
+				$this->maniaControl->getCallbackManager()->triggerCallback(Callbacks::ONRESPAWN, $data[0]);
+				break;
+			case 'LibXmlRpc_OnStunt':
+				$this->maniaControl->getCallbackManager()->triggerCallback(Callbacks::ONSTUNT, $data);
+				break;
+		}
+	}
+
+	/**
+	 * Trigger the Ranking of a Player
+	 *
+	 * @param array $data
+	 */
+	private function triggerPlayerRanking(array $data) {
+		$player = $this->maniaControl->getPlayerManager()->getPlayer($data[1]);
+		$this->maniaControl->getCallbackManager()->triggerCallback(Callbacks::PLAYERRANKING, $player, $data[0], $data[6], $data[5]);
+	}
+}

core/Callbacks/Listening.php

@@ -0,0 +1,76 @@
+<?php
+
+namespace ManiaControl\Callbacks;
+
+/**
+ * Model Class for a Basic Listening
+ *
+ * @author    ManiaControl Team <mail@maniacontrol.com>
+ * @copyright 2014 ManiaControl Team
+ * @license   http://www.gnu.org/licenses/ GNU General Public License, Version 3
+ */
+class Listening {
+	/*
+	 * Public Properties
+	 */
+	public $listener = null;
+	public $method = null;
+
+	/**
+	 * Construct a new Timer Listening
+	 *
+	 * @param object $listener
+	 * @param mixed  $method
+	 */
+	public function __construct($listener, $method) {
+		$this->listener = $listener;
+		$this->method   = $method;
+	}
+
+	/**
+	 * Check if the given Listener and Method build a valid Callback
+	 *
+	 * @param object $listener
+	 * @param mixed  $method
+	 * @return bool
+	 */
+	public static function checkValidCallback($listener, $method) {
+		if (is_callable($method)) {
+			return true;
+		}
+		$listenerCallback = array($listener, $method);
+		if (is_callable($listenerCallback)) {
+			return true;
+		}
+		return false;
+	}
+
+	/**
+	 * Trigger the Listener's Method
+	 */
+	public function triggerCallback() {
+		$params = func_get_args();
+		$this->triggerCallbackWithParams($params);
+	}
+
+	/**
+	 * Trigger the Listener's Method with the given Array of Params
+	 *
+	 * @param array $params
+	 */
+	public function triggerCallbackWithParams(array $params) {
+		call_user_func_array($this->getUserFunction(), $params);
+	}
+
+	/**
+	 * Get the Callable User Function
+	 *
+	 * @return callable
+	 */
+	public function getUserFunction() {
+		if (is_callable($this->method)) {
+			return $this->method;
+		}
+		return array($this->listener, $this->method);
+	}
+}

core/Callbacks/Models/BaseCallback.php

@@ -0,0 +1,37 @@
+<?php
+
+namespace ManiaControl\Callbacks\Models;
+
+use ManiaControl\Players\Player;
+
+/**
+ * Base Model Class for Callbacks
+ *
+ * @author    ManiaControl Team <mail@maniacontrol.com>
+ * @copyright 2014 ManiaControl Team
+ * @license   http://www.gnu.org/licenses/ GNU General Public License, Version 3
+ */
+abstract class BaseCallback {
+	/*
+	 * Public Properties
+	 */
+	public $name = null;
+	public $rawCallback = null;
+	public $isLegacyCallback = null;
+
+	public $pid = null;
+	public $login = null;
+	/** @var Player $player */
+	public $player = null;
+
+	/**
+	 * Set the corresponding Player
+	 *
+	 * @param Player $player
+	 */
+	public function setPlayer(Player $player) {
+		$this->pid    = $player->pid;
+		$this->login  = $player->login;
+		$this->player = $player;
+	}
+}

core/Callbacks/Models/RecordCallback.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace ManiaControl\Callbacks\Models;
+
+/**
+ * Base Model Class for Callbacks
+ *
+ * @author    ManiaControl Team <mail@maniacontrol.com>
+ * @copyright 2014 ManiaControl Team
+ * @license   http://www.gnu.org/licenses/ GNU General Public License, Version 3
+ */
+class RecordCallback extends BaseCallback {
+	/*
+	 * Constants
+	 */
+	const CHECKPOINT = 'RecordCallback.Checkpoint';
+	const FINISH     = 'RecordCallback.Finish';
+	const LAPFINISH  = 'RecordCallback.LapFinish';
+
+	/*
+	 * Public Properties
+	 */
+	public $isEndRace = null;
+	public $isEndLap = null;
+	public $time = null;
+	public $lapTime = null;
+	public $checkpoint = null;
+	public $lapCheckpoint = null;
+	public $lap = null;
+	public $blockId = null;
+}

core/Callbacks/ShootManiaCallbacks.php

@@ -0,0 +1,127 @@
+<?php
+
+namespace ManiaControl\Callbacks;
+
+use ManiaControl\Callbacks\Models\RecordCallback;
+use ManiaControl\ManiaControl;
+
+/**
+ * Class handling and parsing ShootMania Callbacks
+ *
+ * @author    ManiaControl Team <mail@maniacontrol.com>
+ * @copyright 2014 ManiaControl Team
+ * @license   http://www.gnu.org/licenses/ GNU General Public License, Version 3
+ */
+class ShootManiaCallbacks implements CallbackListener {
+	/*
+	 * Constants
+	 */
+	const CB_TIMEATTACK_ONSTART      = 'TimeAttack_OnStart';
+	const CB_TIMEATTACK_ONRESTART    = 'TimeAttack_OnRestart';
+	const CB_TIMEATTACK_ONCHECKPOINT = 'TimeAttack_OnCheckpoint';
+	const CB_TIMEATTACK_ONFINISH     = 'TimeAttack_OnFinish';
+
+	/*
+	 * Private properties
+	 */
+	/** @var ManiaControl $maniaControl */
+	private $maniaControl = null;
+
+	/**
+	 * Create a new ShootMania Callbacks Instance
+	 *
+	 * @param ManiaControl    $maniaControl
+	 * @param CallbackManager $callbackManager
+	 */
+	public function __construct(ManiaControl $maniaControl, CallbackManager $callbackManager) {
+		$this->maniaControl = $maniaControl;
+
+		// Register for script callbacks
+		$callbackManager->registerCallbackListener(Callbacks::SCRIPTCALLBACK, $this, 'handleScriptCallbacks');
+	}
+
+	/**
+	 * Handle Script Callbacks
+	 *
+	 * @param string $name
+	 * @param mixed  $data
+	 */
+	public function handleScriptCallbacks($name, $data) {
+		switch ($name) {
+			case 'LibXmlRpc_Rankings':
+				$this->maniaControl->getServer()->getRankingManager()->updateRankings($data[0]);
+				break;
+			case 'LibXmlRpc_Scores':
+				$this->maniaControl->getCallbackManager()->triggerCallback(Callbacks::SCORES, $data);
+				break;
+			case 'LibAFK_IsAFK':
+				$this->triggerAfkStatus($data[0]);
+				break;
+			case 'WarmUp_Status':
+				$this->maniaControl->getCallbackManager()->triggerCallback(Callbacks::WARMUPSTATUS, $data[0]);
+				break;
+			case self::CB_TIMEATTACK_ONCHECKPOINT:
+				$this->handleTimeAttackOnCheckpoint($name, $data);
+				break;
+			case self::CB_TIMEATTACK_ONFINISH:
+				$this->handleTimeAttackOnFinish($name, $data);
+				break;
+		}
+	}
+
+	/**
+	 * Triggers the AFK Status of an Player
+	 *
+	 * @param string $login
+	 */
+	private function triggerAfkStatus($login) {
+		$player = $this->maniaControl->getPlayerManager()->getPlayer($login);
+		$this->maniaControl->getCallbackManager()->triggerCallback(Callbacks::AFKSTATUS, $player);
+	}
+
+	/**
+	 * Handle TimeAttack OnCheckpoint Callback
+	 *
+	 * @param string $name
+	 * @param array  $data
+	 */
+	public function handleTimeAttackOnCheckpoint($name, array $data) {
+		$login  = $data[0];
+		$player = $this->maniaControl->getPlayerManager()->getPlayer($login);
+		if (!$player) {
+			return;
+		}
+
+		// Trigger checkpoint callback
+		$checkpointCallback              = new RecordCallback();
+		$checkpointCallback->rawCallback = array($name, $data);
+		$checkpointCallback->name        = $checkpointCallback::CHECKPOINT;
+		$checkpointCallback->setPlayer($player);
+		$checkpointCallback->time = (int)$data[1];
+
+		$this->maniaControl->getCallbackManager()->triggerCallback($checkpointCallback);
+	}
+
+	/**
+	 * Handle TimeAttack OnFinish Callback
+	 *
+	 * @param string $name
+	 * @param array  $data
+	 */
+	public function handleTimeAttackOnFinish($name, array $data) {
+		$login  = $data[0];
+		$player = $this->maniaControl->getPlayerManager()->getPlayer($login);
+		if (!$player) {
+			return;
+		}
+
+		// Trigger finish callback
+		$finishCallback              = new RecordCallback();
+		$finishCallback->rawCallback = array($name, $data);
+		$finishCallback->name        = $finishCallback::FINISH;
+		$finishCallback->setPlayer($player);
+		$finishCallback->time = (int)$data[1];
+
+		$this->maniaControl->getCallbackManager()->triggerCallback($finishCallback);
+	}
+}

core/Callbacks/TimerListener.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace ManiaControl\Callbacks;
+
+/**
+ * Interface for TimerListener
+ *
+ * @author    ManiaControl Team <mail@maniacontrol.com>
+ * @copyright 2014 ManiaControl Team
+ * @license   http://www.gnu.org/licenses/ GNU General Public License, Version 3
+ */
+interface TimerListener {
+}

core/Callbacks/TimerListening.php

@@ -0,0 +1,70 @@
+<?php
+
+namespace ManiaControl\Callbacks;
+
+/**
+ * Model Class for a Timer Listening
+ *
+ * @author    ManiaControl Team <mail@maniacontrol.com>
+ * @copyright 2014 ManiaControl Team
+ * @license   http://www.gnu.org/licenses/ GNU General Public License, Version 3
+ */
+class TimerListening extends Listening {
+	/*
+	 * Public Properties
+	 */
+	public $deltaTime = null;
+	public $oneTime = null;
+	public $lastTrigger = null;
+	public $instantCall = null;
+
+	/**
+	 * Construct a new Timer Listening
+	 *
+	 * @param TimerListener $listener
+	 * @param mixed         $method
+	 * @param float         $milliSeconds
+	 * @param bool          $oneTime
+	 * @param bool          $instantCall
+	 */
+	public function __construct(TimerListener $listener, $method, $milliSeconds, $oneTime = false, $instantCall = true) {
+		parent::__construct($listener, $method);
+
+		$this->deltaTime = $milliSeconds / 1000.;
+		$this->oneTime   = (bool)$oneTime;
+		if ($this->oneTime) {
+			$this->lastTrigger = time(true);
+		}
+		$this->instantCall = (bool)$instantCall;
+		if (!$this->instantCall) {
+			$this->lastTrigger = microtime(true);
+		}
+	}
+
+	/**
+	 * Increase last Trigger Time
+	 */
+	public function tick() {
+		if ($this->lastTrigger === null) {
+			$this->lastTrigger = microtime(true);
+		} else {
+			$this->lastTrigger += $this->deltaTime;
+		}
+	}
+
+	/**
+	 * Check if the desired Time is reached
+	 *
+	 * @param float $time
+	 * @return bool
+	 */
+	public function isTimeReached($time = null) {
+		if ($this->lastTrigger === null) {
+			return true;
+		}
+		if (!$time) {
+			$time = microtime(true);
+		}
+		return ($this->lastTrigger + $this->deltaTime <= $time);
+	}
+}

core/Callbacks/TimerManager.php

@@ -0,0 +1,133 @@
+<?php
+
+namespace ManiaControl\Callbacks;
+
+use ManiaControl\ManiaControl;
+
+/**
+ * Class for managing Timed Callbacks
+ *
+ * @author    ManiaControl Team <mail@maniacontrol.com>
+ * @copyright 2014 ManiaControl Team
+ * @license   http://www.gnu.org/licenses/ GNU General Public License, Version 3
+ */
+class TimerManager {
+	/*
+	 * Private properties
+	 */
+	/** @var ManiaControl $maniaControl */
+	private $maniaControl = null;
+	/** @var TimerListening[] $timerListenings */
+	private $timerListenings = array();
+
+	/**
+	 * Construct a new Timer Manager
+	 *
+	 * @param ManiaControl $maniaControl
+	 */
+	public function __construct(ManiaControl $maniaControl) {
+		$this->maniaControl = $maniaControl;
+	}
+
+	/**
+	 * Registers a One Time Listening
+	 *
+	 * @param TimerListener $listener
+	 * @param string        $method
+	 * @param float         $milliSeconds
+	 */
+	public function registerOneTimeListening(TimerListener $listener, $method, $milliSeconds) {
+		$this->registerTimerListening($listener, $method, $milliSeconds, true);
+	}
+
+	/**
+	 * Register a Timer Listening, note < 10ms it can get inaccurate
+	 *
+	 * @param TimerListener $listener
+	 * @param string        $method
+	 * @param float         $milliSeconds
+	 * @param bool          $oneTime
+	 * @return bool
+	 */
+	public function registerTimerListening(TimerListener $listener, $method, $milliSeconds, $oneTime = false) {
+		if ((!is_string($method) || !method_exists($listener, $method)) && !is_callable($method)) {
+			trigger_error("Given Listener (" . get_class($listener) . ") can't handle Timer Callback (No Method '{$method}')!");
+			return false;
+		}
+
+		// Build Timer Listening
+		$listening = new TimerListening($listener, $method, $milliSeconds, $oneTime);
+		$this->addTimerListening($listening);
+
+		return true;
+	}
+
+	/**
+	 * Add a Listening to the current List of managed Timers
+	 *
+	 * @param TimerListening $timerListening
+	 */
+	public function addTimerListening(TimerListening $timerListening) {
+		array_push($this->timerListenings, $timerListening);
+	}
+
+	/**
+	 * Unregister a Timer Listening
+	 *
+	 * @param TimerListener $listener
+	 * @param string        $method
+	 * @return bool
+	 */
+	public function unregisterTimerListening(TimerListener $listener, $method) {
+		$removed = false;
+		foreach ($this->timerListenings as $key => &$listening) {
+			if ($listening->listener === $listener && $listening->method === $method) {
+				unset($this->timerListenings[$key]);
+				$removed = true;
+			}
+		}
+		return $removed;
+	}
+
+	/**
+	 * Unregister a Timer Listener
+	 *
+	 * @param TimerListener $listener
+	 * @return bool
+	 */
+	public function unregisterTimerListenings(TimerListener $listener) {
+		$removed = false;
+		foreach ($this->timerListenings as $key => &$listening) {
+			if ($listening->listener === $listener) {
+				unset($this->timerListenings[$key]);
+				$removed = true;
+			}
+		}
+		return $removed;
+	}
+
+	/**
+	 * Manage the Timings on every ms
+	 */
+	public function manageTimings() {
+		$time = microtime(true);
+
+		foreach ($this->timerListenings as $key => $listening) {
+			/** @var TimerListening $listening */
+
+			if (!$listening->isTimeReached($time)) {
+				continue;
+			}
+
+			if ($listening->oneTime) {
+				// Unregister one time Listening
+				unset($this->timerListenings[$key]);
+			}
+
+			$listening->tick();
+
+			// Call the User Function
+			$listening->triggerCallback($time);
+		}
+	}
+} 

core/Callbacks/TrackManiaCallbacks.php

@@ -0,0 +1,139 @@
+<?php
+
+namespace ManiaControl\Callbacks;
+
+use ManiaControl\Callbacks\Models\RecordCallback;
+use ManiaControl\ManiaControl;
+use ManiaControl\Utils\Formatter;
+
+/**
+ * Class handling and parsing TrackMania Callbacks
+ *
+ * @author    ManiaControl Team <mail@maniacontrol.com>
+ * @copyright 2014 ManiaControl Team
+ * @license   http://www.gnu.org/licenses/ GNU General Public License, Version 3
+ */
+class TrackManiaCallbacks implements CallbackListener {
+	/*
+	 * Private properties
+	 */
+	/** @var ManiaControl $maniaControl */
+	private $maniaControl = null;
+
+	/**
+	 * Create a new TrackMania Callbacks Instance
+	 *
+	 * @param ManiaControl    $maniaControl
+	 * @param CallbackManager $callbackManager
+	 */
+	public function __construct(ManiaControl $maniaControl, CallbackManager $callbackManager) {
+		$this->maniaControl = $maniaControl;
+
+		// Register for callbacks
+		$callbackManager->registerCallbackListener(Callbacks::ONWAYPOINT, $this, 'handleOnWayPointCallback');
+		$callbackManager->registerCallbackListener(CallbackManager::CB_TM_PLAYERCHECKPOINT, $this, 'handlePlayerCheckpointCallback');
+		$callbackManager->registerCallbackListener(CallbackManager::CB_TM_PLAYERFINISH, $this, 'handlePlayerFinishCallback');
+	}
+
+	/**
+	 * Handle OnWayPoint Callback
+	 *
+	 * @param array $callback
+	 */
+	public function handleOnWayPointCallback(array $callback) {
+		$login  = $callback[0];
+		$player = $this->maniaControl->getPlayerManager()->getPlayer($login);
+		if (!$player) {
+			return;
+		}
+
+		// Build callback
+		$wayPointCallback              = new RecordCallback();
+		$wayPointCallback->rawCallback = $callback;
+		$wayPointCallback->setPlayer($player);
+		$wayPointCallback->blockId       = $callback[1];
+		$wayPointCallback->time          = (int)$callback[2];
+		$wayPointCallback->checkpoint    = (int)$callback[3];
+		$wayPointCallback->isEndRace     = Formatter::parseBoolean($callback[4]);
+		$wayPointCallback->lapTime       = (int)$callback[5];
+		$wayPointCallback->lapCheckpoint = (int)$callback[6];
+		$wayPointCallback->lap           = 0;
+		$wayPointCallback->isEndLap      = Formatter::parseBoolean($callback[7]);
+
+		if ($wayPointCallback->checkpoint > 0) {
+			$currentMap = $this->maniaControl->getMapManager()->getCurrentMap();
+			$wayPointCallback->lap += $wayPointCallback->checkpoint / $currentMap->nbCheckpoints;
+		}
+
+		if ($wayPointCallback->isEndRace) {
+			$wayPointCallback->name = $wayPointCallback::FINISH;
+		} else if ($wayPointCallback->isEndLap) {
+			$wayPointCallback->name = $wayPointCallback::LAPFINISH;
+		} else {
+			$wayPointCallback->name = $wayPointCallback::CHECKPOINT;
+		}
+
+		$this->maniaControl->getCallbackManager()->triggerCallback($wayPointCallback);
+	}
+
+	/**
+	 * Handle Hard-Coded Player Checkpoint Callback
+	 *
+	 * @param array $callback
+	 */
+	public function handlePlayerCheckpointCallback(array $callback) {
+		$data   = $callback[1];
+		$login  = $data[1];
+		$player = $this->maniaControl->getPlayerManager()->getPlayer($login);
+		if (!$player) {
+			return;
+		}
+
+		// Build checkpoint callback
+		$checkpointCallback                   = new RecordCallback();
+		$checkpointCallback->isLegacyCallback = true;
+		$checkpointCallback->rawCallback      = $callback;
+		$checkpointCallback->setPlayer($player);
+		$checkpointCallback->time          = (int)$data[2];
+		$checkpointCallback->lap           = (int)$data[3];
+		$checkpointCallback->checkpoint    = (int)$data[4];
+		$checkpointCallback->lapCheckpoint = $checkpointCallback->checkpoint;
+
+		if ($checkpointCallback->lap > 0) {
+			$currentMap = $this->maniaControl->getMapManager()->getCurrentMap();
+			$checkpointCallback->lapCheckpoint -= $checkpointCallback->lap * $currentMap->nbCheckpoints;
+		}
+
+		if ($checkpointCallback->lapCheckpoint === 0) {
+			$checkpointCallback->name = $checkpointCallback::LAPFINISH;
+		} else {
+			$checkpointCallback->name = $checkpointCallback::CHECKPOINT;
+		}
+
+		$this->maniaControl->getCallbackManager()->triggerCallback($checkpointCallback);
+	}
+
+	/**
+	 * Handle Hard-Coded Player Finish Callback
+	 *
+	 * @param array $callback
+	 */
+	public function handlePlayerFinishCallback(array $callback) {
+		$data   = $callback[1];
+		$login  = $data[1];
+		$player = $this->maniaControl->getPlayerManager()->getPlayer($login);
+		if (!$player) {
+			return;
+		}
+
+		// Build finish callback
+		$finishCallback                   = new RecordCallback();
+		$finishCallback->name             = $finishCallback::FINISH;
+		$finishCallback->isLegacyCallback = true;
+		$finishCallback->rawCallback      = $callback;
+		$finishCallback->setPlayer($player);
+		$finishCallback->time = (int)$data[2];
+
+		$this->maniaControl->getCallbackManager()->triggerCallback($finishCallback);
+	}
+}