Tutorial Sistemas de Coordenadas y cámaras en XNA

Tutorial Sistemas de Coordenadas y cámaras en XNA

Hola bueno siguiendo con la introducción a la lógica de los juegos 3D necesitamos saber más de estos. En este post veremos el sistema de coordenadas que usa XNA y la importancia de las cámaras.

Antes de imaginarnos las coordenadas en 3D imaginemos en 2D, que tenemos, pues X y Y, donde podemos ubicar un punto en el espacio digamos en (0,0) o en (10,5) o en (-5,-3) etc. Pues bien ahora que tenemos ese concepto necesitamos saber que para manejar 3D necesitamos una coordenada más la cual es Z  la cual punta hacia nosotros en un esquema se verían así

XNA

Donde tenemos objetos tridimensionales y Z aumenta hacia nosotros y disminuye cuando se aleja.

Vectores

Para manejar posiciones en XNA usamos vectores, y si usaremos mucho las matemáticas y algo de física aquí, así que si has tomado clases de Calculo Vectorial o aun que sea has visto vectores te va servir mucho. Tendremos vectores de posición de velocidad, de aceleración, etc. Pero no se desanimen solo será lo más básico, como suma de vectores. Para usar vectores en XNA tendremos que usar la Clase Vector3, (si ya llevaste un curso de XNA en 2D veras que también hay Vector2).

El constructor de esta clase recibe, en el caso más común, tres parámetros 3 Flotantes que representan X, Y e Z respectivamente.

Cámara

La cámara es un objeto de vital importancia en el mundo 3D ya que con ella se muestra al usuario un vista 2D del mundo 3D, pero que significa esto. Significa que con la cámara “tomamos” un video del mundo el cual se representa en la pantalla de 2D .

XNA nos provee un método para poder visualizar en nuestra PC o Xbox lo que está capturando una cámara en un momento. El método se llama CreateLookAt que es un miembro estático de la clase Matrix (hablaremos más tarde de esta clase), los parámetros que recibe son: la posición de la cámara, el objetivo de la cámara, y la posición a la cual se requiere como arriba. Para estos tres parámetros utiliza Vectores, por ejemplo se puede enviar siempre el Vector3.Up (que representa un vector que siempre apunta al cielo) para decirle a la cámara donde es arriba.

Además contamos con un método estático para poder lograr perspectivas.

CreatePerspectiveFieldOfView este método recibe como parámetros: campo de visión, relación de aspecto, tope cercano y tope lejano.

camara XNA

Como indica la imagen la cámara necesita capturar los objetos en el mundo. Los topes cercano y lejano sirven para indicar que objetos si van a ser dibujados en la pantalla y cuáles no. Por ejemplo si pusiéramos como valores para tope cercano 100 y lejano 1000 solo los objetos que estén a esta distancia podrán ser mostrados, y si tenemos un objeto a una distancia de 1200 no será mostrado en la pantalla.

Bien ya ha sido mucha teoría para el siguiente post dibujaremos nuestro primer modelo en 3D.

Saludos y no se olviden de comentar.

Tutorial Aspectos básicos en XNA

Hola, antes que nada debes de saber que los tutoriales que se verán en este blog se requiere de conocimientos previos en Programación, de preferencia el lenguaje C# (Aun que Java, C y C++ también es bueno) y en programación Orientada objetos ya que en la mayoría de los ejemplos se utilizaran Clases. Y por último haber jugado algunas vez en tu vida un juego de Video en 3D (No Mario, no eres tu soy yo, XD). Si cumples con estos requisitos ya puedes iniciar el tuto, sino búscate unos tutoriales simples de programación de preferencia en C# y dale una checada a la wiki http://es.wikipedia.org/wiki/Poo en su artículo de programación orientada a objetos. En este blog También planeo poner alguno que otro tutorial básico del lenguaje, nada que ver con la programación en XNA. Todo dicho.

En sus marcas… ¿listos?… fuera.

En este tutorial usare Visual Studio 2008 con XNA 3.0

Lo primero que debemos hacer es abrir el Visual Studio

Inicio->Programas->Microsoft Visual Studio 2008

Ahora que tenemos nuestra plataforma abierta debemos crear un nuevo proyecto

Archivo->Nuevo->Proyecto

Seleccionamos Visual C#-> XNA Game Studio 3.0 (en mi caso) y seleccionamos  Windows Game (3.0) y en nombre pondremos MiJuego3D en el la Carpeta que más les guste.

Después de haber hecho esto se crear nuestro nuevo proyecto y se darán cuenta que les aparecerá algo como esto

Este es nuestro Archivo Game1.Cs que se crea por default a iniciar un nuevo proyecto

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;
using Microsoft.Xna.Framework.Net;
using Microsoft.Xna.Framework.Storage;

Estas son todas las extenciones que usa un juego (por default) si eres perpiucas podras notar que hay alguna llamada Input aquí se encuntra todo lo necesario par controlar el juego desde el Mando 3D o el teclado, Audio sirve para reproducir Audio (¿ quien lo habria dicho?) Etc etc. Las veremos detenidamente mas adelante.

