private int ChariotProche(Colis colis)
{
// initialisation du chariot que l'on teste : ici le premier du tableau
Chariot chariot_choisit = Program.tab_chariot[0];
// on met un cout par défaut très grand
double cost = 1000000;
Emplacement empColis = new Emplacement(colis._x, colis._y, colis._orientation, colis._hauteur);
// on passe en revue tous les chariots du tableau pour voir quel chariot est le plus proche du colis.
foreach (Chariot chariot in Program.tab_chariot)
{
if (!chariot.enLivraison)
{
Emplacement empChariot = new Emplacement(chariot._x, chariot._y, chariot._orientation, 0);
// Calcul du cout théorique du déplacement
empChariot.CalculeHCost(empColis);
// Comparaison
if (empChariot.Estimation() < cost)
{
chariot_choisit = chariot;
cost = empChariot.Estimation();
}
}
}
return(chariot_choisit.Get_cle_chariot() - 1);
}
/// <summary>
/// Cette fonction est utilisée lorsque l'on souhaite faire un nouveau colis. Comme les 15 colis
/// doivent être distincts, on doit donc vérifier à chaque colis que le colis nouvellement créé
/// n'existe pas déjà. On doit donc chercher un colis dans un tableau de colis
/// </summary>
/// <entree>
/// <param name="nouveau"> Nouveau colis qui vient d'être fait aléaoiterement </param>
/// <param name="compteur"> le compte int permet de savoir jusqu'à quelque point est rempli le tableau
/// ppour ne pas avoir des comparaisons avec des objets vides et eviter les exceptions et les erreurs </param>
/// </entree>
/// <returns> Cette fonction étant une fonction test, elle renvoie donc un boléen avec true si le colis existe
/// déjà dans le tableau ou false dans le cas contraire. </returns>
private bool Doublon(Colis nouveau, int compteur)
{
for (int k = 0; k < compteur; k++)
{
if (tab_colis[k]._x == nouveau._x && tab_colis[k]._y == nouveau._y)
{
return(true);
}
}
return(false);
}
private int Retrouver_indice_colis_clique(Colis colis)
{
for (int k = 0; k < tab_colis.Length; k++)
{
if (tab_colis[k]._y == colis._y && tab_colis[k]._x == colis._x && tab_colis[k]._orientation == colis._orientation)
{
return(k);
}
}
// le bouton cliqué n'est pas un colis : par défaut
return(-1);
}
private void tmpButton_Click(object sender, EventArgs e)
{
// Expression regulière pour récuperer la position d'un chariot avec le nom du bouton
Regex re = new Regex(@"([0-9]*)\.([0-9]*)");
Button btn = (Button)sender;
String sourcestring = btn.Name;
// Retrouver le bouton et le changer de couleur puis le bloquer
MatchCollection mc = re.Matches(sourcestring);
// 1. lors du premier clic après la génération du formulaire, l'utilisateur doit choisir un chariot qui sera le chariot prioritaire
// on ne comptabilise le clic uniquement si la personne a bien cliqué un chariot
if (nbChariotsClick == 0 && Program.entrepot.cell[int.Parse(mc[0].Groups[2].Value), int.Parse(mc[0].Groups[1].Value)] == 2)
{
// on choisit le chariot prioritaire
Chariot_p = new Chariot_prioritaire(int.Parse(btn.Text), int.Parse(mc[0].Groups[1].Value), int.Parse(mc[0].Groups[2].Value), "Est", 0);
btn.BackColor = Color.Gold;
btn.Refresh();
// on augmente la valeur du clic que si la personne a bien choisi un chariot
nbChariotsClick++;
Consigne_LBL.Text = " Etape 2 : Choissisez un colis parmi ceux indiqués";
}
//2. après le choix du clic, on choisit un colis qui sera attribué au chariot désigné avant
// dans ce cas la on ne comptabilise aussi le clic uniquement si la case cliquée est bien un chariot.
else if (nbChariotsClick == 1 && Est_bien_un_colis(int.Parse(mc[0].Groups[1].Value), int.Parse(mc[0].Groups[2].Value)))
{
// on choisit le colis du chariot prioritaire
btn.BackColor = Color.Gold;
btn.Refresh();
// si la personne place mal son colis, on ne doit pas compte ce clic
nbChariotsClick++;
Aleatoire_BTN.Visible = true;
// On utilise les informations du bouton cliqué pour refaire et retrouver le colis
// on retrouver le colis via une autre fonction selon le principe de séparation des tâches
string orientation = "";
if (btn.Text == "N")
{
orientation = "Nord";
}
else
{
orientation = "Sud";
}
Colis_choisi = Retrouver_colis_clique(int.Parse(mc[0].Groups[1].Value), int.Parse(mc[0].Groups[2].Value), orientation);
repartition[0] = new int[] { Chariot_p.Get_cle_chariot() - 1, Retrouver_indice_colis_clique(Colis_choisi) };
id_colis_choisi = Retrouver_indice_colis_clique(Colis_choisi);
}
}
/// <summary>
/// Cette fonction permet de placer les chariots le long de la premiere colonne lorsque la personne souhaite commencer
/// à visualiser le déplacement de tous les chariots. Les paramètres sont les paramètres habituels de gestion des evemenemts. Cette fonction
/// ne renvoie aucun paramètre.
/// </summary>
/// <entree>
/// <param name="sender"> information sur le bouton cliqué </param>
/// <param name="e"> information sur l'évenement </param>
/// </entree>
/// <sortie> aucune </sortie>
private void Aleatoire_BTN_Click(object sender, EventArgs e)
{
// 2. on affiche les chariots sur le diagramme
Aleatoire_BTN.Visible = false;
// réparition simple des colis
// le colis que devait initialement récupére le chariot choisi
Colis temp1 = tab_colis[Chariot_p.Get_cle_chariot() - 1];
tab_colis[id_colis_choisi] = temp1;
tab_colis[Chariot_p.Get_cle_chariot() - 1] = Colis_choisi;
// on répartie les colis
Repartition_colis_chariots();
Affichage_des_objectifs();
Jouer();
// on lance tous les déplacements
}
/// <summary>
/// Cette fonction utilisé permet de créer un colis de façon aléatoire en utilisant des nombres aléatoires pour les différents paramètres et caractéristiques
/// d'un colis. Elle renvoie donc le colis qui vient d'être fait. On crée des colis en vérifiant que le nouveau colis n'existe pas déjà dans le tableau de colis
/// via une autre fonction test. L'orientation d'un colis ne peut être que le Nord ou le Sud pour que le chariot puisse ensuite venir le chercher.
/// </summary>
/// <entree>
/// < param name="rdn"> Nombre Random qui doit venir des niveaux supérieurs du programme pour avoir des chiffres différents à chaque itération </param>
/// <param name="compteur"> le compteur entier k est en paraètres car on doit le donner à une des fonction utilisée dans le code pour assurer l'abscende
/// des erreurs quand on essaie d'accèder à un colis qui n'a pas encore été crée.</param>
/// </entree>
/// <returns> On renvoie le colis qui vient d'être crée par cette fonction </returns>
private Colis Faire_colis(Random rdn, int compteur)
{
Colis colis_cree = new Colis();
do
{
rdn = new Random();
string orientation = "";
int aleatoire = 2 * rdn.Next();
if (aleatoire <= 1)
{
orientation = "Sud";
}
else
{
orientation = "Nord";
}
colis_cree = new Colis(Choisir_colonne(rdn), Choisir_ligne(rdn), rdn.Next(0, 10), orientation);
} while (Doublon(colis_cree, compteur));
return(colis_cree);
}
/// <summary>
/// Cette fonction survient après le clic de l'utilisateur sur le bouton "Valider". L'utilisateur vient de choisir les caractéristiques de son colis.
/// Suite à cette validation, on vérifie l'emplacement du colis pour voir si cet emplacement est bien valide : que le colis est bien sur une étagère.
/// Si les informations saisies ne sont pas valides comme : un emplacement hors des cases noires ou une hauteur supérieure à 10m, on informe l'utilisateur
/// dans une message box de son erreur. Les paramètres du colis proposés par défaut donne bien sur une étagère.
/// Si l'emplacement est correct, on calcule l'emplacement de fin du chariot en fonction des caractèristique du colis.
/// Elle prend les paramètres habituels des gestionnnaires d'évènement et n'a pas de sortie.
/// </summary>
/// <entree>
/// <param name="sender"> informations sur le bouton cliqué </param>
/// <param name="e"> informations sur l'evenement </param>
/// </entree>
/// <sortie> aucune </sortie>
private void Valider_BTN_Click(object sender, EventArgs e)
{
if (Est_un_colis(int.Parse(Colis_TB.Text), int.Parse(Colis_Localisation_TB.Text)) && int.Parse(Colis_Hauteur_TB.Text) < 11)
{
//1.l'emplacement du début
Emplacement depart = new Emplacement(Chariot_choisi._x, Chariot_choisi._y, Chariot_choisi._orientation, int.Parse(Colis_Hauteur_TB.Text));
string position = Chariot_choisi._x + "." + Chariot_choisi._y;
Program.entrepot.cell[Chariot_choisi._y, Chariot_choisi._x] = 0;
// colorer le bon bouton
Button btn = (Button)this.Controls.Find(position, true)[0];
btn.BackColor = Color.Blue;
// quand la personne a choisi les caractéristiques de son colis
string orientation = "";
try { orientation = Orientation_LIST.SelectedItem.ToString(); }
catch { orientation = "Nord"; }
tab_colis[nb_colis] = new Colis(int.Parse(Colis_TB.Text), int.Parse(Colis_Localisation_TB.Text), int.Parse(Colis_Hauteur_TB.Text), orientation);
// colorer le colis
string position_2 = int.Parse(Colis_TB.Text) + "." + int.Parse(Colis_Localisation_TB.Text);
Button btn_2 = (Button)this.Controls.Find(position_2, true)[0];
btn_2.BackColor = Color.Green;
if (orientation == "Nord")
{
btn_2.Text = "N";
}
else
{
btn_2.Text = "S";
}
btn_2.Refresh();
// 2.trouver l'emplacement d'arrivée
// en fonction de l'orientation du colis, l'emplacement n'est pas le même
Emplacement arrivee = new Emplacement();
// si le colis est au nord, alors le chariot doit se placer sur la case en dessus soit -1 dans la matrice
if (tab_colis[nb_colis]._orientation == "Nord")
{
arrivee.SetY(tab_colis[nb_colis]._y - 1);
}
else
{
arrivee.SetY(tab_colis[nb_colis]._y + 1);
}
// la position en x ne change pas
arrivee.SetX(tab_colis[nb_colis]._x);
// on fait appel à la fonction pour nous trouver
nul = new Graph(arrivee, depart);
chemin = nul.RechercheSolutionAEtoile();
// on enleve les controles lors du remplissage du colis
Valider_BTN.Visible = false;
Orientation_LBL.Visible = false;
Orientation_LIST.Visible = false;
Colis_hauteur_LBL.Visible = false;
Colis_Hauteur_TB.Visible = false;
Colis_Localisation_TB.Visible = false;
Colis_Position_LBL.Visible = false;
Colis_Position_y_LBL.Visible = false;
Colis_TB.Visible = false;
Details_BTN.Visible = true;
Consigne_LBL.Text = "Etape 5 : Evaluer le chemin";
Final_LBL.Visible = true;
// si le chemin est null, c'est qu'il n'y a pas de solution pour que le colis puise être pris par le chariot
if (chemin.Count == 0)
{
Final_LBL.Text = "Pas de solution possible pour ce chemin";
Final_LBL.Visible = true;
Nv_colis_BTN.Visible = true;
}
else
{
Deplacement_chariots();
// le bouton du début est en bleu foncé alors que le chariot est en bleu clair
btn.BackColor = Color.Blue;
double cout = ((Emplacement)chemin[chemin.Count - 1]).GetGCost();
}
// s'il n'y a pas de solution, on n'affiche pas le calcul du retour à la plateforme.
if (chemin.Count > 0)
{
Depot_BTN.Visible = true;
}
UnableChariots();
}
else
{
// si l'utilisateur a mal choisi l'emplacement de son colis
string message = "La position du colis ne correspond pas à la disposition de l'entrepot : il doit être sur une étagère et à une hauteur inférieure ou égal à 10.";
string caption = "Error Detected in Input";
DialogResult result = MessageBox.Show(message, caption);
}
}