IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

XNA/Monogame Discussion :

aide pour jeux sur XNA


Sujet :

XNA/Monogame

  1. #1
    Membre habitué
    Inscrit en
    Janvier 2008
    Messages
    1 159
    Détails du profil
    Informations forums :
    Inscription : Janvier 2008
    Messages : 1 159
    Points : 149
    Points
    149
    Par défaut 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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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;
            }
     
     
     
        }
    }

  2. #2
    Membre régulier

    Profil pro
    Inscrit en
    Juin 2008
    Messages
    92
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Juin 2008
    Messages : 92
    Points : 115
    Points
    115
    Par défaut
    Salut l'ami,
    Je vais te donner quelques conseil et t'aider un peu

    • Dans la méthode Draw de la classe monstre, la première condition ne se réalisera jamais, car tu a mis <4 au lieu de >4. Or, t'as variable changeImage ne sera jamais inférieur à 0, donc encore moins à 4

    • De plus, tu incrémente 2 fois ta variable changeImage dans l'Update, donc, soit tu ne l'incrémente qu'une fois et tu teste >8 et >16, soit tu l'incrémente deux fois, mais dans ce cas tu fais >16, puis >32.
      De toute façon, ce n'est pas la bonne méthode d'animation. Tu dois annimer une image en fonction du temps et pas du nombre de boucle, car le nombre de boucle peut changer d'un instant a un autre a cause d'une tache de fond de ton ordi, ou peut changer d'un ordi a un autre selon sa puissance.
      Donc dans la méthode update tu devrais faire quelque chose comme


      timeSinceLastImageChange += GameTime.ElapsedTime.Milliseconds;
      if(timeSinceLastImageChange > 200)
      {
      changeImage++;
      timeSinceLastImageChange = 0;
      }
      //c'est un peu simplifié, et j'écris de tête, donc possibilité d'erreurs

    • Il y a un truc que je ne comprends pas, pouquoi utilise deux texure pour afficher un monstre ? Tu affiches toujours soit la texture 1 et 3, soit la 2 et 4 ? ça je ne peut pas le comprendre en voyant ton code, il faudrait que je puisse voir les textures.

    • La méthode Update de toutes tes classes est mal conçu, tu ne devrais pas avoir à passer autant de paramètres à chaque fois, juste le GameTime, et à la limite quelques paramètres qui sont propres à ton jeu, et encore, en général si l'appli est bien pensé, et bien codé, on n'a a passé que le gameTime. Il faut séparer la gestion de l'Input de la partie métier.
      Soit tu gères l'Input dans la méthode Update de ton Jeu, si ce n'est pas une gestion très compliqué, soit tu crée carrément une classe InputManager, que tu fais Updater à chaque Update. Dans ton cas, tu peux te contenter de la gestion de l'Update dans la méthode Update de ta classe Game.

    • Ensuite, il y a quelque chose que je ne comprends pas, ton jeu ne fais évolué qu'un seul monstre ? Car ton plateau ne contient apparamament qu'un seul monstre. Si tu veux que ton jeu contienne plusieurs monstres, il faut donc en effet que tu crée une liste de monstre dans ta classe plateau

    • Ensuite, le fait de déplacer les monstres d'une valeur comprise entre 1 et 4 pixel à chaque Update, c'est pas la bonne méthode si tu veux faire varier la vitesse ^^, ça doit vraiment te donner des trucs bizarre.
      A la limite, tout les 50 milliseconde, tu lui donne une chance de réduire sa vitesse d'1 pixel (avec un minimum d'une vitesse de 1pixel si tu ne veux pas qu'il s'arrette des fois ), une chance de l'augmenter d'1 pixel ( avec un plafond ), et une chance qu'elle reste inchangé. C'est facile à faire, je te laisse trouver le code tout seul
      Après y'a des méthodes plus compliqués et qui rendent mieux pour faire varier une vitesse de manière élégante, mais contente toi de ça pour le moment

      Pour le positionnement aléatoire c'est simple. Dans l'initialisation, tu met ça :

      Random rand = new Random(System.Environment.TickCount);
      posMonster = new Rectangle(rand.Next(0, 500), rand.Next(0, 500), textureMonster.Width, textureMonster.Height);
      // La encore, c'est simplifié, et je code de tete

    • Pour ton petit bonhomme qui n'est pas censé sortir de l'écran, j'ai remarqué que tu ne testais que le cas ou il sortait à gauche de l'écran, tu ne teste pas s'il sort à droite, en haut, ou en bas, ou c'est moi qui me trompe, je n'ai peut être pas regardé au bon endroit ?


    Voilà, j'éspère que j'ai pu t'aider,
    n'hésites pas à reposer des questions en cas de besoin
    bonne continuation pour ton ptit jeu

Discussions similaires

  1. Aide pour Script sur Oracle
    Par Melusine21 dans le forum SQL
    Réponses: 21
    Dernier message: 12/07/2007, 15h43
  2. hello "besoin d'aide pour diagramme sur excel"
    Par katwar dans le forum Excel
    Réponses: 1
    Dernier message: 18/06/2007, 12h52
  3. [VBA-E] aide pour macro sur excel
    Par letoulouzin31 dans le forum Macros et VBA Excel
    Réponses: 21
    Dernier message: 24/05/2006, 12h29
  4. Besoin d'aide pour requête sur grosse table
    Par Fabouney dans le forum Langage SQL
    Réponses: 3
    Dernier message: 25/01/2006, 10h01
  5. aide pour requete sur 2 tables avec clé étranere
    Par richton95 dans le forum Requêtes
    Réponses: 4
    Dernier message: 02/12/2005, 14h32

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo