aide pour jeux sur XNA

bonjour voila je crée actuellement un jeux sur XNA.Mais j'ai quelque problème:
1)i faut que l'homme ne sort pas de l'ecran mais il sort quand meme.
2)je voudrait que les monstre dans le jeux apparaissent a une position aleatoire(donc je pense toucher au constructeur de la classe monstre mais cela me donne des effets pas genaile)
3)On m a aussi dit qu il faudrait que je fasse une liste de monstre dans la classe plateau de mon projet mais je ne vois pas pk?
MERCI beaucoup j attend avec impatience votre aide.
1 page:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
#region Using Statements
using System;
using System.Collections.Generic;
using Microsoft.Xna.Framework;
 
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Storage;
#endregion
 
namespace TailsAquatic
{   // type énuméré définissant les états possibles pour le jeu
    public enum etatsJeu
    {
        encours, perdu, gagne, blesse             
    }
    /// <summary>
    /// This is the main type for your game
    /// </summary>
    public class TailsAquatic : Microsoft.Xna.Framework.Game
    {   //l'objet graphics contiendra les dessins réalisés avec les méthodes draw
        private GraphicsDeviceManager graphics;
        // l'objet content contient toutes les textures et les polices
        private ContentManager content;
 
        //objet pour dessiner les images, les textes
        private SpriteBatch monSpriteBatch;
 
       // objet de la classe plateau
        private plateau unplateau;
 
        public TailsAquatic()       //constructeur
        {   //instanciation de l'objet graphics
            graphics = new GraphicsDeviceManager(this);
            //définit la taille de la fenêtre du jeu
            graphics.PreferredBackBufferHeight =700;
            graphics.PreferredBackBufferWidth = 1000;
            graphics.IsFullScreen = false;
            //applique les modifications à l'objet graphique
            graphics.ApplyChanges();
            //instancie l'objet content
            content = new ContentManager(Services);
            // définit le délai entre deux exécutions de boucle de jeu
            this.IsFixedTimeStep = true;
            this.TargetElapsedTime = new TimeSpan(0, 0, 0, 0, 10);
 
        }
 
 
        /// <summary>
        /// Allows the game to perform any initialization it needs to before starting to run.
        /// This is where it can query for any required services and load any non-graphic
        /// related content.  Calling base.Initialize will enumerate through any components
        /// and initialize them as well.
        /// </summary>
        protected override void Initialize()
        { // TODO: Add your initialization logic here
           //instancie l'objet  monSpriteBatch (sert à dessiner les éléments à l'écran)
            monSpriteBatch = new SpriteBatch(graphics.GraphicsDevice);
            //instancie un plateau
            unplateau = new plateau(graphics.GraphicsDevice.Viewport.Width, graphics.GraphicsDevice.Viewport.Height);
            Sound.Initialize();
            //appel de la méthode initialize de la classe de base (Microsoft.Xna.Framework.Game)
            base.Initialize();
        }
 
 
 
