Exemple #1
0
        public void UpdateScientifique2(Scientifique scientifique, Point laby_sortie)
        {
            if (!Impasse(scientifique.position_case_actuelle) && !carte_ia_inter[scientifique.position_case_actuelle.X, scientifique.position_case_actuelle.Y])
            {
                if (case_eloigne == Point.Zero && !une_premiere_fois)
                    carte_ia = GenLabyIA(laby_sortie, carte_ia, laby);
                else
                    carte_ia = GenLabyIA(case_eloigne, carte_ia, laby);

            }
            else
            {
                une_premiere_fois = true;
                idmax = 0;
                carte_ia = GenLabyIA(laby_sortie, carte_ia, laby);
                DirectionScient(scientifique, carte_ia);
                CaseObjectif(scientifique.position_case_actuelle);
                carte_ia = GenLabyIA(case_eloigne, carte_ia, laby);
            }
        }
Exemple #2
0
        public void DirectionScient(Scientifique scientifique, int[,] carte_ia)
        {
            Point pos_ia = new Point(scientifique.position_case_actuelle.X, scientifique.position_case_actuelle.Y);
            for (int i = 0; i < Config.largeur_labyrinthe; i++)
            {
                for (int j = 0; j < Config.hauteur_labyrinthe; j++)
                {
                    carte_direct[i, j] = laby.Carte[i, j];
                }
            }

            int[,] carte_ia_direction = carte_direct;
            Random rand = new Random();
            int choix = 0;
            Point choix2 = new Point(-1, -1);
            Point choix3 = new Point(-1, -1);
            Point choix4 = new Point(-1, -1);

            if (pos_ia.Y > 0 && laby.Carte[pos_ia.X, pos_ia.Y - 1] != 1 && (new Point(pos_ia.X, pos_ia.Y - 1) != scientifique.position_case_precedente || carte_ia[pos_ia.X, pos_ia.Y - 1] < carte_ia[pos_ia.X, pos_ia.Y]) && !carte_impasse[pos_ia.X, pos_ia.Y - 1])
                choix2 = new Point(pos_ia.X, pos_ia.Y - 1);
            if (pos_ia.X > 0 && laby.Carte[pos_ia.X - 1, pos_ia.Y] != 1 && (new Point(pos_ia.X - 1, pos_ia.Y) != scientifique.position_case_precedente || carte_ia[pos_ia.X - 1, pos_ia.Y] < carte_ia[pos_ia.X, pos_ia.Y]) && !carte_impasse[pos_ia.X - 1, pos_ia.Y])
                if (choix2 == new Point(-1, -1))
                    choix2 = new Point(pos_ia.X - 1, pos_ia.Y);
                else
                    choix3 = new Point(pos_ia.X - 1, pos_ia.Y);

            if (pos_ia.Y < laby.Size.Y - 1 && laby.Carte[pos_ia.X, pos_ia.Y + 1] != 1 && (new Point(pos_ia.X, pos_ia.Y + 1) != scientifique.position_case_precedente || carte_ia[pos_ia.X, pos_ia.Y + 1] < carte_ia[pos_ia.X, pos_ia.Y]) && !carte_impasse[pos_ia.X, pos_ia.Y + 1])
                if (choix2 == new Point(-1, -1))
                    choix2 = new Point(pos_ia.X, pos_ia.Y + 1);
                else if (choix3 == new Point(-1, -1))
                    choix3 = new Point(pos_ia.X, pos_ia.Y + 1);
                else
                    choix4 = new Point(pos_ia.X, pos_ia.Y + 1);

            if (pos_ia.X < laby.Size.X - 1 && laby.Carte[pos_ia.X + 1, pos_ia.Y] != 1 && (new Point(pos_ia.X + 1, pos_ia.Y) != scientifique.position_case_precedente || carte_ia[pos_ia.X + 1, pos_ia.Y] < carte_ia[pos_ia.X, pos_ia.Y]) && !carte_impasse[pos_ia.X + 1, pos_ia.Y])
                if (choix2 == new Point(-1, -1))
                    choix2 = new Point(pos_ia.X + 1, pos_ia.Y);
                else if (choix3 == new Point(-1, -1))
                    choix3 = new Point(pos_ia.X + 1, pos_ia.Y);
                else if (choix4 == new Point(-1, -1))
                    choix4 = new Point(pos_ia.X + 1, pos_ia.Y);

            if (choix2 == new Point(-1, -1))
                choix2 = new Point(pos_ia.X, pos_ia.Y);

            if (choix3 == new Point(-1, -1))
                choix3 = choix2;

            if (choix4 == new Point(-1, -1))
                choix4 = choix3;

            if (carte_ia[pos_ia.X, pos_ia.Y] > carte_ia[choix2.X, choix2.Y])
            {
                if (Config.index_difficulte == 2)
                    choix = 2;
                else if (Config.index_difficulte == 1)
                {
                    int rand0m = rand.Next(0, 100);
                    if (rand0m > 33)
                        choix = 2;
                    else if (rand0m >= 16)
                        choix = 3;
                    else
                        choix = 4;
                }
                else
                    if (nb_chemin[pos_ia.X, pos_ia.Y] < 2) //Le scientifique se trouve dans une impasse
                        choix = 2;
                    else
                        choix = rand.Next(2, nb_chemin[pos_ia.X, pos_ia.Y] + 1);

            }
            else if (carte_ia[pos_ia.X, pos_ia.Y] > carte_ia[choix3.X, choix3.Y])
            {
                if (Config.index_difficulte == 2)
                    choix = 3;
                else if (Config.index_difficulte == 1)
                {
                    int rand0m = rand.Next(0, 100);
                    if (rand0m > 33)
                        choix = 3;
                    else if (rand0m >= 16)
                        choix = 2;
                    else
                        choix = 4;
                }
                else
                    if (nb_chemin[pos_ia.X, pos_ia.Y] < 2) //Le scientifique se trouve dans une impasse
                        choix = 3;
                    else
                        choix = rand.Next(2, nb_chemin[pos_ia.X, pos_ia.Y] + 1);
            }
            else if (carte_ia[pos_ia.X, pos_ia.Y] > carte_ia[choix4.X, choix4.Y])
            {
                if (Config.index_difficulte == 2)
                    choix = 4;
                else if (Config.index_difficulte == 1)
                {
                    int rand0m = rand.Next(0, 100);
                    if (rand0m > 33)
                        choix = 4;
                    else if (rand0m >= 16)
                        choix = 2;
                    else
                        choix = 3;
                }
                else
                    if (nb_chemin[pos_ia.X, pos_ia.Y] < 2) //Le scientifique se trouve dans une impasse
                        choix = 4;
                    else
                        choix = rand.Next(2, nb_chemin[pos_ia.X, pos_ia.Y] + 1);
            }
            else
            {
                if (nb_chemin[pos_ia.X, pos_ia.Y] < 2) //Le scientifique se trouve dans une impasse
                    choix = 2;
                else
                    choix = rand.Next(2, nb_chemin[pos_ia.X, pos_ia.Y] + 1);
            }

            if (choix == 2)
            {
                if (new Point(pos_ia.X, pos_ia.Y - 1) != choix2)
                {
                    if (pos_ia.Y > 0)
                        carte_ia_direction[pos_ia.X, pos_ia.Y - 1] = 1;
                }
                if (new Point(pos_ia.X - 1, pos_ia.Y) != choix2)
                {
                    if (pos_ia.X > 0)
                        carte_ia_direction[pos_ia.X - 1, pos_ia.Y] = 1;
                }
                if (new Point(pos_ia.X, pos_ia.Y + 1) != choix2)
                {
                    if (pos_ia.Y < laby.Size.Y - 1)
                        carte_ia_direction[pos_ia.X, pos_ia.Y + 1] = 1;
                }
                if (new Point(pos_ia.X + 1, pos_ia.Y) != choix2)
                {
                    if (pos_ia.X < laby.Size.X - 1)
                        carte_ia_direction[pos_ia.X + 1, pos_ia.Y] = 1;
                }
            }
            else if (choix == 3)
            {
                if (new Point(pos_ia.X, pos_ia.Y - 1) != choix3)
                {
                    if (pos_ia.Y > 0)
                        carte_ia_direction[pos_ia.X, pos_ia.Y - 1] = 1;
                }
                if (new Point(pos_ia.X - 1, pos_ia.Y) != choix3)
                {
                    if (pos_ia.X > 0)
                        carte_ia_direction[pos_ia.X - 1, pos_ia.Y] = 1;
                }
                if (new Point(pos_ia.X, pos_ia.Y + 1) != choix3)
                {
                    if (pos_ia.Y < laby.Size.Y - 1)
                        carte_ia_direction[pos_ia.X, pos_ia.Y + 1] = 1;
                }
                if (new Point(pos_ia.X + 1, pos_ia.Y) != choix3)
                {
                    if (pos_ia.X < laby.Size.X - 1)
                        carte_ia_direction[pos_ia.X + 1, pos_ia.Y] = 1;
                }
            }
            else if (choix == 4)
            {
                if (new Point(pos_ia.X, pos_ia.Y - 1) != choix4)
                {
                    if (pos_ia.Y > 0)
                        carte_ia_direction[pos_ia.X, pos_ia.Y - 1] = 1;
                }
                if (new Point(pos_ia.X - 1, pos_ia.Y) != choix4)
                {
                    if (pos_ia.X > 0)
                        carte_ia_direction[pos_ia.X - 1, pos_ia.Y] = 1;
                }
                if (new Point(pos_ia.X, pos_ia.Y + 1) != choix4)
                {
                    if (pos_ia.Y < laby.Size.Y - 1)
                        carte_ia_direction[pos_ia.X, pos_ia.Y + 1] = 1;
                }
                if (new Point(pos_ia.X + 1, pos_ia.Y) != choix4)
                {
                    if (pos_ia.X < laby.Size.X - 1)
                        carte_ia_direction[pos_ia.X + 1, pos_ia.Y] = 1;
                }
            }
            carte_direct = carte_ia_direction;
        }
