[XNA] Introducción a los juegos multijugador (1/?)

Los juegos multijugador online, son difíciles de manejar desde código. Pero esto en XNA es diferente ya que no debemos preocuparnos tanto por la comunicación entre las PC’s y las consolas de Xbox 360. Esto porque XNA encapsula toda esta complejidad en un marco de conexión.

¿Por qué son difíciles los juegos online desde código?

Porque hay muchos más problemas para hacerle frente a cosas como: el programa que recibirá los mensajes del anfitrión o de otros jugadores, enviar mensajes, el proceso de entrada de jugador local, llevar a cabo la inteligencia artificial, física, cálculos y al mismo tiempo no dejar congelada la pantalla.

Como soluciona esto XNA

XNA nos ayuda con la mayoría de estos problemas de comunicación, ya que nos proporciona los medios para controlar el flujo de los mensajes entre los agentes para garantizar que los mensajes no se pierdan y que todos los mensajes lleguen en el mismo orden en que fueron enviados. Sin embargo aun tenemos que resolver otros problemas.

Aunque la codificación de un juego multijugador completo podría ser difícil, los pasos básicos son simples para la creación de un juego multijugador en donde varios jugadores se puede conectar. Existen cuatro pasos para un juego multijugador:

1. Registrar un jugador (en un equipo local o remoto)
2. Crear un periodo de sesiones, así como el establecimiento de sus propiedades
3. Esperar a otros jugadores a unirse
4. Cambiar el estado de la sesión a “Play”

Ahora vamos a ver como crear una clase sencilla, que nos servirá para aprender las bases de como crear un juego en red en XNA.

Todo inicio en el año 2002 cuando Microsoft lanzo lo que conocemos hoy como Xbox LIVE, en donde la intención principal es proporcionar un servicio en línea para la distribución de los contenidos de juegos (demos, trilers y contenidos extras de cada juego como mapas) y la conexión de los jugadores en el Xbox. Fue en el año de 2007 donde Microsoft amplio este servicio para Windows con el lanzamiento de Windows LIVE. Desde XNA podemos conectarnos a ambos servicios. XNA encapsula toda la manipulación de los perfiles en Vivo con el espacio de nombres GamerServices, lo que hace más fácil la creación de cuentas, conectarse a un perfil y también utilizar muchos dispositivos en vivo, así como la guía de pantallas para manipular la información del jugador.

La forma más sencilla de acceder a estos elementos es a través  del GamerServicesComponent que nos permite por ejemplo responder a la interacción del usuario, por ejemplo: la presentación de la Guía LIVE cuando  el usuario presiona Start.

Pero vamos a ver esto con un ejemplo sencillo. Comencemos creando un nuevo proyecto de tipo Windows Game al que llamaremos XNADemo. A continuación abrimos la clase Game1.cs y vamos a incluir la siguiente línea de código en el constructor de la clase, justo después de la línea que establece el contenido del directorio raíz.

//Agregamos el Componente que hace referencia a nuestro juego
Components.Add(new GamerServicesComponent(this));

Si ahora ejecutamos nuestra juego y como no disponemos de un perfil en LIVE configurado para inicio de sesión automático nos muestra la siguiente pantalla para crear un perfil.

(Si  No se muestra esta pantalla presione la tecla Inicio)

Aquí tenemos 2 opciones, que es la de crear un nuevo perfil o exportar uno existente. (Para mostrar el funcionamiento crearemos un nuevo perfil). Entonces seleccionamos Crear perfil nuevo

(Asignamos un nombre a nuestro perfil)

Al dar un nombre a nuestro perfil, damos clic en Enviar (Presionamos A en caso de trabajar con el Xbox 360). Este nombre de perfil (que puede modificar más adelante) se utilizará para identificar cuando estés  jugando juegos en red.

y después de esto nos muestra una pantalla con 3 opciones.

(Guardar Perfil del Jugador)

La primera opción nos permite unirnos al sitio de  Windows-LIVE . Después podemos personalizar nuestro Perfil (por ejemplo, el perfil de imagen), según nuestras preferencias. Podemos cerrar la ventana haciendo clic en el botón Listo.

Ahora damos clic en Listo, y vamos a trabajar con nuestra clase para manejar los estados de sesión para poder incorporarlos a un juego. Pero esto lo vemos en otro Post

Etiquetas de Technorati: XNA,XNA Game Studio,Windows Game,Xbox 360

Geek Fest 2.0 mañana en la UNEVE

El día de mañana estaré dando una platica sobre XNA, en donde abordare principalmente el conectividad, donde daremos un ejemplo de que es lo que necesitamos hacer y tomar en cuenta para que nuestro juego pueda jugarse en línea, estaré colgando mañana por la tarde las pptx’s  y las demos, aquí les dejo la agenda por si alguien quiere ir:

Nos vemos mañana en Ecatepec

Etiquetas de Technorati: XNA,SQL Server 2008,Platicas,Eventos MSP

Nuevo sitio de desarrollo Web de Microsoft

