Exemplo n.º 1
0
    /// <summary>
    /// Méthode appelée lorsque la voiture détecte une autre voiture arrivant en sens inverse
    /// </summary>
    /// <param name="hitCar">Voiture détéctée</param>
    private void DetectionMeeting(GameObject hitCar)
    {
        ExtCarController extCarHit = hitCar.gameObject.GetComponent <ExtCarController>();
        IntCarController intCarHit = hitCar.gameObject.GetComponent <IntCarController>();

        // Cas où la voiture est en mode aléatoire et n'a donc pas de position objectif
        if (aleaMode)
        {
            // Cas où la voiture est une voiture intérieure
            if (hitCar.tag == "IntCar")
            {
                isBraking           = true;
                intCarHit.IsBraking = true;
                ReceivingInformation(intCarHit);
            }

            // Cas où la voiture est une voiture extérieure de même couleur
            else if (hitCar.tag == "ExtCar" && extCarHit.exit == this.exit)
            {
                isBraking           = true;
                extCarHit.IsBraking = true;
                ReceivingInformation(extCarHit);
            }
        }

        // Cas où la voiture a une position objectif
        else
        {
            // Si la voiture n'est pas confiante et demande confirmation (ou pas ^^) de l'information
            if (alea.Next(1, 5) >= trust)
            {
                // Cas où la voiture est une voiture intérieure
                if (hitCar.tag == "IntCar")
                {
                    isBraking           = true;
                    intCarHit.IsBraking = true;
                    ReceivingInformation(intCarHit);
                }

                // Cas où la voiture est une voiture extérieure de même couleur
                else if (hitCar.tag == "ExtCar" && extCarHit.exit == this.exit)
                {
                    isBraking           = true;
                    extCarHit.IsBraking = true;
                    ReceivingInformation(extCarHit);
                }
            }
        }

        // La voiture est en train d'échanger de l'information
        endExchange = false;
    }
Exemplo n.º 2
0
    /// <summary>
    /// Méthode appelée lorsque la voiture reçoit de l'information d'une autre voiture (intérieure ou extérieure)
    /// </summary>
    /// <param name="car">Voiture captée pour échanger de l'information</param>
    private void ReceivingInformation(CarController car)
    {
        // Affichage de la flèche d'échange d'information
        DrawArrow(car);

        // Cas où la voiture avec qui on échange de l'information est une voiture extérieure
        if (car is ExtCarController)
        {
            ExtCarController extCar = (ExtCarController)car;

            // Si la voiture est assez généreuse pour partager de l'information (elle n'est donc pas en mode aléatoire)
            if (extCar.alea.Next(2, 6) <= extCar.Generosity && !extCar.aleaMode)
            {
                // ... alors la voiture prend la position objectif de la voiture croisée
                this.target = car.Target;

                // Échange réussi ! ^^ ==> Affichage de la checkmark
                canvasCheck.enabled = true;
                UpdateExchange(true, true, car);

                // Calcul du chemin le plus court pour atteindre sa position objectif
                FindingPath();
                aleaMode = false;
            }
            else
            {
                // Échec de l'échange ! :'( ==> Affichage de la crossmark ==> Il ne se passe rien
                canvasCross.enabled = true;
                UpdateExchange(true, false, car);
            }
        }

        // Cas où la voiture avec qui on échange de l'information est une voiture intérieure
        if (car is IntCarController)
        {
            IntCarController intCar = (IntCarController)car;

            // Cas où la voiture intérieure croisée est sincère
            if (intCar.Sincerity)
            {
                bool extCarKnowsExit = false;

                // Vérification que la voiture intérieure croisée connaît la sortie de "notre" voiture
                foreach (Position exitKnown in intCar.ExitsKnown)
                {
                    if (nodes[exitKnown.Number] == exit)
                    {
                        extCarKnowsExit = true;

                        // La voiture prend la position objectif de la voiture croisée
                        target = new Position(exitKnown.Number);

                        // Échange réussi ! ^^ ==> Affichage de la checkmark
                        canvasCheck.enabled = true;
                        UpdateExchange(false, true, car);

                        // Calcul du chemin le plus court pour atteindre sa position objectif
                        FindingPath();
                        aleaMode = false;
                    }
                }

                // Cas où la voiture intérieure croisée ne connaît pas la sortie de "notre" voiture
                if (!extCarKnowsExit)
                {
                    // Échec de l'échange ! :'( ==> Affichage de la crossmark ==> Il ne se passe rien
                    canvasCross.enabled = true;
                    UpdateExchange(false, false, car);
                }
            }

            // Cas où la voiture intérieure croisée est malhonnête
            else
            {
                bool extCarGivesExit = false;

                // Vérification que la voiture intérieure croisée connaît au moins une sortie
                if (intCar.ExitsKnown.Count != 0)
                {
                    // Cas où la voiture intérieure croisée ne connaît qu'une seule sortie
                    if (intCar.ExitsKnown.Count == 1)
                    {
                        // Vérification que la sortie connue n'est pas celle de "notre" voiture
                        if (nodes[intCar.ExitsKnown[0].Number] != exit)
                        {
                            extCarGivesExit = true;

                            // La voiture prend la position objectif de la voiture croisée
                            target = new Position(intCar.ExitsKnown[0].Number);

                            // Échange réussi ! ^^ ==> Affichage de la checkmark
                            canvasCheck.enabled = true;
                            UpdateExchange(false, true, car);

                            // Calcul du chemin le plus court pour atteindre sa position objectif
                            FindingPath();
                            aleaMode = false;
                        }
                    }

                    // Cas où la voiture intérieure croisée connaît plusieurs sorties
                    else
                    {
                        // On en prend une aléatoirement qui ne soit pas celle de "notre" voiture
                        int exitGiven = alea.Next(intCar.ExitsKnown.Count);
                        while (nodes[intCar.ExitsKnown[exitGiven].Number] == exit)
                        {
                            exitGiven = alea.Next(intCar.ExitsKnown.Count);
                        }

                        extCarGivesExit = true;

                        // La voiture prend la position objectif de la voiture croisée
                        target = new Position(intCar.ExitsKnown[exitGiven].Number);

                        // Échange réussi ! ^^ ==> Affichage de la checkmark
                        canvasCheck.enabled = true;
                        UpdateExchange(false, true, car);

                        // Calcul du chemin le plus court pour atteindre sa position objectif
                        FindingPath();
                        aleaMode = false;
                    }
                }

                // Cas où la voiture intérieure croisée ne connaît pas de sorties
                // ou ne connaît que la sortie de "notre" voiture
                if (!extCarGivesExit)
                {
                    // Échec de l'échange ! :'( ==> Affichage de la crossmark ==> Il ne se passe rien
                    canvasCross.enabled = true;
                    UpdateExchange(false, false, car);
                }
            }
        }
    }
