Exemplo n.º 1
0
        public void UpdateChasseur(Chasseur chasseur, bool triche, Joueur joueur)
        {
            if (!carte_ia_inter[chasseur.position_case_actuelle.X, chasseur.position_case_actuelle.Y] && !Impasse(chasseur.position_case_actuelle))
            {
                if (case_eloigne == Point.Zero && !une_premiere_fois)
                    carte_ia = GenLabyIA(joueur.position_case_actuelle, carte_ia, laby);
                else
                    carte_ia = GenLabyIA(case_eloigne, carte_ia, laby);

            }
            else
            {
                une_premiere_fois = true;
                idmax = 0;
                carte_ia = GenLabyIA(joueur.position_case_actuelle, carte_ia, laby);
                Direction(chasseur, carte_ia);
                CaseObjectif(chasseur.position_case_actuelle);
                carte_ia = GenLabyIA(case_eloigne, carte_ia, laby);
            }
            if (triche)
            {
                KeyboardState clavier = Keyboard.GetState();

                // Déplacement de la carte des fréquence
                if (clavier.IsKeyDown(Keys.Left))
                    BordGaucheIA -= 5;
                if (clavier.IsKeyDown(Keys.Right))
                    BordGaucheIA += 5;
                if (clavier.IsKeyDown(Keys.Up))
                    BordHautIA -= 5;
                if (clavier.IsKeyDown(Keys.Down))
                    BordHautIA += 5;
            }
        }
Exemplo n.º 2
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);
 }
Exemplo n.º 3
0
 public void CaseAccssibleScientifique(Point pos_ia, Joueur joueur)
 {
     for (int x = 0; x < laby.Size.X; x++)
     {
         for (int y = 0; y < laby.Size.Y; y++)
         {
             carte_ia_acces[x, y] = false;
         }
     }
     Point pos;
     int compteur;
     Queue<Point> file = new Queue<Point>();
     carte_ia_acces[pos_ia.X, pos_ia.Y] = true;
     file.Enqueue(pos_ia);
     while (file.Count > 0)
     {
         compteur = file.Count;
         for (int i = 0; i < compteur; i++)
         {
             pos = file.Dequeue();
             // Haut
             if (pos.Y - 1 >= 0 && laby.Carte[pos.X, pos.Y - 1] != 1 && !(pos.X == joueur.position_case_actuelle.X && pos.Y - 1 == joueur.position_case_actuelle.Y) && carte_ia_acces[pos.X, pos.Y - 1] == false)
             {
                 carte_ia_acces[pos.X, pos.Y - 1] = true;
                 file.Enqueue(new Point(pos.X, pos.Y - 1));
             }
             // Droite
             if (pos.X + 1 < laby.Size.X && laby.Carte[pos.X + 1, pos.Y] != 1 && !(pos.X + 1 == joueur.position_case_actuelle.X && pos.Y == joueur.position_case_actuelle.Y) && carte_ia_acces[pos.X + 1, pos.Y] == false)
             {
                 carte_ia_acces[pos.X + 1, pos.Y] = true;
                 file.Enqueue(new Point(pos.X + 1, pos.Y));
             }
             // Bas
             if (pos.Y + 1 < laby.Size.Y && laby.Carte[pos.X, pos.Y + 1] != 1 && !(pos.X == joueur.position_case_actuelle.X && pos.Y + 1 == joueur.position_case_actuelle.Y) && carte_ia_acces[pos.X, pos.Y + 1] == false)
             {
                 carte_ia_acces[pos.X, pos.Y + 1] = true;
                 file.Enqueue(new Point(pos.X, pos.Y + 1));
             }
             // Gauche
             if (pos.X - 1 >= 0 && laby.Carte[pos.X - 1, pos.Y] != 1 && !(pos.X - 1 == joueur.position_case_actuelle.X && pos.Y == joueur.position_case_actuelle.Y) && carte_ia_acces[pos.X - 1, pos.Y] == false)
             {
                 carte_ia_acces[pos.X - 1, pos.Y] = true;
                 file.Enqueue(new Point(pos.X - 1, pos.Y));
             }
         }
     }
 }
Exemplo n.º 4
0
        public bool ScienNonBloque(Point pos_ia, Point position_scientifique, Joueur joueur)
        {
            for (int x = 0; x < laby.Size.X; x++)
            {
                for (int y = 0; y < laby.Size.Y; y++)
                {
                    carte_ia[x, y] = laby.Size.X * laby.Size.Y;
                }
            }

            int id = 0;
            Point pos;
            int compteur;
            Queue<Point> file = new Queue<Point>();
            carte_ia[pos_ia.X, pos_ia.Y] = id;
            file.Enqueue(pos_ia);
            while (file.Count > 0)
            {
                id++;
                compteur = file.Count;
                for (int i = 0; i < compteur; i++)
                {
                    pos = file.Dequeue();
                    // Haut
                    if (pos.Y - 1 >= 0 && laby.Carte[pos.X, pos.Y - 1] != 1 && !(pos.X == joueur.position_case_actuelle.X && pos.Y - 1 == joueur.position_case_actuelle.Y) && carte_ia[pos.X, pos.Y - 1] > id)
                    {
                        carte_ia[pos.X, pos.Y - 1] = id;
                        file.Enqueue(new Point(pos.X, pos.Y - 1));
                    }
                    // Droite
                    if (pos.X + 1 < laby.Size.X && laby.Carte[pos.X + 1, pos.Y] != 1 && !(pos.X + 1 == joueur.position_case_actuelle.X && pos.Y == joueur.position_case_actuelle.Y) && carte_ia[pos.X + 1, pos.Y] > id)
                    {
                        carte_ia[pos.X + 1, pos.Y] = id;
                        file.Enqueue(new Point(pos.X + 1, pos.Y));
                    }
                    // Bas
                    if (pos.Y + 1 < laby.Size.Y && laby.Carte[pos.X, pos.Y + 1] != 1 && !(pos.X == joueur.position_case_actuelle.X && pos.Y + 1 == joueur.position_case_actuelle.Y) && carte_ia[pos.X, pos.Y + 1] > id)
                    {
                        carte_ia[pos.X, pos.Y + 1] = id;
                        file.Enqueue(new Point(pos.X, pos.Y + 1));
                    }
                    // Gauche
                    if (pos.X - 1 >= 0 && laby.Carte[pos.X - 1, pos.Y] != 1 && !(pos.X - 1 == joueur.position_case_actuelle.X && pos.Y == joueur.position_case_actuelle.Y) && carte_ia[pos.X - 1, pos.Y] > id)
                    {
                        carte_ia[pos.X - 1, pos.Y] = id;
                        file.Enqueue(new Point(pos.X - 1, pos.Y));
                    }
                }
            }
            return (carte_ia[position_scientifique.X, position_scientifique.Y] != laby.Size.X * laby.Size.Y);
        }
Exemplo n.º 5
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();
        }