        /// <summary>
        /// Load your graphics content.  If loadAllContent is true, you should
        /// load content from both ResourceManagementMode pools.  Otherwise, just
        /// load ResourceManagementMode.Manual content.
        /// </summary>
        /// <param name="loadAllContent">Which type of content to load.</param>
 
 
        protected override void LoadGraphicsContent(bool loadAllContent)
        {
            if (loadAllContent)
            { //charge les textures
                unplateau.LoadGraphicsContent(content);
            }
        }
 
 
        /// <summary>
        /// Unload your graphics content.  If unloadAllContent is true, you should
        /// unload content from both ResourceManagementMode pools.  Otherwise, just
        /// unload ResourceManagementMode.Manual content.  Manual content will get
        /// Disposed by the GraphicsDevice during a Reset.
        /// </summary>
        /// <param name="unloadAllContent">Which type of content to unload.</param>
        protected override void UnloadGraphicsContent(bool unloadAllContent)
        {
            if (unloadAllContent == true)
            {
                content.Unload();
            }
            Sound.Shutdown();
 
        }
 
 
        /// <summary>
        /// Allows the game to run logic such as updating the world,
        /// checking for collisions, gathering input and playing audio.
        /// </summary>
        /// <param name="gameTime">Provides a snapshot of timing values.</param>
        protected override void Update(GameTime gameTime)
        {   
            // Allows the default game to exit on Xbox 360 and Windows
            if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
                this.Exit();
 
 
            // TODO: Add your update logic here
            //mise à jour du plateau
            unplateau.Update(GamePad.GetState(PlayerIndex.One), Keyboard.GetState(), gameTime);
            //appel de la méthode update de la classe de base (Microsoft.Xna.Framework.Game)
            base.Update(gameTime);
 
        }
 
 
        /// <summary>
        /// This is called when the game should draw itself.
        /// </summary>
        /// <param name="gameTime">Provides a snapshot of timing values.</param>
        protected override void Draw(GameTime gameTime)
        {   
            //efface le contenu de l'écran, et le colorie en bleu
            graphics.GraphicsDevice.Clear(Color.CornflowerBlue);
 
            // TODO: Add your drawing code here
            //Début de l'affichage des éléments de l'écran:  AlphaBlend utilise les transparences des images dessinées.
            monSpriteBatch.Begin(SpriteBlendMode.AlphaBlend);
            //dessine le plateau
            unplateau.Draw(monSpriteBatch, gameTime);
 
            monSpriteBatch.End();
            //appel de la méthode draw de la classe de base (Microsoft.Xna.Framework.Game)
            base.Draw(gameTime);
        }
 
 
 
    }
}

2 page:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Storage;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Audio;
 
namespace TailsAquatic
{
    class plateau
 
    { //texture
        private Texture2D texturePaysage;
        //police
        private SpriteFont policeMessage;
 
        // pour positionner le paysage   
        private Rectangle rectPaysage;
        // etat du jeu
        private etatsJeu etatCourant;
        //temps total depuis le début du jeu
        private double tempsParties = 0;
        //nombre de vie depuis le debut du jeu
        private int viesTotales = 3;
        private int viesActuel = 0;
 
 
        //personnages du plateau
        private homme unhomme;
        private monstre unmonstre;
 
 
        //indique si le son a été joué
        private bool sonjoué;
 
        //constructeur
        public plateau(int largeur, int hauteur)
        {
            InitJeu();
            rectPaysage = new Rectangle(0, 0, largeur, hauteur);
 
 
        }
        //intialise les données du jeu
        private void InitJeu()
        {
            viesActuel = viesTotales;   
            rectPaysage.X = 0;      //position du paysage
            sonjoué = false;
            unhomme = new homme();      //instancie un homme
            unmonstre = new monstre();    //instancie un monstre
 
            etatCourant = etatsJeu.encours;
        }
 
        public void LoadGraphicsContent(ContentManager monContent)
        {  //charge les textures    
            texturePaysage = monContent.Load<Texture2D>("images/paysage") as Texture2D;
            homme.LoadGraphicsContent(monContent);
            monstre.LoadGraphicsContent(monContent);
            policeMessage = monContent.Load<SpriteFont>("maPolice") as SpriteFont;
        }
 
