예제 #1
0
        // Le constructeur
        public Scientifique(Viewport vp, Labyrinthe labyrinthe, ContentManager Content, IA ia)
        {
            /** Pour le model **/
            model = Content.Load<Model>("Models/Scientifique/hazmat");
            skeleton_base = new CSkeletonBase(model);
            skeleton_base.setAnimation("walk_normal");
            skeleton_base.TimeScale = 2;
            scale = 0.02f;
            RotationX(0);
            RotationY(0);
            RotationZ(0);
            localWorld = Matrix.Identity;

            /** Infos sur le scientifique **/
            increment = new Vector2(0);
            laby = labyrinthe;
            position = laby.scientifique_position_initiale / scale;
            position_case_actuelle = new Point((int)(position.X / (laby.CellSize.X / scale)), (int)(position.Z / (laby.CellSize.Z / scale)));
            position_case_precedente = position_case_actuelle;
            case_transition = position_case_actuelle;
            changement_de_case = false;
            immobile = true;

            pos_temp = position;

            temporisation = 0;
            //pos_prec = -1;
            frequence = new int[laby.Size.X, laby.Size.Y];
            for (int x = 0; x < laby.Size.X; x++)
            {
                for (int y = 0; y < laby.Size.Y; y++)
                {
                    frequence[x, y] = 0;
                }
            }

            EspaceTexte = 22;
            BordGaucheFrequence = vp.Width / 2 - (EspaceTexte * laby.Size.X) / 2;
            BordHautFrequence = vp.Height / 2 - (EspaceTexte * laby.Size.Y) / 2;

            // Pour la rotation du chasseur
            direction = 2; // Au début, il regarde en bas

            vitesse_initiale = 0.01f;
            vitesse = vitesse_initiale;
            distance_deplacement = 0.42f;
            vitesse_rotation = 0.05f;

            // IA
            this.ia = ia;
            min_id = MinID(ia.carte_ia);
            min_id_prec = min_id;
        }
예제 #2
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();
        }