Création de la classe Game1

Comme dans tous les projets Microsoft XNA, la classe Game1 dérive de la classe Microsoft.Xna.Framework.Game (page éventuellement en anglais) qui fournit l'initialisation de base des périphériques graphiques, la logique de jeu et le code de rendu pour les jeux XNA. La classe Game1 est relativement simple étant donné que la majeure partie du travail est effectuée dans les classes GamePieceCollection et GamePiece.

Création du code

Les membres privés de la classe se composent d'un objet GamePieceCollection pour contenir les pièces de jeu, d'un objet GraphicsDeviceManager (page éventuellement en anglais) et d'un objet SpriteBatch (page éventuellement en anglais) pour le rendu des pièces de jeu.

#region PrivateMembers
// Number of game pieces.
private const int GamePieceCount = 6;
// The collection of game pieces.
private GamePieceCollection faces;
// Graphics device manager.
private GraphicsDeviceManager graphics;
// The sprite batch used for rendering game pieces.
private SpriteBatch spriteBatch;
#endregion

Lors de l'initialisation du jeu, ces objets sont instanciés.

#region ConstructorInitialize
public Game1()
{
    graphics = new GraphicsDeviceManager(this);
    Content.RootDirectory = "Content";
    // This is the default but assigning here explicitly
    // to show that resizing is not supported. The view port
    // boundaries used to bounce a game piece would not be
    // updated if the window was resized.
    Window.AllowUserResizing = false;
}

/// <summary>
/// Allows the game to perform any initialization it needs to before starting to run.
/// </summary>
protected override void Initialize()
{
    IsMouseVisible = true;
    faces = new GamePieceCollection();
    // base.Initialize calls the LoadContent method.
    base.Initialize();
}
#endregion

Lorsque la méthode LoadContent (page éventuellement en anglais) est appelée, les pièces de jeu sont créées et assignées à l'objet GamePieceCollection. Il existe deux types de pièces de jeu. Le facteur d'échelle pour les pièces est légèrement modifié pour créer des pièces plus petites et plus grandes.

#region LoadContent
/// <summary>
/// LoadContent will be called once per game. Load all content here.
/// </summary>
protected override void LoadContent()
{
    spriteBatch = new SpriteBatch(GraphicsDevice);

    string filename = System.Diagnostics.Process.GetCurrentProcess().MainModule.FileName;
    string path = System.IO.Path.GetDirectoryName(filename) + @"\Content";

    // Scale pieces from 100% to 160%
    float scale = 1.0f;
    float scaleFactor = 0.60f / ((GamePieceCount/2)-1);
    for (int k = 0; k < GamePieceCount / 2; k++)
    {
        GamePiece face1 = new GamePiece(spriteBatch, path + @"\Face1.png");
        GamePiece face2 = new GamePiece(spriteBatch, path + @"\Face2.png");

        face1.Scale = face2.Scale = scale;
        face1.PieceColor = Color.Green;
        face2.PieceColor = Color.LightSalmon;
        faces.Add(face1);
        faces.Add(face2);
        scale += scaleFactor;
    }
}
#endregion

La méthode Update (page éventuellement en anglais) est appelée plusieurs fois par l'infrastructure XNA pendant l'exécution du jeu. La méthode Update appelle les méthodes ProcessInertia et UpdateFromMouse dans la collection de pièces de jeu. Ces méthodes sont décrites dans Création de la classe GamePieceCollection.

#region UpdateGame
/// <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)
{
    faces.ProcessInertia();
    faces.UpdateFromMouse();
    base.Update(gameTime);
}
#endregion

La méthode Draw (page éventuellement en anglais) est également appelée plusieurs fois par l'infrastructure XNA pendant l'exécution du jeu. La méthode Draw effectue le rendu des pièces de jeu en appelant la méthode Draw de l'objet GamePieceCollection. Cette méthode est décrite dansCréation de la classe GamePieceCollection.

#region DrawGame
/// <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)
{
    GraphicsDevice.Clear(Color.CornflowerBlue);
    spriteBatch.Begin();
    faces.Draw();
    spriteBatch.End();
    base.Draw(gameTime);
}
#endregion

Voir aussi

Concepts

Utilisation de manipulations et de l'inertie dans une application XNA

Création de la classe GamePiece

Création de la classe GamePieceCollection

Listes de codes complets

Autres ressources

Manipulations et inertie