Archivo

Archive for 27 junio 2008

Microsoft Environment

junio 27, 2008 Deja un comentario

En Microsoft creemos en el potencial del software y la tecnología para ayudar a las personas y las empresas de todo el mundo para fomentar la sostenibilidad del medio ambiente.

msenviroment

Para saber como Microsoft y muchos de sus socios utilizan las tecnologías innovadoras y prácticas responsables para abordar los retos medioambientales en todo el mundo, si quieren saber más de esto visiten la página de Microsoft Environment.

Además de que pueden ver un vídeo sobre los esfuerzos de Microsoft para mejorar el medio ambiente 🙂

URL:http://www.microsoft.com/environment/

Categorías:imagine cup, Microsoft

Descarga Microsoft Virtual PC 2007 SP1

junio 25, 2008 Deja un comentario

vpc Como ya lo saben Virtual PC permite mantener la compatibilidad de las aplicaciones de legado y personalizadas durante la migración para nuevos sistemas de operativos y aumenta la eficacia de apoyo, desarrollo y formación de personal.
Con Microsoft ® Virtual PC 2007, puede crear y ejecutar uno o más máquinas, cada uno con su propio sistema operativo, virtuales en un solo equipo. Esto le proporciona la flexibilidad necesaria para utilizar distintos sistemas operativos en un equipo físico.
Para obtener más información sobre las formas que puede utilizar máquinas virtuales, consulte Virtual PC online .
Esta actualización para Microsoft Virtual PC 2007 incluye soporte para los siguientes sistemas operativos de invitados y Físicos:

 

Soporte para Sistemas Operativos Invitados:

    Windows Vista® Ultimate Edition con Service Pack 1 (SP1)
    Windows Vista® Business Edition con Service Pack 1 (SP1)
    Windows Vista® Enterprise Edition con Service Pack 1 (SP1)
    Windows Server® 2008 Standard
    Windows XP Professional con Service Pack 3

Soporte para Sistemas Operativos Fisicos ó Host:

Windows Vista® Ultimate Edition con Service Pack 1 (SP1)
Windows Vista® Business Edition con Service Pack 1 (SP1)
Windows Vista® Enterprise Edition con Service Pack 1 (SP1)
Windows XP Professional con Service Pack 3

y puedes descargarlo desde ak

URL:http://www.microsoft.com/downloads/details.aspx?displaylang=es&FamilyID=28c97d22-6eb8-4a09-a7f7-f6c7a1f000b5

Categorías:Betas, Virtual PC

Vota por este blog desde Blog IT

junio 24, 2008 Deja un comentario

 

Si por cualquier motivo ingresas a este sencillo blog con frecuencia, ahora puedes dar un voto para que sea de los mejor Blogs de IT en México. Desde este sitio podrás dar apoyo y respaldo, razón por la  cual puedes proporcionar tu voto de respaldo por el Blog de https://mspnor.wordpress.com

Como ?

1. Ingresa a www.blogit.ms , registrate como miembro de este sitio, una vez registrado entra con tu cuenta de correo como usuario y tu password escogido para el sitio de BLOG IT.

2. Dirigirte a la sección “Vota Aquí” del sitio BLOG IT, selecciona la categoría de Microsoft Expression en la cual esta concursando y da tu voto por Norberto Rojas

Listo!!!

blogit

Categorías:Blogroll, Blogs

[WPF] Imágenes en 3D con Visual Studio 2008 y Expression Blend 2

junio 20, 2008 8 comentarios

En este pequeño tutorial aprenderemos como manipular las imágenes en 3D, para esto vamos a utilizar tanto Visual Studio 2008 y Expression Blend 2, así que vamos a iniciar. Lo primero que hacemos es crear un nuevo proyecto en VS 2008, de tipo WPF Aplication  con el nombre de Imagen3D, como se ve en la figura:

El segundo paso es crear una carpeta llamada Imágenes en donde colocaremos las imágenes a mostrar, para esto en el Explorador de soluciones, seleccionamos nuestro proyecto y damos clic-derecho->Add->New Folder, esto como se ve en la imágenes:

Dentro de esta carpeta colocaremos nuestras imágenes, es recomendable que renombremos  las mismas con nombres desde el 1has el numero de imágenes que queramos, para agregar los archivos a la carpeta, tenemos que dar clic-derecho en la carpeta->Add->Existing Item… y buscamos los archivos.

Para poder poder observar los archivos a agregar es necesario seleccionar que el tipo de archivos que queremos ver son imágenes, como se ve en la imagen:

Como les comente, es recomendable que el nombre de nuestras imágenes sea sencillo como un número, esto por comodidad, ya que utilizaremos este nombre dentro del código y de esta manera será más fácil, aunque sino lo cambian no hay problema, solo recuerden el nombre de sus imágenes, ok

