public Bonus(Labyrinthe laby, ContentManager Content, Vector3 position, List<int> liste_bonus_actifs) { position_bonus = position; position_case_bonus = new Point((int)(position_bonus.X / laby.CellSize.X), (int)(position_bonus.Z / laby.CellSize.Z)); // On choisit aléatoirement le type du bonus /* * 0 => Lenteur * 1 => Inversion * 2 => Gel * 3 => Touches changées * 4 => Caméra inversée * 5 => Téléportation * 6 => Sprint * 7 => Fil d'Ariane * 8 => Carte * 9 => Caméra changée * 10 => Obscurité * 11 => Boussole sortie */ if (liste_bonus_actifs.Count > 0) { type = rand.Next(liste_bonus_actifs.Count); type = liste_bonus_actifs[type]; } else type = rand.Next(12); // On charge le model bonus = Content.Load<Model>(@"Models\bonus"); }
public IA(Labyrinthe labyrinthe, Point position_joueur, Viewport vp) { laby = labyrinthe; taille = new Point(laby.Size.X, laby.Size.Y); carte_ia = new int[taille.X, taille.Y]; pos_prec = new Stack<Point>(); pos_ia = position_joueur; carte_ia[pos_ia.X, pos_ia.Y] = 0; pos_prec.Push(pos_ia); carte_ia = GenLabyIA(pos_ia, carte_ia, laby); EspaceTexte = 35; BordGaucheIA = vp.Width / 2 - (EspaceTexte * laby.Size.X) / 2; BordHautIA = vp.Height / 2 - (EspaceTexte * laby.Size.Y) / 2; idmax = 0; carte_ia_acces = new bool[Config.largeur_labyrinthe, Config.hauteur_labyrinthe]; carte_ia_inter = new bool[taille.X, taille.Y]; carte_direct = new int[taille.X, taille.Y]; nb_chemin = new int[taille.X, taille.Y]; carte_ia2 = new int[taille.X, taille.Y]; carte_impasse = new bool[taille.X, taille.Y]; }
// 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; }
public static int[,] GenLabyIA(Point pos_ia, int[,] matrice, Labyrinthe laby) { for (int x = 0; x < laby.Size.X; x++) { for (int y = 0; y < laby.Size.Y; y++) { matrice[x, y] = laby.Size.X * laby.Size.Y; } } int id = 0; Point pos; int compteur; Queue<Point> file = new Queue<Point>(); matrice[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 && matrice[pos.X, pos.Y - 1] > id) { matrice[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 && matrice[pos.X + 1, pos.Y] > id) { matrice[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 && matrice[pos.X, pos.Y + 1] > id) { matrice[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 && matrice[pos.X - 1, pos.Y] > id) { matrice[pos.X - 1, pos.Y] = id; file.Enqueue(new Point(pos.X - 1, pos.Y)); } } } return matrice; }
// Le constructeur public Joueur(Viewport vp, Labyrinthe laby, SoundBank SoundBank) { /** Infos sur le joueur **/ position = laby.joueur_position_initiale; position_case_actuelle = new Point((int)(position.X / laby.CellSize.X), (int)(position.Z / laby.CellSize.Z)); position_case_precedente = position_case_actuelle; case_transition = position_case_actuelle; changement_de_case = false; reference = new Vector3(0.0f, 0.0f, 1.0f); cible = position + reference; vitesse_initiale = 4.0f; vitesse = vitesse_initiale; noclip = false; gel = false; inversertouches = false; immobile = true; // Le saut valeur_saut = 0; vitesse_saut = 3.5f; compteur_saut_initial = (3 / vitesse_saut) - 0.021f; compteur_saut = compteur_saut_initial; saut = false; // Se baisser baisse = false; this.SoundBank = SoundBank; if (Config.modedejeu) son_saut = "saut"; else son_saut = "saut_chasseur"; vivant = true; // Clavier clavier_prec = Keyboard.GetState(); // Les touches Touches = new Keys[] { aMAZEing_Escape.Properties.Settings.Default.avancer, aMAZEing_Escape.Properties.Settings.Default.droite, aMAZEing_Escape.Properties.Settings.Default.reculer, aMAZEing_Escape.Properties.Settings.Default.gauche }; TouchesFausses = new Keys[] { Keys.Z, Keys.D, Keys.S, Keys.Q }; // Initialisation de la matrice de coût matrice_cout = new int[Config.largeur_labyrinthe, Config.hauteur_labyrinthe]; matrice_cout = IA.GenLabyIA(position_case_actuelle, matrice_cout, laby); }
public Pieges(Labyrinthe laby, ContentManager Content, Vector3 position) { this.position = position; position_case = new Point((int)(position.X / laby.CellSize.X), (int)(position.Z / laby.CellSize.Z)); cellsize = laby.CellSize; // On choisit aléatoirement le type du bonus if (Config.trappe && Config.laser) type = rand.Next(0, 2); else if (Config.laser) type = 1; else type = 0; if (type == 1) { // Si il y a 2 murs face à face sur cette case if ( ((position_case.Y == Config.hauteur_labyrinthe - 1 || laby.Carte[position_case.X, position_case.Y + 1] == 1) && (position_case.Y == 0 || laby.Carte[position_case.X, position_case.Y - 1] == 1)) || ((position_case.X == Config.largeur_labyrinthe - 1 || laby.Carte[position_case.X + 1, position_case.Y] == 1) && (position_case.X == 0 || laby.Carte[position_case.X - 1, position_case.Y] == 1))) { if ((position_case.X == Config.largeur_labyrinthe - 1 || laby.Carte[position_case.X + 1, position_case.Y] == 1) && (position_case.X == 0 || laby.Carte[position_case.X - 1, position_case.Y] == 1)) direction_laser = "EO"; else direction_laser = "NS"; } else type = 0; } // On charge le model // Piques if (type == 0) { piques = Content.Load<Model>(@"Models\Pieges\piques"); trappe = Content.Load<Model>(@"Models\Pieges\trappe"); position = new Vector3(position.X, position.Y - laby.CellSize.Y, position.Z); afficher_trappe = true; trappe_ferme = "trappe_ferme"; rotation_trappe = 90; translation_trappe = Vector2.Zero; if (Config.index_difficulte == 2) trappe_declenchement = 2f; else if (Config.index_difficulte == 1) trappe_declenchement = 3f; else trappe_declenchement = 4f; } // Laser else { effet_laser = Content.Load<Effect>(@"Effets\laser"); laser = Content.Load<Model>(@"Models\Pieges\laser"); if (rand.Next(2) == 1) hauteur_laser = 0.5f; else hauteur_laser = laby.CellSize.Y / 2; this.position = new Vector3(this.position.X, this.position.Y + hauteur_laser, this.position.Z - laby.CellSize.Z / 2); } }
public void BuildMaze(Point size, Vector3 cellSize, ContentManager Content, Labyrinthe laby, GraphicsDevice graphics, List<int> liste_bonus_actifs) { // On créé la carte réelle Carte = new int[size.X, size.Y]; carte_espace_bonus = new bool[Config.largeur_labyrinthe, Config.hauteur_labyrinthe]; carte_espace_pieges = new bool[Config.largeur_labyrinthe, Config.hauteur_labyrinthe]; // On la remplie de mur for (int y = 0; y < size.Y; y++) for (int x = 0; x < size.X; x++) Carte[x, y] = 1; // Taille Size = size; CellSize = cellSize; // Aléatoire random = new Random(); //Bonus // Création de la liste des bonus liste_bonus = new List<Bonus>(); // Pièges liste_pieges = new List<Pieges>(); // On place la sortie sortie_position = new Point(random.Next(size.X), random.Next(size.Y)); // On la rabat sur le bord le plus proche if (sortie_position.X > size.X / 2) { if (sortie_position.Y > sortie_position.X) sortie_position = new Point(sortie_position.X, size.Y - 1); else sortie_position = new Point(size.X - 1, sortie_position.Y); } else { if (sortie_position.Y > sortie_position.X) sortie_position = new Point(0, sortie_position.Y); else sortie_position = new Point(sortie_position.X, 0); } // On place la sortie sur la carte Carte[sortie_position.X, sortie_position.Y] = 3; // On initialise le tableau des positions précédente pour la génération du labyrinthe pos_prec = new Stack<Point>(); pos_prec.Push(sortie_position); pos_actuelle = sortie_position; // On initialise le tableau des cases possibles casespossibles = new bool[4]; murs_possibles = new bool[4]; // Puis on applique un algorithme pour générer le labyrinthe if (Config.laby_algo) { // Labyrinthe parfait GenLabyParfait(); } else { // Labyrinthe imparfait GenLabyImparfait(sortie_position, pos_prec, 2); } // On place le joueur Point position_aleatoire = new Point(random.Next(size.X), random.Next(size.Y)); int[,] matrice_distance_sortie_joueur = new int[size.X, size.Y]; matrice_distance_sortie_joueur = IA.GenLabyIA(sortie_position, matrice_distance_sortie_joueur, laby); while (Carte[position_aleatoire.X, position_aleatoire.Y] == 1 || (matrice_distance_sortie_joueur[position_aleatoire.X, position_aleatoire.Y] <= (Size.X + Size.Y) / 2)) position_aleatoire = new Point(random.Next(size.X), random.Next(size.Y)); // On place le joueur dans le jeu (au milieu de la case qui a été choisie aléatoirement) joueur_position_initiale = new Vector3((position_aleatoire.X * cellSize.X) + cellSize.X / 2, cellSize.Y / 2, (position_aleatoire.Y * cellSize.Z) + cellSize.Z / 2); // On calcule sa position en case joueur_position_initiale_case = new Point((int)(joueur_position_initiale.X / laby.CellSize.X), (int)(joueur_position_initiale.Z / laby.CellSize.Z)); // On place le joueur sur la carte Carte[position_aleatoire.X, position_aleatoire.Y] = 2; if (Config.modedejeu) { // On place le chasseur position_aleatoire = new Point(random.Next(size.X), random.Next(size.Y)); // Calcul de la distance joueur - chasseur int[,] matrice_distance_joueur_chasseur = new int[size.X, size.Y]; matrice_distance_joueur_chasseur = IA.GenLabyIA(joueur_position_initiale_case, matrice_distance_joueur_chasseur, laby); while (Carte[position_aleatoire.X, position_aleatoire.Y] != 0 || matrice_distance_joueur_chasseur[position_aleatoire.X, position_aleatoire.Y] <= (laby.Size.X + laby.Size.Y)/2) { position_aleatoire.X = random.Next(size.X); position_aleatoire.Y = random.Next(size.Y); } // On place le chasseur dans le jeu (au milieu de la case qui a été choisie aléatoirement) chasseur_position_initiale = new Vector3((position_aleatoire.X * cellSize.X) + cellSize.X / 2, 0, (position_aleatoire.Y * cellSize.Z) + cellSize.Z / 2); // On place le chasseur sur la carte Carte[position_aleatoire.X, position_aleatoire.Y] = 4; } else { // On place le scientifique position_aleatoire = new Point(random.Next(size.X), random.Next(size.Y)); // Calcul de la distance joueur - scientifique int[,] matrice_distance_joueur_scientifique = new int[size.X, size.Y]; matrice_distance_joueur_scientifique = IA.GenLabyIA(joueur_position_initiale_case, matrice_distance_joueur_scientifique, laby); // Calcul de la distance scientifique - sortie int[,] matrice_distance_sortie_scientifique = new int[size.X, size.Y]; matrice_distance_sortie_scientifique = IA.GenLabyIA(sortie_position, matrice_distance_sortie_scientifique, laby); while (Carte[position_aleatoire.X, position_aleatoire.Y] == 1 || matrice_distance_joueur_scientifique[position_aleatoire.X, position_aleatoire.Y] <= (laby.Size.X + laby.Size.Y) / 3 || matrice_distance_sortie_scientifique[position_aleatoire.X, position_aleatoire.Y] <= (laby.Size.X + laby.Size.Y) / 2) { position_aleatoire.X = random.Next(size.X); position_aleatoire.Y = random.Next(size.Y); } // On place le joueur dans le jeu (au milieu de la case qui a été choisie aléatoirement) scientifique_position_initiale = new Vector3((position_aleatoire.X * cellSize.X) + cellSize.X / 2, 0, (position_aleatoire.Y * cellSize.Z) + cellSize.Z / 2); // On calcule sa position en case scientifique_position_initiale_case = new Point((int)(scientifique_position_initiale.X / laby.CellSize.X), (int)(scientifique_position_initiale.Z / laby.CellSize.Z)); // On place le joueur sur la carte Carte[position_aleatoire.X, position_aleatoire.Y] = 4; } /*** On place les bonus ***/ if (Config.active_bonus) { // On remplit toutes les cases non chemin avec des true pour ne pas poser de bonus dessus for (int y = 0; y < size.Y; y++) for (int x = 0; x < size.X; x++) if (Carte[x, y] != 0) carte_espace_bonus[x, y] = true; nb_bonus = 0; bool plein_bonus = false; while (!plein_bonus) { Point position_bonus = new Point(random.Next(size.X), random.Next(size.Y)); while (carte_espace_bonus[position_bonus.X, position_bonus.Y]) { position_bonus = new Point(random.Next(size.X), random.Next(size.Y)); } liste_bonus.Add(new Bonus(laby, Content, new Vector3((position_bonus.X * cellSize.X) + cellSize.X / 2, cellSize.Y / 8, (position_bonus.Y * cellSize.Z) + cellSize.Z / 2), liste_bonus_actifs)); Carte[position_bonus.X, position_bonus.Y] = 5; // On indique les positions où ne peuvent pas apparaitre d'autre bonus for (int x = 0; x < Config.largeur_labyrinthe; x++) for (int y = 0; y < Config.hauteur_labyrinthe; y++) { double distance_case_bonus = Math.Sqrt(Math.Pow(liste_bonus[nb_bonus].position_case_bonus.X - x, 2) + Math.Pow(liste_bonus[nb_bonus].position_case_bonus.Y - y, 2)); if (distance_case_bonus <= ray(laby.Size) / 3) carte_espace_bonus[x, y] = true; } int nb_true = 0; for (int x = 0; x < Config.largeur_labyrinthe; x++) for (int y = 0; y < Config.hauteur_labyrinthe; y++) if (carte_espace_bonus[x, y]) nb_true++; if (nb_true == Config.hauteur_labyrinthe * Config.largeur_labyrinthe) plein_bonus = true; nb_bonus++; } // On supprime des bonus en fonction de la configuration du jeu int bonus_aleatoire = random.Next(0, liste_bonus.Count); if (Config.nb_bonus_index == 0) { for (int i = 0; i < nb_bonus / 1.2; i++) { Carte[liste_bonus[bonus_aleatoire].position_case_bonus.X, liste_bonus[bonus_aleatoire].position_case_bonus.Y] = 0; liste_bonus.Remove(liste_bonus[bonus_aleatoire]); bonus_aleatoire = random.Next(0, liste_bonus.Count); nb_bonus--; } } else if (Config.nb_bonus_index == 1) { for (int i = 0; i < nb_bonus / 1.5; i++) { Carte[liste_bonus[bonus_aleatoire].position_case_bonus.X, liste_bonus[bonus_aleatoire].position_case_bonus.Y] = 0; liste_bonus.Remove(liste_bonus[bonus_aleatoire]); bonus_aleatoire = random.Next(0, liste_bonus.Count); nb_bonus--; } } if (Config.nb_bonus_index < 2) { // Actualise la carte des apparitions possibles pour les bonus for (int x = 0; x < Config.largeur_labyrinthe; x++) { for (int y = 0; y < Config.hauteur_labyrinthe; y++) { if (Carte[x, y] == 0) carte_espace_bonus[x, y] = false; } } // On indique les positions où ne peuvent pas apparaitre d'autres bonus for (int x = 0; x < Config.largeur_labyrinthe; x++) { for (int y = 0; y < Config.hauteur_labyrinthe; y++) { foreach (Bonus bonus in liste_bonus) { double distance_case_bonus = Math.Sqrt(Math.Pow(bonus.position_case_bonus.X - x, 2) + Math.Pow(bonus.position_case_bonus.Y - y, 2)); if (distance_case_bonus <= ray(laby.Size) / 5) { carte_espace_bonus[x, y] = true; } } } } } } /*** On place les pièges ***/ if (Config.active_pieges) { for (int y = 0; y < size.Y; y++) for (int x = 0; x < size.X; x++) if (Carte[x, y] != 0) carte_espace_pieges[x, y] = true; nb_pieges = 0; bool plein_piege = false; while (!plein_piege) { Point position_pieges = new Point(random.Next(size.X), random.Next(size.Y)); while (Carte[position_pieges.X, position_pieges.Y] != 0 || carte_espace_pieges[position_pieges.X, position_pieges.Y]) { position_pieges = new Point(random.Next(size.X), random.Next(size.Y)); } liste_pieges.Add(new Pieges(laby, Content, new Vector3((position_pieges.X * cellSize.X) + cellSize.X / 2, 0, (position_pieges.Y * cellSize.Z) + cellSize.Z / 2))); Carte[position_pieges.X, position_pieges.Y] = 6; // On indique les positions où ne peuvent pas apparaître d'autre pieges for (int x = 0; x < Config.largeur_labyrinthe; x++) { for (int y = 0; y < Config.hauteur_labyrinthe; y++) { foreach (Pieges pieges in liste_pieges) { double distance_case_pieges = Math.Sqrt(Math.Pow(pieges.position_case.X - x, 2) + Math.Pow(pieges.position_case.Y - y, 2)); if (distance_case_pieges <= ray(laby.Size) / 5) carte_espace_pieges[x, y] = true; } } } int nb_true = 0; for (int x = 0; x < Config.largeur_labyrinthe; x++) { for (int y = 0; y < Config.hauteur_labyrinthe; y++) { if (carte_espace_pieges[x, y]) nb_true++; } } if (nb_true == Config.hauteur_labyrinthe * Config.largeur_labyrinthe) plein_piege = true; nb_pieges++; } // Si il n'y a que les lasers d'activé if (!Config.trappe) { for (int i = 0; i < liste_pieges.Count; i++) { if (!( ((liste_pieges[i].position_case.Y == Config.hauteur_labyrinthe - 1 || laby.Carte[liste_pieges[i].position_case.X, liste_pieges[i].position_case.Y + 1] == 1) && (liste_pieges[i].position_case.Y == 0 || laby.Carte[liste_pieges[i].position_case.X, liste_pieges[i].position_case.Y - 1] == 1)) || ((liste_pieges[i].position_case.X == Config.largeur_labyrinthe - 1 || laby.Carte[liste_pieges[i].position_case.X + 1, liste_pieges[i].position_case.Y] == 1) && (liste_pieges[i].position_case.X == 0 || laby.Carte[liste_pieges[i].position_case.X - 1, liste_pieges[i].position_case.Y] == 1)))) { Carte[liste_pieges[i].position_case.X, liste_pieges[i].position_case.Y] = 0; liste_pieges.Remove(liste_pieges[i]); nb_pieges--; i--; } } } // On supprime des pièges en fonction de la configuration du jeu int piege_aleatoire = random.Next(0, liste_pieges.Count); if (Config.nb_pieges_index == 0) { for (int i = 0; i < nb_pieges / 1.2; i++) { Carte[liste_pieges[piege_aleatoire].position_case.X, liste_pieges[piege_aleatoire].position_case.Y] = 0; liste_pieges.Remove(liste_pieges[piege_aleatoire]); piege_aleatoire = random.Next(0, liste_pieges.Count); nb_pieges--; } } else if (Config.nb_pieges_index == 1) { for (int i = 0; i < nb_pieges / 1.5; i++) { Carte[liste_pieges[piege_aleatoire].position_case.X, liste_pieges[piege_aleatoire].position_case.Y] = 0; liste_pieges.Remove(liste_pieges[piege_aleatoire]); piege_aleatoire = random.Next(0, liste_pieges.Count); nb_pieges--; } } if (Config.nb_pieges_index < 2) { // Actualise la carte des apparitions possibles pour les bonus for (int x = 0; x < Config.largeur_labyrinthe; x++) { for (int y = 0; y < Config.hauteur_labyrinthe; y++) { if (Carte[x, y] == 0) carte_espace_pieges[x, y] = false; } } // On indique les positions où ne peuvent pas apparaitre d'autres bonus for (int x = 0; x < Config.largeur_labyrinthe; x++) { for (int y = 0; y < Config.hauteur_labyrinthe; y++) { foreach (Pieges piege in liste_pieges) { double distance_case_piege = Math.Sqrt(Math.Pow(piege.position_case.X - x, 2) + Math.Pow(piege.position_case.Y - y, 2)); if (distance_case_piege <= ray(laby.Size) / 3) { carte_espace_pieges[x, y] = true; } } } } } } }
public List<Material> BuildMazeMaterial(Labyrinthe laby, GraphicsDevice graphicsDevice, Texture2D[] textures, bool fil_ariane, bool[,] carte_resolution) { this.laby = laby; carte = laby.Carte; MeshMaker maker = new MeshMaker(); for (int y = 0; y < laby.Size.Y; y++) for (int x = 0; x < laby.Size.X; x++) BuildMazeMaterial(maker, x, y, textures, fil_ariane, carte_resolution); return maker.BuildMaterials(graphicsDevice); }
public void Update(Viewport vp, GameTime gameTime, ContentManager cm, float yaw, float pitch, float temps, Labyrinthe laby, bool triche) { clavier = Keyboard.GetState(); Vector3 deplacement = Vector3.Zero; // On actualise la position du joueur position_case_actuelle = new Point((int)(position.X / laby.CellSize.X), (int)(position.Z / laby.CellSize.Z)); // Est-ce que le joueur se trouve sur un piège ? if (laby.Carte[position_case_actuelle.X, position_case_actuelle.Y] == 6) { // Quel piège ? foreach (Pieges piege in laby.liste_pieges) { if (piege.position_case == position_case_actuelle) { if (piege.type == 0 && !piege.afficher_trappe) trappe = true; else laser = true; } } } else { trappe = false; laser = false; } // Le joueur change de case if (case_transition != position_case_actuelle) { if (immobile) immobile = false; changement_de_case = true; matrice_cout = IA.GenLabyIA(position_case_actuelle, matrice_cout, laby); position_case_precedente = case_transition; } else changement_de_case = false; if (!gel && vivant) { if (inversertouches) { if (clavier.IsKeyDown(TouchesFausses[0])) deplacement.Z += vitesse * temps; if (clavier.IsKeyDown(TouchesFausses[1])) deplacement.Z -= vitesse * temps; if (clavier.IsKeyDown(TouchesFausses[2])) deplacement.X += vitesse * temps; if (clavier.IsKeyDown(TouchesFausses[3])) deplacement.X -= vitesse * temps; } else { if (clavier.IsKeyDown(Touches[0])) deplacement.Z += vitesse * temps; if (clavier.IsKeyDown(Touches[2])) deplacement.Z -= vitesse * temps; if (clavier.IsKeyDown(Touches[3])) deplacement.X += vitesse * temps; if (clavier.IsKeyDown(Touches[1])) deplacement.X -= vitesse * temps; } } // Activation du mode noclip if (triche && clavier.IsKeyDown(Keys.N)) noclip = true; else if(triche && clavier_prec.IsKeyDown(Keys.N) && !clavier.IsKeyDown(Keys.N)) noclip = false; // Empêche le joueur des limites du labyrinthe if (position.Y > 0) { position.X = MathHelper.Clamp(position.X, 0 + 0.2f, (laby.Size.X * laby.CellSize.X) - 0.2f); position.Z = MathHelper.Clamp(position.Z, 0 + 0.2f, (laby.Size.Y * laby.CellSize.Z) - 0.2f); } #region Collisions if (noclip == false) { if (trappe && position.Y < laby.joueur_position_initiale.Y) { position.Z = MathHelper.Clamp(position.Z, (position_case_actuelle.Y) * laby.CellSize.Z + 0.2f, (position_case_actuelle.Y + 1) * laby.CellSize.Z - 0.2f); position.X = MathHelper.Clamp(position.X, (position_case_actuelle.X) * laby.CellSize.X + 0.2f, (position_case_actuelle.X + 1) * laby.CellSize.Z - 0.2f); } else { //Mur en X // Si on est pas au bord if (position_case_actuelle.X + 1 < laby.Size.X && position_case_actuelle.X - 1 >= 0) { // Mur à gauche if (laby.Carte[position_case_actuelle.X - 1, position_case_actuelle.Y] == 1) { // Mur à gauche et à droite if (laby.Carte[position_case_actuelle.X + 1, position_case_actuelle.Y] == 1) position.X = MathHelper.Clamp(position.X, position_case_actuelle.X * laby.CellSize.X + 0.2f, (position_case_actuelle.X + 1) * laby.CellSize.X - 0.2f); // Mur à gauche et pas à droite else position.X = MathHelper.Clamp(position.X, position_case_actuelle.X * laby.CellSize.X + 0.2f, (position_case_actuelle.X + 2) * laby.CellSize.X - 0.2f); } // Pas de mur à gauche else { // Pas de mur à droite et mur à gauche if (laby.Carte[position_case_actuelle.X + 1, position_case_actuelle.Y] == 1) position.X = MathHelper.Clamp(position.X, (position_case_actuelle.X - 1) * laby.CellSize.X + 0.2f, (position_case_actuelle.X + 1) * laby.CellSize.X - 0.2f); // Sinon, il n'y a pas de mur => on ne fait rien ! } } // Si on est au bord à gauche et qu'il y a un mur à droite else if (position_case_actuelle.X - 1 < 0 && laby.Carte[position_case_actuelle.X + 1, position_case_actuelle.Y] == 1) position.X = MathHelper.Clamp(position.X, 0 + 0.2f, (position_case_actuelle.X + 1) * laby.CellSize.X - 0.2f); // Si on est au bord à droite et qu'il y a un mur à gauche else if (position_case_actuelle.X + 1 >= laby.Size.X && laby.Carte[position_case_actuelle.X - 1, position_case_actuelle.Y] == 1) position.X = MathHelper.Clamp(position.X, position_case_actuelle.X * laby.CellSize.X + 0.2f, laby.Size.X * laby.CellSize.X - 0.2f); // Murs en Y // Si on est pas au bord if (position_case_actuelle.Y + 1 < laby.Size.Y && position_case_actuelle.Y - 1 >= 0) { // Mur en haut if (laby.Carte[position_case_actuelle.X, position_case_actuelle.Y - 1] == 1) { // Mur en haut et en bas if (laby.Carte[position_case_actuelle.X, position_case_actuelle.Y + 1] == 1) position.Z = MathHelper.Clamp(position.Z, position_case_actuelle.Y * laby.CellSize.Z + 0.2f, (position_case_actuelle.Y + 1) * laby.CellSize.Z - 0.2f); // Mur en haut et pas de mur en bas else position.Z = MathHelper.Clamp(position.Z, position_case_actuelle.Y * laby.CellSize.Z + 0.2f, (position_case_actuelle.Y + 2) * laby.CellSize.Z - 0.2f); } // Pas de mur en haut else { // Pas de mur en haut et pas de mur en bas if (laby.Carte[position_case_actuelle.X, position_case_actuelle.Y + 1] == 1) position.Z = MathHelper.Clamp(position.Z, (position_case_actuelle.Y - 1) * laby.CellSize.Z + 0.2f, (position_case_actuelle.Y + 1) * laby.CellSize.Z - 0.2f); } } // Si on est au bord en haut et qu'il y a un mur en bas else if (position_case_actuelle.Y - 1 < 0 && laby.Carte[position_case_actuelle.X, position_case_actuelle.Y + 1] == 1) position.Z = MathHelper.Clamp(position.Z, 0 + 0.2f, (position_case_actuelle.Y + 1) * laby.CellSize.Z - 0.2f); // Si on est au bord en bas et qu'il y a un mur en haut else if (position_case_actuelle.Y + 1 >= laby.Size.Y && laby.Carte[position_case_actuelle.X, position_case_actuelle.Y - 1] == 1) position.Z = MathHelper.Clamp(position.Z, position_case_actuelle.Y * laby.CellSize.Z + 0.2f, laby.Size.Y * laby.CellSize.Z - 0.2f); // **** Collisions coins **** \\ /* * Il y a plusieurs problemes dus a la conversion de la carte 2D en 3D : * D'abord on fait le test si dans les coins il y a les murs et si autour non. * Ensuite on compare la position du joueur avec celle du coin du mur en faisant attention * avec les coordonnées, nous amenant parfois a comparer avec un autre mur, car la coordonnée du mur * est située en bas a droite sur une carte... Compliqué tout ça !! * */ double distPointHautGauche = Math.Sqrt(Math.Pow(position.X - (position_case_actuelle.X * laby.CellSize.X), 2) + Math.Pow(position.Z - (position_case_actuelle.Y * laby.CellSize.Z), 2)); double distPointHautDroite = Math.Sqrt(Math.Pow(position.X - ((position_case_actuelle.X + 1) * laby.CellSize.X), 2) + Math.Pow(position.Z - (position_case_actuelle.Y * laby.CellSize.Z), 2)); double distPointBasGauche = Math.Sqrt(Math.Pow(position.X - ((position_case_actuelle.X) * laby.CellSize.X), 2) + Math.Pow(position.Z - ((position_case_actuelle.Y + 1) * laby.CellSize.Z), 2)); double distPointBasDroite = Math.Sqrt(Math.Pow(position.X - ((position_case_actuelle.X + 1) * laby.CellSize.X), 2) + Math.Pow(position.Z - ((position_case_actuelle.Y + 1) * laby.CellSize.Z), 2)); // Coté gauche de carte if (position_case_actuelle.X == 0) { // Coin haut-gauche if (position_case_actuelle.Y == 0) { // Mur bas-droite if (laby.Carte[position_case_actuelle.X + 1, position_case_actuelle.Y] != 1 && laby.Carte[position_case_actuelle.X, position_case_actuelle.Y + 1] != 1 && laby.Carte[position_case_actuelle.X + 1, position_case_actuelle.Y + 1] == 1 && distPointBasDroite < 0.1f) { position.X -= 0.1f; position.Z -= 0.1f; } } // Coté gauche hors coins haut et bas else if (position_case_actuelle.Y + 1 < laby.Size.Y) { // Pas de mur a droite if (laby.Carte[position_case_actuelle.X + 1, position_case_actuelle.Y] != 1) { // Mur haut-droite if (laby.Carte[position_case_actuelle.X, position_case_actuelle.Y - 1] != 1 && laby.Carte[position_case_actuelle.X + 1, position_case_actuelle.Y - 1] == 1 && distPointHautDroite < 0.1f) { position.X -= 0.1f; position.Z += 0.1f; } // Mur bas-droite if (laby.Carte[position_case_actuelle.X, position_case_actuelle.Y + 1] != 1 && laby.Carte[position_case_actuelle.X + 1, position_case_actuelle.Y + 1] == 1 && distPointBasDroite < 0.1f) { position.X -= 0.1f; position.Z -= 0.1f; } } } // Coin bas-gauche else { // Mur haut-droite if (laby.Carte[position_case_actuelle.X, position_case_actuelle.Y - 1] != 1 && laby.Carte[position_case_actuelle.X + 1, position_case_actuelle.Y] != 1 && laby.Carte[position_case_actuelle.X + 1, position_case_actuelle.Y - 1] == 1 && distPointHautDroite < 0.1f) { position.X -= 0.1f; position.Z += 0.1f; } } } // Partout dans la carte sauf coins haut-gauche et bas-gauche else if (position_case_actuelle.X > 0 && position_case_actuelle.X + 1 < laby.Size.X) { // bord haut if (position_case_actuelle.Y == 0) { // Pas de mur en bas if (laby.Carte[position_case_actuelle.X, position_case_actuelle.Y + 1] != 1) { // Mur bas-gauche if (laby.Carte[position_case_actuelle.X - 1, position_case_actuelle.Y] != 1 && laby.Carte[position_case_actuelle.X - 1, position_case_actuelle.Y + 1] == 1 && distPointBasGauche < 0.1f) { position.X += 0.1f; position.Z -= 0.1f; } // Mur bas-droite if (laby.Carte[position_case_actuelle.X + 1, position_case_actuelle.Y] != 1 && laby.Carte[position_case_actuelle.X + 1, position_case_actuelle.Y + 1] == 1 && distPointBasDroite < 0.1f) { position.X -= 0.1f; position.Z -= 0.1f; } } } // Milieu de carte else if (position_case_actuelle.Y + 1 < laby.Size.Y) { // Pas de mur en haut if (laby.Carte[position_case_actuelle.X, position_case_actuelle.Y - 1] != 1) { // Mur haut-gauche if (laby.Carte[position_case_actuelle.X - 1, position_case_actuelle.Y] != 1 && laby.Carte[position_case_actuelle.X - 1, position_case_actuelle.Y - 1] == 1 && distPointHautGauche < 0.1f) { position.X += 0.1f; position.Z += 0.1f; } // Mur haut-droite if (laby.Carte[position_case_actuelle.X + 1, position_case_actuelle.Y] != 1 && laby.Carte[position_case_actuelle.X + 1, position_case_actuelle.Y - 1] == 1 && distPointHautDroite < 0.1f) { position.X -= 0.1f; position.Z += 0.1f; } } // Pas de mur en bas if (laby.Carte[position_case_actuelle.X, position_case_actuelle.Y + 1] != 1) { // Mur bas-gauche if (laby.Carte[position_case_actuelle.X - 1, position_case_actuelle.Y] != 1 && laby.Carte[position_case_actuelle.X - 1, position_case_actuelle.Y + 1] == 1 && distPointBasGauche < 0.1f) { position.X += 0.1f; position.Z -= 0.1f; } // Mur bas-droite if (laby.Carte[position_case_actuelle.X + 1, position_case_actuelle.Y] != 1 && laby.Carte[position_case_actuelle.X + 1, position_case_actuelle.Y + 1] == 1 && distPointBasDroite < 0.1f) { position.X -= 0.1f; position.Z -= 0.1f; } } } // coté bas else { // Pas de mur en haut if (laby.Carte[position_case_actuelle.X, position_case_actuelle.Y - 1] != 1) { // Mur haut-gauche if (laby.Carte[position_case_actuelle.X - 1, position_case_actuelle.Y] != 1 && laby.Carte[position_case_actuelle.X - 1, position_case_actuelle.Y - 1] == 1 && distPointHautGauche < 0.1f) { position.X += 0.1f; position.Z += 0.1f; } // Mur haut-droite if (laby.Carte[position_case_actuelle.X + 1, position_case_actuelle.Y] != 1 && laby.Carte[position_case_actuelle.X + 1, position_case_actuelle.Y - 1] == 1 && distPointHautDroite < 0.1f) { position.X -= 0.1f; position.Z += 0.1f; } } } } // Bord droit else if (position_case_actuelle.X + 1 == laby.Size.X) { // Coin haut-droite if (position_case_actuelle.Y == 0) { // Mur bas-gauche if (laby.Carte[position_case_actuelle.X - 1, position_case_actuelle.Y] != 1 && laby.Carte[position_case_actuelle.X, position_case_actuelle.Y + 1] != 1 && laby.Carte[position_case_actuelle.X - 1, position_case_actuelle.Y + 1] == 1 && distPointBasGauche < 0.1f) { position.X += 0.1f; position.Z -= 0.1f; } } // Coté droit sauf coins else if (position_case_actuelle.Y > 0 && position_case_actuelle.Y + 1 < laby.Size.Y) { // Pas de mur a gauche if (laby.Carte[position_case_actuelle.X, position_case_actuelle.Y] != 1) { // Mur haut-gauche if (laby.Carte[position_case_actuelle.X, position_case_actuelle.Y - 1] != 1 && laby.Carte[position_case_actuelle.X - 1, position_case_actuelle.Y - 1] == 1 && distPointHautGauche < 0.1f) { position.X += 0.1f; position.Z += 0.1f; } // Mur bas-gauche if (laby.Carte[position_case_actuelle.X, position_case_actuelle.Y + 1] != 1 && laby.Carte[position_case_actuelle.X - 1, position_case_actuelle.Y + 1] == 1 && distPointBasGauche < 0.1f) { position.X += 0.1f; position.Z -= 0.1f; } } } // Coin bas-droite else { // Mur haut-gauche if (laby.Carte[position_case_actuelle.X - 1, position_case_actuelle.Y] != 1 && laby.Carte[position_case_actuelle.X, position_case_actuelle.Y] != 1 && laby.Carte[position_case_actuelle.X - 1, position_case_actuelle.Y - 1] == 1 && distPointHautGauche < 0.1f) { position.X += 0.1f; position.Z += 0.1f; } } } } } #endregion // Tombe dans une trappe if (trappe && !saut || position.Y < 0) position.Y -= vitesse_saut/30; else if (!baisse) position.Y = (float)(laby.joueur_position_initiale.Y + (Math.Sin(MathHelper.ToRadians((float)valeur_saut) % Math.PI))); /** Saut **/ // Son if (!saut && !baisse && clavier_prec != clavier && clavier.IsKeyDown(aMAZEing_Escape.Properties.Settings.Default.sauter) && !trappe) SoundBank.PlayCue(son_saut); if (saut || (clavier_prec != clavier && clavier.IsKeyDown(aMAZEing_Escape.Properties.Settings.Default.sauter) && !trappe)) { valeur_saut += vitesse_saut; compteur_saut -= temps; if (!saut) saut = true; if (compteur_saut < 0 || baisse) { saut = false; compteur_saut = compteur_saut_initial; valeur_saut = 0; } } // Se baisser float gravite = 9.8f; // 2 cas ou l'on modifie la hauteur du joueur if (clavier.IsKeyDown(aMAZEing_Escape.Properties.Settings.Default.sebaisser)) { baisse = true; vitesse = vitesse_initiale / 2; // Soit il est en position normale et appuie sur la touche if (!(saut) && position.Y > 0.5) position.Y -= gravite * temps; } // Soit il n'appuie pas et il etait accroupi. else if (position.Y < laby.joueur_position_initiale.Y && !(saut) && !trappe) { vitesse = vitesse_initiale; position.Y += gravite * temps; baisse = false; } Matrix ViewRotationMatrix = Matrix.CreateRotationX(yaw) * Matrix.CreateRotationY(pitch); Matrix MoveRotationMatrix = Matrix.CreateRotationY(pitch); Vector3 transformedReference = Vector3.Transform(reference, ViewRotationMatrix); position += Vector3.Transform(deplacement, MoveRotationMatrix); cible = transformedReference + position; case_transition = position_case_actuelle; clavier_prec = clavier; }
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(); }