Discussion :

[TheYoungGeek43]

Bonjour,

J'ai fait une classe Animated sprite mais j'ai un problème c'est si par exemple je modifie le source Rect (dans le code) il ne se modifie pas (dans le jeu) et j'aimerais savoir pourquoi j'ai fait de nombreux test

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
using System;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Input;
 
namespace Gamecodeur_JAM_1
{
    public class Player
    {
        // VARIABLE
        AnimatedSprite player;
        int index;
        bool walk;
        bool idle;
        bool attack;
        // CONSTRUCTOR
        public Player(ContentManager content)
        {
            player = new AnimatedSprite("player/playerWalk", content, 64, 64, index, SheetOrientation.HORIZONTAL);
 
            this.idle = true;
            this.walk = false;
            this.attack = false;
 
        }
 
        // UPDATE & DRAW
        public void Update(ContentManager content, Input input,GameTime gameTime)
        {
            /**UTILISER ISKEYDOWN POUR LES MOVE ET ISKEY POUR L'ATTACK ET INTERRACTION**/
 
            if (input.IsKeyDown(Keys.Up) || input.IsDPad("UP")) 
            {
                this.player.Move(gameTime, Direction.UP);
                //this.player.SetIndex(0);
                //index = 0;
            }
            else if (input.IsKeyDown(Keys.Down) || input.IsDPad("DOWN"))
            {
                this.player.Move(gameTime,Direction.DOWN);
                //this.player.SetIndex(1);
                //index = 1;
            }
            else if (input.IsKeyDown(Keys.Right) || input.IsDPad("RIGHT"))
            {
                this.player.Move(gameTime, Direction.RIGHT);
                //this.player.SetIndex(2);
                //index = 2;
            }
            else if (input.IsKeyDown(Keys.Left) || input.IsDPad("LEFT"))
            {
                this.player.Move(gameTime, Direction.LEFT);
                //this.player.SetIndex(3);
                //index = 3;
            }
        }
 
        public void Draw(SpriteBatch spriteBatch)
        {
            spriteBatch.Begin();
                player.Draw(spriteBatch);
            spriteBatch.End();
        }
 
        // FUNCTION
    }
}

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
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Content;
using System.Diagnostics;
 
namespace Gamecodeur_JAM_1
{
    public enum SheetOrientation
    {
        VERTICAL,
        HORIZONTAL
    }
    public enum Direction
    {
        UP,
        DOWN,
        LEFT,
        RIGHT
    }
 
    public class AnimatedSprite : Sprite
    {
        // VARIABLE
        public Rectangle sourceRectangle;
 
        private SheetOrientation sheetOrientation;
        private Direction direction;
 
        private int spriteWidth, spriteHeight, currentIndex;
 
        // SETTER & GETTER
        public void SetIndex(int index)
        {
            this.currentIndex = index;
        }
 
        // CONSTRUCTOR
        public AnimatedSprite(string imgPath, ContentManager content, int spriteWidth, int spriteHeight, int index, SheetOrientation sheetOrientation)
            : base(imgPath, content)
        {
            this.spriteWidth = spriteWidth;
            this.spriteHeight = spriteHeight;
            this.currentIndex = index;
            this.sheetOrientation = sheetOrientation;
            this.imgPath = imgPath;
 
            this.destinationRectangle = new Rectangle(this.x, this.y, this.spriteWidth, this.spriteHeight);
 
            //if (this.sheetOrientation == SheetOrientation.HORIZONTAL)
            //{
                this.sourceRectangle = new Rectangle(this.currentIndex, 0, this.spriteWidth, this.spriteHeight);
            //}
            //else
            //{
                //this.sourceRectangle = new Rectangle(0, this.currentIndex, this.spriteWidth, this.spriteHeight);
            //}
        }
 
        // UPDATE & DRAW
 
        public override void Update(int x, int y)
        {
            this.destinationRectangle.X = x;
            this.destinationRectangle.Y = y;
            this.destinationRectangle.Width = this.spriteWidth;
            this.destinationRectangle.Height = this.spriteHeight;
 
            //if (this.sheetOrientation == SheetOrientation.HORIZONTAL)
            //{
                //this.sourceRectangle = new Rectangle(this.currentIndex, 3, this.spriteWidth, this.spriteHeight);
            //}
            //else
            //{
                this.sourceRectangle = new Rectangle(0, this.currentIndex, this.spriteWidth, this.spriteHeight);
            //}
        }
 
        public override void Draw(SpriteBatch spriteBatch)
        {
            spriteBatch.Draw(this.texture, this.destinationRectangle, this.sourceRectangle, this.color);
        }
 
