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;
}
}
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);
}
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));
}
}
}
}
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);
}
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();
}