ya que tenemos agregados nuestros archivos dentro de la carpeta Imagenes, ahora toca agregar una clase a nuestro proyecto, para esto al igual que la carpeta damos clic derecho en el nombre de nuestro proyecto->Add->Class y VS2008 automáticamente nos arranca con la clase, a esta clase la llamaremos CrearImagen y el primer paso en esta clase es agregar los namespaces necesario que son:

using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;

El primer paso en esta clase, es crear una instancia de la clase Image que se llama _miDatoActual y especificando que la clase es pública.

class CrearImagen { private static Image _miDatoActual = new Image(); }

Después creamos una variable pública de tipo Image y crear un getter que devuelva el valor de _miDatoActual

public static Image misImagenes { get { return _miDatoActual; } }

Luego Creamos una clase llamada Imagenes dentro de la casle CrearImagen

public class Imagenes : ObservableCollection<ImageData> { }

En este momento Visual Studio no sabe lo que un ObservableCollection, así que para que VS lo se entere, lo seleccionamos y damos clic-derecho->Resolve->System.Collections.ObjectModel

Creamos el constructor de la clase Images y declaramos la ruta de acceso de nuestras imágenes.

public class Images : ObservableCollection<ImageData>
{
public Images()
{
this.Add(new ImageData(@”Imagenes\1.jpg”));
this.Add(new ImageData(@”Imagenes\2.jpg”));
this.Add(new ImageData(@”Imagenes\3.jpg”));
this.Add(new ImageData(@”Imagenes\4.jpg”));
this.Add(new ImageData(@”Imagenes\5.jpg”)); } }

Creamos la clase de ImageData después de la clase de Imagenes y hacerla del tipo INotifyPropertyChanged. Esta clase se activará para cada imagen agregamos. También tendrá que tener esta clase de utilizar tal el System.ComponentModel como lo hicimos con la clase Imagenes y creamos una cadena privada que se llama _sNombreImagen.

public class ImageData : INotifyPropertyChanged { private string _sNombreImagen = “”; }

Crear el constructor de ImageData y pasar en sImagenName, que es la ruta de acceso
pasado de la clase Images. Creamos una variable llamada NombreImagen y le asignamos sImagenName la cual será pública y de tipo String. Por último creamos los getters y serters necesarios para establecer y definir el nombre de la imagen y la ruta en la que se encuentra con ayuda de un evento llamado NotifyPropertyChanged que definiremos más adelante, entonces el código de esta clase queda así:

public class ImageData : INotifyPropertyChanged
{
private string _sNombreImagen = “”;
public ImageData(string sNombreImagen)
{
NombreImagen = sNombreImagen;
}
public string NombreImagen
{
get { return _sNombreImagen; }
set { _sNombreImagen = value;
NotifyPropertyChanged(NombreImagen); } } }

Agregar el método PropertyChangedEventHandler y NotifyPropertyChanged dentro de la misma clase de ImageData

public event PropertyChangedEventHandler PropertyChanged;
protected void NotifyPropertyChanged(String sProp)
{
if (PropertyChanged != null)
{
PropertyChanged(this, new PropertyChangedEventArgs(sProp)); } }

Hasta este punto dejamos nuestra aplicación por el lado del código, regresaremos casi al final, ahora construimos nuestra solución presionando F6 y abrimos nuestro proyecto con Expression Blend 2. Todo esto sin cerrar VS 2008.

Lo primero es modificar el alto y ancho de nuestra ventana, que queda con 600 en Height y 800 en Width. Ahora con el objeto del Grid seleccionado en Objects and TimeLine en el panel de propiedades vamos a cambiar el Backgroung a GradientBrush. Así mismo cambiamos el color del Grid para tener una mejor apariencia como se ve en las figura.


Para obtener este color tenemos tres colores, azul, blanco y azul

Después creamos nuestro DataSource, para esto nos vamos al tag de Project y damos clic en +CTR Object. y en Add CLR Object Data Source seleccionamos CrearImagen

11

Automáticamente Expression Blend 2 nos crea dicho DataSource y lo podemos observar dentro del código XAML, dando clic en Split para ver el diseño y el código

<Window.Resources>
<ObjectDataProvider x:Key=”CrearImagenDS” ObjectType=”{x:Type Imagen3D:CrearImagen}” d:IsDataSource=”True”/>
</Window.Resources>

A continuación tenemos que agregar los controles que nos van a permitir seleccionar una imagen y visualizarla, con el Grid seleccionado buscamos un ComoBox que llamaremos miCB y un rectangulo que llamaremos ImagenPlana y los colocamos de las siguiente manera.


Si presionamos en este momento F5 nos podemos dar cuenta que nuestra aplicación aun es muy sencilla, pero veamos cómo ponerla un poco más interesante.