Plataforma Web de Microsoft para: el hogar, diseño, foros, blogs, etc. Todo sobre como poner en practica las tecnologías de Microsoft para tener una web innovadora.

Se ve bastante bien el sito, en donde encontramos infinidad de recursos, aquí una miradita:

 

Como se observa en la figura, podemos acceder a información sobre eventos, blogs, productos, etc. así que les recomiendo que le echen un vistazo y me cuenten como les va, seria una buena idea hacer algo así para estudiantes, no creen?

URL: http://www.microsoft.com/web/default.aspx

Etiquetas de Technorati: Microsoft,Explore Web,visual Studio,Expression,XNA,Silverlight

XNA Game Studio 3.0 Beta en camino

Aunque aún falta tiempo, aquí unos detalles de esta última versión d XNA Game Studio.

Zune:

• Compatibilidad con la próxima versión de firmware 3.0 de Zune
• Estabilidad de implementación mejorada.
• Soporte para la implementación de ZUNE en Windows Vista x64.
• Ahora se podrá usar el monitor de rendimiento remoto para juegos de Zune.

Xbox 360

• Plantillas para proyectos de Xbox 360 (aunque no se podrán realizar proyectos de Xbox 360 hasta la versión final)

Framework y características en Visual Studio

• Enumerate and play back media on your Windows computer or Xbox 360.
• Simple sound effect support on Windows computers and Xbox 360.
• Support for Rich Presence (lets friends know what’s going on in your game).
• Support for Invites (ask your friends to join you in a multiplayer game) and Join Session In Progress (after you see what your friends are doing, you can join their current session with just a couple of button presses, even if that’s a different game to the one you are currently playing)
• Compress your content and save space with the new content compression features!
• ClickOnce packaging support for distributing your XNA Framework games on Windows.
• Upgrade your project from XNA Game Studio 2.0 using the Project Upgrade Wizard!
• Take screen captures of your game running on Zune through the XNA Game Studio Device Center.
• Support for .NET language features like Linq
• Create multiple content projects and leverage cross project synchronization in Visual Studio.
• FBX importer improvements: read materials containing multiple textures, and export custom shader materials directly out of Max or Maya.

Al parecer esta versión será lanzada la próxima semana, así que estaremos pendientes. De igual manera parecer que seta Beta será algo muy cercano a la versión final, así que si encuentran alguna problema (casi nunca sucede ), tenderemos que reportarlo para que no este en la última versión

 

Etiquetas de Technorati: XNAA Game Studio 3.0,Zune,Betas,Windows Game

Descarga Libro de XNA

Ya hace tiempo que revise el libro de Rob Miles, que escribió sobre XNA Game Studio 2.0, y hoy en su página me encuentro con que puedes descargar algunos capítulos de este libro. así que aquí te dejo la URL para que los descarguen.

                                     

Los capítulos parecen ser los primeros cuatro y el tema de XNA Hypnotic Display, así que desde aquí lo pueden descargar:

URL: http://www.robmiles.com/xna-book-downloads/

Etiquetas de Technorati: XNA Games Studio,XNA Games Studio 2.0,Xbox 360,Windows,Games

MSDN Center de XNA en Español

Así es amigos, ya esta en línea un sitio en MSDN latam un lugar dedicado a XNA Game Studio totalmente en español, con información sobre ¿Qué es XNA?, Aprender, Presentaciones, Novedades, Comunnity Games, FAQs y claro Creators Club.

Espero que si les interesa saber más sobre este producto, no dejen de visitar este sitio, y seguir aprendiendo de XNA Game Studio el cual esta formado  con recursos y comunidades que se centran en permitir a los desarrolladores de juegos tener éxito en la plataforma de juego de Microsoft.

URL: http://www.microsoft.com/spanish/msdn/latam/xna/default.aspx

Etiquetas de Technorati: XNA,XNA Games Studio,MSDN,Creator Club

[Tips - XNA] Detección de Colisones

Aquí vamos hacer uso de un par te rectángulos, que junto con la propiedad de intersección se encargara de la intersección, es decir; el rectángulo de un automóvil con el de otro, que en mi caso se trata del camaro y de los otros coches, bien, aquí necesitaremos de cargar otro Sprite, de realizar un método llamado MueveOtros Atuos(), de la colisión y por ultimo de dibujar dichos otros autos. Entonces primero declaramos las variables a utilizar que son las siguientes:

//varibales de los autos
        Texture2D[] Coches = new Texture2D[2];
        Vector2[] posCoches = new Vector2[2];

        //donde apareceran los autos en el eje X y en Y
        int[] posX = { 270, 428 };
        int posAleatoria;

        //varibale para determinar la posicion aleatoria
        Random ran = new Random();
        //recatngulo de los otros coches
        Rectangle[] recCoches = new Rectangle[2];
        
        //variable bool de detección de colision
        bool deteccionActiva = true;

        //velocidad de los coches
        int velCoches = 3;