Exemple #3
0
 public void UpdateBis(Scientifique scientifique, Joueur joueur)
 {
     idmax = 0;
     CaseAccssibleScientifique(scientifique.position_case_actuelle, joueur);
     CaseLaPlusEloigne(joueur.position_case_actuelle);
     carte_ia = GenLabyIA(case_eloigne, carte_ia, laby);
 }
Exemple #4
0
        public override bool Init()
        {
            if (!Config.pause)
            {
                /**************************************/
                /*** Constantes pour le labyrinthe ****/
                /**************************************/
                int hauteur = Config.hauteur_labyrinthe;
                int largeur = Config.largeur_labyrinthe;

                // On génére un chiffre aléatoire
                Random rand = new Random();

                spriteBatch = new SpriteBatch(graphics.GraphicsDevice);

                // On charge la police du texte
                Kootenay = Content.Load<SpriteFont>(@"Polices\Kootenay");
                Arial = Content.Load<SpriteFont>(@"Polices\Arial");

                perso = Content.Load<SpriteFont>(@"Polices\Perso");

                // Carte 2D
                carte2D_joueur = Content.Load<Texture2D>(@"Images\carte2D\joueur");
                carte2D_mur = Content.Load<Texture2D>(@"Images\carte2D\mur");
                carte2D_chemin = Content.Load<Texture2D>(@"Images\carte2D\chemin");
                carte2D_sortie = Content.Load<Texture2D>(@"Images\carte2D\sortie");
                if (Config.modedejeu)
                {
                    carte2D_chasseur = Content.Load<Texture2D>(@"Images\carte2D\chasseur");
                    carte2D_joueur = Content.Load<Texture2D>(@"Images\carte2D\joueur");
                }
                else
                {
                    carte2D_chasseur = Content.Load<Texture2D>(@"Images\carte2D\joueur");
                    carte2D_joueur = Content.Load<Texture2D>(@"Images\carte2D\chasseur");
                }

                carte2D_bonus = Content.Load<Texture2D>(@"Images\carte2D\bonus");
                carte2D_piege = Content.Load<Texture2D>(@"Images\carte2D\piege");

                // Boussole et Chronometre
                if (Config.modedejeu)
                {
                    chronometre_texture = Content.Load<Texture2D>(@"Images\chronometre");
                    boussole_support = Content.Load<Texture2D>(@"Images\boussole_support");
                    boussole_fleche = Content.Load<Texture2D>(@"Images\boussole_fleche");
                    boussole_fleche_sortie = Content.Load<Texture2D>(@"Images\boussole_fleche-sortie");
                }
                else
                {
                    radar_cible = Content.Load<Texture2D>(@"Images\radar_cible");
                    radar_support = Content.Load<Texture2D>(@"Images\radar_support");
                }

                // Temporisation
                tempo_load = Content.Load<Texture2D>(@"Images\tempo_load");
                tempo_fixe = Content.Load<Texture2D>(@"Images\tempo_fixe");

                effet = Content.Load<Effect>(@"Effets\Effet2");

                // Audio
                Audio = new AudioEngine(@"Content\Musiques\ambiance.xgs");

                // Charge la banque de musiques
                SoundBank = new SoundBank(Audio, @"Content\Musiques\Sound Bank.xsb");
                WaveBank = new WaveBank(Audio, @"Content\Musiques\Wave Bank.xwb");

                // Joue la musique d'ambiance
                musique_ambiance = SoundBank.GetCue("ambiance_labyrinthe");

                // Sons
                if (Config.modedejeu)
                    son_mort = "mort";
                else
                    son_mort = "mort_chasseur";

                musique_ambiance.Play();

                // Fixe le volume du jeu
                Audio.GetCategory("Musiques").SetVolume(aMAZEing_Escape.Properties.Settings.Default.volume_musiques);
                Audio.GetCategory("Sons").SetVolume(aMAZEing_Escape.Properties.Settings.Default.volume_sons);

                // Sons d'ambiance aléatoire
                son_ambiance_aleatoire = SoundBank.GetCue("son_ambiance_aleatoire");
                compteur_son_ambiance_aleatoire = rand.Next(10, 30);

                // Son mort subite
                if (Config.modedejeu)
                    son_mort_subite = SoundBank.GetCue("son_mort_subite_chasseur");
                else
                    son_mort_subite = SoundBank.GetCue("son_mort_subite_chasse");

                son_mort_subite_unique = false;

                if (Config.modedejeu)
                    musique_poursuite = SoundBank.GetCue("poursuite");

                // On charge les textures
                textures = new Texture2D[8];
                textures[0] = Content.Load<Texture2D>(@"Textures\texture_plafond");
                textures[1] = Content.Load<Texture2D>(@"Textures\texture_mur");
                textures[2] = Content.Load<Texture2D>(@"Textures\texture_mur_sortie");
                textures[3] = Content.Load<Texture2D>(@"Textures\texture_fond_sortie");
                textures[4] = Content.Load<Texture2D>(@"Textures\texture_sol");
                textures[5] = Content.Load<Texture2D>(@"Textures\texture_mur_trappe");
                textures[6] = Content.Load<Texture2D>(@"Textures\texture_sol_trappe");
                textures[7] = Content.Load<Texture2D>(@"Textures\texture_sol_plafond_sortie");

                noir = Content.Load<Texture2D>(@"Images\black");

                transition_fin_blanc = Content.Load<Texture2D>(@"Images\blanc");

                compteur_transition_debut = 2f;
                transition_debut_finie = false;
                transition_debut_messages = new string[2];
                transition_debut_messages[0] = "Pret ?";
                transition_debut_messages[1] = "Go !";

                /***************************************************/
                /***************** Initialisation ! ****************/
                /***************************************************/

                // Triche
                triche = false;
                pass = "";
                compteur_message_triche = 0;

                // Liste des bonus actifs
                if (!Config.modedejeu)
                    Config.boussole_sortie = false;
                liste_bonus_actifs = new List<int>();
                liste_bonus_actifs = Liste_Bonus_Actifs();

                if (liste_bonus_actifs.Count == 0)
                    Config.active_bonus = false;

                // Pièges désactivés ?
                if (!Config.trappe && !Config.laser)
                    Config.active_pieges = false;

                // Génération du labyrinthe
                laby = new Labyrinthe();

                laby.BuildMaze(new Point(largeur, hauteur), new Vector3(2.5f), Content, laby, graphics.GraphicsDevice, liste_bonus_actifs);
                // On charge le labyrinthe en vertices
                materialBuilder = new MazeMaterialBuilder();

                // On génére un chiffre aléatoire
                rand = new Random();

                // Joueur
                joueur = new Joueur(graphics.GraphicsDevice.Viewport, laby, SoundBank);
                son_mort_unique = false;

                // Chasseur
                if (Config.modedejeu)
                {
                    // IA
                    ia = new IA(laby, new Point((int)(joueur.position.X / laby.CellSize.X), (int)(joueur.position.Z / laby.CellSize.Z)), graphics.GraphicsDevice.Viewport);

                    chasseur = new Chasseur(graphics.GraphicsDevice.Viewport, laby, Content, ia);
                    poursuite = false;
                    compteur_animation_fin_chasseur = 1f;
                    chasseur_touche = false;
                }
                // Scientifique
                else
                {
                    // IA
                    ia = new IA(laby, laby.sortie_position, graphics.GraphicsDevice.Viewport);

                    scientifique = new Scientifique(graphics.GraphicsDevice.Viewport, laby, Content, ia);
                    compteur_animation_fin_scientifique = 1f;
                    scientifique_touche = false;
                }

                // Carte de sortie
                if (Config.modedejeu)
                {
                    carte_joueur_sortie = new bool[Config.largeur_labyrinthe, Config.hauteur_labyrinthe];
                    GenCarteJoueurSortie();
                    materials = materialBuilder.BuildMazeMaterial(laby, graphics.GraphicsDevice, textures, joueur.fil_ariane, carte_joueur_sortie);
                    materials_save = materials;
                }
                else
                {
                    carte_joueur_scientifique = new bool[Config.largeur_labyrinthe, Config.hauteur_labyrinthe];
                    GenCarteJoueurScientifique();
                    materials = materialBuilder.BuildMazeMaterial(laby, graphics.GraphicsDevice, textures, joueur.fil_ariane, carte_joueur_scientifique);
                    materials_save = materials;
                }

                // Infos par texte
                InfoTexteGauche = 0;
                InfoTexteHaut = 40;

                // Constantes pour l'affichage de la carte 2D
                EspaceTexte = 22;
                EspaceTexture = carte2D_chemin.Width;

                TextureRedimension = 1;
                carte2D_taille_texture = new Vector2(carte2D_chemin.Width * TextureRedimension, carte2D_chemin.Height * TextureRedimension);
                BordGaucheTexture = (int)(graphics.GraphicsDevice.Viewport.Width / 2 - (carte2D_taille_texture.X * (laby.Size.X) * echelle) / 2);
                BordHautTexture = (int)(graphics.GraphicsDevice.Viewport.Height / 2 - (carte2D_taille_texture.Y * laby.Size.Y * echelle) / 2);
                carte2D_couleur_texture = Color.White;

                echelle = 0;
                while (carte2D_taille_texture.Y * echelle * laby.Size.Y < graphics.GraphicsDevice.Viewport.Height - (graphics.GraphicsDevice.Viewport.Height / 4) &&
                        carte2D_taille_texture.X * echelle * laby.Size.X < graphics.GraphicsDevice.Viewport.Height)
                {
                    echelle += 0.01f;
                }

                BordGaucheTexture = (int)(graphics.GraphicsDevice.Viewport.Width / 2 - (carte2D_taille_texture.X * (laby.Size.X) * echelle) / 2);
                BordHautTexture = (int)(graphics.GraphicsDevice.Viewport.Height / 2 - (carte2D_taille_texture.Y * laby.Size.Y * echelle) / 2);

                // Pour le déplacement de la caméra
                nearPlane = 0.01f;
                farPlane = 10000.0f;
                fieldOfView = 60.0f;
                aspectRatio = (float)graphics.GraphicsDevice.Viewport.Width / (float)graphics.GraphicsDevice.Viewport.Height;
                Projection = Matrix.CreatePerspectiveFieldOfView(MathHelper.ToRadians(fieldOfView), aspectRatio, nearPlane, farPlane);

                // Souris
                yaw = 0;
                pitch = 0;

                clavier_prec = Keyboard.GetState();
                Mouse.SetPosition(graphics.GraphicsDevice.Viewport.Width / 2, graphics.GraphicsDevice.Viewport.Height / 2);
                souris_prec = Mouse.GetState();

                // Chrono
                chrono = 1;
                chrono_meilleur_score = 0;

                // Bonus
                geler_compteur = 0;
                changervitesse_compteur = 0;
                inverser_position = false;
                teleportation_aleatoire = false;
                inversertouche_compteur = 0;
                inversercamera_compteur = 0;
                changercamera_compteur = 0;
                inversercamera = false;
                changercamera = false;
                affichercarte2D_compteur = 0;
                affichercarte2D = false;
                cecite = false;
                cecite_compteur = 0;
                boussole_sortie = false;
                boussole_sortie_compteur = 0;
                compteur_message_bonus = 0;

                compteur_total = 0;

                // Temporisation
                tempo_load_largeur = ((tempo_load.Width / 2) * graphics.GraphicsDevice.Viewport.Width) / 800;
                tempo_load_hauteur = ((tempo_load.Height / 2) * graphics.GraphicsDevice.Viewport.Height) / 600;

                tempo_fixe_largeur = graphics.GraphicsDevice.Viewport.Width;
                tempo_fixe_hauteur = ((tempo_fixe.Height / 1) * graphics.GraphicsDevice.Viewport.Height) / 600;

                ia.CaseIntersection(); //Définis les cases du labyrinthe qui sont des intersections.
                ia.CaseImpasse(); //Définis les cases du labyrinthe qui sont des impasses.
                if(Config.active_mort_subite)
                    mortsubite = 60 * Config.min_mort_subite + Config.sec_mort_subite;
                facteur = 1.52196;

            }
            else
            {
                Config.pause = false;
                if (Config.modedejeu)
                {
                    if(musique_poursuite.IsPaused)
                        musique_poursuite.Resume();
                }
                musique_ambiance.Resume();
            }
            return base.Init();
        }