Anterior | Índice | Siguiente
Capítulo 1: Hola Mundo
Lenguaje: C#
Para: VS2003 / VS2005 / VS2008
Por Dark-N: hernaldog@gmail.com
Visita mi Blog


http://darknromhacking.com


Objetivo: Mostrar en pantalla el clásico "hola mundo". Primero usaremos Visual Studio 2003 con C# y con SDL .NET 4.0. Para ver un ejemplo del "Hola Mundo" en Visual Basic .NET ver este tutorial de la Página Oficial de Sdl.Net.

Lo primero es eliminar la clase que viene por defecto llamada "form1.cs" ya que nos sirve de mucho:



Agregar una nueva clase, que será nuestra ventana. Le llamaremos "cap1.cs":





Abrimos la clase que creamos y contendrá el siguiente código C#:

using System;

namespace cap1
{
    /// 
    /// Summary description for cap1.
    /// 
    public class cap1
    {
        public cap1()
        {
            //
            // TODO: Add constructor logic here
            //
        }
    }
}

Para empezar a programar, lo primero es hacer el "puente" para usar la referencia que hicimos a SdlDotNet, para esto se usa la instrucción using, también se debe hacer referencia a SdlDotNet.Sprites que nos permite manejar Sprites que son objetos que podemos mover en pantalla, palabras que se rendearán, etc, y a System.Drawing que nos permite definir puntos X,Y en pantalla para posicionar objetos:

using System;
using System.Drawing;
using SdlDotNet;
using SdlDotNet.Sprites;

Se debe cambiar el namespace a tutorial:

...
namespace tutorial
{
...

Ahora en el constructor se inicializa la ventana que mostrará el juego, que en nuestro caso solo mostrará un mensaje. El código que se debe colocar es el que configura la resolución y el que inicia el game-loop. El game-loop es un ciclo infinito que realiza todo juego, donde solo se preocupa de pintar en pantalla mientras la aplicación esté andando. Desde ahora no se hablará de pintar en pantalla, sino de hacer render en pantalla.

public class cap1
{
    public cap1()
    {
        //modo ventana, resolución 400x300
        Video.SetVideoModeWindow(400, 300);
        Events.Tick += new TickEventHandler(Events_Tick);
    }

    //game-loop
    private void Events_Tick(object sender, TickEventArgs e)
    {
    }
    ...

Lo que sigue es poner el código que se rendeará en el game-loop. Lo que se hace es esto:

...
private void Events_Tick(object sender, TickEventArgs e)
{

    // Limpar la pantalla (dejarla negra)
    Video.Screen.Fill(Color.Black);

    // aquí LOGICA del nuestro juego
    juego();

    // Se actualiza la pantalla siempre
    Video.Screen.Update();
}
...

Finalmente la lógica del juego, que solo es mostrar un texto (un objeto Sprite) en la pantalla (la pantalla es en verdad es un Surface). En SDL. NET los Sprites son simples objetos 2D que se pueden mover en pantalla, como un texto o una imagen.
Los Surfaces representan información gráfica. Puedes crear nuevas Surfaces o cargarlas de diferentes partes como de una imagen. En general un Surface es el "fondo" en el que actua un Sprite. La pantalla, lo que se ve negro en el fondo es el surface principal llamado Video.Screen.
Los Sprites igual pueden cargar otros Surfaces, como imagenes, asi los puedes mover ya que los Sprites tienen la propiedad X,Y.

...
// lógica de nuestro juego
private void juego() 
{
    //creamos una variable fuente, tamaño 18
    SdlDotNet.Font fuente = new SdlDotNet.Font("../../fuentes/ARIAL.TTF",18);
    
    //cremos un texto de color amarillo y le damos una posición 20,20
    TextSprite texto = new TextSprite("Hola Mundo", fuente, Color.Yellow, new Point(20,20));
    
    //se pinta en el Surface principal llamado Video.Screen
    texto.Render(Video.Screen);
}
...

Ya podemos mostrar en pantalla algo, lo único que falta es que podamos salir de la aplicación, para esto devemos manejar Evento del Teclado. Usaremos Events.KeyboardDown para registrar cuando una tecla se ejecute y hacer una función asociada a ese Evento que permita salir del juego:

...
public void Run()
{    
    //Agregamos Evento de presionar una tecla
    Events.KeyboardDown +=new KeyboardEventHandler(this.Keyboard);
    Events.Run();
}

private void Keyboard(object sender, KeyboardEventArgs e)
{    
    //Salimos del juego con tecla Escape o la tecla 'Q'
    if(e.Key == Key.Escape || e.Key == Key.Q)
    {
        Events.QuitApplication();
    }        
}
...

Finalmente debemos probar lo que hemos hecho, para esto primero se debe compilar la aplicación. En palabras sencillas, la compilación es la etapa en que construimos una salida a partir de los archivos fuentes, la salida puede ser un EXE, un DLL, etc. En nuestro caso, como es un juego ejecutable la salida es un EXE, por eso escogimos en un principio un proyecto tipo Windows Application.
El proceso es sencillo, se selecciona el proyecto con el 2do. botón del mouse y se escoge Rebuild:



Se compilará y en la ventana output que está abajo muestra la salida, si hubieron errores o si salió todo ok.



Como se ve en la imagen superior, debería decir que 1 elemento salió bien y que 0 elemento falló: 1 succeeded, 0 failed.
Con esto se generó la salida en la carpeta de Salida de cada proyecto llamada bin. La ruta completa es C:\SDL\cap1\bin\Debug, mira allí y verás el ejecutable:



Ahora es tiempo de Ejecutar lo que hemos hecho, para esto hay 2 maneras, simplemente ejecutar el tutorial.exe mostrado arriba, o en el mismo Visual Studio .NET usar el Modo Depuración/Debug al presionar F5 o el signo Play azul:



En ambos casos nos ejecutará nuestra aplicación:



Con escape sales de la aplicación.
La ventaja de usar el método de Debug (con F5) es que mientras se ejecuta el juego, puedes poner puntos de breakpoint en el código haciendo clic a la izquierda de la linea que deseas que se detenga la ejecución o con F9 sobre la línea, asi puedes detener la ejecución e ir paso a paso con F10. Esto sirve mucho para seguir la ejecución del juego y ver posibles errores:






Código fuente de este capítulo:

//Archivo: cap1.cs
//Autor: Dark-N
using System;
using System.Drawing;
using SdlDotNet;
using SdlDotNet.Sprites;


namespace tutorial
{
    public class cap1
    {
        public cap1()
        {
            //modo ventana, resolución 400x300
            Video.SetVideoModeWindow(400, 300);
            Events.Tick += new TickEventHandler(Events_Tick);
        }