Como se observa, aquí son mas variables, pero de igual manera se indica para que nos sirven cada una de ellas, ahora el paso siguiente es la carga del Sprite de los otros autos, como se observa en la declaración de la textura y del vector se trata de un arreglo y en este caso es para 2 valores, bien entonces el Sprite que se llama “carros” que está en la carpeta Content lo cargamos en el método protected override void LoadContent() dentro de un for, y queda así:

//carga del sprite de los otros autos
            for (int i = 0; i < 2; i++)
            {
                //carga de los sprites
                Coches[i] = Content.Load<Texture2D>("carros");
                //posicion aleatoria en Y
                posAleatoria = ran.Next(-1000, 0);
                posCoches[i].Y = posAleatoria;
                //posicion en X, solo 2 valores
                //del lado der o izq del camino
                posAleatoria = ran.Next(0, 2);
                posCoches[i].X = posX[posAleatoria];
                

            }

Como con los otros ejemplos, ahora sigue trabajar con el método Update(), que es aquí en donde llamamos al método MoverOtrosAutos(), que como su nombre lo dice se utiliza la lógica para que los otros coches se mueven solos y de manera aleatoria. La definición y cuerpo del método va con este código:

//método para mover los coches
        private void MueveOtrosAutos()
        {
            int maxHeight = graphics.PreferredBackBufferHeight;
            for (int i = 0; i < 2; i++)
            {
                
                posCoches[i].Y += velCoches;
                if (posCoches[i].Y > maxHeight)
                {
                    posAleatoria = ran.Next(-1000, 0);
                    posCoches[i].Y = posAleatoria;
                    posAleatoria = ran.Next(0, 2);
                    posCoches[i].X = posX[posAleatoria];
                }               
            }
        }

Se observa en el método que la definición de vector de los coches en la posición X y Y es similar a la de la carga de los Sprites, por lo de mas solo se limita al alto de la pantalla para que estos aparezcan al inicio de la misma y se muevan hacia abajo. Para observar cómo es que aparecen los coches aleatoriamente, solo resta la parte de dibujarlos en pantalla, todo esto dentro del método protected override void Draw(GameTime gameTime) y esto después de dibujar el camino y el camaro, el código es este:

//dibujamos los autos
           //en este caso solo son 2
           for (int i = 0; i < 2; i++)
           {
               spriteBatch.Draw(Coches[i], posCoches[i], Color.White);
           }

Y si toda va bien, compilamos y ejecutamos nuestro proyecto y podemos ver como aparecen nuestros autos a evadir, pero sin embargo si topamos con uno de ellos no pasa nado, esto se observa como en las siguientes imágenes.

Para solucionar este problema de que se encimen las texturas, es aquí en donde declaramos nuestros rectángulos para la detección de la colisión, entonces inicializamos dichos rectángulos dentro del método protected override void Update(GameTime gameTime) y la definición e inicialización de dichos rectángulos es así:

//inicialización de los rectangulos
           //para detectar la colision

//recangulo del camaro
Rectangle recCamaro = new Rectangle((int)posCamaro.X, (int)posCamaro.Y, 
    Camaro.Width, Camaro.Height);
//rectangulo de los otros coches
for (int i = 0; i < 2; i++)
{
 recCoches[i] = new Rectangle((int)posCoches[i].X, (int)posCoches[i].Y, 
          Coches[i].Width, Coches[i].Height);
}

Ya que tenemos esto, ahora hacemos uso de la variable booleana deteccionActiva dentro del mismo método Update() la cual colocamos después de llamar al método MoverOtros Autos() y con una condición que va de esta manera:

//colisión de los rectangulos
                for (int j = 0; j < 2; j++)
                {
                    if (recCamaro.Intersects(recCoches[j]))
                        deteccionActiva = false;
                }

Para poder identificar esto, trabajamos dentro del método Draw() y colocamos una condición para dibujar al camaro, que funciona o se dibuja solo si la variable deteccionActiva esta activa, si esta en false que indica que existe dicha colisión, el camaro no será dibujado, y entonces queda así:

//dibujar el camaro
            if (deteccionActiva == true) 
                spriteBatch.Draw(Camaro, posCamaro, Color.White);

De esta manera cuando choquen los autos el camaro desaparece. Para terminar con este pequeño tutorial, cuando choque se sale del juego. Con esta pequeña condición para que pinte una explosión cuando esto suceda.

 

else if (deteccionActiva == false)
           {
               spriteBatch.Draw(choque, posCamaro, Color.White);
               deteccionActiva = true;
               base.ResetElapsedTime();
               base.Exit();
           }

[Tips - XNA] Cargar y Manipular Sonidos

Gracias al Content Pipeline es muy fácil hacer la integración de sonidos a nuestros juegos, vamos a ver cómo hacerlo y después manipularlo para que se reproduzca cuando acelere nuestro camaro. Los primero es crear una carpeta desde el explorador de soluciones, que este dentro de la carpeta Content, a la que llamaremos Sonidos, aquí agregaremos nuestros sonidos, que tienen que estar en formato .wav, hacemos esto como se ve en las figuras:

Abrimos el programa Microsoft Cross-Plataform Audio Creation Tool (XACT) que viene adjunto en la instalación de XNA, que nos sirve para preparar nuestros sonidos para el juego. Ya con el programa iniciado, creamos un nuevo proyecto y lo direccionamos a la carpeta de sonidos, es decir el producto de este proyecto debe estar en la ruta en donde se encuentran nuestros sonidos, para esto damos clic en File->New Project damos la ruta y nombre que en mi caso es “camaro” tal y como se observa en la siguiente figura.

            

Creamos un Nuevo Wave Bank que va a contener nuestros archivos de sonido y agregamos los archivos de sonido.

Ya con los archivos agregados, el siguiente paso es agregar un Sound Bank, y ya que lo tenemos que arrastrar los sonidos que tenemos en el Wave Bank al Sound Bank en la parte del Cue.

      

Ahora que ya tenemos los archivos en el Cue, vamos a abrir el XACT Auditioning Utility, Para esto vamos a Inicio Programas- XNA 2.0- Tools – XACT Auditioning Utility, nos aparece algo asi:

   

Esto es para hacer la conexión con el proyecto que tenemos en XACT, ahora solo resta seleccionar nuestro sonido de cars y reproducirlo y observamos cómo se conecta el XACT Auditioning Utility. Ya por utimo tenemos que construir nuestro proyecto, para esto damos clic en File->Build…, Listo ya tenemos preparados nuestros sonidos.

Para poder manipularlo debemos asegurarnos que el producto de nuestro proyecto en XACT este dentro de nuestra carpeta de sonidos, una vez teniendo esto vamos a trabajar con él. Como lo hemos hecho antes lo primero es la declaración:

//audio
        static AudioEngine audio;
        static WaveBank ondas;
        static SoundBank sonidos;

Ahora nos queda cargar los archivos necesarios, esto dentro del método LoadContent(),

//carga del proyecto de XACT
  audio = new AudioEngine("Content\\Sonidos\\Camaro.xgs");
  ondas = new WaveBank(audio,"Content\\Sonidos\\Camaro.xwb");
  sonidos = new SoundBank(audio,"Content\\Sonidos\\Camarosound.xsb");

Dentro de la carpeta Content-Sonidos esta el proyecto .xap y XNA Engine, através del AudioEngine nos creará el .xgs,.xwb y .xsb en hora de ejecución. Ahora solo falta colocar el código para probar si realmente carga los archivos de sonido en el método Update(), esto cuando acelere nuestro camaro, entonces la parte de código queda así:

//mover el camaro hacia arriba, y cargar el sonido
 else if (estadoTeclado0.IsKeyUp(Keys.Up) && estadoTeclado.IsKeyDown(Keys.Up))
 {
      velocidadCamaro++;
      if (velocidadCamaro > 10)
             velocidadCamaro = 10;
      posCamaro.Y -= velocidadCamaro;   //limite del camaro hacia arriba
      if (posCamaro.Y < 0)
             posCamaro.Y = 0;
      sonidos.PlayCue("cars");
  }

Así ya tenemos nuestro sonido, cada vez que presionemos la tecla de la flecha hacia arriba, ahora hagamos más interesante el juego y hablemos de colisiones.

[Tips - XNA] Escribir Texto en XNA

Bien, el hacer esto realmente resulta muy sencillo gracias a los elementos con los que cuenta XNA y sobre todo esta versión, si recuerdan como cargar un Sprite que contiene una textura, se darán cuenta que con el texto es muy similar, solo que tenemos que manipular en un documento XML las propiedades con las que se dibujara nuestro texto, y bien como todo iniciamos con la declaración de nuestro objeto que es de la clase SpriteFont .

        //spritefotn para la velocidad
        SpriteFont velCamaroText;

Este spriteFont solo mostrará de manera textual lo que le indiquemos, para manipular las propiedades del texto debemos agregar dentro de nuestra carpeta Content nuestro elemento con extensión “.spriteFont” y lo hacemos dando clic derecho en la carpeta Content->Agregar nuevo elemento y seleccionamos un SpriteFont al que llamaremos “Velocidad”

Al dar clic en Agregar automáticamente nos abre dicho documento llamado Velocidad.spriteFont el cual contiene varias propiedades, podemos observar que es un documento XML que tiene como referencia el namespace de Microsoft.Xna.Framework.Content.Pipeline.Graphics que nos facilita la manipulación de las propiedades del texto como nombre del Font, tamaño, estilo, el espacio, etc. El documento se ve así, en donde ya le cambie de nombre y tiene “Arial”.

<?xml version="1.0" encoding="utf-8"?>
<XnaContent xmlns:Graphics="Microsoft.Xna.Framework.Content.Pipeline.Graphics">
  <Asset Type="Graphics:FontDescription">
    <FontName>Arial</FontName>
    <Size>14</Size>
    <Spacing>0</Spacing>
    <UseKerning>true</UseKerning>
    <Style>Regular</Style>
      <CharacterRegions>
      <CharacterRegion>
        <Start> </Start>
        <End>~</End>
      </CharacterRegion>
    </CharacterRegions>
  </Asset>
</XnaContent>

El manipular este documento resulta muy sencillo, el paso indicado es la carga de este srpiteFont que se hace de la misma manera que una textura, dentro del método de LoadContent() lo cargamos con esta instrucción:

    //carga del texto
    velCamaroText = Content.Load<SpriteFont>("Velocidad");

Ahora para poder verlo en pantalla solo falta dibujarlo, y esto al igual que los sprite’s de texturas en 2D lo hacemos con el spritebatch solo con el método DrawString, todo esto dentro del método protected override void Draw(GameTime gameTime) y queda de esta manera:

  //dibujamos el texto
  spriteBatch.DrawString(velCamaroText,
        "Aqui va la velocidad!", new Vector2(580,560), Color.Black);

Se observa que el texto a dibujar es el segundo parámetro que recibe el método DrawString(), así compilamos y ejecutamos, se puede observar algo como esto:

         

Ok, ya sabemos cómo escribir Texto en XNA, ahora aprovechamos esto para colocar ahí la velocidad de nuestro “camaro”, para esto necesitamos declarar una variable que se llamara velocidadCamaro.

   int velocidadCamaro = 0;

Como ya tenemos la velocidad que se le asigna a nuestro camaro, solo falta mandarla a pantalla, porque ya en el método Update() tenemos una instrucción que lo hace, solo agregamos el incremento y lo asignamos para que se mueva el auto hacia arriba, el código queda así:

//mover el camaro hacia arriba
  else if (estadoTeclado0.IsKeyUp(Keys.Up) && estadoTeclado.IsKeyDown(Keys.Up))
  {
       velocidadCamaro++;
       posCamaro.Y -= velocidadCamaro;
       //limite del camaro hacia arriba
       if (posCamaro.Y < 0)
            posCamaro.Y = 0;
  }

Y para imprimirlo solo cambiamos el segundo parámetro del método DrawStrin() que tenía el texto “Aquí va le velocidad” por el de velocidadCamaro.ToString() y listo, se incrementara la velocidad y nuestro auto camina más rápido, entonces la instrucción de dibujar el texto de la velocidad queda así:

 

//dibujamos el texto

 spriteBatch.DrawString(velCamaroText, velocidadCamaro.ToString()+ "0 KM/h", new Vector2(580,560), Color.Black);

Si dejamos esto así, se observara un detalle, que consiste en que el contador se queda en su último valor, es decir; el que tenía hasta que se dejo de presionar la tecla de la flecha hacia arriba, para esto debemos ponerle un límite o regresarlo a cero, cuando el camaro frene, entonces podemos hacer lo siguiente.

//mover el camaro hacia arriba
 else if (estadoTeclado0.IsKeyUp(Keys.Up) && estadoTeclado.IsKeyDown(Keys.Up))
 {
    velocidadCamaro++;
    if (velocidadCamaro > 10)
         velocidadCamaro = 10;
    posCamaro.Y -= velocidadCamaro;
    //limite del camaro hacia arriba
    if (posCamaro.Y < 0)
         posCamaro.Y = 0;
 }

En donde incrementamos la velocidad, pero le colocamos un limite de 10, para que no vaya muy rapido el camaro, y asu vez cuando frene o el camaro vaya hacia abajo lo decrementamos y colocamos un limite en 0 de lamisma manera y queda así:

//mover el camaro hacia abajo
               else if (estadoTeclado.IsKeyDown(Keys.Down))
               {
                   velocidadCamaro -= 1; ;
                   if (velocidadCamaro < 0)
                       velocidadCamaro = 0;
                   posCamaro.Y += 3;
                   //limite del camaro hacia abajo
                   if (posCamaro.Y > 460)
                       posCamaro.Y = 460;

               }

Y ahora podemos manipular la velocidad de nuestro camaro como queramos, bien aquí termina esto del texto, adelante indicaremos como cargar el sonido de aceleración y manipularlo.

[XNA] DreamBuildPLay 2008 Challenge! (DBP 2008)

“El juego de tu sueños, constrúyelo hoy, millones lo pueden jugar mañana ” . Como ya lo saben esto se trata de una competencia mundial, para saber quién es capaz de crear el mejor juego para Xbox 360 usando XNA Game Studio 2.0. Los participantes de este año compiten por  $75,00. A demás uno de los 10 finalistas tendrá la oportunidad de un contrato de publicación de Xbox Live.

Al parecer los juegos ganadores del año pasado, pronto los veremos publicados en Xbox Live Arcade. Y como el concurso de este año solo contara con el desarrollo para Xbox 360 a todos los participantes se les otorgara una suscripción a XNA Creator Club por 12 meses . Para obtener más información sobre este concurso no olviden visitar la dirección de www.dreambuildplay.com y ah participar.

[XNA] Listo para la descarga CTP de XNA Game Studio 3.0

Hace unos días se lanzo esta CTP de XNA Game Studio que la principal característica es dar el soporte al desarrollo de video juegos para la familia de dispositivos Zune. Esta característica nos da el acceso a la mayoría de de las funciones del API de XNA.

 

