Version 1.14a

onyx2/include/Class/File/alliances_batiments.php

@@ -0,0 +1,257 @@
+<?php
+require_once("Class/File/interface.php");
+
+class FileAlliancesBatiments extends FileCommun implements File
+{
+	public function objectInFile($object)
+	{
+		foreach($this->files as $keyF => $file)
+		{
+			foreach($file as $keyE => $element)
+			{
+				if ($element[0] == $object)
+					return array($keyF, $keyE);
+			}
+		}
+		return false;
+	}
+
+	public function nbObjectInFile($object, $type = null)
+	{
+		$c = 0;
+		if (isset($type))
+		{
+			if (!isset($type) || $type)
+			{
+				foreach($this->files as $file)
+				{
+					$c += count(array_keys($file, array($object, true)));
+				}
+			}
+			if (!isset($type) || !$type)
+			{
+				foreach($this->files as $file)
+				{
+					$c += count(array_keys($file, array($object, false)));
+				}
+			}
+		}
+		return $c;
+	}
+
+	public function addObjet($object, $nombre, surface $planete)
+	{
+		//On vérifie que l'on ne dépasse pas la taille maximale de la file
+		if (!$this->checkMaxSize($planete))
+			throw new ExceptionHB(1, 1);
+
+		//Validation des conditions de construction
+		if (!dAlliancesBatiments::needed($object, $planete))
+			throw new ExceptionHB(1, 2);
+
+		//On vérifie qu'il n'y ait pas une demande de démolition du même bâtiment
+		if ($this->nbObjectInFile($object, true) >= 1)
+			throw new ExceptionHB(1, 7);
+
+		//Calcul du prochain niveau du batiment
+		$nextLvl = $planete->batiments[$object] + $this->nbObjectInFile($object, false) + 1;
+
+		//On recherche le lieu ayant le moins de construction en cours
+		$lieu = $this->findShorter();
+
+		//On rafraîchit le temps de la file si aucun objet n'est en file d'attente
+		$this->refreshTime($lieu);
+
+		//On vérifie qu'il y ait assez de ressources sur la planète
+		if ($planete->checkAndRetireRessources(dAlliancesBatiments::metal($object, $nextLvl, $planete), dAlliancesBatiments::cristal($object, $nextLvl, $planete), dAlliancesBatiments::hydrogene($object, $nextLvl, $planete), dAlliancesBatiments::credits($object, $nextLvl, $planete)))
+		{
+			$this->files[$lieu][] = array($object, false);
+			$planete->addModif("file_bat");
+			return true;
+		}
+		else
+			throw new ExceptionHB(1, 4);
+	}
+
+	public function addDemolition($object, $nombre, surface $planete)
+	{
+		//On vérifie que l'on ne dépasse pas la taille maximale de la file
+		if (!$this->checkMaxSize($planete))
+			throw new ExceptionHB(1, 1);
+
+		//On vérifie que le niveau actuel du batiment ne soit non nul
+		if ($planete->batiments[$object] <= $this->nbObjectInFile($object, false))
+			throw new ExceptionHB(1, 6);
+
+		//On vérifie qu'il n'y ait pas une demande de construction du même bâtiment
+		if ($this->nbObjectInFile($object, false) >= 1)
+			throw new ExceptionHB(1, 7);
+
+		//On recherche le lieu ayant le moins de construction en cours
+		$lieu = $this->findShorter();
+
+		//On rafraîchit le temps de la file si aucun objet n'est en file d'attente
+		$this->refreshTime($lieu);
+
+		$this->files[$lieu][] = array($object, true);
+
+		$planete->addModif("file_bat");
+
+		return true;
+	}
+
+	public function delObjet($id, $nombre, $lieu, surface $planete)
+	{
+		//Vérification de l'existance de l'objet en file d'attente
+		if (empty($this->files[$lieu][$id]))
+			throw new ExceptionHB(1, 5);
+
+		//On récupère le type de batiment
+		$object = $this->files[$lieu][$id][0];
+
+		//On gère les démolition
+		//@todo -cFileBatiments Est-ce vraiment utile de calculer le niveau du batiment en cas de démolition ?
+		if ($this->files[$lieu][$id][1])
+			$lvlAnnule = $planete->batiments[$object] - $this->nbObjectInFile($object, true) + 1;
+		else
+			$lvlAnnule = $planete->batiments[$object] + $this->nbObjectInFile($object, false);
+
+		//On met à jour le temps si on vient d'annuler le premier batiment en lice
+		if ($id == $this->findFirstKey($lieu))
+			$this->times[$lieu] = time();
+
+		$planete->addModif("file_bat");
+
+		if (!$this->files[$lieu][$id][1])
+		{
+			//On redonne 60% des ressources au joueur si c'est la première construction dans la file d'attente
+			if ($id == 0)
+				$planete->addRessources(dAlliancesBatiments::metal($object, $lvlAnnule, $planete)*0.6, dAlliancesBatiments::cristal($object, $lvlAnnule, $planete)*0.6, dAlliancesBatiments::hydrogene($object, $lvlAnnule, $planete)*0.6, dAlliancesBatiments::credits($object, $lvlAnnule, $planete)*0.6);
+			else
+				$planete->addRessources(dAlliancesBatiments::metal($object, $lvlAnnule, $planete), dAlliancesBatiments::cristal($object, $lvlAnnule, $planete), dAlliancesBatiments::hydrogene($object, $lvlAnnule, $planete), dAlliancesBatiments::credits($object, $lvlAnnule, $planete));
+		}
+
+		//Effacement de la file
+		unset($this->files[$lieu][$id]);
+
+		return true;
+	}
+
+	public function ready(SURFACE $planete)
+	{
+		//On parcourt la liste des lieux de construction
+		foreach($this->files as $keyF => $file)
+		{
+			//On vérifie qu'il y a bien des éléments dans cette file d'attente
+			if (count($file) == 0)
+				continue;
+
+			//On parcourt la file
+			foreach ($file as $keyE => $element)
+			{
+				$tempsEcoule = time() - $this->times[$keyF];
+
+				//On gère les démolitions
+				if ($element[1])
+				{
+					//On récupère le niveau actuel du batiment
+					$lvl = $planete->batiments[$element[0]];
+
+					//On calcul le temps de démolition nécessaire (60% du niveau actuel)
+					$tempsNecessaire = dAlliancesBatiments::temps($element[0], $lvl, $planete, true);
+
+					if ($tempsEcoule >= $tempsNecessaire)
+					{
+						$metal = dAlliancesBatiments::metal($element[0], $lvl, $planete);
+						$cristal = dAlliancesBatiments::cristal($element[0], $lvl, $planete);
+						$hydrogene = dAlliancesBatiments::hydrogene($element[0], $lvl, $planete);
+
+						//On redonne 70% des ressources du batiment au joueur
+						$planete->addRessources($metal*0.7, $cristal*0.7, $hydrogene*0.7);
+
+						//On retire un niveau au batiment
+						$planete->batiments[$element[0]]--;
+
+						//On efface l'entrée de la file et on met à jour le temps de la file
+						unset($this->files[$keyF][$keyE]);
+						$this->times[$keyF] += $tempsNecessaire;
+
+						//On demande la mise à jour des champs modifiés
+						$planete->addModif(array("batiments", $element[0]));
+						$planete->addModif("file_bat");
+
+						//On retire les points
+						$planete->addPoints($metal, $cristal, $hydrogene, 0, true);
+
+						unset($metal, $cristal, $hydrogene);
+					}
+					//Si le temps écoulé n'est pas suffisant pour ce batiment, on annule tous les suivants
+					else
+						break;
+				}
+				else //Cas de la construction
+				{
+					//Récupération du niveau du batiment
+					$lvl = $planete->batiments[$element[0]] + 1;
+
+					$tempsNecessaire = dAlliancesBatiments::temps($element[0], $lvl, $planete);
+
+					//Si le temps écoulé est suffisant
+					if ($tempsEcoule >= $tempsNecessaire)
+					{
+						//On ajoute un niveau au batiment
+						$planete->batiments[$element[0]]++;
+
+						//On efface l'entrée de la file et on met à jour le temps de la file
+						unset($this->files[$keyF][$keyE]);
+						$this->times[$keyF] += $tempsNecessaire;
+
+						//On demande la mise à jour des champs modifiés
+						$planete->addModif(array("batiments", $element[0]));
+						$planete->addModif("file_bat");
+
+						//On ajoute les points
+						$planete->addPoints(dAlliancesBatiments::metal($element[0], $planete->batiments[$element[0]], $planete), dAlliancesBatiments::cristal($element[0], $planete->batiments[$element[0]], $planete), dAlliancesBatiments::hydrogene($element[0], $planete->batiments[$element[0]], $planete));
+					}
+					//Si le temps écoulé n'est pas suffisant pour ce batiment, on annule tous les suivants
+					else
+						break;
+				}
+			}
+
+		}
+	}
+
+
+	public function printFile(SURFACE $planete, $lieu = NULL)
+	{
+		$out = array();
+		foreach ($this->files as $keyF => $file)
+		{
+			if (isset($lieu) && $lieu != $keyF)
+				continue;
+
+			$prems = true;
+			foreach ($file as $keyE => $element)
+			{
+				if ($element[1]) //Cas d'une démolition
+				{
+					$temps = dAlliancesBatiments::temps($element[0], $planete->batiments[$element[0]], $planete, true);
+					if ($prems)
+						$temps -= time() - $this->times[$keyF];
+					$out[$keyF][$keyE] = array($element[0], $element[1], ceil($temps), $prems);
+				}
+				else //Cas d'une construction
+				{
+					$temps = dAlliancesBatiments::temps($element[0], $planete->batiments[$element[0]]+1, $planete);
+					if ($prems)
+						$temps -= time() - $this->times[$keyF];
+					$out[$keyF][$keyE] = array($element[0], $element[1], ceil($temps), $prems);
+				}
+				$prems = false;
+			}
+		}
+		return $out;
+	}
+}
+?>

