Curso “Programación de Juegos”
Curso Gratuito.
Entrega 4.
El flujo de los programas
Este no pretende ser un curso académico de programación, sino un curso práctico que pretende ayudar a los programadores a definir las estructuras más importantes de un programa que les permitan crear rutinas de soporte para videojuegos.
Como también está pensado para programadores, vamos a cambiar un poco el modo de abordar los problemas.
En lo primero que vamos a pensar, es en el FLUJO DE UN PROGRAMA (vea el primer grafico de la nota).
Sin entrar en demasiados detalles clásicamente existen dos tipos de flujo que permiten ejecutar las instrucciones individualmente:
1) 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, lenguajes como Qbasic (que usaremos en la mayoría de los ejemplos de este curso) permiten iniciar el programa (declarando funciones, rutinas variables y constantes) y luego 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, llamadas a subrutinas pero finalmente se llega al final.
Para evitar llegar al final, se requiere que el programador establezca una instrucción de repetición para crear un bucle infinito pero controlado para que el usuario pueda terminar el programa.
Adicionalmente el bucle debe controlar eventos para poder generar las respuestas adecuadas (selecciones del usuario, errores, imprevistos, etc)
Este tipo de esctructuras y flujos venían bien en entornos uni-tareas porque el CPU trabajaba con un programa por vez y corresponde a la estructura más elegida por los primeros compiladores.
En un entorno visual como windows en sus versiones 1.0 a 3.11 o incluso a sus versiones windows 95,98 y ME, la ejecución de tareas se realiza de un modo diferente: los entornos visuales son en realidad programas que se ejecutan en bucles infinitos hasta que el usuario decide terminar la ejecución del entorno (apagar windows) y se requiere que por cada aplicación ejecutada por el usuario (ventana) se abra un proceso que debe ser controlado por el bucle sin fin del sistema operativo, inaugurando así el proceso de multitarea. Es entonces que los compiladores incorporan el bucle MAIN, que deberá ser enlazado al bucle main del sistema operativo.
Si bien Qbasic trabaja con la primer estructura, no hay ningún inconveniente en la posibilidad de crear una estructura de bucle sin fin para la ejecución de nuestros programas de ejemplo.
La estructura principal
2) Permitirle al usuario controlar con las teclas del cursor una carácter que podra mover libremente por la pantalla como si fuera un pequeño sprite. La técnica que emplearemos será la misma que permite controlar objetos de gran tamaño o gráficos, pero iniciando ahora con una muy pequeña cantidad de información que debe ser controlada y procesada.
3) Definir las áreas por las que el pequeño sprite-carácter puede moverse libremente. Para ello delimitaremos un tamaño en la pantalla, que deberá respetar el sprite-carácter y los controles del usuario.
4) Mover el sprite-carácter y verificar que todo se haga del modo correcto.
Bloque de declaraciones:
1. Introducción
2. A quienes va dirigido el curso
3.Temario del curso / Herramientas
4.Primer programa (codigo fuente)
Curso Gratuito.
Entrega 4.
El flujo de los programas
Este no pretende ser un curso académico de programación, sino un curso práctico que pretende ayudar a los programadores a definir las estructuras más importantes de un programa que les permitan crear rutinas de soporte para videojuegos.
Como también está pensado para programadores, vamos a cambiar un poco el modo de abordar los problemas.
En lo primero que vamos a pensar, es en el FLUJO DE UN PROGRAMA (vea el primer grafico de la nota).
Sin entrar en demasiados detalles clásicamente existen dos tipos de flujo que permiten ejecutar las instrucciones individualmente:
1) 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, lenguajes como Qbasic (que usaremos en la mayoría de los ejemplos de este curso) permiten iniciar el programa (declarando funciones, rutinas variables y constantes) y luego 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, llamadas a subrutinas pero finalmente se llega al final.
Para evitar llegar al final, se requiere que el programador establezca una instrucción de repetición para crear un bucle infinito pero controlado para que el usuario pueda terminar el programa.
Adicionalmente el bucle debe controlar eventos para poder generar las respuestas adecuadas (selecciones del usuario, errores, imprevistos, etc)
Este tipo de esctructuras y flujos venían bien en entornos uni-tareas porque el CPU trabajaba con un programa por vez y corresponde a la estructura más elegida por los primeros compiladores.
2) Pero cuando apareció windows y los entornos visuales con posibilidad de establecer multitareas (ejecutar más de un programa por vez), 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.
En un entorno visual como windows en sus versiones 1.0 a 3.11 o incluso a sus versiones windows 95,98 y ME, la ejecución de tareas se realiza de un modo diferente: los entornos visuales son en realidad programas que se ejecutan en bucles infinitos hasta que el usuario decide terminar la ejecución del entorno (apagar windows) y se requiere que por cada aplicación ejecutada por el usuario (ventana) se abra un proceso que debe ser controlado por el bucle sin fin del sistema operativo, inaugurando así el proceso de multitarea. Es entonces que los compiladores incorporan el bucle MAIN, que deberá ser enlazado al bucle main del sistema operativo.
Si bien Qbasic trabaja con la primer estructura, no hay ningún inconveniente en la posibilidad de crear una estructura de bucle sin fin para la ejecución de nuestros programas de ejemplo.
La estructura principal
El programa que vamos a construir ahora comienza por:
Un bloque de instrucciones en el que se deben declarar las funciones, subrutinas y las variables empleadas
Un segundo bloque de instrucciones para dibujar la pantalla
Una estructura do-loop que generará el bucle infinito controlado que en su interior tendrá instrucciones para controlar los eventos y permitirá salir controladamente según la decisión del usuario
La idea general del primer programa es
1) Crear un programa en baja resolución (solo texto) para nuestro juego. Luego avanzaremos sobre programas gráficos, pero en esta etapa inicial veremos como se trabaja en una pantalla de baja resolución con técnicas que se usan también en entornos gráficos, pero que en definitiva son iguales, con la diferencia de cantidad de información que se procesa. En pantalla de caracteres la cantidad de información procesada es mínima.
Un segundo bloque de instrucciones para dibujar la pantalla
Una estructura do-loop que generará el bucle infinito controlado que en su interior tendrá instrucciones para controlar los eventos y permitirá salir controladamente según la decisión del usuario
La idea general del primer programa es
1) Crear un programa en baja resolución (solo texto) para nuestro juego. Luego avanzaremos sobre programas gráficos, pero en esta etapa inicial veremos como se trabaja en una pantalla de baja resolución con técnicas que se usan también en entornos gráficos, pero que en definitiva son iguales, con la diferencia de cantidad de información que se procesa. En pantalla de caracteres la cantidad de información procesada es mínima.
2) Permitirle al usuario controlar con las teclas del cursor una carácter que podra mover libremente por la pantalla como si fuera un pequeño sprite. La técnica que emplearemos será la misma que permite controlar objetos de gran tamaño o gráficos, pero iniciando ahora con una muy pequeña cantidad de información que debe ser controlada y procesada.
3) Definir las áreas por las que el pequeño sprite-carácter puede moverse libremente. Para ello delimitaremos un tamaño en la pantalla, que deberá respetar el sprite-carácter y los controles del usuario.
4) Mover el sprite-carácter y verificar que todo se haga del modo correcto.
Bloque de declaraciones:
Variables c, f
Variables c y f enteras (fila y columna) que permiten saber cual es la posición actual del sprite-carácter en pantalla. Estas variables deben ser monitorizadas permanentemente por el programa para saber si se intenta salir de los límites de la pantalla que se han definido para el movimiento del sprite-carácter.
Se inicia el programa con posición en fila12, columna 40
DIM c AS INTEGER
DIM f AS INTEGER
c = 40
f = 12
Variable KeyPress
Variable KeyPress string que me indica en todo momento la tecla que el usuario ha presionado. El bucle verificará si es una tecla válida y procesará la acción cuando corresponda. En esta primer versión de nuestro juego, las teclas válidas con las cuatro teclas de cursos (para movimientos del usuario), y las teclas ESC (escape) y S (para salir) que facilitan que el juego termine.
DIM KeyPress AS STRING
Constantes MnFila, MxFila, MnCol, MxCol
La pantalla de baja resolución de texto está limitada a las columnas y filas definidas en estas variables. Con ellas, delimitamos el tablero de juego en la pantalla. Todos los movimientos de pantalla deben controlar que estos límites no sean excedidos por los movimientos del sprite-carácter
CONST MnFila = 3
CONST MxFila = 20
CONST MnCol = 1
CONST MxCol = 80
Variables c y f enteras (fila y columna) que permiten saber cual es la posición actual del sprite-carácter en pantalla. Estas variables deben ser monitorizadas permanentemente por el programa para saber si se intenta salir de los límites de la pantalla que se han definido para el movimiento del sprite-carácter.
Se inicia el programa con posición en fila12, columna 40
DIM c AS INTEGER
DIM f AS INTEGER
c = 40
f = 12
Variable KeyPress
Variable KeyPress string que me indica en todo momento la tecla que el usuario ha presionado. El bucle verificará si es una tecla válida y procesará la acción cuando corresponda. En esta primer versión de nuestro juego, las teclas válidas con las cuatro teclas de cursos (para movimientos del usuario), y las teclas ESC (escape) y S (para salir) que facilitan que el juego termine.
DIM KeyPress AS STRING
Constantes MnFila, MxFila, MnCol, MxCol
La pantalla de baja resolución de texto está limitada a las columnas y filas definidas en estas variables. Con ellas, delimitamos el tablero de juego en la pantalla. Todos los movimientos de pantalla deben controlar que estos límites no sean excedidos por los movimientos del sprite-carácter
CONST MnFila = 3
CONST MxFila = 20
CONST MnCol = 1
CONST MxCol = 80
Variables string dimensionadas Screen$(4 TO 19)
Es un array de variables que contienen el dibujo de la pantalla para la zona
del tablero.
Inicialmente no tienen contenido, pero en otras versiones de este
mismo programa, agregaremos elementos para que colisione el sprite-carácter.
Abarcan un total de 16 filas de caracteres que van desde la columna 1 a la 80.
· Variable aux integer
Es una variable auxiliar que se usa en el bucle for-next para imprimir la
pantalla del juego con las variables Screen$(x)
'=================================================================================
'Bloque de pantalla
'Sección que define las
variables que contienen el dibujo de la pantalla (Screen$())
'y dibuja la pantalla inicial
del programa
'=================================================================================
'Dibujar pantalla inicial
CLS
LOCATE 1, 1
PRINT "Nuestro primer
programa de juegos"
LOCATE 2, 1
PRINT
"--------------------------------------------------------------------------------"
Screen$(4) = " "
Screen$(5) = "
"
Screen$(6) = "
"
Screen$(7) = "
"
Screen$(8) = "
"
Screen$(9) = " "
Screen$(10) = "
"
Screen$(11) = "
"
Screen$(12) = "
"
Screen$(13) = "
"
Screen$(14) = " "
Screen$(15) = "
"
Screen$(16) = "
"
Screen$(17) = "
"
Screen$(18) = "
"
Screen$(19) = "
"
LOCATE 21, 1
PRINT
"--------------------------------------------------------------------------------"
LOCATE 23, 1
PRINT
"-----------------------------------Presiona [ESC] o [S] para salir del
juego----"
'Imprimir fondo de pantalla
FOR aux = MnFila + 1 TO MxFila
- 1
LOCATE aux, 1
PRINT Screen$(aux)
NEXT aux
'=================================================================================
'Bloque del bucle infinito
contrtolado del programa
'Sección que el bucle do-loop
que permite trabajar al programa hasta que el usuario
'presiona la tecla S o ESC
'=================================================================================
'Bucle principal del programa
DO
'===============================================================
'detectar la tecla
presionada
KeyPress =
UCASE$(INKEY$) 'espera por la tecla
presionada por el usuario y la
'asigna a KeyPress
'observe las rutinas de
detecci¢n de teclas detenidamente:
'cada vez que el usuario
decide mover el caracter-sprite elegido,
'el programa hace lo
siguiente:
'
' 1.Valida el movimiento
del usuario para asegurarse que el
' ese movimiento no se salga de los limites definidos
del
' escenario (Constantes MnFila, MxFila, MnCol
y MxCol)
' Esto se define en cada doble condicion AND
que debe
' cumplirse para que el programa realice el
movimiento:
'
'
IF KeyPress = CHR$(0) + CHR$(72) AND f > MnFila THEN
'
' 2.Si el movimiento se
realiza dentro de los limites del
' escenario, el programa procede a borrar la
presencia
' actual del caracter-sprite en la pantalla
posicionando
' al cursos en la fila y columna actual para
eliminar la
' presencia del caracter [+]:
'
' LOCATE f, c 'se posiciona en pantalla
' PRINT " " 'borra el carater
'
' 3.Una vez borrada la
pantalla, ahora deber calcular la nueva
' posici¢n del caracter-sprite para dibujarla
en la pantalla
' porque en caso contrario, el caracter-sprite
desapareceria
' de la pantalla. Esto se hace con las lineas:
'
' f = f - 1 'al mover arriba
' f = f + 1 'al mover abajo
' c = c - 1 'al mover a la izquierda
' c = c + 1 'al mover a la derecha
'
' con esto se concreta el bloque pirncipal de
calculo para
' cada tecla seleccionada que se evalua con la
doble condicion
' IF+AND para cada caso.
'
' 4.Finalmente, al haberse
validado y calculado el movimiento y
' adem s de borrar la presencia del
caracter-sprite, se debe
' proceder a redibujar al caracter-sprite en
la nueva posicion
' en pantalla. Esto se hace fuera de las
condiciones IF
' Vaya al final de la condicion IF (por debajo
del END IF)
' para ver este 4 paso final
'
'===============================================================
'si la tecla presionada es
una tecla de cursor...
IF KeyPress = CHR$(0) + CHR$(72) AND f >
MnFila THEN
'Tecla de cursor: Movimiento
arriba
'solo entra a estas
instrucciones si la fila actual es mayor que el límite minimo
'de la fila de pantalla
definida. Por eso se ha colocado el AND. Se deben cumplir
'las dos condiciones:
'1.se presiono la tecla
fecha arriba
'2.a la variable f se le
puede restar una unidad sin que sea menor a MnFila
LOCATE f, c 'se posiciona en el lugar actual del
caracter-sprite
PRINT " " 'refresca la pantalla borrando el
caracter-sprite actual
f = f - 1
'mueve al caracter-sprite una linea hacia "arriba"
ELSEIF KeyPress = CHR$(0) + CHR$(80) AND f <
MxFila THEN
'Tecla de cursor:
Movimiento abajo
'solo entra a estas
instrucciones si la fila actual es menor que el límite máximo
'de la fila de pantalla
definida. Por eso se ha colocado el AND. Se deben cumplir
'las dos condiciones:
'1.se presiono la tecla
fecha abajo
'2.a la variable f se le
puede sumar una unidad sin que salga del valor de MxFila
LOCATE f, c 'se posiciona en el lugar actual del
caracter-sprite
PRINT " " 'refresca la pantalla borrando el
caracter-sprite actual
f = f + 1 'mueve al caracter-sprite una linea hacia
"abajo"
ELSEIF KeyPress = CHR$(0) + CHR$(75) AND c > MnCol THEN
'Tecla de cursor: Movimiento
izquierda
'solo entra a estas
instrucciones si la columna actual es mayor que el límite mínimo
'de la columna de
pantalla definida. Por eso se ha colocado el AND. Se deben cumplir
'las dos condiciones:
'1.se presiono la tecla
fecha izquierda
'2.a la variable c se le
puede restar una unidad sin que su valor sea menor a MnCol
LOCATE f, c 'se posiciona en el lugar actual del
caracter-sprite
PRINT " " 'refresca la pantalla borrando el
caracter-sprite actual
c = c - 1 'mueve al caracter-sprite una columna
hacia la "izquierda"
ELSEIF KeyPress = CHR$(0) + CHR$(77) AND c <
MxCol THEN
'Tecla de cursor: Movimiento
derecha
'solo entra a estas
instrucciones si la columna actual es menor que el límite máximo
'de la columna de
pantalla definida. Por eso se ha colocado el AND. Se deben cumplir
'las dos condiciones:
'1.se presiono la tecla
fecha derecha
'2.a la variable c se le
puede sumar una unidad sin que su valor exceda MxCol
LOCATE f, c 'se posiciona en el lugar actual del
caracter-sprite
PRINT " " 'refresca la pantalla borrando el
caracter-sprite actual
c = c + 1 'mueve al caracter-sprite una columna
hacia la "derecha"
'===============================================================
'si la tecla presionada es
ESC (escape)
ELSEIF KeyPress = CHR$(27)
THEN EXIT DO 'si presiona ESC sale del bucle y
'termina el programa
END IF
'===============================================================
'si la tecla presionada no
es ninguna de las programadas, sigue
'actualizando los datos de
informacion de pantalla
LOCATE 1, 1
PRINT "Puntos";
Puntos; " "
LOCATE 22, 1
PRINT "Posicion
Fila"; f; " Columna"; c; "
"
'Dibuja nuestro
'caracter-sprite'
LOCATE f, c
PRINT "+"
LOOP UNTIL KeyPress = "S"
END
Cuando corra el programa, verá que el movimiento del carácter-cursor es
muy fluído y no
requiere de una gran carga para el microprocesador.
----------------------------------------------------------------------
Curso Gratuito de Programación de VideoJuegos1. Introducción
2. A quienes va dirigido el curso
3.Temario del curso / Herramientas
4.Primer programa (codigo fuente)
5.Detectando colisiones y comiendo objetos
6.Eliminando el bug de nuestro programa
7.Juego completo "El Minero"
8.La I.A. ( Inteligencia artificial ) en los juegos
9.La generación de bots enemigos en el juego
6.Eliminando el bug de nuestro programa
7.Juego completo "El Minero"
8.La I.A. ( Inteligencia artificial ) en los juegos
9.La generación de bots enemigos en el juego
----------------------------------------------------------------------
Por Ricardo Ponce
Links de Interés:
Cursos de Formación Profesional
Toda la oferta de cursos
Libros Gratuitos para Usted
Nuestro Canal YouTube
Toda la oferta de cursos
Libros Gratuitos para Usted
Nuestro Canal YouTube
