martes, 10 de mayo de 2016

Curso de Juegos (4)

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.




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.

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 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 VideoJuegos

  1. 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 ----------------------------------------------------------------------



http://profesorponce.blogspot.com.ar/p/libros-publicados.html

No hay comentarios:

Publicar un comentario