onyx2/include/Class/File/batiments.php

@@ -0,0 +1,268 @@
+<?php
+require_once("Class/File/interface.php");
+
+class FileBatiments extends FileCommun implements File
+{
+	public function objectInFile($object)
+	{
+		foreach($this->files as $keyF => $file)
+		{
+			foreach($file as $keyE => $element)
+			{
+				if ($element[0] == $object)
+					return array($keyF, $keyE);
+			}
+		}
+		return false;
+	}
+
+	public function nbObjectInFile($object, $type = null)
+	{
+		$c = 0;
+		if (!isset($object))
+		{
+			foreach($this->files as $file)
+			{
+				$c += count($file);
+			}
+		}
+		else
+		{
+			if (!isset($type) || $type)
+			{
+				foreach($this->files as $file)
+				{
+					$c += count(array_keys($file, array($object, true)));
+				}
+			}
+			if (!isset($type) || !$type)
+			{
+				foreach($this->files as $file)
+				{
+					$c += count(array_keys($file, array($object, false)));
+				}
+			}
+		}
+		return $c;
+	}
+
+	public function addObjet($object, $nombre, surface $planete)
+	{
+		//On vérifie que l'on ne dépasse pas la taille maximale de la file
+		if (!$this->checkMaxSize($planete))
+			throw new ExceptionHB(1, 1);
+
+		//Validation des conditions de construction
+		if (!dBatiments::needed($object, $planete))
+			throw new ExceptionHB(1, 2);
+
+		//On vérifie qu'il n'y ait pas une demande de démolition du même bâtiment
+		if ($this->nbObjectInFile($object, true) >= 1)
+			throw new ExceptionHB(1, 7);
+
+		//On vérifie qu'il reste suffisamment de place sur la planète
+		if ($planete->casesRest <= 0 || $planete->casesRest <= $this->nbObjectInFile(null))
+			throw new ExceptionHB(1, 0);
+
+		//Calcul du prochain niveau du batiment
+		$nextLvl = $planete->batiments[$object] + $this->nbObjectInFile($object, false) + 1;
+
+		//On recherche le lieu ayant le moins de construction en cours
+		$lieu = $this->findShorter();
+
+		//On rafraîchit le temps de la file si aucun objet n'est en file d'attente
+		$this->refreshTime($lieu);
+
+		//On vérifie qu'il y ait assez de ressources sur la planète
+		if ($planete->checkAndRetireRessources(dBatiments::metal($object, $nextLvl, $planete), dBatiments::cristal($object, $nextLvl, $planete), dBatiments::hydrogene($object, $nextLvl, $planete), dBatiments::credits($object, $nextLvl, $planete)))
+		{
+			$this->files[$lieu][] = array($object, false);
+			$planete->addModif("file_bat");
+			return true;
+		}
+		else
+			throw new ExceptionHB(1, 4);
+	}
+
+	public function addDemolition($object, $nombre, surface $planete)
+	{
+		//On vérifie que l'on ne dépasse pas la taille maximale de la file
+		if (!$this->checkMaxSize($planete))
+			throw new ExceptionHB(1, 1);
+
+		//On vérifie que le niveau actuel du batiment ne soit non nul
+		if ($planete->batiments[$object] <= $this->nbObjectInFile($object, false))
+			throw new ExceptionHB(1, 6);
+
+		//On vérifie qu'il n'y ait pas une demande de construction du même bâtiment
+		if ($this->nbObjectInFile($object, false) >= 1)
+			throw new ExceptionHB(1, 7);
+
+		//On recherche le lieu ayant le moins de construction en cours
+		$lieu = $this->findShorter();
+
+		//On rafraîchit le temps de la file si aucun objet n'est en file d'attente
+		$this->refreshTime($lieu);
+
+		$this->files[$lieu][] = array($object, true);
+
+		$planete->addModif("file_bat");
+
+		return true;
+	}
+
+	public function delObjet($id, $nombre, $lieu, surface $planete)
+	{
+		//Vérification de l'existance de l'objet en file d'attente
+		if (empty($this->files[$lieu][$id]))
+			throw new ExceptionHB(1, 5);
+
+		//On récupère le type de batiment
+		$object = $this->files[$lieu][$id][0];
+
+		//On gère les démolition
+		//@todo -cFileBatiments Est-ce vraiment utile de calculer le niveau du batiment en cas de démolition ?
+		if ($this->files[$lieu][$id][1])
+			$lvlAnnule = $planete->batiments[$object] - $this->nbObjectInFile($object, true) + 1;
+		else
+			$lvlAnnule = $planete->batiments[$object] + $this->nbObjectInFile($object, false);
+
+		//On met à jour le temps si on vient d'annuler le premier batiment en lice
+		if ($id == $this->findFirstKey($lieu))
+			$this->times[$lieu] = time();
+
+		$planete->addModif("file_bat");
+
+		if (!$this->files[$lieu][$id][1])
+		{
+			//On redonne 60% des ressources au joueur si c'est la première construction dans la file d'attente
+			if ($id == 0)
+				$planete->addRessources(dBatiments::metal($object, $lvlAnnule, $planete)*0.6, dBatiments::cristal($object, $lvlAnnule, $planete)*0.6, dBatiments::hydrogene($object, $lvlAnnule, $planete)*0.6, dBatiments::credits($object, $lvlAnnule, $planete)*0.6);
+			else
+				$planete->addRessources(dBatiments::metal($object, $lvlAnnule, $planete), dBatiments::cristal($object, $lvlAnnule, $planete), dBatiments::hydrogene($object, $lvlAnnule, $planete), dBatiments::credits($object, $lvlAnnule, $planete));
+		}
+
+		//Effacement de la file
+		unset($this->files[$lieu][$id]);
+
+		return true;
+	}
+
+	public function ready(SURFACE $planete)
+	{
+		//On parcourt la liste des lieux de construction
+		foreach($this->files as $keyF => $file)
+		{
+			//On vérifie qu'il y a bien des éléments dans cette file d'attente
+			if (count($file) == 0)
+				continue;
+
+			//On parcourt la file
+			foreach ($file as $keyE => $element)
+			{
+				$tempsEcoule = time() - $this->times[$keyF];
+
+				//On gère les démolitions
+				if ($element[1])
+				{
+					//On récupère le niveau actuel du batiment
+					$lvl = $planete->batiments[$element[0]];
+
+					//On calcul le temps de démolition nécessaire (60% du niveau actuel)
+					$tempsNecessaire = dBatiments::temps($element[0], $lvl, $planete, true);
+
+					if ($tempsEcoule >= $tempsNecessaire)
+					{
+						$metal = dBatiments::metal($element[0], $lvl, $planete);
+						$cristal = dBatiments::cristal($element[0], $lvl, $planete);
+						$hydrogene = dBatiments::hydrogene($element[0], $lvl, $planete);
+
+						//On redonne 70% des ressources du batiment au joueur
+						$planete->addRessources($metal*0.7, $cristal*0.7, $hydrogene*0.7);
+
+						//On retire un niveau au batiment
+						$planete->batiments[$element[0]]--;
+
+						//On efface l'entrée de la file et on met à jour le temps de la file
+						unset($this->files[$keyF][$keyE]);
+						$this->times[$keyF] += $tempsNecessaire;
+
+						//On demande la mise à jour des champs modifiés
+						$planete->addModif(array("batiments", $element[0]));
+						$planete->addModif("file_bat");
+
+						//On retire les points
+						$planete->addPoints($metal, $cristal, $hydrogene, 0, true);
+
+						unset($metal, $cristal, $hydrogene);
+					}
+					//Si le temps écoulé n'est pas suffisant pour ce batiment, on annule tous les suivants
+					else
+						break;
+				}
+				else //Cas de la construction
+				{
+					//Récupération du niveau du batiment
+					$lvl = $planete->batiments[$element[0]] + 1;
+
+					$tempsNecessaire = dBatiments::temps($element[0], $lvl, $planete);
+
+					//Si le temps écoulé est suffisant
+					if ($tempsEcoule >= $tempsNecessaire)
+					{
+						//On ajoute un niveau au batiment
+						$planete->batiments[$element[0]]++;
+
+						//On efface l'entrée de la file et on met à jour le temps de la file
+						unset($this->files[$keyF][$keyE]);
+						$this->times[$keyF] += $tempsNecessaire;
+
+						//On demande la mise à jour des champs modifiés
+						$planete->addModif(array("batiments", $element[0]));
+						$planete->addModif("file_bat");
+
+						//On ajoute les points
+						$planete->addPoints(dBatiments::metal($element[0], $planete->batiments[$element[0]], $planete), dBatiments::cristal($element[0], $planete->batiments[$element[0]], $planete), dBatiments::hydrogene($element[0], $planete->batiments[$element[0]], $planete));
+					}
+					//Si le temps écoulé n'est pas suffisant pour ce batiment, on annule tous les suivants
+					else
+						break;
+				}
+			}
+
+		}
+	}
+
+
+	public function printFile(SURFACE $planete, $lieu = null)
+	{
+		$out = array();
+		foreach ($this->files as $keyF => $file)
+		{
+			if (isset($lieu) && $lieu != $keyF)
+				continue;
+
+			$prems = true;
+			foreach ($file as $keyE => $element)
+			{
+				if ($element[1]) //Cas d'une démolition
+				{
+					$temps = dBatiments::temps($element[0], $planete->batiments[$element[0]], $planete, true);
+					if ($prems)
+						$temps -= time() - $this->times[$keyF];
+					$out[$keyF][$keyE] = array($element[0], $element[1], ceil($temps), $prems);
+				}
+				else //Cas d'une construction
+				{
+					$temps = dBatiments::temps($element[0], $planete->batiments[$element[0]]+1, $planete);
+					if ($prems)
+						$temps -= time() - $this->times[$keyF];
+					$out[$keyF][$keyE] = array($element[0], $element[1], ceil($temps), $prems);
+				}
+				$prems = false;
+			}
+		}
+		return $out;
+	}
+}
+?>

