Este documento presenta los conceptos básicos de la programación de videojuegos. Explica que los juegos se basan en la entrada, procesamiento y salida de datos, y provee un ejemplo de código pseudocódigo para un juego simple que mueve un personaje con las flechas del teclado.

1. Cpu 1
ai l
to
GI
UA J td .
e ui l
s o c
Po rmai d v e je o
rga c n e i o u g s
ó d
J 20
i 0x
a J v r eee R i
a i L tlr u
e i z

2. Capitulo
Conceptos básicos.
Durante la siguiente guía, se trabajaran los conceptos de la programación de video juego
comenzando desde lo simple para luego ir aumentando la dificultad. Los ejemplos dados
en esta guía serán escritos en un pseudo-código. Es decir, ninguno en especial, solamente
se toman las bases de un lenguaje de alto nivel, y se generalizan para dar una idea de
como deberia ser el codigo en distintos lenguajes. Este pseudo-codigo esta principalmente
basado en C/C++ por lo cual si programas en el sera aun más util.
Antes de comenzar con nuestra guía asumiremos que se tienen conocimientos avanzados
en algún lenguaje de programación, pero de todos modos intentaremos abarcar desde la
raíz los conceptos propios de los video juegos. Manos a la obra.
Lo primero que debemos saber, es como funciona un juego. Básicamente, las 3 reglas
básicas son la ENTRADA, el PROCESAMIENTO y la SALIDA, que se van agrupando de
distinta forma para ir creando la diversidad propia de los video juegos.
ENTRADA: En la entrada se llaman funciones encargadas de recibir información de los
controladores (como joystick, teclado, Mouse), y de asignar el estado de los botones o
teclas en las variables, para ver si fue apretado o no un botón.
PROCESAMIENTO: Es en este espacio donde se le da sentido a lo que se reciba en la
ENTRADA, y donde se procesa el juego en si. Un ejemplo de procesamiento, sería el
recibir la tecla “Enter” del teclado, y decirle al juego que entre al menú.

3. SALIDA: Es aquí donde se llama a rutinas encargadas de mostrar todo en pantalla,
además de reproducir música y sonidos, enviar datos (en el caso de un juego online), etc.
Ya sabemos la estructura mínima de un juego. Algunos programadores prefieren
especificar cada una de las áreas o espacio, generando 3 funciones madre llamadas
ENTRADA, PROCESAMIENTO y SALIDA, pero para mi gusto, es una limitación, porque
quita el dinamismo del código. Sin embargo, comenzaré ilustrando con estas funciones.
Implementación en pseudo-código:
Función Principal(argumentos externos)
{
Mientras (Usuario_No_Presione_ESC() )
{
Entrada()
Procesamiento()
Salida()
}
}
Esta es una plantilla de un juego simple, veremos como podemos desarrollarla.
Para ejemplificar, crearé un pequeño juego sin mucho sentido, en el cual se pueda mover
al personaje con las flechas por la pantalla.
En la función Entrada, debemos verificar si fueron presionadas las teclas, con el siguiente
pseudo-código (las variables booleanas deben estar definidas globalmente, es decir, fuera
de las funciones, para que puedan ser leídas desde cualquier sección):
Booleano izquierda, derecha, arriba, abajo = False
Entrada()
{
izquierda, derecha, arriba, abajo = False
Si (Usuario_presiona_izquierda() )
{
Izquierda = True

4. }
Si (Usuario_presiona_derecha() )
{
Derecha = True
}
Si (Usuario_presiona_arriba() )
{
Arriba = True
}
Si (Usuario_presiona_abajo() )
{
Abajo = True
}
}
Si ya saben por donde irá el código, notarán que no tiene eficiencia. Lo hago de esta
manera solo para demostrar y marcar el funcionamiento de las áreas.
El código, cuando es llamado, inicializa las 4 variables a “False”, luego pasa por
condiciones relativas a la pulsación de botones, y por cada uno asigna “True” si fue
presionado.
Sigamos con el área de procesamiento
Generaremos 2 variables enteras (deben ser globales, es decir, que puedan ser leídas
desde cualquier parte del código), que serán las coordenadas de nuestro personaje.
Entero x, y
X = 0
Y = 0
Procesamiento()
{
Si (Izquierda == True) Entonces
{
X = X – 1 // Se le resta 1 unidad al componente x de la
coordenada, para moverlo a la izquierda
}
Si (Derecha == True) Entonces
{
X = X + 1 // Se le suma 1 unidad al componente x de la
coordenada, para moverlo a la derecha
}
Si (Arriba == True) Entonces

5. {
Y = Y – 1 // Se le resta 1 unidad al componente y de la
coordenada, para moverlo hacia arriba
}
Si (Abajo == True) Entonces
{
Y = Y + 1 // Se le suma 1 unidad al componente y de la
coordenada, para moverlo hacia abajo
}
}
OBSERVACIÓN: Al contrario del trabajo con gráficos cartesianos, el eje Y está invertido.
Es decir, si sumamos unidades, “nos movemos hacia abajo”.
En el procesamiento, se lee el estado de cada tecla (definido con la función Entrada() ), y
se le asigna la acción (en este caso, actualizar las coordenadas).
Vamos ahora a la función de salida.
Salida()
{
Dibujar_en_pantalla_al_personaje_en_la_ubicación_x_e_y(X,Y)
}
Lo que hace esta función, es dibujar al personaje en pantalla (se puede implementar
simplemente en cualquier lenguaje de programación, conociendo alguna función de dibujo
en pantalla con coordenadas), en X e Y.
Una breve explicación del código final:
Recordemos el esquema básico de un juego simple:
Función Principal(argumentos externos)
{
Mientras (Usuario_No_Presione_ESC() )
{
Entrada()
Procesamiento()
Salida()
}
}
Mientras el usuario no presione la tecla ESC (o la tecla que se defina para el término de

6. ejecución), se repetirán las 3 funciones por ciclos. Llega a la función Entrada(), y se
inicializan las 4 variables (arriba, abajo, izquierda, derecha) a “False”. Luego, se comprueba
si alguna de las teclas fue presionada, y en el caso de ser así, se almacena la información
en las variables (con un “True”).
Luego, en Procesamiento() se analiza que teclas fueron presionadas, y se le aplica una
transformación en el eje para simular movimiento. ¿Cómo?
Si tenemos un ciclo que se repite varias veces por segundo, en el cual se muestra una
imagen en pantalla; y en cada ciclo, restamos 1 unidad a la coordenada X, veremos que el
personaje se “mueve” a la izquierda (el mismo efecto que se logra en una película de cine
antigua, que se giraba una cinta a gran velocidad, para mostrar varias imágenes por
segundo, generando la sensación de movimiento).
En la función Salida(), se muestra el personaje según las coordenadas (en el caso de que
fueran alteradas con respecto a las anteriores, generará el cambio de posición, que en
repetición generará movimiento).
La repetición cíclica de estas 3 funciones, nos ha ayudado a crear una simple base para un
próximo juego.
En los siguientes capítulos analizaremos características propias de los juegos (animación,
colisiones, dinamismo).