        public void Update(GamePadState EtatGamePad, KeyboardState EtatClavier, GameTime Temps)
        {
            if (etatCourant == etatsJeu.encours)
            {
                if (Temps.TotalGameTime.TotalMinutes - tempsParties < 10)
                {//positionnement du paysage
                    rectPaysage.X--;
                    if ( rectPaysage.X<=-rectPaysage.Width)
                    {
                        rectPaysage.X=0;
                    }
 
                    //on passe en paramètre le temps du jeu : paramètre Temps de  cette méthode Update (voir qq lignes plus haut)
                    unhomme.Update(GamePad.GetState(PlayerIndex.One), Keyboard.GetState(), rectPaysage, Temps);
                    unmonstre.Update(GamePad.GetState(PlayerIndex.One), Keyboard.GetState(), Temps, rectPaysage);
                    //détection de collision
                    if (unhomme.collision(unmonstre))
                    {
                        viesActuel--;       //on décrémente le nombre de vies
 
                        // modif : solution temporaire; normalement il faudrait détruire le monstre :  unmonstre=null; (mais comme vous en avez un seul....)
                        unmonstre = new monstre();   // on crée un nouveau monstre (vous pouvez aussi remplacer cette instruction par une instruction qui change la position  du monstre existant                        //(ou alors, il faut déplacer l'homme : car l'homme et le monstre étant toujours à la même place, donc toujours en collision,  le nb de vies est très vite =0
                        //le délai entre deux exécutions de la méthode update ne laisse pas le temps de faire bouger l'homme (il est de 10 millisecondes (voir dans le constructeur de la classe tailsaquatic :  this.TargetElapsedTime = new TimeSpan(0, 0, 0, 0, 10);
 
                        if (viesActuel == 0) 
                        etatCourant = etatsJeu.perdu;
 
 
                    }
                    else
                        if (unhomme.collisionMissile(unmonstre) )
 
                            // modif : solution temporaire; normalement il faudrait détruire le monstre :  unmonstre=null; (mais comme vous en avez un seul....)
                            unmonstre = new monstre();   // on crée un nouveau monstre (vous pouvez aussi remplacer cette instruction par une instruction qui change la position  du monstre existant
 
                }
                else etatCourant = etatsJeu.gagne;
            }
            else
            {//si l'état courant est perdu ou gagné
 
                if (EtatClavier.IsKeyDown(Keys.Enter))
                {// si le joueur a appuyé sur entrer
                    etatCourant = etatsJeu.encours;
                    tempsParties = Temps.TotalGameTime.TotalMinutes;
                    this.InitJeu();
                }
 
            }
            Sound.Update();
        }
 
        public void Draw(SpriteBatch monSpriteBatch, GameTime temps)
        { //le rectangle définit la position de l'affichage de l'image, mais aussi sa taille
            //dessine 2 fois le paysage pour donner un effet de défilement
            monSpriteBatch.Draw(texturePaysage, rectPaysage, Color.White);
            Rectangle rectPaysage2 = new Rectangle(rectPaysage.X + rectPaysage.Width, 0, rectPaysage.Width, rectPaysage.Height);
            monSpriteBatch.Draw(texturePaysage, rectPaysage2, Color.White);
 
            //dessine les personnages
            unhomme.Draw(monSpriteBatch, etatCourant);
            unmonstre.Draw(monSpriteBatch);
            if (etatCourant == etatsJeu.encours)
            {
                monSpriteBatch.DrawString(policeMessage, "Times: " + ((int)(temps.TotalGameTime.TotalMinutes - tempsParties)).ToString(), new Vector2(10, rectPaysage.Height / 40),Color.White);
 
                monSpriteBatch.DrawString(policeMessage, "Vies: " + ((int)(viesActuel)).ToString(), new Vector2(900, rectPaysage.Height / 40), Color.White);
 
                if (!sonjoué)
                {//jouer le son
                    Cue son = Sound.Play("sonjeu");
                    Sound.Stop(son);
                    sonjoué = true;
 
                }
 
            }
            else
            {
                if (etatCourant == etatsJeu.perdu)
                {
 
                    monSpriteBatch.DrawString(policeMessage, "Perdu!!", new Vector2(rectPaysage.Width / 2, rectPaysage.Height / 2), Color.Red);
                  //  modif
                    monSpriteBatch.DrawString(policeMessage, "vies :" + viesActuel.ToString(), new Vector2(900, rectPaysage.Height / 40), Color.White);
 
                    if(!sonjoué)
                    {//jouer le son
                        Cue son = Sound.Play("Gameover");
                        Sound.Stop(son);
                        sonjoué = true;
 
                    }
 
 
                }
 
 
                else
                    monSpriteBatch.DrawString(policeMessage, "Gagne!!", new Vector2(rectPaysage.Width / 2, rectPaysage.Height / 2), Color.Red);
 
 
 
            }
 
        }
    }
}