Algo interesante de esta versión, es que requiere de la instalación de Visual Studio 2008 en cualquiera de sus versiones, obviamente con el soporte para Visual C# qué es el lenguaje con el que se desarrolla. Pueden practicar con Visual C# 2008 Express Edition.

Existen cosas importantes que debemos considerar para trabajar con esta CTP, que son las siguientes:

• Visual Studio 2008 Standar Edition o superior (con soporte para el lenguaje C#) o C# Visual 2008 Express son necesarios para instalar y ejecutar la CTP de XNA Game Studio 3.0.
• No es necesario desinstalar Visual Studio 2005 o XNA Game Studio 2.0, ya que estos productos pueden funcionar a la par con Visual Studio 2008 y XNA Game Studio 3.0.
• Esta versión CTP de XNA Game Studio no permite el desarrollo de juegos para Xbox 360, solo es compatible para Windows y Zune. Si quieren desarrollar e implementar Juegos para su Xbox 360, se debe continuar usando la versión 2.0 de XNA Game Studio por el momento.
• Esta CTP no funciona aún en sistemas de 64 bits, este soporte se le dará en la versión RTM.

Pues bien si quieren hacer pruebas y revisar que trae de nuevo esta versión, está disponible  a través del sitio de XNA Creators Club (http://creators.xna.com), en donde encontrarán toda la información.

Descarga: http://www.microsoft.com/downloads/details.aspx?FamilyId=DF4AF56A-58A7-474C-BFD0-7CF8ED3036A3&displaylang=en

[Tips - XNA] Manipulación del estado del Teclado (parte 2)

Aquí vamos a observar cómo es que podemos realizar la manipulación del teclado para mover un automóvil, bien lo que hacemos primero es cargar el Sprite, luego moverlo (manipularlo) y por ultimo dibujarlo como lo hicimos con el Sprite de camino, así que iniciamos declarando nuestras variables de la siguiente manera:

//varibales del auto
        Texture2D Camaro;
        Vector2 posCamaro;
        //limites del camino, para q el camaro no salga del camino
        int maxIzq = 270;
        int maxDer = 428;

Bien, ya con las variables necesarias establecidas, seguimos con la carga de nuestro Sprite que en mi caso se llama “camaro”, y que se encuentra en la carpeta Content, como lo hicimos con el camino, lo cargamos dentro de nuestro método protected override void LoadContent(), nuestro código va debajo del bucle for, y queda así:

//carga de la textura del camaro y su posicion
            Camaro = Content.Load<Texture2D>("camaroarriba");

            //indica en donde aparece el camaro,
            //a la hora de ejecutar el juego
            posCamaro = new Vector2(350, 300);

El siguiente paso es darle movimiento a nuestro auto, así que para ello necesitamos declarar la variable del estado del teclado, esto dentro del método protected override void Update(GameTime gameTime), y quedas así:

//manupulacion del teclado para mover el camaro
            KeyboardState estadoTeclado = Keyboard.GetState();

Esta declaración nos permite indicar que hacer cada que se presione cierta tecla de nuestro teclado. Ahora solo queda darle la lógica, es decir que hacer cada que se presione o no cierta tecla, lo que hacemos es decirle que según las flechas del teclado, el automóvil se mueva hacia la izquierda, derecha, arriba y abajo. De la misma manera lo limitamos para que no salga de la pantalla ni del camino, dentro del mismo método de Update, colocamos este código después de la declaración:

//mover el camaro hacia la izq
            if (estadoTeclado.IsKeyDown(Keys.Left))
            {
                posCamaro.X -= 4;
                //limite del camaro a la izq
                if (posCamaro.X < maxIzq)
                    posCamaro.X = maxIzq;
            }
            //moverl el camaro hacia la der
            else if (estadoTeclado.IsKeyDown(Keys.Right))
            {
                posCamaro.X += 4;
                //limite del camaro hacia la der
                if (posCamaro.X > maxDer)
                    posCamaro.X = maxDer;
            }
            //mover el camaro hacia arriba
            else if (estadoTeclado.IsKeyDown(Keys.Up))
            {
                posCamaro.Y -= 3;
                //limite del camaro hacia arriba
                if (posCamaro.Y < 0)
                    posCamaro.Y = 0;
            }
            //mover el camaro hacia abajo
            else if (estadoTeclado.IsKeyDown(Keys.Down))
            {
                posCamaro.Y += 3;
                //limite del camaro hacia abajo
                if (posCamaro.Y > 460)
                    posCamaro.Y = 460;
            }

Ya que tenemos la carga de nuestro Sprite, y la lógica para que este se mueva, ahora solo nos queda dibujarlo, recuerden que para aumentar o disminuir la velocidad a la que se mueve el auto, solo basta con cambiar el valor de 4 por otro número dentro de las condiciones. Por el momento para dibujar nuestro Sprite escribimos el siguiente código dentro del método protected override void Draw(GameTime gameTime) justo debajo del SpriteBatch.Draw del camino.

//dibujar el camaro
            spriteBatch.Draw(Camaro, posCamaro, Color.White);

Ahora si compilamos y ejecutamos, podemos observar nuestro camaro, y lo podemos mover con las flechas del teclado, y queda algo así.

    

[Tips - XNA] Cargar un Sprite y Animarlo (parte 1)

Bien, lo primero es declarar las variables necesarias, que son la Textura2D que contendrá nuestra imagen y el Vector2D para la posición de nuestro camino, es decir; en donde lo colocaremos. La declaración serán vectores, ya que lo cargaremos más de una vez y lo dibujaremos por igual. La declaración queda así:

//varibales del camino
       Texture2D[] Camino = new Texture2D[2];
       Vector2[] posCamino = new Vector2[2];

Después seguimos con el proceso de cargar nuestro Sprite, que se realiza dentro del método protected override void LoadContent(), lo que hacemos aquí es cargar el sprite pero dentro de un bucle for, para que lo carguemos más de una vez y cada vez lo coloquemos en posiciones diferentes, el código dentro del método LoadContent() va así:

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
      for (int i = 0; i < 2; i++)
      {
          Camino[i] = Content.Load<Texture2D>("camino");
      }
      posCamino[0] = Vector2.Zero;
      posCamino[1] = new Vector2(0, -600);
}

De esta manera tenemos 2 veces la textura y la colocaremos en diferentes posiciones, esto con el fin simular el movimiento de nuestro Sprite, que en el caso es un camino.

Para poder simular el movimiento de un camino, como es nuestro caso necesitamos un método que realice esta función, el cual llamaremos MueveCamino() y este contiene lo siguiente:

private void MueveCamino()
        {
            int vel = 6;//velocidad a la que se mueve el camino
            int max = graphics.PreferredBackBufferHeight; // indica el maximo en el alto

            for (int j = 0; j < 2; j++)
            {
                //inidicamos la vel en el eje Y
                posCamino[j].Y += vel;
                //si llega al maximo que se regrese, todo sobre el eje Y
                if (posCamino[j].Y > max)
                    posCamino[j].Y = -591;
            }
        }

Tenemos que tomar en cuenta que este método debe ser llamado, por el método principal de protected override void Update(GameTime gameTime, para que dicha simulación pueda ocurrir, entonces nuestro método Update(), queda así:

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
            MueveCamino();
            base.Update(gameTime);
        }

Ahora solo nos resta dibujar nuestros Sprites, y esto lo hacemos dentro del método protected override void Draw(GameTime gameTime), y como ya sabemos para esto necesitamos nuestra varibale de spriteBatch que se declara automáticamente al inico del proyecto.

Existen tres métodos que utilizaremos dentro del spriteBatch, que son: Begin(), Draw() y End() que como sus nombres los dicen, sirve para iniciar, dibujar y terminar, en nuestro caso al momento de dibujar, también lo haremos dentro de un for, esto para que lo dibujen un par de veces y simular el movimiento del camino. El método Draw(), queda así:

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

            // TODO: Add your drawing code here
            spriteBatch.Begin(SpriteBlendMode.AlphaBlend);
            for (int i = 0; i < 2; i++)
                spriteBatch.Draw(Camino[i], posCamino[i], Color.White);
            spriteBatch.End();

            base.Draw(gameTime);
        }