        private void Events_Tick(object sender, TickEventArgs e)
        {

            // Limpar la pantalla (dejarla negra)
            Video.Screen.Fill(Color.Black);

            //aqui LOGICA del nuestro juego>
            juego();

            // Se actualiza la pantalla
            Video.Screen.Update();
        }

        // lógica de nuestro juego
        private void juego() 
        {
            //creamos una variable fuente, tamaño 18
            SdlDotNet.Font fuente = new SdlDotNet.Font("../../fuentes/ARIAL.TTF",18);
            
            //cremos un texto de color amarillo y le damos una posición 20,20
            TextSprite texto = new TextSprite("Hola Mundo", fuente, Color.Yellow, new Point(20,20));
            
            //se pinta en el Surface principal llamado Video.Screen
            texto.Render(Video.Screen);
            
        }        

        public void Run()
        {    
            Events.KeyboardDown +=new KeyboardEventHandler(this.Keyboard);
            Events.Run();
        }

        private void Keyboard(object sender, KeyboardEventArgs e)
        {    
            //Salimos del juego con tecla Escape
            if(e.Key == Key.Escape)
            {
                Events.QuitApplication();
            }        
        }

        [STAThread]
        public static void Main()
        {
            cap1 juego = new cap1();
            juego.Run();
        }
    }
    
}

Recuerda cambiarle el nombre al archivo tutorial.exe por otro mas representativo como cap1_hola_mundo.exe.

Estamos listos para pasar a aprender a usar Sprites con imágenes.

Fuentes: Bajar Proyecto VS2003 + SDL.NET 4.0 Cap 1 al 4.


Agregado: Usamos Visual Studio 2005 con SDL .NET 6.0

Así se ve el proyecto:


Guárdala en el disco para verla en su tamaño original.

El código fuente como se ve es distinto al anterior, esto es porque ahora usamos SDL .NET 6.0 y usamos también generics para el uso de Eventos en C#:

using System;
using System.Windows.Forms;
using System.Collections.Generic;
using System.Drawing; //colores
using System.Text;

using SdlDotNet;
using SdlDotNet.Graphics; //para sprites
using SdlDotNet.Core; //Eventos
using SdlDotNet.Graphics.Sprites;  //textos
using SdlDotNet.Input; //keyborad


namespace SDLNet_2005
{
    class HolaMundo
    {
        public HolaMundo()
        {}