onyx2/include/Class/File/caserne.php

@@ -0,0 +1,309 @@
+<?php
+require_once("Class/File/interface.php");
+
+class FileCaserne extends FileCommun implements File
+{
+	public function objectInFile($object, $lieu = null)
+	{
+		if (isset($lieu))
+		{
+			if (!empty($this->files[$lieu]))
+			{
+				foreach($this->files[$lieu] as $keyE => $element)
+				{
+					if ($element[0] == $object)
+						return array($lieu, $keyE);
+				}
+			}
+		}
+		else
+		{
+			foreach($this->files as $keyF => $file)
+			{
+				foreach($file as $keyE => $element)
+				{
+					if ($element[0] == $object)
+						return array($keyF, $keyE);
+				}
+			}
+		}
+
+		return false;
+	}
+
+	public function nbObjectInFile($object)
+	{
+		$c = 0;
+		foreach($this->files as $key => $file)
+		{
+			foreach($file as $element)
+			{
+				if ($element[0] == $object)
+					$c += $element[1];
+			}
+		}
+		return $c;
+	}
+
+	public function addObjet($object, $nombre, surface $planete, $lieu = null)
+	{
+		//Vérification du nombre passé en entrée
+		if (!is_numeric($nombre) || $nombre < 0 || $nombre > 99999)
+			throw new ExceptionHB(3, 8);
+
+		//Validation des conditions de construction
+		if (!dCaserne::needed($object, $planete))
+			throw new ExceptionHB(3, 2);
+
+		//On vérifie que l'on ne dépasse pas la taille maximale de la file
+		if (!($sauvLastKey = $this->objectInFile($object, $lieu)) && !$this->checkMaxSize($planete, $lieu))
+			throw new ExceptionHB(3, 1);
+
+		//On tronque au maximum d'unités constructible sur la planète
+		if (($metal = dCaserne::metal($object, 1, $planete)) > 0)
+			$metal = $planete->metal/$metal;
+		else
+			$metal = $nombre;
+		if (($cristal = dCaserne::cristal($object, 1, $planete)) > 0)
+			$cristal = $planete->cristal/$cristal;
+		else
+			$cristal = $nombre;
+		if (($hydrogene = dCaserne::hydrogene($object, 1, $planete)) > 0)
+			$hydrogene = $planete->hydrogene/$hydrogene;
+		else
+			$hydrogene = $nombre;
+
+		$nombre = floor(min($nombre, $metal, $cristal, $hydrogene));
+
+		//On vérifie qu'il y ait assez de ressources sur la planète
+		if ($planete->checkAndRetireRessources(dCaserne::metal($object, $nombre, $planete), dCaserne::cristal($object, $nombre, $planete), dCaserne::hydrogene($object, $nombre, $planete), dCaserne::credits($object, $nombre, $planete)))
+		{
+			//Si il existe déjà l'objet en file d'attente, on l'ajoute
+			if(isset($sauvLastKey) && isset($this->files[$sauvLastKey[0]][$sauvLastKey[1]]))
+			{
+				//On rafraîchit le temps de la file si aucun objet n'est en file d'attente
+				$this->refreshTime($sauvLastKey[0]);
+
+				$this->files[$sauvLastKey[0]][$sauvLastKey[1]][1] += $nombre;
+			}
+			else
+			{
+				if (!isset($lieu))
+				{
+					//On recherche le lieu ayant le moins de construction en cours
+					$lieu = $this->findShorter();
+				}
+
+				//On rafraîchit le temps de la file si aucun objet n'est en file d'attente
+				$this->refreshTime($lieu);
+
+				$this->files[$lieu][] = array($object, $nombre, false);
+			}
+
+			$planete->addModif("file_cas");
+			return true;
+		}
+		else
+			throw new ExceptionHB(3, 4);
+	}
+
+	public function addDemolition($object, $nombre, surface $planete, $lieu = null)
+	{
+		//On vérifie que l'on ne dépasse pas la taille maximale de la file
+		if (!$this->checkMaxSize($planete, $lieu) && !($sauvLastKey = $this->objectInFile($object, $lieu)))
+			throw new ExceptionHB(3, 1);
+
+		//Vérification du nombre passé en entrée
+		if (!is_numeric($nombre) || $nombre < 0 || $nombre > 99999)
+			throw new ExceptionHB(3, 8);
+
+		//On vérifie que le nombre d'unité actuel soit non nul
+		if ($planete->casernes[$object] < $nombre)
+			throw new ExceptionHB(3, 6);
+
+		if (!isset($lieu))
+		{
+			//On recherche le lieu ayant le moins de construction en cours
+			$lieu = $this->findShorter();
+		}
+
+		//On rafraîchit le temps de la file si aucun objet n'est en file d'attente
+		$this->refreshTime($lieu);
+
+		//Si il existe déjà l'objet en file d'attente, on l'ajoute
+		if(isset($sauvLastKey))
+			$this->files[$sauvLastKey[0]][$sauvLastKey[1]][1] += $nombre;
+		else
+			$this->files[$lieu][] = array($object, $nombre, false);
+
+		$planete->addModif("file_cas");
+
+		return true;
+	}
+
+	public function delObjet($id, $nombre, $lieu, surface $planete)
+	{
+		//Vérification de l'existance de l'objet en file d'attente
+		if (empty($this->files[$lieu][$id]))
+			throw new ExceptionHB(1, 5);
+
+		//Si $nombre est supérieur au nombre présent dans la file, on le réduit
+		if ($this->files[$lieu][$id][1] < $nombre)
+			$nombre = $this->files[$lieu][$id][1];
+
+		//On récupère les informations disponibles
+		$objet = $this->files[$lieu][$id][0];
+		$nombreMax = $this->files[$lieu][$id][1];
+
+		//On met à jour le temps si on vient d'annuler le premier groupe d'unités en lice
+		if ($id == $this->findFirstKey($lieu) && $nombreMax == $nombre)
+			$this->times[$lieu] = time();
+
+		$planete->addModif("file_cas");
+
+		if (!$this->files[$lieu][$id][2])
+			$planete->addRessources(dCaserne::metal($objet, $nombre, $planete), dCaserne::cristal($objet, $nombre, $planete), dCaserne::hydrogene($objet, $nombre, $planete), dCaserne::credits($objet, $nombre, $planete));
+
+		//Effacement de la file
+		if ($nombre >= $nombreMax)
+			unset($this->files[$lieu][$id]);
+		else
+			$this->files[$lieu][$id][1] -= $nombre;
+		$planete->addModif("file_cas");
+
+		return true;
+	}
+
+	public function ready(SURFACE $planete)
+	{
+		//On parcourt la liste des lieux de construction
+		foreach($this->files as $keyF => $file)
+		{
+			//On vérifie qu'il y a bien des éléments dans cette file d'attente
+			if (count($file) == 0)
+				continue;
+
+			//On parcourt la liste à la recherche des unités terminées dans l'ordre
+			foreach($file as $keyE => $element)
+			{
+				//Calcul du temps écoulé depuis le dernier entraînement
+				$tempsEcoule = time() - $this->times[$keyF];
+
+				//On gére les licenciments !
+				if ($element[2])
+				{
+					//On vérifie qu'il reste des unités du type sur la planète
+					if ($planete->casernes[$element[0]] <= 0)
+					{
+						unset($this->files[$keyF][$keyE]);
+						$planete->addModif("file_cas");
+					}
+					else
+					{
+						//Récupération de 60% du temps nécessaire
+						$tempsNecessaire = dCaserne::temps($element[0], 1, $planete) * 0.6;
+
+						//Calcul du nombre d'unités maximum
+						$nbUnitee = min(floor($tempsEcoule/$tempsNecessaire), $element[1], $planete->casernes[$element[0]]);
+
+						//Si le temps écoulé est suffisant
+						if ($nbUnitee > 0)
+						{
+							//On redonne 70% des ressources de l'unité au joueur
+							$planete->addRessources(dCaserne::metal($element[0], $nbUnitee, $planete)*0.7, dCaserne::cristal($element[0], $nbUnitee, $planete)*0.7, dCaserne::hydrogene($element[0], $nbUnitee, $planete)*0.7, dCaserne::credits($element[0], $nbUnitee, $planete)*0.7);
+
+							//On retire les unités
+							$planete->casernes[$element[0]] -= $nbUnitee;
+
+							//On efface l'entrée de la file et on met à jour le temps de la file
+							if ($nbUnitee >= $element[1])
+								unset($this->filefiles[$keyF][$keyE]);
+							else
+								$this->file[$key][1] -= $nbUnitee;
+							$this->timefiles[$keyF] += $tempsNecessaire*$nbUnitee;
+
+							//On demande la mise à jour des champs modifiés
+							$planete->addModif(array("casernes", $element[0]));
+							$planete->addModif("file_cas");
+
+							if ($nbUnitee < $element[1])
+								return false;
+						}
+						//Si le temps écoulé n'est pas suffisant pour cette unité, on annule toutes les suivantes
+						else
+							break;
+					}
+				}
+				else //Cas de la construction
+				{
+					//Récupération du temps nécessaire
+					$tempsNecessaire = dCaserne::temps($element[0], 1, $planete);
+
+					//Calcul du nombre d'unités maximum
+					$nbUnitee = min(floor($tempsEcoule/$tempsNecessaire), $element[1]);
+
+					//Si le temps écoulé est suffisant
+					if ($nbUnitee > 0)
+					{
+						//On ajoute le nombre d'unités
+						$planete->casernes[$element[0]] += $nbUnitee;
+
+						//On efface l'entrée de la file et on met à jour le temps de la file
+						if ($nbUnitee >= $element[1])
+							unset($this->files[$keyF][$keyE]);
+						else
+							$this->files[$keyF][$keyE][1] -= $nbUnitee;
+						$this->times[$keyF] += $tempsNecessaire * $nbUnitee;
+
+						//On demande la mise à jour des champs modifiés
+						$planete->addModif(array("casernes", $element[0]));
+						$planete->addModif("file_cas");
+
+						if ($nbUnitee < $element[1])
+							break;
+					}
+					//Si le temps écoulé n'est pas suffisant pour ce batiment, on annule tous les suivants
+					else
+						break;
+				}
+			}
+		}
+	}
+
+
+	function printFile(SURFACE $planete, $lieu = NULL)
+	{
+		$out = array();
+		foreach ($this->files as $keyF => $file)
+		{
+			if (isset($lieu) && $lieu != $keyF)
+				continue;
+
+			$prems = true;
+			foreach ($file as $keyE => $element)
+			{
+				if ($element[2])
+				{
+					$temps = dCaserne::temps($element[0], 1, $planete) * 0.6;
+					if ($prems)
+						$temps_moins = time() - $this->times[$keyF];
+					else
+						$temps_moins = 0;
+					$out[$keyF][$keyE] = array($element[0], $element[1], $element[2], ceil($temps * $element[1] - $temps_moins), ceil($temps - $temps_moins), $prems);
+				}
+				else
+				{
+					$temps = dCaserne::temps($element[0], 1, $planete);
+					if ($prems)
+						$temps_moins = time() - $this->times[$keyF];
+					else
+						$temps_moins = 0;
+					$out[$keyF][$keyE] = array($element[0], $element[1], $element[2], ceil($temps * $element[1] - $temps_moins), ceil($temps - $temps_moins), $prems);
+				}
+				$prems = false;
+			}
+		}
+		return $out;
+	}
+}
+?>

