}//Fin gestion aerienne
/// <summary>
/// Met a jour les elements de l'aeroport.(Considerant cet appel comme une minute)
/// </summary>
public void Update()
{
//On met a jour le temps
_temps = _temps.AddMinutes(1);
UpdateGestionAerienne();
UpdateGestionSol();
foreach (Piste p in _pistes)
{
if (p != null)
{
p.Update();
}
}
for (int i = 0; i < _pistes.Count; i++)
{
if (_pistes[i].AvionsDecolles.Count > 0)
{
_avionsDecolles.AddRange(_pistes[i].AvionsDecolles);
//On ecrit un message comme quoi les avions ont decollés
for (int j = 0; j < _pistes[i].AvionsDecolles.Count; j++)
{
ObjVolants avions = _pistes[i].AvionsDecolles[j];
_stringDump.Insert(0, _temps.ToString("yyyy-MM-dd: H:mm") + "\t: " + "-L'avion " + avions.NoVol + " a décollé.");
}
//On efface les avions
_pistes[i].AvionsDecolles.Clear();
}
}
//On met à jour les embarquadères
foreach (Embarquadere t in _embarquaderes)
{
if (t != null)
{
t.Update();
}
}
//Met a jour l'essence des objets volants.
if (!_avionsEnAttentes.EstVide)
{
ObjVolants[] tableauTmp = _avionsEnAttentes.Tableau;
for (int i = 0; i < tableauTmp.Length; i++)
{
if (tableauTmp[i] != null)
{
tableauTmp[i].EssenceActuel -= tableauTmp[i].Consommation;
}
}
} //FIN S'il y a des avions en attente
} //Fin update
/// <summary>
/// Ajoute un objet volant dans la file d'attente si possible
/// </summary>
/// <returns>Vrai si l'ajout a ete fait et Faux si l'ajout n'a pas ete possible</returns>
public bool EnQueueFileAttente(ObjVolants objet)
{
if (fileAttente.Count < tailleFileAttente)
{
fileAttente.Enqueue(objet);
return(true);
}
return(false);
}
/// <summary>
/// Permet à un avion de se débarasser de ses passagers
/// </summary>
/// <param name="tempsRequis">Temps requis à l'avion avant de terminer</param>
public void DebarquerAvion(int tempsRequis, ObjVolants avion)
{
embarquer = false;
_avion = avion;
tempsActuel = 0;
_tempsRequis = tempsRequis;
libre = false;
termine = false;
avion.NbPassagers = 0;
}
/// <summary>
/// Permet à un avion de remplir son essence et ses passagers
/// </summary>
/// <param name="tempsRequis">Temps requis pour embarquer les passagers</param>
/// <param name="avion">Avion qui doit embarquer les passagers</param>
/// <param name="nbPassager">Nombre de passagers qui doivent embarquer dans l'avion</param>
public void EmbarquerAvion(int tempsRequis, ObjVolants avion, int nbPassager)
{
embarquer = true;
_avion = avion;
tempsActuel = 0;
_tempsRequis = tempsRequis;
libre = false;
termine = false;
avion.EssenceActuel = avion.MaxEssence;
avion.NbPassagers = nbPassager;
}
/// <summary>
/// Deifinie s'il est possible ou pas d'atterir. S'il est possible, l'avion sera prise en charge par la piste et procedera a l'atterrisage.
/// </summary>
/// <param name="objet">Objet volant qui tente d'atterir sur la piste.</param>
/// <returns>Vrai si l'objet a atterie ou Faux si elle n'est pas pu</returns>
public bool Atterrir(ObjVolants objet)
{
if (!occupee) // Si la piste n'est pas occupee
{
//On ajoute l'Avion à la piste
utilisateur = objet;
utilisateur.Statut = ObjVolants.StatutAvion.Atterissage;
occupee = true;
return(true);
}
return(false);
}
/// <summary>
/// Permet de retirer l'avion prenant actuellement l'embarquadère
/// </summary>
/// <returns>Avion ayant teminé ainsi que bool (Est-ce que l'avion embarquait), pour savoir si l'avion embarquais ou débarquais des passagers</returns>
public ObjVolants RetirerAvion()
{
if (!termine)
{
throw new EmbarquadereNonTermine("L'avion n'à pas encore terminée avec l'embarquadère! Il est impossible de la retirer");
}
ObjVolants avionBackup = _avion;
_avion = default(ObjVolants);
tempsActuel = 0;
_tempsRequis = 0;
libre = true;
termine = false;
return(avionBackup);
}
//Methodes
/// <summary>
/// Determine si un avion peut decoller et si celle-ci peut, elle quittera la zone d'attente et decollera.
/// </summary>
/// <returns></returns>
public bool Decoller()
{
if (!occupee)
{
//SI la piste est libre
if (fileAttente.Count != 0) //S'il y a des avions qui veulent decoller
{
occupee = true;
utilisateur = fileAttente.Dequeue();
utilisateur.Statut = ObjVolants.StatutAvion.Decollage;
return(true);
}
}
return(false);
}
} //Fin update
public void UpdateGestionSol()
{
//1. On vérifie si les embarquadères ont terminés
foreach (Embarquadere t in _embarquaderes)
{
if (t != null)
{
//S'il à terminé
if (t.Termine && !t.Libre)
{
//Si l'avion embarquait des passagers et allait vers la piste de décollage, et qu'il reste de la place dans la file d'attente
if (t.Embarquer && _pistes[0].TailleFileAttente > _pistes[0].FileAttente.Count)
{
ObjVolants avion = t.RetirerAvion();
_pistes[0].FileAttente.Enqueue(avion);
_stringDump.Insert(0, _temps.ToString("yyyy-MM-dd: H:mm") + "\t: " + "-L'avion " + avion.NoVol + " a quitté l'embarquadère.");
}
//Si l'avion allait dans un hangar attendre
if (!t.Embarquer && _hangar.Count <= _hangar.Grandeur)
{
ObjVolants avion = t.RetirerAvion();
_hangar.Ranger(avion);
_stringDump.Insert(0, _temps.ToString("yyyy-MM-dd: H:mm") + "\t: " + "-L'avion " + avion.NoVol + " se stationne dans un hangar.");
}
}
}
}
//2. On vérifie s'il y a des avions en attente pour débarquer les passagers
//TODO: Gestion pour plusieurs pistes
if (_pistes[0].TaxiWay.Count > 0)
{
foreach (Embarquadere i in _embarquaderes)
{
if (i != null)
{
if (i.Libre)
{
ObjVolants avion = _pistes[0].TaxiWay.Dequeue();
//+3 = temps de déplacement pour se rendre à l'embarquadère
i.DebarquerAvion(avion.NbPassagers / 20 + 3, avion);
_stringDump.Insert(0, _temps.ToString("yyyy-MM-dd: H:mm") + "\t: " + "-L'avion " + avion.NoVol + " débarque ses passagers.");
break;
}
}
}
}
//3. On vérifie si des avions doivent décoller et qu'il y à de la place dans les embarquadères
foreach (Embarquadere embarq in _embarquaderes)
{
if (embarq != null)
{
if (embarq.Libre && _hangar.Regarder())
{
ObjVolants avion = _hangar.Retirer();
Random rnd = new Random();
int nbPassagers = rnd.Next(avion.MaxPassager / 5, avion.MaxPassager);
embarq.EmbarquerAvion(nbPassagers / 10 + 1, avion, nbPassagers);
_stringDump.Insert(0, _temps.ToString("yyyy-MM-dd: H:mm") + "\t: " + "-L'avion " + avion.NoVol + " embarque des passagers.");
}
}
}
}
/// <summary>
/// Gere les avions dans les airs et gere le decollage
/// </summary>
public void UpdateGestionAerienne()
{
//TODO : Extra : Implementer la gestion aerienne pour l'ensemble des pistes
if (!_pistes[0].EstOccupee) //Si la piste est libre
{
//Atterir
if (_avionsEnAttentes.Nombre > 0) //S'il y a un avion qui peut atterrir
{
if (_pistes[0].FileAttente.Count == 0) // Si aucun avions est en attente de decoller, la piste peut être utiliser
{
//On fait atterrir le premier en attente
_pistes[0].Atterrir(_avionsEnAttentes.Extraire());
}
else if (_avionsEnAttentes.Peek().TempsRestant > _pistes[0].FileAttente.Peek().TempsDecollage + _pistes[0].TempsPreparationPiste) // Pas d'urgence d'atterir
{
//On a le temps de faire decoller un avion
_pistes[0].Decoller();
}
else
{
//Il est urgent de faire atterir cet avion
_pistes[0].Atterrir(_avionsEnAttentes.Extraire());
}
}
else if (_pistes[0].FileAttente.Count > 0) // S'il y a des avions qui peuvent decoller
{
//Fait decoller le premier avion dans la file
_pistes[0].Decoller();
}
}//Fin piste !occupe
if ((double)(Count / _capaciteObjVolants) <= 0.95) //On veut remplir l'aeroport a un maximum de 80%
{
while (_avionsEnAttentes.Nombre > 0) //Pas assez de gaz pour attendre. On fait fois 2 question d'avoir un certaine marge
{
//Eventuelle redirection
/*
* if(_avionsEnAttentes.Peek().TempsRestant <= _avionsEnAttentes.Peek().TempsAtterissage * 2)
* RedirigerAvion(_avionsEnAttentes.Extraire());
* else
* break;
*/
if (_avionsEnAttentes.Peek().TempsRestant <= 1)
{
ObjVolants avions = _avionsEnAttentes.Extraire();
avions.Statut = ObjVolants.StatutAvion.Ecrase;
_stringDump.Insert(0, _temps.ToString("yyyy-MM-dd: H:mm") + "\t: " + "-L'avion " + avions.NoVol + " s'est écrasé.");
_cimetiere.Add(avions);
}
else
{
break;
}
}
}
else //On verifie le temps d'attente dans les airs
{
//TODO : Verifier le temps d'attente des avions ->Implementer des variables initialiser lors d'envoi vers autres aeroport
}
}//Fin gestion aerienne
/// <summary>
/// Redirige un avion vers un autre aeroport
/// </summary>
/// <param name="objVolants">Avion à ajouter</param>
public void RedirigerAvion(ObjVolants objVolants)
{
objVolants.Statut = ObjVolants.StatutAvion.Ecrase;
_stringDump.Insert(0, _temps.ToString("yyyy-MM-dd: H:mm") + "\t: " + "-L'avion " + objVolants.NoVol + " a été redirigé.");
_cimetiere.Add(objVolants);
}
//Methodes
/// <summary>
/// Ajoute un objetvolant dans la zone aerienne de l'aeroport.
/// </summary>
/// <param name="objetVolant">Avion à ajouter</param>
public void AjouterAvionAttente(ObjVolants objetVolant)
{
_avionsEnAttentes.Ajouter(objetVolant);
}
/// <summary>
/// Met a jour different composants de la piste. Par exemple, si la piste a besoin d'être prepare, elle le sera. Si un avion est en train de coller
/// ou bien d'atterrir, la progression continuera.
/// </summary>
public void Update()
{
if (occupee)
{
if (utilisateur == null) // Si un objVolants vient d'atterir/decoller mais que la piste est en preparation
{
if (progressionPiste < tempsPreparationPiste) // Si la preparation n'est pas fini
{
progressionPiste++;
}
else
{
occupee = false;
progressionPiste = 0;
}
}
else //Si un avion est encore en train d'atterir ou decoller
{
if (utilisateur.Statut == ObjVolants.StatutAvion.Decollage)
{
if (progressionPiste < utilisateur.TempsDecollage) // Si l'objets volants n'a pas fini de decoller
{
progressionPiste++;
}
else //L'avion s'envole et on prepare la piste
{
utilisateur.Statut = ObjVolants.StatutAvion.EnVol;
_avionsDecolles.Add(utilisateur);
utilisateur = null;
progressionPiste = 0;
}
}
else if (utilisateur.Statut == ObjVolants.StatutAvion.Atterissage)
{
if (progressionPiste < utilisateur.TempsAtterissage) // Si l'avion n'a pas atteri
{
progressionPiste++;
}
else //L'avion a atteri
{
if (taxiWay.Count < tailleTaxiWay) // S'il reste de la place dans le taxi way
{
//On l'ajout au taxi way
utilisateur.Statut = ObjVolants.StatutAvion.AuSol;
taxiWay.Enqueue(utilisateur);
//On supprime l'avion de la piste
utilisateur = null;
//On prepare la piste
progressionPiste = 0;
}
else //Si le taxi way est plein, on fait attendre l'avion sur la piste
{
utilisateur.Statut = ObjVolants.StatutAvion.SurPisteEnAttente;
}
} // Fin si avion atteri
} // Fin si avion en atterissage
else if (utilisateur.Statut == ObjVolants.StatutAvion.SurPisteEnAttente)
{
if (taxiWay.Count < tailleTaxiWay) // Si il y a de la place dans le taxi way
{
utilisateur.Statut = ObjVolants.StatutAvion.AuSol;
//On ajoute l'avion au taxi way
taxiWay.Enqueue(utilisateur);
//On libere la piste et la prepare
utilisateur = null;
progressionPiste = 0;
} // Fin si on peut ajouter l'avion en attente sur le taxi way
} //Fin si avion est en attente sur piste
} //Fin si avion en train de decoller ou atterir
} // Fin si la piste est utilisee
}