Ahora estas siguientes instruciones que se pueden ver

namespace MiJuego3D
{
    /// <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";
        }

Indican el espacio de nombres de nuestra aplicación que en este caso es un juego, el cosntructor del mismo, miren esta linea

public class Game1 : Microsoft.Xna.Framework.Game

Indica que Game1 es una Clase que Herada de Juego(Game).El cual tiene 2 atributos  el mas imporante de mencionar en este momento es el

GraphicsDeviceManager graphics;

Que es a grandes rasgos el dispositivo de video de la PC o Xbox dependiendo del proyecto.

Ahora bien pasaremos al cosntructor de nuestro juego

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

La primera linea le dice que va usar el dispositivo de video de la maquina que esta ejecutando el juego, parece exagerado pero es muy importante. La segunda linea señala la ubicación fisica de nuestra carpeta de Contenido, esta es donde guardaremos todos los archivos externos del juegos (Musica, imagines,videos,modelos 3D , etc.)

Continuemos.

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

Esta parte de codigo espara poner todo el codigo que necesitemos para inicializar nuestro juego, aunque ahora solo tenga una linea.

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
        }

El metodo LoadContent es usado para cargar los archivos que antes mencione (Musica, imagines,videos,modelos 3D , etc.) en la memoria principal para poderlos usar.

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

Por el contrario UnloadContent Elimina de la memoria los archivos que ya no usemos.

Ahora veremos uno de los metodos mas importantes de un videojuego el metodo Update, ya que el algoritmo principal de un videojuego es como muestro a continuacion:

Como se aprecia hay un ciclo infinito donde actualiza la informacion y luego dibuja algo en la pantalla.

La informacion por default en XNA nos muestra que cuando el jugador uno del Mando Xbox pulsa el boton Atrás saldra del  Juego. Algo no muy comun en los videojuegos pero no se preocupen ahora lo modificamos.

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);
        }

Si bien Actualizar es importante Dibujar es Igual de importante en un juego. Aquí esta el metodo Draw

protected override void Draw(GameTime gameTime)
        {
            GraphicsDevice.Clear(Color.CornflowerBlue);
            // TODO: Add your drawing code here
            base.Draw(gameTime);
        }

Lo unico que nos aparece es que en todo momento borrara la pantalla y dibujar en su lugar un color Azulito (CornflowerBlue)

Bien ya terminamos de Explicar todo el codigo que nos muestra el Archivo Game1.cs pero que pasa parece que Visual Studio no solo ha creado este archivo si no varios,veamos.

Nos ha creado un Program.Cs 3 Menús una imagen y hasta un icono. De los menús solo diré que Content sirve para Organizar los archivos externos que manejemos, el icono es para mostrarlo en la ejecución del juego. Y el Archivo Program.Cs

using System;
namespace MiJuego3D
{
    static class Program
    {
        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        static void Main(string[] args)
        {
            using (Game1 game = new Game1())
            {
                game.Run();
            }
        }
    }
}

Solo es para Ejecutar nuestro juego, esto, salvo alguna excepción quedara siempre igual.

No era mi intención que este tutorial se ampliara tanto pero es necesario conocer por que están aquí las cosas, así que he decidió hacerlo en dos partes. Esta la explicación y otra en donde en verdad dibujemos un modelo en 3D. Ahora solo queda pulsar F5 (Ejecutar) y deberías ver algo como esto.

Tutorial Archivos y Estructuras en C

Hola solo para traerles un mini tutorial para que se entienda mejor el uso de estructuras en C, aplicado con guardado en archivos. Aunque es muy simple a los principiantes les va servir mucho.

Subi un video en youtube en:

les dejo el codigo completo aqui

#include <stdio.h>
//ahora debemos de incluir nuestra estructura //
//para este ejemplo usaremos una estructura llamada albañil

//la cual contiene los siguientes datos
//nombre, folio, RFC, direccion, mail, horas trabajasdas, activida realizada y su tipo de pago

struct albanil {
    char nombre[50];
    char folio[10];
 char RFC[11];
 char calle[20];
 char CP[6];
 char colonia[20];
 char mail[50];
 char horas[2];
 char actividad[50];
 char pago[4];
};struct albanil albanil;

//ahora dentro de nuestro main