onyx2/include/Class/File/interface.php

@@ -0,0 +1,113 @@
+<?php
+if(!defined('ONYX')) exit;
+
+interface File
+{
+	public function objectInFile($object);
+	public function nbObjectInFile($object);
+	public function addObjet($object, $nombre, surface $planete);
+	public function addDemolition($object, $nombre, surface $planete);
+	public function delObjet($id, $nombre, $lieu, surface $planete);
+	public function ready(surface $planete);
+
+	public function printFile(surface $planete, $lieu = NULL);
+}
+
+class FileCommun
+{
+	protected $files = array();
+	protected $times = array();
+	protected $simultane;
+
+	function __construct()
+	{
+		$this->times[] = time();
+		$this->simultane = 1;
+	}
+
+	function refreshTime($lieu)
+	{
+		if (empty($this->files[$lieu]) || count($this->files[$lieu]) < 1)
+			$this->times[$lieu] = time();
+	}
+
+	function reajusteVacances($timelost)
+	{
+		foreach($this->times as $key => $time)
+			$this->times[$key] += $timelost;
+
+		return serialize($this);
+	}
+
+	function hasObject()
+	{
+		foreach($this->files as $file)
+		{
+			if (count($file) > 0)
+				return true;
+		}
+
+		return false;
+	}
+
+	function checkMaxSize(surface $planete, $lieu = null)
+	{
+		$nombre = 0;
+		if (isset($lieu))
+		{
+			if (!empty($this->files[$lieu]))
+				$nombre = count($this->files[$lieu]);
+		}
+		else
+		{
+			foreach($this->files as $file)
+			{
+				$nombre += count($file);
+			}
+		}
+
+
+		return ($nombre < dDonnees::tailleFile($planete));
+	}
+
+	function findShorter()
+	{
+		$short = 0;
+		$value = 99;
+		foreach($this->files as $key => $file)
+		{
+			if ($key >= $this->simultane)
+				break;
+
+			$count = count($file);
+			if ($value > $count)
+			{
+				$value = $count;
+				$short = $key;
+			}
+		}
+
+		return $short;
+	}
+
+	function findFirstKey($lieu)
+	{
+		foreach($this->files[$lieu] as $key => $file)
+			return $key;
+	}
+
+
+	function DEBUG__print()
+	{
+		var_dump($this);
+		var_dump($this->files);
+	}
+
+	function DEBUG__setTime($lieu, $moins)
+	{
+		$this->times[$lieu] -= $moins;
+
+		return $this->times[$lieu];
+	}
+}
+?>