        private Surface screen;

        private void Quit(object sender, QuitEventArgs e)
        {
            Events.QuitApplication();
        }

        private void Teclado(object sender, KeyboardEventArgs e)
        {
            switch (e.Key)
            {
                case Key.Escape:
                case Key.Q:
                    Events.QuitApplication();
                    break;
            }
        }


        //ciclo de juego (game-loop)
        private void Tick(object sender, TickEventArgs args)
        {
            //fondo negro
            screen.Fill(Color.Black);
            
            //texto con fuente
            SdlDotNet.Graphics.Font fuente = new SdlDotNet.Graphics.Font("../../fuentes/comic.TTF", 18);
            TextSprite texto = new TextSprite("hola mundo", fuente, Color.Yellow);
            texto.Center = new Point(screen.Width / 2, screen.Height / 2);
            screen.Blit(texto);
            
            screen.Update();
        }

        public void Run()
        {

            Video.WindowIcon(new Icon("../../imagenes/mario3.ico"));
            Video.WindowCaption = "SDL.NET - Hola Mundo";
            screen = Video.SetVideoMode(300, 400);

            Events.KeyboardDown += new EventHandler < KeyboardEventArgs >(this.Teclado);
            Events.Tick += new EventHandler < TickEventArgs >(this.Tick);
            Events.Quit += new EventHandler < QuitEventArgs >(this.Quit);
            Events.Run();
        }

        /// 
        static void Main(string[] args)
        {
            HolaMundo game = new HolaMundo();            
            game.Run();
            
        }
    }
}
Si le das F5 la salida es:



El proyecto completo usando VS 2005 bájalo desde aquí.

Agregado: Ahora con C# + Visual Studio 2008 usando SDL.NET SDK 6.0 con el Framework 2.0

Crea el proyecto de esta forma:


Cambia las propiedades del proyecto para que la salida sea de tipo Windows Application:


Asi se debe ver tu proyecto. Nota que las referencias que están en rojo las debes agregar:


Este es el Código fuente que es muy parecido al de VS 2005 por no decir igual:

//Archivo: HolaMundo.cs
//Autor: Dark-N
//fecha: 20-05-2009

using System;
using System.Collections.Generic; //para eventos y otras cosas
using System.Drawing; //colores

using SdlDotNet.Graphics; //para sprites
using SdlDotNet.Core; //Eventos
using SdlDotNet.Graphics.Sprites;  //textos
using SdlDotNet.Input; //keyborad

namespace SDLNet_VS2008
{
    class HolaMundo
    {       
        private Surface screen;

        private void Evento_Salir(object sender, QuitEventArgs e)
        {
            Events.QuitApplication();
        }

        private void Evento_Teclado(object sender, KeyboardEventArgs e)
        {            
            if (e.Key == Key.Escape)
                Events.QuitApplication();          
        }

        //ciclo de juego (game-loop)
        private void Evento_Tick(object sender, TickEventArgs args)
        {
            //fondo negro
            screen.Fill(Color.Black);

            //texto con fuente
            SdlDotNet.Graphics.Font fuente = new SdlDotNet.Graphics.Font("arial.TTF", 16);
            TextSprite texto = new TextSprite("¡Hola Mundo! con Framework 2.0 + C# + VS2008", fuente, Color.Yellow);
            texto.Center = new Point(screen.Width / 2, screen.Height / 2);
            screen.Blit(texto);

            screen.Update();
        }

        public void Run()
        {         
            Video.WindowCaption = "SDL.NET - Hola Mundo";
            screen = Video.SetVideoMode(400, 300);
            SdlDotNet.Core.Events.Fps = 60;

            SdlDotNet.Core.Events.KeyboardDown += new EventHandler < KeyboardEventArgs >(this.Evento_Teclado);
            SdlDotNet.Core.Events.Tick += new EventHandler < TickEventArgs >(this.Evento_Tick);
            SdlDotNet.Core.Events.Quit += new EventHandler < QuitEventArgs >(this.Evento_Salir);
            Events.Run();
        }

        static void Main()
        {
            HolaMundo game = new HolaMundo();
            game.Run();
        }
    }
}

Antes de compilar recuerda copiar la fuente ARIAL.TTF en el directorio bin/debug de tu aplicación. Si no la haces, se caerá la aplicación.

Compila el proyecto con F5 y debería ejecutarse la aplicación:


El proyecto completo usando VS 2008 bájalo desde aquí.


Anterior | Índice | Siguiente
Volver a Página Principal

blog comments powered by Disqus
2003 - 2018    La Web de Dark-N