Guardamos nuestro proyecto en Expression Blend 2 y ahora trabajamos de nuevo con VS2008 en donde abrimos el archivo de Window1.xaml y en los Recursos creamos un DataTemplate que llamaremos ImagenDT que indicara al ComoBox que contenido mostrar, que en nuestro caso es la Imagen y el Textblock, la definición de DataTemplate es así:

<Window.Resources>
<DataTemplate x:Key=”ImagenDT”>
<StackPanel Orientation=”Horizontal”>
<Image Source=”{Binding Path=NombreImagen}” Height=”50″ Width=”50″/>
<TextBlock Text=”{Binding Path=NombreImagen}”/>
</StackPanel>
</DataTemplate> <ObjectDataProvider x:Key=”CrearImagenDS” ObjectType=”{x:Type Imagen3D:CrearImagen}” d:IsDataSource=”True”/>
</Window.Resources>

Dentro del código XAML localizamos el ComboBox y en la propiedad de ItemSource le indicamos que use misImagenes que se encuentra den CrearImagenDS, al igual le indicamos que use el DataTemplate que acabamos de crear, entones el código del miCB queda así:

<ComboBox HorizontalAlignment=”Left” Margin=”21.167,22,0,0″ VerticalAlignment=”Top” Width=”261.111″ Height=”51.389″ IsSynchronizedWithCurrentItem=”True” x:Name=”miCB” ItemsSource=”{Binding Path=misImagenes, Source={StaticResource CrearImagenDS}}” ItemTemplate=”{StaticResource ImagenDT}”>
<ComboBox.Background>
<LinearGradientBrush EndPoint=”0,1″ StartPoint=”0,0″>
<GradientStop Color=”#FF9DB6DA” Offset=”0″/>
<GradientStop Color=”#FF1F66CB” Offset=”0.996″/>
</LinearGradientBrush>
</ComboBox.Background>
</ComboBox>

Ahora si todo va bien, y ejecutamos nuestro proyecto nos aparece en el ComoboBox las fotos que tenemos en nuestra carpeta, y la aplicación se ve más o menos así:


Después de esto, tenemos que indicar que la imagen que seleccionemos se muestre dentro de nuestro rectángulo, y lo que tenemos que hacer es localizar nuestro rectángulo ImagenPlanta dentro del XAML y lo modificamos de manera que eliminamos el Fill y le indicamos que lo rellene con lo que seleccionamos.

<Rectangle Stroke=”#FF000000″ Margin=”229.055,108.499,110.611,84.667″ x:Name=”ImagenPlana”> <Rectangle.Fill>
<ImageBrush ImageSource=”{Binding Path=SelectedItem.NombreImagen, ElementName=miCB}”/>
</Rectangle.Fill>

</Rectangle>Ahora sí, si ejecutamos nuestro proyecto, podemos observar que la imagen que seleccionemos en él Como es la imagen que se muestra en el rectángulo, y se ve más o menos así:

Muy bien, ahora hagamos esto un poco más interesante, y pongamos varias opciones para que nos muestren las imágenes, entonces agregamos 3 radio butons del lado izq del rectángulo, con estas características:

<RadioButton HorizontalAlignment=”Left” Margin=”21.167,178,0,0″ VerticalAlignment=”Top” Width=”163.833″ Height=”33″ Content=”Imagen Plana (2D)” x:Name=”Imagen2DRB” IsChecked=”True”/>

<RadioButton HorizontalAlignment=”Left” Margin=”21.167,240,0,0″ VerticalAlignment=”Top” Width=”163.833″ Height=”29″ Content=”Imagen 3D” x:Name=”Imagen3DRB” IsChecked=”False”/>

<RadioButton HorizontalAlignment=”Left” Margin=”21.167,0,0,233″ VerticalAlignment=”Bottom” Width=”163.833″ Height=”38″ Content=”Animación 3D” x:Name=”Animacion3DRB” IsChecked=”False”/>

Ahora para trabajar con la segunda opción de la imagen en 3D, seleccionamos el rectángulo ImagenPlana y en el panel de Apariencia en la propiedad Visibility seleccionamos Collapsed para poder trabajar con otra imagen.

En Expreesion Blend 2 vamos al tag de Proyecto y en la carpeta de Imágenes, seleccionamos una y la arrastramos al Grid, con la imagen seleccionada damos clic en Tools -> Make Image 3D, por último deshabilitamos la opción de ClipToBounds en el panel de Apariencia.

Ya teniendo esto, seleccionamos el Viewport3D y damos doble clic sobre la imagen, para poder manipularla y la colocan en la posición que quieran, pueden rotarla en cualquiera de los 3 ejes (x,y,z), por ejemplo así:

Recuerden colocarle nombre a este Viewport3D, en mi caso lo llame Imagen3D. Dentro del código XAML buscamos el Viewport3D y modificamos su propiedad de diffusematerial como el siguiente código:

<DiffuseMaterial>
<DiffuseMaterial.Brush>
<ImageBrush ImageSource=”{Binding Path=SelectedItem.NombreImagen, ElementName=miCB}” Stretch=”Fill”/> </DiffuseMaterial.Brush>
</DiffuseMaterial>

También seleccionamos el Viewport3D llamado Imagen3D y en su propiedad visibility indicamos Collapsed, para trabajar con la última parte que será un Viewport3D con el nombre de cubo, y como es una explicación larga por el momento solo agregaremos el código, que se encuentra en un txt que podrán descargar desde aquí, este lo pegaran debajo del Viewport3D llamado Imagen3D, podemos observar cómo nos muestra un cubo, que es con el que trabajaremos una sencilla animación. Así que el código lo pegan aquí:

</Grid> en el proyeccto
<!–pegar aquí–>
</Grid>
</Window>

y podemos observar que si nos muestra una especie de cubo.


Ahora seleccionamos el Viewport3D llamado Animacion3D y cambiamos su propiedad de Visibility a Collapsed, por otro lado seleccionamos el Rectángulo llamado ImagenPlana al cual indicaremos su propiedad de Visibility en Visible. Ejecutamos nuestro proyecto presionando F5.

Pues bien hasta aquí, parece que todo va bien, ahora tenemos que darle funcionalidad a los Radio Buttons, para esto vamos a VS2008 y abrimos el archivo Window1.xaml.cs en donde agregaremos funcionalidad a cada uno de los eventos click de los botones, en donde solo indicaremos que se va a mostrar y que en cada uno de ellos, el código es el siguiente:

public partial class Window1 : Window
{
public Window1()
{
InitializeComponent(); Imagen2DRB.Click += new RoutedEventHandler(Imagen2DRB_Click);
Imagen3DRB.Click += new RoutedEventHandler(Imagen3DRB_Click); Animacion3DRB.Click += new RoutedEventHandler(Animacion3DRB_Click);
}

void Animacion3DRB_Click(object sender, RoutedEventArgs e)
{
Animacion3D.Visibility = Visibility.Visible;
ImagenPlana.Visibility = Visibility.Collapsed;
Imagen3D.Visibility = Visibility.Collapsed;
}

void Imagen3DRB_Click(object sender, RoutedEventArgs e)
{
Animacion3D.Visibility = Visibility.Collapsed;
ImagenPlana.Visibility = Visibility.Collapsed; Imagen3D.Visibility = Visibility.Visible;
}

void Imagen2DRB_Click(objectsender, RoutedEventArgs e)
{
Animacion3D.Visibility = Visibility.Collapsed;
ImagenPlana.Visibility = Visibility.Visible;
Imagen3D.Visibility = Visibility.Collapsed;
}
}

Si ejecutamos nuestro proyecto de nuevo presionando F5, podemos observar que ya funcionan nuestros radio Buttons, ahora solo resta hacer la animación de nuestro cubo, lo primero es poner como Visible nuestro cubo, luego damos clic en +Event y en +StoryBoard, a este último lo llamaremos AnimacionCubo, como se ve en las siguientes figuras:

Ahora pongan atención, seleccionamos la línea en el segundo 0, vamos a manipular sus propiedades de transformación cada 2 segundos, tanto de la posición en X, Y y del ángulo

Los valores completos son los siguientes:

Segundo 0 X=90, Y=0, Angle=-40
Segundo 2 X=-90, Y=0, Angle= 40
Segundo 4 X=0, Y=45, Angle=-180
Segundo 6 X=0, Y=0, Angle=0

Ya para terminar, solo falta indicarle que esto lo haga todo el tiempo, para esto solo seleccionamos el AnimacionCubo y en la propiedad RepeatBehavior asignamos Forever, cerramos el StoryBoard llamado AnimacionCubo y listo, tenemos nuestro proyecto listo, ahora podemos observar cómo es que funciona. (Recuerden poner el último viewport3D en Collapsed y el Rectángulo en Visible). Espero que les sea de utilidad este pequeño tutoría. Como producto final tenemos algo como esto:

Puedes descargar el código aquí

[Tips – XNA] Detección de Colisones

junio 19, 2008 1 comentario

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.

image image

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

Categorías:Games, Tips, XNA

[Tips – XNA] Cargar y Manipular Sonidos

junio 19, 2008 Deja un comentario

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:

image image

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.

             image

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

image image

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.

       image

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:

    image

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.

Categorías:Games, Tips, XNA

[Tips – XNA] Escribir Texto en XNA

junio 19, 2008 Deja un comentario

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”

image image

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:

          image

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.

Categorías:Games, Tips, XNA