onyx2/include/Class/File/spatial.php

@@ -0,0 +1,309 @@
+<?php
+require_once("Class/File/interface.php");
+
+class FileSpatial extends FileCommun implements File
+{
+	public function objectInFile($object, $lieu = null)
+	{
+		if (isset($lieu))
+		{
+			if (!empty($this->files[$lieu]))
+			{
+				foreach($this->files[$lieu] as $keyE => $element)
+				{
+					if ($element[0] == $object)
+						return array($lieu, $keyE);
+				}
+			}
+		}
+		else
+		{
+			foreach($this->files as $keyF => $file)
+			{
+				foreach($file as $keyE => $element)
+				{
+					if ($element[0] == $object)
+						return array($keyF, $keyE);
+				}
+			}
+		}
+
+		return false;
+	}
+
+	public function nbObjectInFile($object)
+	{
+		$c = 0;
+		foreach($this->files as $key => $file)
+		{
+			foreach($file as $element)
+			{
+				if ($element[0] == $object)
+					$c += $element[1];
+			}
+		}
+		return $c;
+	}
+
+	public function addObjet($object, $nombre, surface $planete, $lieu = null)
+	{
+		//Vérification du nombre passé en entrée
+		if (!is_numeric($nombre) || $nombre < 0 || $nombre > 99999)
+			throw new ExceptionHB(3, 8);
+
+		//Validation des conditions de construction
+		if (!dSpatial::needed($object, $planete))
+			throw new ExceptionHB(3, 2);
+
+		//On vérifie que l'on ne dépasse pas la taille maximale de la file
+		if (!($sauvLastKey = $this->objectInFile($object, $lieu)) && !$this->checkMaxSize($planete, $lieu))
+			throw new ExceptionHB(3, 1);
+
+		//On tronque au maximum d'unités constructible sur la planète
+		if (($metal = dSpatial::metal($object, 1, $planete)) > 0)
+			$metal = $planete->metal/$metal;
+		else
+			$metal = $nombre;
+		if (($cristal = dSpatial::cristal($object, 1, $planete)) > 0)
+			$cristal = $planete->cristal/$cristal;
+		else
+			$cristal = $nombre;
+		if (($hydrogene = dSpatial::hydrogene($object, 1, $planete)) > 0)
+			$hydrogene = $planete->hydrogene/$hydrogene;
+		else
+			$hydrogene = $nombre;
+
+		$nombre = floor(min($nombre, $metal, $cristal, $hydrogene));
+
+		//On vérifie qu'il y ait assez de ressources sur la planète
+		if ($planete->checkAndRetireRessources(dSpatial::metal($object, $nombre, $planete), dSpatial::cristal($object, $nombre, $planete), dSpatial::hydrogene($object, $nombre, $planete), dSpatial::credits($object, $nombre, $planete)))
+		{
+			//Si il existe déjà l'objet en file d'attente, on l'ajoute
+			if(isset($sauvLastKey) && isset($this->files[$sauvLastKey[0]][$sauvLastKey[1]]))
+			{
+				//On rafraîchit le temps de la file si aucun objet n'est en file d'attente
+				$this->refreshTime($sauvLastKey[0]);
+
+				$this->files[$sauvLastKey[0]][$sauvLastKey[1]][1] += $nombre;
+			}
+			else
+			{
+				if (!isset($lieu))
+				{
+					//On recherche le lieu ayant le moins de construction en cours
+					$lieu = $this->findShorter();
+				}
+
+				//On rafraîchit le temps de la file si aucun objet n'est en file d'attente
+				$this->refreshTime($lieu);
+
+				$this->files[$lieu][] = array($object, $nombre, false);
+			}
+
+			$planete->addModif("file_vais");
+			return true;
+		}
+		else
+			throw new ExceptionHB(3, 4);
+	}
+
+	public function addDemolition($object, $nombre, surface $planete, $lieu = null)
+	{
+		//On vérifie que l'on ne dépasse pas la taille maximale de la file
+		if (!$this->checkMaxSize($planete, $lieu) && !($sauvLastKey = $this->objectInFile($object, $lieu)))
+			throw new ExceptionHB(3, 1);
+
+		//Vérification du nombre passé en entrée
+		if (!is_numeric($nombre) || $nombre < 0 || $nombre > 99999)
+			throw new ExceptionHB(3, 8);
+
+		//On vérifie que le nombre d'unité actuel soit non nul
+		if ($planete->vaisseaux[$object] < $nombre)
+			throw new ExceptionHB(3, 6);
+
+		if (!isset($lieu))
+		{
+			//On recherche le lieu ayant le moins de construction en cours
+			$lieu = $this->findShorter();
+		}
+
+		//On rafraîchit le temps de la file si aucun objet n'est en file d'attente
+		$this->refreshTime($lieu);
+
+		//Si il existe déjà l'objet en file d'attente, on l'ajoute
+		if(isset($sauvLastKey))
+			$this->files[$sauvLastKey[0]][$sauvLastKey[1]][1] += $nombre;
+		else
+			$this->files[$lieu][] = array($object, $nombre, false);
+
+		$planete->addModif("file_vais");
+
+		return true;
+	}
+
+	public function delObjet($id, $nombre, $lieu, surface $planete)
+	{
+		//Vérification de l'existance de l'objet en file d'attente
+		if (empty($this->files[$lieu][$id]))
+			throw new ExceptionHB(1, 5);
+
+		//Si $nombre est supérieur au nombre présent dans la file, on le réduit
+		if ($this->files[$lieu][$id][1] < $nombre)
+			$nombre = $this->files[$lieu][$id][1];
+
+		//On récupère les informations disponibles
+		$objet = $this->files[$lieu][$id][0];
+		$nombreMax = $this->files[$lieu][$id][1];
+
+		//On met à jour le temps si on vient d'annuler le premier groupe d'unités en lice
+		if ($id == $this->findFirstKey($lieu) && $nombreMax == $nombre)
+			$this->times[$lieu] = time();
+
+		$planete->addModif("file_vais");
+
+		if (!$this->files[$lieu][$id][2])
+			$planete->addRessources(dSpatial::metal($objet, $nombre, $planete), dSpatial::cristal($objet, $nombre, $planete), dSpatial::hydrogene($objet, $nombre, $planete), dSpatial::credits($objet, $nombre, $planete));
+
+		//Effacement de la file
+		if ($nombre >= $nombreMax)
+			unset($this->files[$lieu][$id]);
+		else
+			$this->files[$lieu][$id][1] -= $nombre;
+		$planete->addModif("file_vais");
+
+		return true;
+	}
+
+	public function ready(SURFACE $planete)
+	{
+		//On parcourt la liste des lieux de construction
+		foreach($this->files as $keyF => $file)
+		{
+			//On vérifie qu'il y a bien des éléments dans cette file d'attente
+			if (count($file) == 0)
+				continue;
+
+			//On parcourt la liste à la recherche des unités terminées dans l'ordre
+			foreach($file as $keyE => $element)
+			{
+				//Calcul du temps écoulé depuis le dernier entraînement
+				$tempsEcoule = time() - $this->times[$keyF];
+
+				//On gére les licenciments !
+				if ($element[2])
+				{
+					//On vérifie qu'il reste des unités du type sur la planète
+					if ($planete->vaisseaux[$element[0]] <= 0)
+					{
+						unset($this->files[$keyF][$keyE]);
+						$planete->addModif("file_vais");
+					}
+					else
+					{
+						//Récupération de 60% du temps nécessaire
+						$tempsNecessaire = dSpatial::temps($element[0], 1, $planete) * 0.6;
+
+						//Calcul du nombre d'unités maximum
+						$nbUnitee = min(floor($tempsEcoule/$tempsNecessaire), $element[1], $planete->vaisseaux[$element[0]]);
+
+						//Si le temps écoulé est suffisant
+						if ($nbUnitee > 0)
+						{
+							//On redonne 70% des ressources de l'unité au joueur
+							$planete->addRessources(dSpatial::metal($element[0], $nbUnitee, $planete)*0.7, dSpatial::cristal($element[0], $nbUnitee, $planete)*0.7, dSpatial::hydrogene($element[0], $nbUnitee, $planete)*0.7, dSpatial::credits($element[0], $nbUnitee, $planete)*0.7);
+
+							//On retire les unités
+							$planete->vaisseaux[$element[0]] -= $nbUnitee;
+
+							//On efface l'entrée de la file et on met à jour le temps de la file
+							if ($nbUnitee >= $element[1])
+								unset($this->filefiles[$keyF][$keyE]);
+							else
+								$this->file[$key][1] -= $nbUnitee;
+							$this->timefiles[$keyF] += $tempsNecessaire*$nbUnitee;
+
+							//On demande la mise à jour des champs modifiés
+							$planete->addModif(array("vaisseaux", $element[0]));
+							$planete->addModif("file_vais");
+
+							if ($nbUnitee < $element[1])
+								return false;
+						}
+						//Si le temps écoulé n'est pas suffisant pour cette unité, on annule toutes les suivantes
+						else
+							break;
+					}
+				}
+				else //Cas de la construction
+				{
+					//Récupération du temps nécessaire
+					$tempsNecessaire = dSpatial::temps($element[0], 1, $planete);
+
+					//Calcul du nombre d'unités maximum
+					$nbUnitee = min(floor($tempsEcoule/$tempsNecessaire), $element[1]);
+
+					//Si le temps écoulé est suffisant
+					if ($nbUnitee > 0)
+					{
+						//On ajoute le nombre d'unités
+						$planete->vaisseaux[$element[0]] += $nbUnitee;
+
+						//On efface l'entrée de la file et on met à jour le temps de la file
+						if ($nbUnitee >= $element[1])
+							unset($this->files[$keyF][$keyE]);
+						else
+							$this->files[$keyF][$keyE][1] -= $nbUnitee;
+						$this->times[$keyF] += $tempsNecessaire * $nbUnitee;
+
+						//On demande la mise à jour des champs modifiés
+						$planete->addModif(array("vaisseaux", $element[0]));
+						$planete->addModif("file_vais");
+
+						if ($nbUnitee < $element[1])
+							break;
+					}
+					//Si le temps écoulé n'est pas suffisant pour ce batiment, on annule tous les suivants
+					else
+						break;
+				}
+			}
+		}
+	}
+
+
+	function printFile(SURFACE $planete, $lieu = NULL)
+	{
+		$out = array();
+		foreach ($this->files as $keyF => $file)
+		{
+			if (isset($lieu) && $lieu != $keyF)
+				continue;
+
+			$prems = true;
+			foreach ($file as $keyE => $element)
+			{
+				if ($element[2])
+				{
+					$temps = dSpatial::temps($element[0], 1, $planete) * 0.6;
+					if ($prems)
+						$temps_moins = time() - $this->times[$keyF];
+					else
+						$temps_moins = 0;
+					$out[$keyF][$keyE] = array($element[0], $element[1], $element[2], ceil($temps * $element[1] - $temps_moins), ceil($temps - $temps_moins), $prems);
+				}
+				else
+				{
+					$temps = dSpatial::temps($element[0], 1, $planete);
+					if ($prems)
+						$temps_moins = time() - $this->times[$keyF];
+					else
+						$temps_moins = 0;
+					$out[$keyF][$keyE] = array($element[0], $element[1], $element[2], ceil($temps * $element[1] - $temps_moins), ceil($temps - $temps_moins), $prems);
+				}
+				$prems = false;
+			}
+		}
+		return $out;
+	}
+}
+?>