int main()
{
    FILE *ptr; //inicializaremo una variable a archivo como apuntador
    char archivo[50];//y tendremos una cadena archivo para guardar el archiv con el nombre que sedessee
    printf("Como quieres que se llame tu archivo ");
    scanf("%s",&archivo);
    printf("Dime tu numero de folio ");
    scanf("%s",albanil.folio);
    printf("Dime tu nombre ");
    scanf("%s",albanil.nombre);
    printf("Dime tu RFC ");
    scanf("%s",albanil.RFC);
    printf("Dime tu direccion ");
    scanf("%s",albanil.calle);
    printf("Dime tu codigo postal ");
    scanf("%s",albanil.CP);
    printf("Dime tu colonia ");
    scanf("%s",albanil.colonia);
    printf("Dime tu correo electronico ");
    scanf("%s",albanil.mail);
    printf("Dime cuantas horas trabajaste ");
    scanf("%s",albanil.horas);
    printf("Dime en que trabajaste ");
    scanf("%s",albanil.actividad);
    printf("Dime cuanto te van a pagar ");
    scanf("%s",albanil.pago);
    ptr=fopen(archivo,"a");
    fprintf(ptr,"folio %s\n",albanil.folio);
    fprintf(ptr,"nombre %s\n",albanil.nombre);
    fprintf(ptr,"RFC %s\n",albanil.RFC);
    fprintf(ptr,"calle %s\n",albanil.calle);
    fprintf(ptr,"cp %s\n",albanil.CP);
    fprintf(ptr,"colona %s\n",albanil.colonia);
    fprintf(ptr,"correo %s\n",albanil.mail);
    fprintf(ptr,"horas %s\n",albanil.horas);
    fprintf(ptr,"actividad %s\n",albanil.actividad);
    fprintf(ptr,"pago %s\n",albanil.pago);
    fclose(ptr);
    return 0;
}

Creando un Cuestionario en lenguaje C

bzk Gaming

Hola pues les traigo el primer código fuente des este blog, algo muy fácil pero que les va ayudar mucho a los novatos.

Ya que se manejan mucho los arreglos multidimensionales  y se utilizan los números aleatorios.

El objetivo es crear un cuestionario con un numero n de preguntas (en ejemplo 80) con tres posibles respuestas cada uno.

Ejemplo:

pregunta 1: Cuanto es 10 *5

a) 55

b) 10

c) 50

algo por el estilo, jeje. ahora bien aqui les dejo el código completo. Fue compilado y ejecutado en Dev C++ 4.9.9.2

el código no tiene errores, cualquier duda aquí estoy para aclararla. Saludos

Codigo C

Nivel: Principiante, Basico

#include <time.h>
#include <stdio.h>
#include <stdlib.h>
int main()
{
      char preguntas[80][100]={"pregunta", //AQui van preguntas
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta",
                             "pregunta"};
      char respuestas[80][3][60]={//aqui van respuestas
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},
                               {"R1","R2","R3"},

                               };
      int buenas[80]={1,2,0,1,2,1,2,0,1,2,1,2,0,1,2,1,2,0,1,2,
                      1,2,0,1,2,1,2,0,1,2,1,2,0,1,2,1,2,0,1,2,
                      1,2,0,1,2,1,2,0,1,2,1,2,0,1,2,1,2,0,1,2,
                      1,2,0,1,2,1,2,0,1,2,1,2,0,1,2,1,2,0,1,2};//aquie pones las respuestas correctas
      int i,j,k,pregun,pexiste,rexiste,bien,respondio;
      int pregunta[11];
      int respuesta[5];
      srand(time(NULL));//para que los numeros sean alazer siempre
      for(i=0;i<10;i++) //para 10 preguntas
      {
           do{
               pexiste=0;
               pregunta[i]=rand()%80;//selecciona lazar una pregunta
               if(i!=1)
               {
                       j=i;
                       for(j;j>(-1);j--)
                       {
                             if(pregunta[i]==pregunta[j-1])
                             {
                                 pexiste=1;
                             }
                       }
               }
           }while(pexiste==1);

          printf("\n%s %d\n",preguntas[pregunta[i]],pregunta[i]);//se imprime el enunciado de la pregunta

          for(k=0;k<3;k++)//se imprimen sus 3 posibles respuestas alazar
          {
                do{
                   rexiste=0;
                   respuesta[k]=(rand()%3);//selsciona lazar una posible respuesta

                   if(i!=1)
                   {
                           j=k;
                           for(j;j>(-1);j--)
                           {
                                 if(respuesta[k]==respuesta[j-1])//cuando ya se uso ya no se usa
                                 {
                                     rexiste=1;
                                 }
                           }
                   }
               }while(rexiste==1);
               printf("%d.- %s\t",k+1,respuestas[pregunta[i]][respuesta[k]]);//impprime la posibles respuesta
               if(k==buenas[pregunta[i]]) //calcula cual es numero de la respuesta buena
               {
                  bien=k;
               }

          }
          printf("Respuesta: ");
               scanf("%d",&respondio);
               if((respondio-1)==bien)//evalua si la respuesta fue la correcta
               {
                    printf("Correcto ");
               }
               else
               {
                   printf("Incorrecto ");
               }

      }

            system("pause");//pausa antes de salir del programa
            return 0;
}

Aunque se vea un poco apantallador 150 lineas de código es basura (bueno no basura pero…)
Esta en C aun que luego tratare de subirlo en C++, para que veamos un poco de POO.

Saludos.