3 page:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Storage;
using Microsoft.Xna.Framework.Content;
 
namespace TailsAquatic
{
    class monstre
    {
        int changeImage;
        //propiétés statiques : tous les monstres utilisent les mêmes textures
        static private Texture2D textureMonstre4;
        static private Texture2D textureMonstre3;
        static private Texture2D textureMonstre2;
        static private Texture2D textureMonstre1;
        //chaque monstre a les propriétés suivantes :
        private Rectangle posMonstre;     //position du monstre 
        private Rectangle posMonstre1;
 
 
 
             public Rectangle PosMonstre1
        { get
             {  return posMonstre1;}
 
 
        }
 
 
        public Rectangle PosMonstre
        { get
             {  return posMonstre;}
 
 
        }
                  //utilisée pour changer les images toutes les 8 exécutions de boucle
 
        static public void LoadGraphicsContent(ContentManager monContent) 
        {
            //charge les textures
           textureMonstre4 = monContent.Load<Texture2D>("images/monstre/Pieuvre2") as Texture2D;
           textureMonstre3 = monContent.Load<Texture2D>("images/monstre/Pieuvre1")as Texture2D;
           textureMonstre1 = monContent.Load<Texture2D>("images/monstre/Requin1") as Texture2D;
           textureMonstre2 = monContent.Load<Texture2D>("images/monstre/Requin2") as Texture2D;
 
        }
        public monstre()        //constructeur par défaut
        {
         changeImage = 0;
 
         posMonstre = new Rectangle(100,0,80,80);
         Random aleatoire = new Random((int)posMonstre.X);
         posMonstre1 = new Rectangle(500, 0, 90, 90);
 
        }
 
 
         public void Update(GamePadState EtatGamePad, KeyboardState EtatClavier, GameTime Temps, Rectangle ecran )
        {   //initialiation du générateur de nb aléatoires
          Random aleatoire = new Random((int)Temps.TotalRealTime.TotalMilliseconds);
 
              posMonstre.X = (posMonstre.X - aleatoire.Next(1, 4));//vitesse du monstre
              posMonstre.Y = ecran.Height - 400;
              changeImage++;
              posMonstre1.X = (posMonstre1.X - aleatoire.Next(1, 4));//vitesse du monstre
              posMonstre1.Y = ecran.Height - 200;
              changeImage++;
 
              if (posMonstre.X <= 0)
              {
                  posMonstre.X = ecran.Width;
              }
              if (posMonstre1.X <= 0)
              {
                  posMonstre1.X = ecran.Width;
              }
 
 
 
         }
 
        public void Draw(SpriteBatch monSpriteBatch)
        { if (changeImage < 4)
                {//si on a exécuté 8 boucles : on affiche la première image
                    monSpriteBatch.Draw(textureMonstre1, posMonstre, Color.White);
                    monSpriteBatch.Draw(textureMonstre3, posMonstre1, Color.White);
 
                }
                else
                {//si on a exécuté plus de 8 boucles : on affiche la deuxième image
                    monSpriteBatch.Draw(textureMonstre2, posMonstre, Color.White);
                    monSpriteBatch.Draw(textureMonstre4, posMonstre1, Color.White);
                    if (changeImage > 16)
                    {
                        changeImage = 0;
                    }
 
 
                }
        }
 
 
 
         }
 
    }

4 page:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Storage;
using Microsoft.Xna.Framework.Content;
 
 
namespace TailsAquatic
{
    class homme
    {   //propiétés statiques : tous les hommes utilisent les mêmes textures
        static private Texture2D textureHomme1;
        static private Texture2D textureHommeKO;
        static private Texture2D textureMissile;
 
       // pour détecter la collision, il faut que les missiles soit dessinés dans des objets Rectangle
        // ce qui implique des modifications dans les méthodes draw et update
        List<Rectangle> listPosMissile = new List<Rectangle>();
        //chaque homme dispose des propriétés suivantes
        private Rectangle posHomme;
 