onyx2/include/Class/File/technologies.php

@@ -0,0 +1,163 @@
+<?php
+require_once("Class/File/interface.php");
+
+//Un object au sens technologie est définit par un tableau : array($branche, $tech);
+
+class FileTechnologies extends FileCommun implements File
+{
+	public function objectInFile($object)
+	{
+		foreach($this->files as $keyF => $file)
+		{
+			foreach($file as $keyE => $element)
+			{
+				if ($element[0] == $object)
+					return array($keyF, $keyE);
+			}
+		}
+		return false;
+	}
+
+	public function nbObjectInFile($branche, $tech = null)
+	{
+		$c = 0;
+		foreach($this->files as $file)
+		{
+			$c += count(array_keys($file, array($branche, $tech)));
+		}
+		return $c;
+	}
+
+	public function addObjet($branche, $tech, surface $planete)
+	{
+		//On vérifie que l'on ne dépasse pas la taille maximale de la file
+		if (!$this->checkMaxSize($planete))
+			throw new ExceptionHB(4, 1);
+
+		//On vérifie qu'il n'y ait pas une recherche de la même technologie
+		if ($this->nbObjectInFile($branche, $tech) >= 1)
+			throw new ExceptionHB(4, 7);
+
+		//On vérifie que la technologie ne soit pas déjà développée
+		if (dTechnologies::idToBit($tech) & $planete->technologies[$branche])
+			throw new ExceptionHB(4, 7);
+
+		//Validation des conditions de construction
+		if (!dTechnologies::needed(array($branche, $tech), $planete))
+			throw new ExceptionHB(4, 2);
+
+		//On recherche le lieu ayant le moins de construction en cours
+		$lieu = $this->findShorter();
+
+		//On rafraîchit le temps de la file si aucun objet n'est en file d'attente
+		$this->refreshTime($lieu);
+
+		//On vérifie qu'il y ait assez de ressources sur la planète
+		if ($planete->checkAndRetireRessources(dTechnologies::metal($branche, $tech, $planete), dTechnologies::cristal($branche, $tech, $planete), dTechnologies::hydrogene($branche, $tech, $planete), dTechnologies::credits($branche, $tech, $planete)))
+		{
+			$this->files[$lieu][] = array($branche, $tech);
+			$planete->addModif("file_tech");
+			return true;
+		}
+		else
+			throw new ExceptionHB(4, 4);
+	}
+
+	public function addDemolition($object, $nombre = 1, surface $planete)
+	{
+		trigger_error("Pas de démolition possible pour les technologies");
+	}
+
+	public function delObjet($id, $nombre = 1, $lieu, surface $planete)
+	{
+		//Vérification de l'existance de l'objet en file d'attente
+		if (empty($this->files[$lieu][$id]))
+			throw new ExceptionHB(4, 5);
+
+		//On récupère la branche et l'id de la technologie
+		$branche = $this->files[$lieu][$id][0];
+		$tech = $this->files[$lieu][$id][1];
+
+		//On met à jour le temps si on vient d'annuler la première recherche en lice
+		if ($tech == $this->findFirstKey($lieu))
+			$this->times[$lieu] = time();
+
+		$planete->addModif("file_tech");
+
+		//On redonne 70% des ressources au joueur si c'est la première construction dans la file d'attente
+		if ($id == 0)
+			$planete->addRessources(dTechnologies::metal($branche, $tech, $planete)*0.7, dTechnologies::cristal($branche, $tech, $planete)*0.7, dTechnologies::hydrogene($branche, $tech, $planete)*0.7, dTechnologies::credits($branche, $tech, $planete)*0.7);
+		else
+			$planete->addRessources(dTechnologies::metal($branche, $tech, $planete), dTechnologies::cristal($branche, $tech, $planete), dTechnologies::hydrogene($branche, $tech, $planete), dTechnologies::credits($branche, $tech, $planete));
+
+		//Effacement de la file
+		unset($this->files[$lieu][$id]);
+
+		return true;
+	}
+
+	public function ready(surface $planete)
+	{
+		//On parcourt la liste des lieux de recherche
+		foreach($this->files as $keyF => $file)
+		{
+			//On vérifie qu'il y a bien des éléments dans cette file d'attente
+			if (count($file) == 0)
+				continue;
+
+			//On parcourt la file
+			foreach ($file as $keyE => $element)
+			{
+				$tempsEcoule = time() - $this->times[$keyF];
+
+				$tempsNecessaire = dTechnologies::temps($element[0], $element[1], $planete);
+
+				//Si le temps écoulé est suffisant
+				if ($tempsEcoule >= $tempsNecessaire)
+				{
+					//On ajoute un niveau au batiment
+					$planete->technologies[$element[0]] = $planete->technologies[$element[0]] | dTechnologies::idToBit($element[1]);
+
+					//On efface l'entrée de la file et on met à jour le temps de la file
+					unset($this->files[$keyF][$keyE]);
+					$this->times[$keyF] += $tempsNecessaire;
+
+					//On demande la mise à jour des champs modifiés
+					$planete->addModifUser(array("technologies", $element[0]));
+					$planete->addModif("file_tech");
+
+					//On ajoute les points
+					$planete->addPoints(dTechnologies::metal($element[0], $element[0], $planete), dTechnologies::cristal($element[0], $element[1], $planete), dTechnologies::hydrogene($element[0], $element[1], $planete), dTechnologies::credits($element[0], $element[1], $planete));
+				}
+				//Si le temps écoulé n'est pas suffisant pour ce batiment, on annule tous les suivants
+				else
+					break;
+			}
+
+		}
+	}
+
+
+	public function printFile(surface $planete, $lieu = null)
+	{
+		$out = array();
+		foreach ($this->files as $keyF => $file)
+		{
+			if (isset($lieu) && $lieu != $keyF)
+				continue;
+
+			$prems = true;
+			foreach ($file as $keyE => $element)
+			{
+				$temps = dTechnologies::temps($element[0], $element[1], $planete);
+				if ($prems)
+					$temps -= time() - $this->times[$keyF];
+				$out[$keyF][$keyE] = array($element[0], $element[1], ceil($temps), $prems);
+
+				$prems = false;
+			}
+		}
+		return $out;
+	}
+}
+?>