        // FUNCTION
        public void Move(GameTime gameTime, Direction direction)
        {
            if (direction == Direction.UP)
            {
                this.destinationRectangle.Y -= (int)Information.PLAYER_SPEED;
                this.sourceRectangle.X = 0;
            }
            else if (direction == Direction.DOWN)
            {
                this.destinationRectangle.Y += (int)Information.PLAYER_SPEED;
                this.sourceRectangle.X = 0;
            }
            if (direction == Direction.LEFT)
            {
                this.destinationRectangle.X -= (int)Information.PLAYER_SPEED;
                this.sourceRectangle.X = 0;
            }
            else if (direction == Direction.RIGHT)
            {
                this.destinationRectangle.X += (int)Information.PLAYER_SPEED;
                this.sourceRectangle.X = 0;
            }
        }
    }
}

Merci pour vos réponse

[LittleWhite]

Bonjour,

Lorsque vous avez un souci, n'hésitez pas à utiliser le débogueur (ou des print) pour voir comment évolue les valeurs de votre donnée.
Moi, je vois un souci :

Code c# :

Sélectionner tout - Visualiser dans une fenêtre à part

this.sourceRectangle = new Rectangle(0, this.currentIndex, this.spriteWidth, this.spriteHeight);

Normalement, vous devez modifier les valeurs x et y. (y, suivant le nombre de ligne dans la feuille de sprite). Ce qui donne (dans la théorie

Code c# :

Sélectionner tout - Visualiser dans une fenêtre à part

this.sourceRectangle = new Rectangle((this.currentIndex % nombre_de_colonne) * this.spriteWidth, (this.currentIndex % nombre_de_ligne) * this.spriteHeight, this.spriteWidth, this.spriteHeight);

Je pense que c'est clair, mais n'hésitez pas à demander des explications.

[TheYoungGeek43]

Je suis désoler mais je ne comprend pas pourquoi je doit utiliser modulo (%) ça ne serais pas mieux d'utiliser une division (/)?

[LittleWhite]

En effet, je me suis trompé en écrivant rapidement le code ce matin . Il y a une division, pour les Y et modulo pour les X (de mémoire ).

[TheYoungGeek43]

Je comprend pas pourquoi modulo pour X (je suis débutant) car utiliser une division pour les deux serait suffisant non ?

[LittleWhite]

Ok, je vais poser la preuve.
Prenons une feuille de sprite, 4x4, où chaque sprite fait 64x64.
Pour simplifier et généraliser, on va avoir les variables suivantes :

size = 64
nb_col = 4
nb_lig = 4

On numérote les sprite de haut gauche à bas droite, de 0 à 15 (je suis un informaticien ).
Pour chaque sprite, il faut trouver x et y, les coordonnées en haut à gauche de chaque sprite.

---

Commençons pour le premier sprite (sprite 0).
X doit être à 0, ainsi que Y.

Sprite 1:
X doit être à 64, Y à 0
Sprite 2:
X doit être à 128, Y à 0
Sprite 3:
X doit être à 192, Y à 0
Sprite 4: (premier sur la deuxième ligne)
X doit être à 0, Y à 64
Sprite 5:
X doit être à 64, Y à 64
et ainsi de suite.

Par la suite idx, c'est le numéro du sprite.
Ok, donc, pour la première ligne, on remarque que

X = idx * size

Par contre, lorsque l'on arrive à 4, ça recommence à 0.
Pareil pour 8 et 12.

Pour les Y, on remarque que l'augmentation, c'est tous les 4.
Pour les Y, c'est facile car :
idx 0, 1, 2, 3 -> 0
idx 4, 5, 6, 7 -> 1
idx 8, 9, 10, 11 -> 2
idx 12, 13, 14, 15 -> 3

On remarque "directement" que :
idx / 4 -> numéro de la ligne à utiliser.
Ensuite, il ne reste plus qu'à multiplier par la hauteur du sprite.
Donc :
Y = (idx / 4) * size

On reprend pour les X.
idx 0, 4, 8, 12 -> 0
idx 1, 5, 9, 12 -> 1
idx 2, 6, 10, 13 -> 2
idx 3, 7, 11, 14 -> 3
Et l'opération qui permet cela, c'est ... le modulo (le reste de la division).
Donc :
idx % 4 -> numéro de colonne à utiliser.
Comme pour les Y, il faut multiplier par la largeur du sprite :
X = (idx % 4) * size


Voilà, c'est fini.

Un jour que j'espère très prochainement, j'écrirai un tutoriel sur cela, avec des schémas