              //utilisée pour changer les images toutes les 8 exécutions de boucle de jeu
 
 
        public Rectangle PosHomme
        {
            get
            { return posHomme; }
 
        }
 
        public homme()
        {//constructeur par défaut
 
            //taille du rectangle de l homme
            posHomme = new Rectangle(200,0,98,58);
        }
 
        static public void LoadGraphicsContent(ContentManager monContent)
        {
            //charge les textures
            textureHomme1 = monContent.Load<Texture2D>("images/homme/ManRight1") as Texture2D;
            textureHommeKO = monContent.Load<Texture2D>("images/homme/ManKilled") as Texture2D;
            textureMissile = monContent.Load<Texture2D>("images/objects/tire") as Texture2D;
 
        }
 
 
       public void Update(GamePadState EtatGamePad, KeyboardState EtatClavier,  Rectangle ecran, GameTime tempsjeu)
           // on ajoute le temps du jeu en paramètre pour gérer la création des missiles
        {//teste l'état du clavier   
 
 
            if (posHomme.X <= 0)//des que la position de l'homme disparait de l'ecran alors on le repositionne a droite
            {
                posHomme.X = ecran.Width;
 
            }
 
 
 
            for (int i = 0; i < listPosMissile.Count; i++)
            { // modif : 
              Rectangle r = listPosMissile[i];
                r.X++;
               listPosMissile[i] = r;
 
                if (listPosMissile[i].X < 0) listPosMissile.RemoveAt(i);
            }
 
 
            if (tempsjeu.TotalGameTime.TotalMilliseconds % 200 == 0)
            {//la test  de la touche espace se fait toutes les 500 millisecondes  (%  : modulo): pour éviter de créer trop de missiles
                // en effet, le délai de rafraîchissement du jeu, défini dans le constructeur de la classe tailsaquatic
                if (Keyboard.GetState().IsKeyDown(Keys.Space) && PosHomme.X > 20)
                {//si on appuyé sur espace, le personnage lance un missile
 
                    listPosMissile.Add(new Rectangle(posHomme.X, posHomme.Y, textureMissile.Width, textureMissile.Height));
 
                }
            }
 
 
                 if (Keyboard.GetState().IsKeyDown(Keys.Right))
                 {
                     posHomme.X++; 
 
                 }
                 if (Keyboard.GetState().IsKeyDown(Keys.Left))
                 {
                     posHomme.X--;
                 }
            //controle fleche haut
                 if (Keyboard.GetState().IsKeyDown(Keys.Down))
                 {
                     posHomme.Y++;
 
                 }
 
                 if (Keyboard.GetState().IsKeyDown(Keys.Up))
                 {
                     posHomme.Y--;
 
                 }
 
 
         }
        public void Draw(SpriteBatch monSpriteBatch, etatsJeu etat)
        {
            if (etat == etatsJeu.encours)
            {
 
 
                    monSpriteBatch.Draw(textureHomme1, PosHomme, Color.White);
                    for (int i = 0; i < listPosMissile.Count; i++)
                       monSpriteBatch.Draw(textureMissile, listPosMissile[i], Color.White);
 
            }
                else
                {
                    if (etat == etatsJeu.perdu)
                    {
                        monSpriteBatch.Draw(textureHommeKO, PosHomme, Color.White);
                    }
                }
            }
 
 
       public  bool collision(monstre lemonstre)
        {// détecte une collision entre l'objet homme en cours et lemonstre passé en paramètre
         return posHomme.Intersects(lemonstre.PosMonstre);
       }
 
        public bool collisionMissile(monstre lemonstre)
        {// détecte une collision entre les missiles et lemonstre passé en paramètre
 
            bool detection=false;
            int i = 0;
            while  ( i < listPosMissile.Count)
            {
                if (listPosMissile[i].Intersects(lemonstre.PosMonstre))
                {
                    detection = true;
                       listPosMissile.RemoveAt(i);     //on supprime le missile
                } 
                else i++;
              }
              return detection;
        }
 
 
 
    }
}