Curso programación de videojuegos - Leccion 01 ~ ProfesorPonce (Home)

Curso se Programación de VideoJuegos en PureBasic
Lección 01: Estructura básica de un programa de videojuego

La diferencia principal entre un programa convencional y un videojuego se basa en que en un programa tradicional el software espera la intervención del usuario para seguir los trazos de ejecución programados para cada evento.

En un videojuego, si bien se espera la intervención del usuario, hay muchos eventos que se producen y que deben tenerse en cuenta, así como procesos que corren y que determinan que el programa refresque datos permanentemente y controle resultados.

El programa debe controlar movimientos de enemigos, trayectorias, procesos, actualizar la información de las interfaces, etc. Muchos videojuegos tienen numerosas rutinas de ejecución automáticas además de las acciones que decide el operador humano.

En lo primero que vamos a pensar, es en el FLUJO DE UN PROGRAMA.

Sin entrar en demasiados detalles clásicamente existen dos tipos de flujo que permiten ejecutar las instrucciones individualmente:

Los programas de ejecución lineal. Aclaremos que en realidad, en lenguaje máquina todos los programas son de ejecución linea por línea y que la omisión, el salto y la búsqueda de subrutinas y funciones son en realidad saltos controlados por eventos o variables. Pero ahora nos referimos al alto nivel de un lenguaje.

En el alto nivel, los viejos programas DOS los programas CONSOLA permiten iniciar el programa declarando funciones, rutinas variables y constantes para luego comenzar comienzan la ejecución del código instrucción por instrucción hasta terminar en la instrucción final para terminar saliendo del programa al sistema operativo.

En el medio del principio y fin, contamos con instrucciones, llamadas a funciones y subrutinas pero finalmente se llega al final.

Para evitar llegar al final, se requiere que el programador establezca instrucciones repetitivas para crear un bucle infinito pero con salida controlada para que el usuario pueda terminar o para que un evento culmine con la ejecución. En caso de no hacerlo, la ejecución del programa se hace lineal y culmina con un programa que se cierra y devuelve el control al sistema operativo que lo ejecuta.

Adicionalmente el bucle implementado debe controlar eventos para poder generar las respuestas adecuadas (selecciones del usuario, captura de errores, imprevistos, bots, enemigos, etc).

Este tipo de estructuras y flujos venían bien en entornos unitareas en donde el CPU trabajaba con un programa por vez y esta era la estructura más elegida por los primeros compiladores. Los programas podían ser lineales o incorporaban bucles de ejecución a la espera de las decisiones del usuario.

Pero cuando apareció Windows y los entornos visuales (Linux, MacOS, etc), se hizo necesario crear estructuras de soporte porque los entornos y sistemas operativos comenzaron a trabajar de un modo diferente para permitir la ejecución multi-hilo y la apertura de varias ventanas de programas que se ejecutaban simultáneamente.

En un entorno visual (GUI) la ejecución de tareas se realiza de un modo diferente porque los programas se ejecutan en bucles infinitos y se requiere que por cada aplicación se abra un proceso que debe ser controlado por el bucle sin fin del propio sistema operativo.

Es entonces que los programas incorporan en algunos lenguajes el bucle MAIN (o equivalente), que deberá ser vinculado al bucle main del propio sistema operativo en el que se ejecute el programa.

En el caso de nuestro curso, en el que usaremos el lenguaje PureBasic, este bucle estará representado por la estructura REPEAT/UNTIL que contendrá dentro de sí todas las rutinas prioritarias que se deberán ejecutar durante el videojuego.

En el caso del lenguaje PureBasic, un programa tiene un comportamiento lineal semejante a los programas DOS. Se ejecuta linealmente hasta terminar.

Para evitar que termine, el programador debe implementar el bucle REPEAT para iniciar un bucle que debe controlarse mediante la captura de diferentes EVENTOS.

El primer programa que vamos a construir ahora comienza por un bloque de instrucciones iniciales en el que se deben declarar las enumeraciones, algunas variables clave, generar la ventanas y controles y agregar la detección de teclas mediante las instrucciones AddKeyboardShortcut.

; bloque de enumeracion
Enumeration
;xxxxxx
EndEnumeration

; variables

ks.l=0 ; ks = keyboard shortcut
#FLAGS = #PB_Window_SystemMenu | #PB_Window_ScreenCentered | #PB_Window_MinimizeGadget |

#PB_Window_MaximizeGadget

; generación de ventana y controles principales
OpenWindow(#Ventana_Principal, x, y, 450, 300, "Base de Juego", #FLAGS) ; ventana principal
TextGadget(#CAPTURA, 40, 40, 140, 25, "Tecla........") ; label que indicara que te cla se presionó

AddKeyboardShortcut(#Ventana_Principal,#PB_Shortcut_Left, 101)
AddKeyboardShortcut(#Ventana_Principal,#PB_Shortcut_Up, 102)
AddKeyboardShortcut(#Ventana_Principal,#PB_Shortcut_Right, 103)
AddKeyboardShortcut(#Ventana_Principal,#PB_Shortcut_Down, 104)
AddKeyboardShortcut(#Ventana_Principal,#PB_Shortcut_Escape, 105)

Repeat
   ;estructura de ducle principal
   ;control del sprite
   ;estructura de captura de eventos de tecla presionada
   ;derivación a rutinas según la tecla presionada

Until ;repetición hasta que usuario termine el programa con ESCAPE o (X)

End ;fin del programa

Los eventos son capturados dentro de una estructura REPEAT-UNTIL

Cuando una tecla es capturada, el programa ejecutará un conjunto de instrucciones específico según la tecla presionada

La idea general del primer programa es

Crear un programa básico (esqueleto) para nuestro juego. Luego avanzaremos sobre programas con sprites pero en esta etapa inicial veremos como se trabaja en una estructura mínima que servirá de base a nuestros desarrollos.

Permitirle al usuario controlar las teclas de movimiento del cursos para drle la idea de cómo se debe emplear algunas técnicas de programación dentro de PureBasic.