Ya por ultimo compilamos y ejecutamos, ahora se carga nuestro Sprite y además de todo tiene movimiento, se ve algo así:

        

Ahora nos vemos en el siguiente, Tip, que será el como agregar el auto, para luego manipular el estado del teclado.

[Tips - XNA] FullScreen

Cuando creamos un aplicación para Windows, el Dispositivo que administra nuestra ventana lo tenemos por Default en 800 x 600, y cuando corremos dicha aplicación, nos aparece una ventana como esta:

                

Es decir; se ve la forma de nuestra ventana, y si queremos tenerlo en pantalla completa o manipular las dimensiones tenemos que hacer unos pequeños cambios, primero es colocar la propiedad graphics.IsFullScreen = true; que por default viene en False, esto para poder manipular el modo de pantalla completa, esto lo declaramos dentro del método protected override void Initialize().

 

protected override void Initialize()
        {
            // TODO: Add your initialization logic here
            graphics.IsFullScreen = true;
            base.Initialize();
        }

Esto nos indica que nuestro juego se ejecutara en modo FullScreen, pero si solo escribimos esto, sabemos que no sucederás así, esto porque necesitamos indicarle que se efectuaran cambios en el graphics Device, y eso se hace dentro del método protected override void Update(), Así que agregamos la instrucción:

graphics.ApplyChanges();

Ya con esto, al ejecutar tenemos corriendo nuestro juego, en modo de pantalla completa , de la misma manera podemos manipular el ancho y alto de nuestra ventana, que sería algo similar a esto:

graphics.PreferredBackBufferHeight = 800;
           graphics.PreferredBackBufferWidth = 700;

Y de esta manera, manipular las propiedades de ancho y alto de la ventan, en caso de ser una aplicación para Xbox 360, lo que podemos hacer para que ocupe todo el ancho y alto es lo siguiente:

