Razón Artificial

La ciencia y el arte de crear videojuegos

Tutorial XNA 2 – Entendiendo el código

Escrito por adrigm el 19 de noviembre de 2010 en Desarrollo Videojuegos, Programación | 2 Comentarios.

Después de tener nuestro proyecto listo y de haber ejecutado y ver una ventana vacía es hora de ver que es lo que tenemos y que nos ha creado el Visual Studio por defecto. Para ello prestamos atención al explorador de soluciones de la parte derecha, deberíamos tener algo como esto.

En principio prestamos atención a 3 cosas:

  • El fichero Program.cs
  • El fichero Game1.cs
  • MiPongContent (Content)

Los dos primeros son los únicos ficheros de código que nos crea Visual Studio que pasamos a comentar a continuación. El Content es el manejador de contenido es aquí donde cargaremos los diferentes recursos que usemos en nuestros juegos: Imágenes, Sonidos, Fuentes, etc.

El archivo Program.cs

using System;

namespace MiPong // Namespace del juego que es el nombre del mismo
{
#if WINDOWS || XBOX
    static class Program
    {
        /// <summary>
        /// Este es el punto de entrada al juego, empieza ejecutandose aquí.
        /// </summary>
        static void Main(string[] args)
        {
            using (Game1 game = new Game1()) // Crea un objeto game de la clase Game1 (nuestro juego).
            {
                game.Run(); // Lanza el juego con el método Run().
            }
        }
    }
#endif
}

Bueno Como vemos por los comentarios que he puesto en el código este archivo es el principal de nuestro proyecto y se encarga de crear la clase del programa y el método main que es el punto de entrada a los porgramas C#. Luego dentro crea un objeto Game1 que es la clase de nuestro juego (el otro archivo) y llama a su método Run() que se encarga de entrar en el bucle del juego.

El archivo Game1.cs

El archivo Game1.cs tiene bastanes cosas, en este tutorial explicaremos la estructura general y lo que es relevante de momento. Lo pongo entero y vamos explicándolo paso a paso.

using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.GamerServices;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Media;

namespace MiPong
{
    /// <summary>
    /// This is the main type for your game
    /// </summary>
    public class Game1 : Microsoft.Xna.Framework.Game
    {
        GraphicsDeviceManager graphics;
        SpriteBatch spriteBatch;

        public Game1()
        {
            graphics = new GraphicsDeviceManager(this);
            Content.RootDirectory = "Content";
        }

        /// <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

            base.Initialize();
        }

        /// <summary>
        /// LoadContent will be called once per game and is the place to load
        /// all of your content.
        /// </summary>
        protected override void LoadContent()
        {
            // Create a new SpriteBatch, which can be used to draw textures.
            spriteBatch = new SpriteBatch(GraphicsDevice);

            // TODO: use this.Content to load your game content here
        }

        /// <summary>
        /// UnloadContent will be called once per game and is the place to unload
        /// all content.
        /// </summary>
        protected override void UnloadContent()
        {
            // TODO: Unload any non ContentManager content here
        }

        /// <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 game to exit
            if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
                this.Exit();

            // TODO: Add your update logic here

            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)
        {
            GraphicsDevice.Clear(Color.CornflowerBlue);

            // TODO: Add your drawing code here

            base.Draw(gameTime);
        }
    }
}

Primero tenemos los using que se encargan de importar las partes de .Net y XNA necesarias, vemos algunos de los imports de XNA ahí con respecto a los típicos de un programa en C#.

A continuación abrimos el Namespace de nuestro juego que se llama igual que nuestro proyecto en nuestro caso MiPong. Todas las clases que escribamos para nuestro proyecto deberían de estar dentro de este Namespace.

Ya dentro del Namespace vemos solamente la creación de una Clase, la clase Game1 que hereda de Microsoft.Xna.Framework.Game y será la clase principal de nuestro juego, es de la que creamos el objeto en el archivo Program.cs. Vamos a comentar la clase.

Lo primero que nos encontramos son dos variable de clase:

GraphicsDeviceManager graphics;
SpriteBatch spriteBatch;

Son el manejador de gráficos y de sprites, muy útiles y usados. Ya los veremos en profundidad a continuación.

Luego viene el constructor de la clase:

public Game1()
        {
            graphics = new GraphicsDeviceManager(this);
            Content.RootDirectory = "Content";
        }

Simplemente crea el GraphicsDeviceManager que es el encargado de dibujar en pantalla. La otra línea define el directorio del contenido, de momento no nos preocuparemos por esto porque no vamos a tener que tocar el constructor.

protected override void Initialize()
        {
            // TODO: Add your initialization logic here

            base.Initialize();
        }

Este método solo se ejecuta una vez, al principio y en el se debe iniciar toda la lógica del juego, es decir, dar valores a variables, crear objetos necesarios, etc.

protected override void LoadContent()
        {
            // Create a new SpriteBatch, which can be used to draw textures.
            spriteBatch = new SpriteBatch(GraphicsDevice);

            // TODO: use this.Content to load your game content here
        }

Este método también se carga una sola vez y se usa para cargar el contenido, imagenes, texturas, etc. Dentro creamos el spriteBatch que lo usamos para dibujar texturas en pantalla. En XNA todos los sprites son texturas.

 protected override void UnloadContent()
        {
            // TODO: Unload any non ContentManager content here
        }

El método UnloadContent es para quitar contenido, de momento no lo usaremos.

protected override void Update(GameTime gameTime)
        {
            // Allows the game to exit
            if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
                this.Exit();

            // TODO: Add your update logic here

            base.Update(gameTime);
        }

El método Update, es de los más importantes se ejecuta continuamente y en el deberemos poner todo lo que necesita ser comprobado constantemente. Teclado, Colisiones, Movimiento, etc.

Dentro tenemos:

 if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
                this.Exit();

Sirve para salir del juego en la Xbox 360 ya que el juego es compatible tanto con WIndows como con Xbox y con muy poco también en Phone 7.

protected override void Draw(GameTime gameTime)
        {
            GraphicsDevice.Clear(Color.CornflowerBlue);

            // TODO: Add your drawing code here

            base.Draw(gameTime);
        }

Por último el método Draw se encaga de dibujar en pantalla los sprites. También se ejecuta constantemente

De todo esto de momento nos debemos de quedar con que se el contenido se carga en el método LoadContent, la lógica se actualiza en Update y se dibuja con el método Draw, lo demás profundizaremos más adelante.

2 Comentarios en "Tutorial XNA 2 – Entendiendo el código"

  1. Adria dice:

    Muy buena guía, muy bien explicado, ánimo y haber si con un poco de suerte seguís con este magniífico tuto de XNA.

  2. BK09 dice:

    Solo van dos post de XNA verdad?. Lo seguiré entonces. Lo acabo de empezar a leer hoy. Sabeis cuando van saliendo los tutoriales’?. Un saludo.

Deja un comentario