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