Exemplo n.º 3
0
    /// <summary>
    /// Méthode pour ajouter les voitures intérieures d'une même couleur
    /// </summary>
    /// <param name="car">Préfab de la voiture intérieure</param>
    /// <param name="nbCars">Nombre de voitures à ajouter</param>
    /// <param name="sincerity">Honnête ou non</param>
    private IEnumerator AddIntCar(GameObject car, int nbCars, bool sincerity, int nbExit0, int nbExit1, int nbExit2, int nbExit3)
    {
        // Liste des nbExit
        List <int> nbExit = new List <int> {
            nbExit0, nbExit1, nbExit2, nbExit3
        };
        // Un petit incrément pour parcourir la liste
        int increment = 0;

        for (int i = 0; i < nbCars; i++)
        {
            // Numéro de la position initiale
            int positionTakenIndex = 0;
            // Le numéro de la position initiale peut-il être attribué à la voiture intérieure ?
            bool notFound = true;

            while (notFound)
            {
                // Choix aléatoire d'une position initiale
                positionTakenIndex = alea.Next(nodes.Count);

                // Si la position choisie aléatoirement est à côté d'une voiture extérieure (positions interdites)
                while (positionTakenIndex == 110 || positionTakenIndex == 111 || positionTakenIndex == 96 || positionTakenIndex == 97)
                {
                    positionTakenIndex = alea.Next(nodes.Count);
                }

                // La position a-t-elle déjà été attribuée à une voiture intérieure ?
                bool positionNotTakenBool = true;

                // Parcours des positions déjà prises par les voitures intérieures
                for (int j = 0; j < positionTakenInt.Count; j++)
                {
                    // Si la position choisie aléatoirement est déjà occupée par une voiture intérieure
                    if (positionTakenInt[j] == positionTakenIndex)
                    {
                        positionNotTakenBool = false;
                    }
                }

                // Si la position n'est pas prise
                if (positionNotTakenBool)
                {
                    notFound = false;
                }
            }

            // Ajout de la position à la liste des positions initiales déjà prises
            positionTakenInt.Add(positionTakenIndex);

            // Initialisation de la position initiale de la voiture intérieure
            Transform  node          = nodes[positionTakenIndex];
            Vector3    spawnPosition = new Vector3(node.transform.position.x, 0, node.transform.position.z);
            Quaternion rotation      = Quaternion.identity;
            rotation.eulerAngles = new Vector3(0, node.transform.eulerAngles.y, 0);
            GameObject       newCar = Instantiate(car, spawnPosition, rotation);
            IntCarController intCar = newCar.GetComponent <IntCarController>();
            intCar.Sincerity  = sincerity;
            intCar.Path       = path;
            intCar.CameraView = cameraView;

            // On vérifie que le nombre de la liste est différent de 0
            while (nbExit[increment] == 0)
            {
                increment += 1;
            }

            // Liste des sorties possibles
            List <int> exits = new List <int> {
                113, 115, 117
            };
            int exitKnown;
            // On crée la liste de sorties connues pour la voiture
            List <Position> exitsKnown = new List <Position>();
            for (int j = 0; j < increment; j++)
            {
                exitKnown = alea.Next(exits.Count);
                // On ajoute une sortie à la liste des sorties connues
                exitsKnown.Add(new Position(exits[exitKnown]));
                // On enlève l'élément de la liste des sorties possibles pour éviter de l'avoir en double dans la liste des sortie connues
                exits.RemoveAt(exitKnown);
            }
            // On dés-incrémente le nombre dans la liste
            nbExit[increment] -= 1;
            // On associe la liste à la voiture
            intCar.ExitsKnown = exitsKnown;

            listIntCars.Add(intCar);

            yield return(new WaitForSeconds(0f));
        }
    }