Creazione della classe Game1Creating the Game1 Class

Come per tutti i progetti di Microsoft XNA, la classe Game1 deriva dalla classe Microsoft.Xna.Framework.Game, che fornisce l'inizializzazione dei dispositivi grafici di base, la logica del gioco e il codice di rendering per i giochi XNA.As with all Microsoft XNA projects, the Game1 class derives from the Microsoft.Xna.Framework.Game class, which provides basic graphics device initialization, game logic, and rendering code for XNA games. La classe Game1 è alquanto semplice perché la maggior parte del lavoro spetta alle classi GamePiece e GamePieceCollection.The Game1 class is fairly simple because most of the work in done in the GamePiece and GamePieceCollection classes.

Creazione del codiceCreating the Code

I membri privati per la classe sono costituiti da un oggetto GamePieceCollection che include le parti del gioco, da un oggetto GraphicsDeviceManager e da un oggetto SpriteBatch usato per il rendering delle parti del gioco.The private members for the class consist of a GamePieceCollection object to hold the game pieces, a GraphicsDeviceManager object, and a SpriteBatch object used to render game pieces.

#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

Durante l'inizializzazione del gioco, viene creata un'istanza di questi oggetti.During game initialization, these objects are instantiated.

#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

Quando viene chiamato il metodo LoadContent, vengono create le parti del gioco che verranno assegnate all'oggetto GamePieceCollection.When the LoadContent method is called, the game pieces are created and assigned to the GamePieceCollection object. Sono disponibili due tipi di parti del gioco.There are two types of game pieces. Il fattore di scala per le parti viene modificato leggermente in modo che siano disponibili alcune parti più piccole e altre più grandi.The scale factor for the pieces is changed slightly so that there are some smaller and some larger pieces.

#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

Il metodo Update viene chiamato ripetutamente da XNA Framework durante l'esecuzione del gioco.The Update method is called repeatedly by the XNA Framework while the game is running. Il metodo Update chiama i metodi ProcessInertia e UpdateFromMouse nella raccolta di parti del gioco.The Update method calls the ProcessInertia and the UpdateFromMouse methods on the game piece collection. Questi metodi sono descritti in Creazione della classe GamePieceCollection.These methods are described in Creating the GamePieceCollection Class.

#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

Anche il metodo Draw viene chiamato ripetutamente da XNA Framework mentre il gioco è in esecuzione.The Draw method is also called repeatedly by the XNA Framework while the game is running. Il metodo Draw esegue il rendering delle parti del gioco chiamando il metodo Draw dell'oggetto GamePieceCollection.The Draw method performs the rendering of game pieces by calling the Draw method of the GamePieceCollection object. Questo metodo viene descritto in Creazione della classe GamePieceCollection.This method is described inCreating the GamePieceCollection Class.

#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

Vedere ancheSee Also

Modifiche e inerziaManipulations and Inertia
Uso delle modifiche e dell'inerzia in un'applicazione XNAUsing Manipulations and Inertia in an XNA Application
Creazione della classe GamePieceCreating the GamePiece Class
Creazione della classe GamePieceCollectionCreating the GamePieceCollection Class
Listati di codice completiFull Code Listings