onyx2/include/Class/File/terrestre.php

@@ -0,0 +1,309 @@
+<?php
+require_once("Class/File/interface.php");
+
+class FileTerrestre extends FileCommun implements File
+{
+	public function objectInFile($object, $lieu = null)
+	{
+		if (isset($lieu))
+		{
+			if (!empty($this->files[$lieu]))
+			{
+				foreach($this->files[$lieu] as $keyE => $element)
+				{
+					if ($element[0] == $object)
+						return array($lieu, $keyE);
+				}
+			}
+		}
+		else
+		{
+			foreach($this->files as $keyF => $file)
+			{
+				foreach($file as $keyE => $element)
+				{
+					if ($element[0] == $object)
+						return array($keyF, $keyE);
+				}
+			}
+		}
+
+		return false;
+	}
+
+	public function nbObjectInFile($object)
+	{
+		$c = 0;
+		foreach($this->files as $key => $file)
+		{
+			foreach($file as $element)
+			{
+				if ($element[0] == $object)
+					$c += $element[1];
+			}
+		}
+		return $c;
+	}
+
+	public function addObjet($object, $nombre, surface $planete, $lieu = null)
+	{
+		//Vérification du nombre passé en entrée
+		if (!is_numeric($nombre) || $nombre < 0 || $nombre > 99999)
+			throw new ExceptionHB(3, 8);
+
+		//Validation des conditions de construction
+		if (!dTerrestre::needed($object, $planete))
+			throw new ExceptionHB(3, 2);
+
+		//On vérifie que l'on ne dépasse pas la taille maximale de la file
+		if (!($sauvLastKey = $this->objectInFile($object, $lieu)) && !$this->checkMaxSize($planete, $lieu))
+			throw new ExceptionHB(3, 1);
+
+		//On tronque au maximum d'unités constructible sur la planète
+		if (($metal = dTerrestre::metal($object, 1, $planete)) > 0)
+			$metal = $planete->metal/$metal;
+		else
+			$metal = $nombre;
+		if (($cristal = dTerrestre::cristal($object, 1, $planete)) > 0)
+			$cristal = $planete->cristal/$cristal;
+		else
+			$cristal = $nombre;
+		if (($hydrogene = dTerrestre::hydrogene($object, 1, $planete)) > 0)
+			$hydrogene = $planete->hydrogene/$hydrogene;
+		else
+			$hydrogene = $nombre;
+
+		$nombre = floor(min($nombre, $metal, $cristal, $hydrogene));
+
+		//On vérifie qu'il y ait assez de ressources sur la planète
+		if ($planete->checkAndRetireRessources(dTerrestre::metal($object, $nombre, $planete), dTerrestre::cristal($object, $nombre, $planete), dTerrestre::hydrogene($object, $nombre, $planete), dTerrestre::credits($object, $nombre, $planete)))
+		{
+			//Si il existe déjà l'objet en file d'attente, on l'ajoute
+			if(isset($sauvLastKey) && isset($this->files[$sauvLastKey[0]][$sauvLastKey[1]]))
+			{
+				//On rafraîchit le temps de la file si aucun objet n'est en file d'attente
+				$this->refreshTime($sauvLastKey[0]);
+
+				$this->files[$sauvLastKey[0]][$sauvLastKey[1]][1] += $nombre;
+			}
+			else
+			{
+				if (!isset($lieu))
+				{
+					//On recherche le lieu ayant le moins de construction en cours
+					$lieu = $this->findShorter();
+				}
+
+				//On rafraîchit le temps de la file si aucun objet n'est en file d'attente
+				$this->refreshTime($lieu);
+
+				$this->files[$lieu][] = array($object, $nombre, false);
+			}
+
+			$planete->addModif("file_ter");
+			return true;
+		}
+		else
+			throw new ExceptionHB(3, 4);
+	}
+
+	public function addDemolition($object, $nombre, surface $planete, $lieu = null)
+	{
+		//On vérifie que l'on ne dépasse pas la taille maximale de la file
+		if (!$this->checkMaxSize($planete, $lieu) && !($sauvLastKey = $this->objectInFile($object, $lieu)))
+			throw new ExceptionHB(3, 1);
+
+		//Vérification du nombre passé en entrée
+		if (!is_numeric($nombre) || $nombre < 0 || $nombre > 99999)
+			throw new ExceptionHB(3, 8);
+
+		//On vérifie que le nombre d'unité actuel soit non nul
+		if ($planete->terrestres[$object] < $nombre)
+			throw new ExceptionHB(3, 6);
+
+		if (!isset($lieu))
+		{
+			//On recherche le lieu ayant le moins de construction en cours
+			$lieu = $this->findShorter();
+		}
+
+		//On rafraîchit le temps de la file si aucun objet n'est en file d'attente
+		$this->refreshTime($lieu);
+
+		//Si il existe déjà l'objet en file d'attente, on l'ajoute
+		if(isset($sauvLastKey))
+			$this->files[$sauvLastKey[0]][$sauvLastKey[1]][1] += $nombre;
+		else
+			$this->files[$lieu][] = array($object, $nombre, false);
+
+		$planete->addModif("file_ter");
+
+		return true;
+	}
+
+	public function delObjet($id, $nombre, $lieu, surface $planete)
+	{
+		//Vérification de l'existance de l'objet en file d'attente
+		if (empty($this->files[$lieu][$id]))
+			throw new ExceptionHB(1, 5);
+
+		//Si $nombre est supérieur au nombre présent dans la file, on le réduit
+		if ($this->files[$lieu][$id][1] < $nombre)
+			$nombre = $this->files[$lieu][$id][1];
+
+		//On récupère les informations disponibles
+		$objet = $this->files[$lieu][$id][0];
+		$nombreMax = $this->files[$lieu][$id][1];
+
+		//On met à jour le temps si on vient d'annuler le premier groupe d'unités en lice
+		if ($id == $this->findFirstKey($lieu) && $nombreMax == $nombre)
+			$this->times[$lieu] = time();
+
+		$planete->addModif("file_ter");
+
+		if (!$this->files[$lieu][$id][2])
+			$planete->addRessources(dTerrestre::metal($objet, $nombre, $planete), dTerrestre::cristal($objet, $nombre, $planete), dTerrestre::hydrogene($objet, $nombre, $planete), dTerrestre::credits($objet, $nombre, $planete));
+
+		//Effacement de la file
+		if ($nombre >= $nombreMax)
+			unset($this->files[$lieu][$id]);
+		else
+			$this->files[$lieu][$id][1] -= $nombre;
+		$planete->addModif("file_ter");
+
+		return true;
+	}
+
+	public function ready(SURFACE $planete)
+	{
+		//On parcourt la liste des lieux de construction
+		foreach($this->files as $keyF => $file)
+		{
+			//On vérifie qu'il y a bien des éléments dans cette file d'attente
+			if (count($file) == 0)
+				continue;
+
+			//On parcourt la liste à la recherche des unités terminées dans l'ordre
+			foreach($file as $keyE => $element)
+			{
+				//Calcul du temps écoulé depuis le dernier entraînement
+				$tempsEcoule = time() - $this->times[$keyF];
+
+				//On gére les licenciments !
+				if ($element[2])
+				{
+					//On vérifie qu'il reste des unités du type sur la planète
+					if ($planete->terrestres[$element[0]] <= 0)
+					{
+						unset($this->files[$keyF][$keyE]);
+						$planete->addModif("file_ter");
+					}
+					else
+					{
+						//Récupération de 60% du temps nécessaire
+						$tempsNecessaire = dTerrestre::temps($element[0], 1, $planete) * 0.6;
+
+						//Calcul du nombre d'unités maximum
+						$nbUnitee = min(floor($tempsEcoule/$tempsNecessaire), $element[1], $planete->terrestres[$element[0]]);
+
+						//Si le temps écoulé est suffisant
+						if ($nbUnitee > 0)
+						{
+							//On redonne 70% des ressources de l'unité au joueur
+							$planete->addRessources(dTerrestre::metal($element[0], $nbUnitee, $planete)*0.7, dTerrestre::cristal($element[0], $nbUnitee, $planete)*0.7, dTerrestre::hydrogene($element[0], $nbUnitee, $planete)*0.7, dTerrestre::credits($element[0], $nbUnitee, $planete)*0.7);
+
+							//On retire les unités
+							$planete->terrestres[$element[0]] -= $nbUnitee;
+
+							//On efface l'entrée de la file et on met à jour le temps de la file
+							if ($nbUnitee >= $element[1])
+								unset($this->filefiles[$keyF][$keyE]);
+							else
+								$this->file[$key][1] -= $nbUnitee;
+							$this->timefiles[$keyF] += $tempsNecessaire*$nbUnitee;
+
+							//On demande la mise à jour des champs modifiés
+							$planete->addModif(array("terrestres", $element[0]));
+							$planete->addModif("file_ter");
+
+							if ($nbUnitee < $element[1])
+								return false;
+						}
+						//Si le temps écoulé n'est pas suffisant pour cette unité, on annule toutes les suivantes
+						else
+							break;
+					}
+				}
+				else //Cas de la construction
+				{
+					//Récupération du temps nécessaire
+					$tempsNecessaire = dTerrestre::temps($element[0], 1, $planete);
+
+					//Calcul du nombre d'unités maximum
+					$nbUnitee = min(floor($tempsEcoule/$tempsNecessaire), $element[1]);
+
+					//Si le temps écoulé est suffisant
+					if ($nbUnitee > 0)
+					{
+						//On ajoute le nombre d'unités
+						$planete->terrestres[$element[0]] += $nbUnitee;
+
+						//On efface l'entrée de la file et on met à jour le temps de la file
+						if ($nbUnitee >= $element[1])
+							unset($this->files[$keyF][$keyE]);
+						else
+							$this->files[$keyF][$keyE][1] -= $nbUnitee;
+						$this->times[$keyF] += $tempsNecessaire * $nbUnitee;
+
+						//On demande la mise à jour des champs modifiés
+						$planete->addModif(array("terrestres", $element[0]));
+						$planete->addModif("file_ter");
+
+						if ($nbUnitee < $element[1])
+							break;
+					}
+					//Si le temps écoulé n'est pas suffisant pour ce batiment, on annule tous les suivants
+					else
+						break;
+				}
+			}
+		}
+	}
+
+
+	function printFile(SURFACE $planete, $lieux = NULL)
+	{
+		$out = array();
+		foreach ($this->files as $keyF => $file)
+		{
+			if (isset($lieu) && $lieu != $keyF)
+				continue;
+
+			$prems = true;
+			foreach ($file as $keyE => $element)
+			{
+				if ($element[2])
+				{
+					$temps = dTerrestre::temps($element[0], 1, $planete) * 0.6;
+					if ($prems)
+						$temps_moins = time() - $this->times[$keyF];
+					else
+						$temps_moins = 0;
+					$out[$keyF][$keyE] = array($element[0], $element[1], $element[2], ceil($temps * $element[1] - $temps_moins), ceil($temps - $temps_moins), $prems, dTerrestre::type($element[0]));
+				}
+				else
+				{
+					$temps = dTerrestre::temps($element[0], 1, $planete);
+					if ($prems)
+						$temps_moins = time() - $this->times[$keyF];
+					else
+						$temps_moins = 0;
+					$out[$keyF][$keyE] = array($element[0], $element[1], $element[2], ceil($temps * $element[1] - $temps_moins), ceil($temps - $temps_moins), $prems, dTerrestre::type($element[0]));
+				}
+				$prems = false;
+			}
+		}
+		return $out;
+	}
+}
+?>