graphics.PreferredBackBufferHeight = graphics.GraphicsDevice.Viewport.Height;
graphics.PreferredBackBufferWidth = graphics.GraphicsDevice.Viewport.Width;

Espero q les sea de utilidad, nos vemos en otro tip

Juegos para Zune con XNA Games Studio 3.0

Una excelente noticia la que nos da el grupo de desarrollo de XNA, ya que no hace mucho que esta la versión 2.0 de XNA Games Studio y ya se muestran las características que tendrá la nueva versión.

Y es que la capacidad de crear juegos para Zune creo que vendrá excelente a las persona que tengan uno de estos dispositivos, ya que permite utilizar la mayor parte de la estructura del API de XNA, sin dejar de lado la perfecta integración con la experiencia de medios que ya nos proporciona Zune,

                                      

Aprende XNA Games Studio 2.0

si crees que sabes lo necesario sobre este producto en su primera versión que solo funciona con la versión Express del Visual Studio y querías saber algo más, te invito a que revises  estos capítulos de un nuevo libro sobre esta nueva versión.

                                  

Aquí el link de la descarga de estos capítulos: Descarga algunos capitulos

Webcasts sobre creación de juegos con C# y XNA Game Studio Express – antes del antro

Así es amigos, desde la parte de Sudamérica surge el hacer estos webcast que ya hacían falta por ak,  la verdad es que es un tema súper interesante y que con mucho gusto los invito a que asistan a estos dos webcast, que aunque serán de introducción y usando starter kits, siempre son un buen punto de referencia.

Algo interesante de estos dos webcast es la hora y el día, porque al parecer son de sábado y aproximadamente a las 9 de la noche, (en lo personal me gusta el horario), justo cuando comienza la noche antes de ver una buena película, iniciar el viaje por el cyber espacio, o prepararse para ir al antro a bailar un poco, así que ya saben espero que puedan asistir y que participen.

Creación de juegos con C# y XNA Game Studio, Parte 1(introducción al ambiente de desarrollo y juegos simples en 2D)

Creación de juegos con C# y XNA Game Studio, Parte 2(starter kits y juegos más complejos)

XNA Games Studio 2.0 Beta

Siguiendo con esto de los videojuegos, aquí una excelente noticia para los adeptos a la programación de videojuegos con XNA, tenemos nueva versión del XNA Game Studio!! 

Esta nueva versión trae una gran serie de mejoras a distintos niveles:

• Soporte para diferentes versiones del IDE. Hasta ahora, XNA Game Studio era compatible con la versión gratuita de VS 2005 C# (Express), ahora, además de tener soporte en esta versión gratuita, tenemos soporte en las versiones Standard, Professional y Team. Con todo ello tenemos una serie de ventajas y herramientas que nos ayudarán en nuestros desarrollos con XNA, como por ejemplo las herramientas de control de versiones de código, la posibilidad del uso de add-ins de Visual Studio, el uso de pruebas unitarias de código o nuevas opciones avanzadas de depuración.

• Mejoras en la conectividad entre el Device Center y la XBOX.

• Herramienta de upgrade de proyectos de la versión anterior a esta, asi como herramientas para la conversión de proyectos Win a XBOX y viceversa.

• Cambios en la manera de trabajar con el Content Pipeline.

• Mejoras en la API de desarrollo, nuevas clases… De entre todas estas me llama la atención la posibilidad de crear juegos en red, multijugador. Y no sólo eso, sino que esta posibilidad permite juegos multijugador entre PC y XBOX!!

• Mejoras a nivel de objetos de gráficos, audio, funciones matemáticas…

Si que es una muy buena noticia, así que ya saben a disfrutar de este nuevo Game Studio. Aquí los links para la instalación

Install XNA Game Studio 2.0 (Beta) as a new user

Install XNA Game Studio 2.0 (Beta) as an existing XNA Game Studio Express user

Gamefest 2007 – Presentaciones y grabaciones de audio

Siguiendo con recursos sobre el desarrollo de videojuegos, un tema que en lo particular me gusta mucho, aquí dejo los links para que se descarguen las presentaciones y grabaciones del Gamefest 2007, en dónde están los temas cómo:

System Programming for Windows and Xbox 360

Graphics

Quality Assurance and Certification

Producer and Business Development

Audio

LIVE

XNA Game Studio

Games for Everyone

Visual Arts

Así que si te interesa, no esperes más u checa este material, que está muy interesante.

Recursos para XNA Games Studio

En estos días que me dedique a aprender un poco más sobre XNA Games Studio, me encontré un buen numero de sitios en donde encontré información muy buena para entender cómo trabaja el XNA Framework y si librería de clases, y por este motivo en este post les dejo los link de estos sitios, espero que de verdad les sea de utilidad a todas aquellas personas que quieren aprender a desarrollar juegos y que obviamente no son profesionales como yo jeje. Aquí la info.

¿Qué es XNA?

XNA Developer Center

What is the XNA Framework

http://www.xna.com/

Creators Club XNA

XNA para torpes

Motor XNA

XNA Codeplex