Programación Aplicada - Tema 2

PROGRAMACIÓ

N

APLIC

ADA

TEMA 2

– DESARROLL

O DE V

IDEOJU

EGOS

Pontificia Universidad Católica Madre y MaestraVicerrectoría AcadémicaFacultad Ciencias de las IngenieríasIngeniería en Sistemas y Computación - ISC

DESARROLLO DE VIDEOJUEGOS

El juego es una actividad que se utiliza para la diversión y el disfrute de los participantes, en muchas ocasiones, incluso como herramienta educativa.

Los juegos normalmente se diferencian del trabajo y del arte, pero en muchos casos estos no tienen una diferenciación demasiado clara.

¿Qué es un juego?¿Qué es un juego?


Según la RAE: Ejercicio recreativo sometido a reglas en el cual se gana o se pierde.

Según Huizinga (1987): El juego es una acción u ocupación libre, que se desarrolla dentro de unos límites temporales y espaciales determinados, según reglas absolutamente obligatorias, aunque libremente aceptadas, acción que tiene fin en sí misma y va acompañada de un sentimiento de tensión y alegría y de la conciencia de -ser de otro modo- que en la vida corriente.

Concepto de JuegoConcepto de Juego


La humanidad ha jugado desde siempre, incluso los animales lo hacen; por eso el juego se considera previo a la cultura misma; existen innumerables manifestaciones de esta actividad en sociedades de todos los tiempos y se cuenta con muchas obras de arte donde se aprecian estas manifestaciones lúdicas.

Historia de los JuegosHistoria de los Juegos


Si nos remontamos al pasado, podemos encontrar en la literatura y el arte antiguo pruebas que nos indican que jugar no es un invento de nuestros días.

Un ejemplo muy palpable seria la forma en que jugaban las tribus primitivas, se podía ver que el juego dependía mucho de lo que hacían en su diario vivir y también era una forma de supervivencia.

En Grecia tenemos el ejemplo ineludible de los juegos griegos que son sin duda los Juegos Olímpicos. Pensadores clásicos como Platón y Aristóteles ya daban una gran importancia al aprender jugando, y animaban a los padres para que dieran a sus hijos juguetes que ayudaran a «formar sus mentes» para actividades futuras como adultos.



En la Edad Media el juego tenía escasa reglamentación y una estructura sencilla, y se utilizaban pocos objetos. La mayor parte se realizaban al aire libre, rudimentarios, lentos y sin pasión por el resultado. Pero años más tarde cuando surge el renacimiento todo cambia drásticamente, ya se había desligado muchas cosas de lo religioso, los juegos populares y tradicionales adquieren fuerza, justifican y refuerzan la posición de clase que los practica o que los contempla.

En tiempos más recientes el juego ha sido estudiado e interpretado de acuerdo a los nuevos planteamientos teóricos que han ido surgiendo en Psicología de Piaget (1932, 1946, 1962, 1966) que ha destacado tanto en sus escritos teóricos como en sus observaciones clínicas la importancia del juego en los procesos de desarrollo.



Platón (uno de los primeros en reconocer el valor práctico del juego) establece que los niños utilicen manzanas para aprender mejor las matemáticas.

También dice que los niños de tres años que más tarde serán constructores se sirvan de útiles auténticos pero de tamaño reducido.



Aristóteles menciona:

“hasta la edad de cinco años, tiempo en que todavía no es bueno orientarlos a un estudio, ni a trabajos coactivos, a fin de que estos no impida el crecimiento se les debe no obstante permitir movimientos para evitar la inactividad corporal; y este ejercicio puede obtenerse por varios sistemas, especialmente por el juego”.



Teorías sobre el juego:

-La teoría del exceso de energía (Herbert Spencer).

Sirve para gastar el sobrante de energía.

-La teoría de la relajación (Lazarus).

Sirve para relajar a los individuos.

-La teoría de la recapitulación (G.S. Hall).

El niño realiza actividades de sus ancestros.

-La teoría del pre-ejercicio (Karld Groos).

Es necesario para la maduración y el crecimiento.



Tipos de juegosTipos de juegos


Es un software creado para el entretenimiento en general y basado en la interacción entre una o varias personas y un aparato electrónico que ejecuta dicho videojuego.

Estos sistemas electrónicos son llamados “plataformas”. Ej.:, podemos mencionar computadores personales y consolas de videojuegos.

¿Qué es un videojuego?¿Qué es un videojuego?


La palabra videojuegos está dividida en dos partes, video y juego, donde juego es el acto en el cual una o varias personas se entretienen y video es el visualizador de gráficos o medio en el cual se graban las imágenes y los sonidos.

Entendemos por videojuegos a todo tipo de juego digital interactivo o software creado para el entretenimiento en general y basado en la interacción entre una o varias personas y un aparato electrónico que ejecuta dicho videojuego. Este dispositivo electrónico puede ser una computadora, un sistema arcade, una videoconsola o un teléfono móvil, los cuales son conocidos como plataformas. En muchos casos, estos recrean entornos y situaciones virtuales en los cuales el jugador puede controlar a uno o varios personajes (o cualquier otro elemento de dicho entorno), para conseguir uno o varios objetivos por medio de unas reglas determinadas.



Todo videojuego posee un medio de entrada usado para ser manipulado e interactuar con este, esta entrada se le conoce como Controlador de Juego y varía dependiendo de la plataforma que se utilice. Un ejemplo claro de esto pudiera ser un controlador de consola, el cual consistiría en un botón y una palanca de mando o varios botones y palancas en caso de ser otra plataforma.



En el año 1947 fue la primera vez que se concibió la idea de un videojuego al patentarla por Thomas T. Goldsmith, Jr. y Estle Ray Mann.

No fue hasta el 1952 cuando apareció el primer videojuego ejecutado en una computadora Edsac, en la universidad de Cambridge, llamado OXO. Fue desarrollado por Alexander S. Douglas, para una ilustración de su tesis de doctorado.

Historia de los videojuegosHistoria de los videojuegos


Era un tic-tac-toe simulado usando como controlador un teléfono de rotación. Se juega contra la computadora, en un tubo de rayos catódicos de 35x16 píxeles.

No tuvo gran auge debido a que las computadoras EDSAC eran exclusivas para la universidad de Cambridge.



El segundo video juego permitía jugar Tennis de mesa entre dos jugadores. Fue desarrollado en el 1958 por William Higinbotham en su lugar de trabajo (Brookhave National Laboratory, una institución gubernamental).



Se ejecutaba usando un osciloscopio como monitor conectado a una computadora analógica.

Tenía el objetivo de entretener a los visitantes, usando una línea horizontal y otra pequeña céntrica vertical a modo de red, para simular la pista.



Cooperación: Tipo de juego en que es necesario cooperar con otros personajes o jugadores para completar los objetivos.

Acción: Los videojuegos de este género consisten básicamente en eliminar enemigos. El contenido tiende a ser violento. Entre estos se encuentran los juegos como vigilante 8 y Grand Theft Auto.

Cartas: Como bien dice su nombre, en este tipo de videojuegos el protagonista juega con cartas.

Disparos: En los cuales el protagonista debe abrirse el camino a base de disparos. Según la temática y desarrollo pueden clasificarse en diferentes subgéneros como disparos en primera persona o tercera persona. Algunos juegos de primera persona son: Quake, Halo, Call of Duty, Medal of Honor y Counter Strike. En tercera persona podemos mencionar también: Max Payne, Metal Gear yGears of War.

Tipos de VideojuegosTipos de Videojuegos


Aventura: Son videojuegos en los que el protagonista debe avanzar interactuando con diversos personajes y objetos. Entre este género podemos mencionar: Mario, Legend of Zelda, God of War, Batman, entre otros.

Educativos: Son videojuegos cuyo objetivo es dar a conocer al usuario algún tipo de conocimiento.

Estrategia: Se caracterizan por la necesidad de manipular a un numeroso grupo de personajes, objetos o datos para lograr los objetivos, en los cuales nos encontramos con: Age of Empires, Starcraft, Imperium, entre otros.

Lucha: Son videojuegos basados en el combate cuerpo a cuerpo.



Rol: Donde el protagonista interpreta un papel y ha de mejorar sus habilidades mientras interactúa con el entorno y otros personajes. Se suelen también caracterizar por que las decisiones de tu personaje influyen en su futuro próximo.

Simulación: Involucran al jugador en una situación simulada determinada. Entre estos se pueden citar Combat Flight Simulator, SimCity o Los Sims.

Deportivo: Son videojuegos basados en el mundo del deporte ya sea de NBA, Tennis, Futbol Americano, Beisbol, entre otros.

Carreras: Son videojuegos en los que se manejan diferentes vehículos, ya sean reales o ficticios, para ganar en diferentes carreras. Entre ellos podemos mencionar: Grand Turismo, Midnight Club, Mario Kart, Need for Speed.


Características básicas de un videojuegoResumen:

1. Escenario.

2. Elementos estáticos y dinámicos.

3. Reglas del juego.

Desarrollo de Desarrollo de videojuegosvideojuegos

Estructura de un videojuego.

A. Características de los Videojuegos.

B. Arquitectura de un Videojuego.

C. Secuencia General de un

Videojuego.

D. Secuencia Lógica de un

Videojuego.

E. Secuencia de Estados de un

VideoJuego.

Resumen:


Estructura de un videojuego.

A. Características de los VIDEOJUEGOS

1. Funciona en tiempo real.

2. Siempre se está realizando acciones como:

a. Dibujar los objetos.

b. Actualizar coordenadas.

c. Determinar colisiones.

d. Mover objetos.

3. Se ejecuta independiente la interacción del usuario.

4. Responde ante eventos de periféricos como teclado,

mouse, controles de juego.


Estructura de un videojuego.B. Arquitectura de un VIDEOJUEGO.

RECURSOS

•Gráficos: texturas,

modelos, sprites, secuencias

cinemáticas, etc.

•Sonidos: efectos de

sonido, música, etc.

•Ficheros de datos:

configuración, salvas de

juegos, mapas, etc.

RECURSOS

Estado del Juego

Entrada Salida


3. Estructura de un videojuego.

B. Arquitectura de un VIDEOJUEGO.

INTERFACES

•Gestión de

entradas: teclado,

ratón, joystick, etc.

•Gestión de

salidas: pantalla,

información a otros

jugadores, etc.

RECURSOS

Estado del Juego

Entrada Salida


3. Estructura de un videojuego.B. Arquitectura de un VIDEOJUEGO.

LOGICA•Lógica de comportamiento: actualiza los elementos del juego según las acciones de los jugadores y las reglas del juego (vidas, matar enemigos, capturar objetos, etc.)

•Lógica del juego: gestiona la secuencia del juego (gráficos, entradas, salidas, sonido).

RECURSOS

Estado del Juego

Entrada Salida


3. Estructura de un videojuego.B. Arquitectura de un VIDEOJUEGO.

ESTADO DEL JUEGO

Estructuras de datos en memoria que guardan el estado actual del juego.

RECURSOS

Estado del Juego

Entrada Salida


3. Estructura de un videojuego.C. Secuencia General de un VIDEOJUEGO.

ESTRUCTURA

LOGICA

Inicialización

• Cargar drivers

gráficos

• Cargar drivers de

sonido

• Iniciar modo

gráfico

Secuencia Lógica

• Bucle que realiza

las

acciones que rigen la

dinámica del juego


3. Estructura de un videojuego.

D. Secuencia Lógica de un VIDEOJUEGO.

Lógica de Comportamien

toMovimientos de objetos

Movimientos de jugadores

Música y Sonido

Renderización





Música y Sonido

Renderización

INICIALIZACION

•Reserva de memoria

necesaria

•Inicializan las variables del

juego

•Abrir y cargar ficheros

(mapas)

•Cargar imágenes, sonidos y

vídeos

•Inicializar variables de

jugadores

•(vidas, armas, etc.)





Música y Sonido

Renderización

GESTION DE ENTRADAS

•Procesar teclado•Procesar ratón•Procesar joystick u otros dispositivos





Música y Sonido

Renderización

LOGICA DE COMPORTAMIENTO

•Captura de ítems•Detección de colisiones•Actualización de variables del juego y jugadores





Música y Sonido

Renderización

MOVIMIENTOS DE OBJETOS

•Mover objetos y enemigos•Rotación de objetos y enemigos•Actualizar estado de los objetos





Música y Sonido

Renderización

MOVIMIENTOS DE JUGADORES

•Procesar variables de cada jugador(movimiento, vidas, energía, etc.)





Música y Sonido

Renderización

MUSICA Y SONIDO

•Actualizar variables de efectos de sonido•Iniciar, parar, terminar efectos de música





Música y Sonido

Renderización

RENDERIZACION

•Dibujar los objetos a partir de modelos, sprites, etc.





Música y Sonido

RenderizaciónACCIONES POST-JUEGO

Comprobaciones del estado del juego: si hay pausa, animación, finalización del juego, etc.


3. Estructura de un videojuego.E. Secuencia de Estados de un VIDEOJUEGO.

FN JUGAR


4. Bucle del Juego y Gestión del Tiempo.

Game_Init()

Game_Update()

Game_Render()

Game_Deinit()

CICLO DE EJECUCION

Frame

Duración estándar: 0.016s -> 60 fps

Duración Superior a 0.032 -> 30 fps

SE PIERDE LA ILUSION DE ANIMACION


4. Bucle del Juego y Gestión del Tiempo.

Duración Frames

Características

de las computado

ras

determinan

Fórmula: Espacio = Velocidad * Tiempo

Se debe medir el tiempo que ha transcurrido desde la ultima ejecución del UPDATE() y mover los objetos en el juego una distancia proporcional al tiempo transcurrido.

Solución


4. Bucle del Juego y Gestión del Tiempo.1- Incluir en el fichero de cabeceras: windows.h

2- Enlazar el proyecto con la librería winmm.lib

3- Modificar el main()…int liLastTime = timeGetTime();int liActualTime;float lfTimeStep;while ( ! Game_HasFinish( & sGAME) ){

liActualTime= timeGetTime();lfTimeStep = (float)(liActualTime-liLastTime)/1000.0;liLastTime=liActualTime;

Game_Update(& sGAME, lfTimeStep);Game_Render(& sGAME);

}…


5. Gestor de los dispositivos de entrada.

Tipos de control de entrada

1.Orientada a Eventos: Cada vez que el estado del dispositivo cambia, la librería lo notifica en forma de un evento.

2.Por Encuesta: Nuestro juego pregunta cada cierto tiempo sobre el estado del dispositivo.

Tipos de dispositivos de entrada

Teclado, Ratón, Joystick, etc.



Librería portable diseñada para la programación aplicada a videojuegos y multimedia, originalmente desarrollada por Shawn Hargreaves empleando una mezcla entre el lenguaje C y assembler.

Bucle del Juego y Gestión del TiempoBucle del Juego y Gestión del Tiempo


#include <allegro.h>

int main(){

allegro_init();

install_keyboard();

set_gfx_mode( GFX_AUTODETECT, 640, 480, 0, 0);

textout_ex(screen, font, "Hola, divertido mundo!", 230, 240, makecol(255, 0, 0), makecol(0, 0, 0));

readkey();

return 0;

}

END_OF_MAIN();


¡Hola mundo!1- Inicialización de Allegro y preparación del teclado.

2- Cambio de resolución de la pantalla.

3- Presentación de un mensaje.



int x = 10;

int y = 10;

int main(){

allegro_init();

install_keyboard();

set_gfx_mode(GFX_AUTODETECT, 640, 480, 0, 0);

while(!key[KEY_ESC]){

// BUCLE PRINCIPAL DEL JUEGO.

}

return 0;

}

END_OF_MAIN();

Bucle del Juego y Gestión del TiempoBucle del Juego y Gestión del TiempoEntrada y Salida1- Arreglo de etiquetas key.

2- Limpiar el caché del teclado.

3- Preparar y liberar el procesamiento en la pantalla.

4- Pausar la ejecución del hilo actual.


while(!key[KEY_ESC]){

clear_keybuf();

acquire_screen();

textout_ex(screen, font, " ", x, y, makecol(0, 0, 0), makecol(0, 0, 0));

if(key[KEY_UP]) --y;

else if(key[KEY_DOWN]) ++y;

else if (key[KEY_RIGHT]) ++x;

else if (key[KEY_LEFT]) --x;

textout_ex(screen, font, "@", x, y, makecol(255, 0, 0), makecol(0, 0, 0));

release_screen();

rest(50);

}

Bucle del Juego y Gestión del TiempoBucle del Juego y Gestión del TiempoEntrada y Salida1- Arreglo de etiquetas key.

2- Limpiar el caché del teclado.

3- Preparar y liberar el procesamiento en la pantalla.

4- Pausar la ejecución del hilo actual.



KEY_A - KEY_Z, KEY_0 - KEY_9, KEY_0_PAD - KEY_9_PAD, KEY_F1 - KEY_F12,

KEY_ESC, KEY_TILDE, KEY_MINUS, KEY_EQUALS, KEY_BACKSPACE, KEY_TAB, KEY_OPENBRACE, KEY_CLOSEBRACE, KEY_ENTER, KEY_COLON, KEY_QUOTE, KEY_BACKSLASH, KEY_BACKSLASH2, KEY_COMMA, KEY_STOP, KEY_SLASH, KEY_SPACE,

KEY_INSERT, KEY_DEL, KEY_HOME, KEY_END, KEY_PGUP, KEY_PGDN, KEY_LEFT, KEY_RIGHT, KEY_UP, KEY_DOWN,

KEY_SLASH_PAD, KEY_ASTERISK, KEY_MINUS_PAD, KEY_PLUS_PAD, KEY_DEL_PAD, KEY_ENTER_PAD,

KEY_PRTSCR, KEY_PAUSE,

KEY_ABNT_C1, KEY_YEN, KEY_KANA, KEY_CONVERT, KEY_NOCONVERT, KEY_AT, KEY_CIRCUMFLEX, KEY_COLON2, KEY_KANJI,

KEY_LSHIFT, KEY_RSHIFT, KEY_LCONTROL, KEY_RCONTROL, KEY_ALT, KEY_ALTGR, KEY_LWIN, KEY_RWIN, KEY_MENU, KEY_SCRLOCK, KEY_NUMLOCK, KEY_CAPSLOCK

KEY_EQUALS_PAD, KEY_BACKQUOTE, KEY_SEMICOLON, KEY_COMMAND



int main()

{

allegro_init();

install_keyboard();


acquire_screen();

clear_to_color(screen, makecol(255, 255, 255));

putpixel(screen, 5, 5, makecol(128, 200, 23));

circle(screen, 20, 20, 10, makecol(255, 0, 0));

circlefill(screen, 50, 50, 25, makecol(0, 255, 0));

rect(screen, 70, 70, 90, 90, makecol(0, 0, 255));

rectfill(screen, 100, 100, 120, 120, makecol(12, 34, 200));

line(screen, 130, 130, 150, 150, makecol(255, 0, 0));



floodfill(screen, 140, 135, makecol(213, 79, 40));

triangle(screen, 200, 200, 200, 220, 220, 210, makecol(213, 79, 40));

release_screen();

readkey();

return 0;

}

END_OF_MAIN();

Bucle del Juego y Gestión del TiempoBucle del Juego y Gestión del TiempoFiguras Geométricas1- Resetear color.

2- Funciones para dibujar: Píxeles, círculos, rectángulos, líneas y triángulos.

3- Funciones para rellenar de color y dibujar figuras coloreadas.



BITMAP *xSprite;

BITMAP *oSprite;

int main()

{

allegro_init();

install_keyboard();

set_color_depth(16);


xSprite = load_bitmap("x.bmp", NULL);

oSprite = load_bitmap("o.bmp", NULL);

acquire_screen();

// AQUÍ IRÍAN LAS FUNCIONES PARA DIBUJAR.

release_screen();

readkey();

return 0;

}

END_OF_MAIN();

Bucle del Juego y Gestión del TiempoBucle del Juego y Gestión del TiempoSprites1- Capturar los archivos BMP de entrada.

2- Punteros a Bitmap.

3- Cambiar la densidad de colores.

4- Cargar imágenes BMP en la pantalla.

5- Dibujar Sprites.






draw_sprite(screen, xSprite, 0, 0);

draw_sprite(screen, oSprite, 200, 0);








Bucle del Juego y Gestión del TiempoBucle del Juego y Gestión del TiempoSprites1- Capturar los archivos BMP de entrada.

2- Punteros a Bitmap.

3- Cambiar la densidad de colores.

4- Cargar imágenes BMP en la pantalla.

5- Dibujar Sprites.



#include <cstdlib>

int x = 100;

int y = 100;

int tempX = 100;

int tempY = 100;

int dir = 1; // Esto es para identificar la dirección de los círculos.

// 1: arriba a la izquierda, 2: abajo a la izquierda,

// 3: arriba a la derecha, 4: abajo a la derecha.

void moverCirculo();

int main()

{

allegro_init();

install_keyboard();



while(!key[KEY_ESC])

{

moverCirculo();

}

return 0;

}

END_OF_MAIN();


Animaciones1- Uso de funciones con Allegro.

2- Uso del concepto de aleatoriedad.

3- Pestañeos.


void moverCirculo()

{

tempX = x;

tempY = y;

if(dir == 1 && x != 20 && y != 20) {

--x;

--y;

}

else if (dir == 2 && x != 20 && y != 460){

--x;

++y;

}

else if (dir == 3 && x != 620 && y != 20){

++x;

--y;

}

else if (dir == 4 && x != 620 && y != 460){

++x;

++y;

}

else{

dir = rand() % 4 + 1;

}

acquire_screen();

circlefill(screen, tempX, tempY, 20, makecol(0, 0, 0));

circlefill(screen, x, y, 20, makecol(128, 255, 0));

release_screen();

rest(10);

}


Animaciones1- Uso de funciones con Allegro.

2- Uso del concepto de aleatoriedad.

3- Pestañeos.



#include <cstdlib>

int x = 100;

int y = 100;

int tempX = 100;

int tempY = 100;

int dir = 1; // Esto es para identificar la dirección de los círculos.

// 1: arriba a la izquierda, 2: abajo a la izquierda,

// 3: arriba a la derecha, 4: abajo a la derecha.

BITMAP *buffer; // Caché temporal para usarlo como el Bitmap principal (double buffer);

void moverCirculo();

int main(){

allegro_init();

install_keyboard();



buffer = create_bitmap(640, 480);

while(!key[KEY_ESC])

moverCirculo();

return 0;

}

END_OF_MAIN();


Animaciones1- Aplicación del concepto “Double Filtering” (filtrado doble).


void moverCirculo()

{

tempX = x;

tempY = y;

if(dir == 1 && x != 20 && y != 20){

--x;

--y;

}

else if (dir == 2 && x != 20 && y != 460){

--x;

++y;

}

else if (dir == 3 && x != 620 && y != 20){

++x;

--y;

}

else if (dir == 4 && x != 620 && y != 460){

++x;

++y;

}

else{

dir = rand() % 4 + 1;

}

acquire_screen();

circlefill(buffer, tempX, tempY, 20, makecol(0, 0, 0));

circlefill(buffer, x, y, 20, makecol(128, 255, 0));

draw_sprite(screen, buffer, 0, 0);

release_screen();

rest(10);

}


Animaciones1- Aplicación del concepto “Double Filtering” (filtrado doble).


if (xmin1 < xmax2 && ymin1 < ymax2 && xmin2 < xmax1 && ymin2 < ymax1) {

/* Colisionan los objetos */

}

Detección de ColisionesDetección de Colisiones

Colisiones estilo “caja”



BITMAP* caja;

BITMAP* buffer;

// Estas variables son para tener la posición del jugador.

// En vez de usar píxeles, usaremos la posición del arreglo 2D.

int x = 15;

int y = 11;

int tempX = 15;

int tempY = 11;

// Esta variable es para saber la cantidad de cajas fuera de los hoyos.

int cajas;


Fondos1- Técnica para gestionar fondos de pantalla.


// Este será la matriz para el fondo. 1 = nubes, 2 = ladrillos, 3 = piso, 4 = hoyo.

int mapa[24][32] = {{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},

{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},

{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},

{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},

{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},

{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},

{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},

{1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,1,1,1,1,1,1,1,1,1,1,1},

{1,1,1,1,1,1,1,1,1,1,2,3,3,3,3,3,3,3,3,3,2,1,1,1,1,1,1,1,1,1,1,1},

{1,1,1,1,1,1,1,1,1,1,2,3,3,3,3,4,3,3,3,3,2,1,1,1,1,1,1,1,1,1,1,1},

{1,1,1,1,1,1,1,1,1,1,2,3,3,3,3,3,3,3,3,3,2,1,1,1,1,1,1,1,1,1,1,1},

{1,1,1,1,1,1,1,1,1,1,2,3,3,3,3,3,3,3,3,3,2,1,1,1,1,1,1,1,1,1,1,1},

{1,1,1,1,1,1,1,1,1,1,2,3,3,3,3,3,3,3,3,3,2,1,1,1,1,1,1,1,1,1,1,1},

{1,1,1,1,1,1,1,1,1,1,2,3,3,3,3,3,3,3,3,3,2,1,1,1,1,1,1,1,1,1,1,1},

{1,1,1,1,1,1,1,1,1,1,2,3,3,3,3,3,3,3,3,3,2,1,1,1,1,1,1,1,1,1,1,1},

{1,1,1,1,1,1,1,1,1,1,2,3,3,3,3,3,3,3,3,3,2,1,1,1,1,1,1,1,1,1,1,1},

{1,1,1,1,1,1,1,1,1,1,2,3,3,3,3,3,3,3,3,3,2,1,1,1,1,1,1,1,1,1,1,1},

{1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,1,1,1,1,1,1,1,1,1,1,1},

{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},

{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},

{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},

{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},

{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},

{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}};




// Esta matriz es para guardar todos los objetos. 100 = jugador, 101 = caja

int objMap[24][32] = {{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},

{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},

{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},

{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},

{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},

{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},

{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},

{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},

{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},

{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},

{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},

{0,0,0,0,0,0,0,0,0,0,0,0,0,101,0,100,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},

{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},

{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},

{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},

{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},

{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},

{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},

{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},

{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},

{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},

{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},

{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},

{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};




void init_juego(){

buffer = create_bitmap( 640, 480);

caja = load_bitmap( "box.bmp", NULL);

cajas = 1;

for (int i = 0; i <= 24; i++){

for( int t = 0; t <= 32; t++){

if( mapa[i][t] == 1) rectfill( buffer, t * 20, i * 20, (t + 1) * 20, (i + 1) * 20, makecol( 128, 255, 255));

else if( mapa[i][t] == 2) rectfill( buffer, t * 20, i * 20, (t + 1) * 20, (i + 1) * 20, makecol( 255, 128, 0));



}

}

for (int i = 0; i <= 24; i++){

for( int t = 0; t <= 32; t++){

if( objMap[i][t] == 100) circlefill( buffer, (t * 20) + 10, (i * 20) + 10, 10, makecol( 255, 255, 0));

else if( objMap[i][t] == 101) draw_sprite( buffer, caja, t * 20, i * 20);

}

}

draw_sprite( screen, buffer, 0, 0);

}




void moverJugador(){

tempX = x;

tempY = y;

if ( key[KEY_UP] && mapa[y - 1][x] == 3){

if( objMap[y - 1][x] != 101){

--y;

} else if( objMap[y - 1][x] == 101 && mapa[y - 2][x] == 3 || objMap[y - 1][x] == 101 && mapa[y - 2][x] == 4){

if (mapa[y - 2][x] == 4) --cajas;

objMap[y - 2][x] = 101;

draw_sprite( buffer, caja, x * 20, (y - 2) *20);

--y;

}

} else if ( key[KEY_DOWN] && mapa[y + 1][x] == 3){

if( objMap[y + 1][x] != 101){

++y;

} else if( objMap[y + 1][x] == 101 && mapa[y + 2][x] == 3 || objMap[y + 1][x] == 101 && mapa[y + 2][x] == 4){

if (mapa[y + 2][x] == 4) --cajas;

objMap[y + 2][x] = 101;

draw_sprite( buffer, caja, x * 20, (y + 2) *20);

++y;

}




} else if ( key[KEY_RIGHT] && mapa[y][x + 1] == 3){

if( objMap[y][x + 1] != 101){

++x;

} else if( objMap[y][x + 1] == 101 && mapa[y][x + 2] == 3 || objMap[y][x + 1] == 101 && mapa[y][x + 2] == 4){

if (mapa[y][x + 2] == 4) --cajas;

objMap[y][x + 2] = 101;

draw_sprite( buffer, caja, (x + 2) * 20, y * 20);

++x;

}

} else if ( key[KEY_LEFT] && mapa[y][x - 1] == 3){

if( objMap[y][x - 1] != 101){

--x;

} else if( objMap[y][x - 1] == 101 && mapa[y][x - 2] == 3 || objMap[y][x - 1] == 101 && mapa[y][x - 2] == 4){

if (mapa[y][x - 2] == 4) --cajas;

objMap[y][x - 2] = 101;

draw_sprite( buffer, caja, (x - 2) * 20, y * 20);

--x;

}

}

acquire_screen();

rectfill( buffer, tempX * 20, tempY * 20, (tempX + 1) * 20, (tempY + 1) * 20, makecol( 255, 0, 0));

circlefill( buffer, (x * 20) + 10, (y * 20) + 10, 10, makecol( 255, 255, 0));


release_screen();

objMap[tempY][tempX] = 0;

objMap[y][x] = 101;

if ( !cajas){

textout_ex( screen, font, "You Win!!!", 320, 240, makecol(0, 0, 255), makecol(0, 0, 0));

}

rest(100);

}




} else if ( key[KEY_LEFT] && mapa[y][x - 1] == 3){

if( objMap[y][x - 1] != 101){

--x;

} else if( objMap[y][x - 1] == 101 && mapa[y][x - 2] == 3 || objMap[y][x - 1] == 101 && mapa[y][x - 2] == 4){

if (mapa[y][x - 2] == 4) --cajas;

objMap[y][x - 2] = 101;

draw_sprite( buffer, caja, (x - 2) * 20, y * 20);

--x;

}

}

acquire_screen();

rectfill( buffer, tempX * 20, tempY * 20, (tempX + 1) * 20, (tempY + 1) * 20, makecol( 255, 0, 0));

circlefill( buffer, (x * 20) + 10, (y * 20) + 10, 10, makecol( 255, 255, 0));


release_screen();

objMap[tempY][tempX] = 0;

objMap[y][x] = 101;

if ( !cajas){

textout_ex( screen, font, "You Win!!!", 320, 240, makecol(0, 0, 255), makecol(0, 0, 0));

}

rest(100);

}




int main(){

allegro_init();

install_keyboard();



init_juego();

while( !key[KEY_ESC]){

moverJugador();

}

return 0;

}

END_OF_MAIN();





BITMAP* buffer;

int cursor_x = 20;

int cursor_y = 20;

void getMouseInfo(){

if(mouse_b & 1){

cursor_x = mouse_x;

cursor_y = mouse_y;

}

}

void updateScreen(){

circlefill ( buffer, cursor_x, cursor_y, 20, makecol( 0, 0, 255));


}


Mouse


int main(){

allegro_init();

install_mouse();

install_keyboard();




show_mouse(buffer);

while( !key[KEY_ESC]){

getMouseInfo();

updateScreen();

}

return 0;

}

END_OF_MAIN();


Mouse



BITMAP* buffer;

int cursor_x = 20;

int cursor_y = 20;

int getMouseInfo(){

if(mouse_b & 1){

cursor_x = mouse_x;

cursor_y = mouse_y;

return 1;

}

return 0;

}

void updateScreen(){

show_mouse(NULL);

circlefill ( buffer, cursor_x, cursor_y, 5, makecol( 0, 0, 255));


}


Mouse


int main(){

allegro_init();

install_mouse();

install_keyboard();




show_mouse(screen);

while( !key[KEY_ESC])

{

int switcher=1;

while(getMouseInfo())

{

updateScreen();

if(getMouseInfo()==0) switcher=0;

}

if(switcher==0) show_mouse(screen);

}

return 0;

}

END_OF_MAIN();


Mouse


Origen: 1992, por Mark Segal y Kurt Akeley.

Es una especificación estándar multi-lenguaje y multi-plataformas para desarrollar aplicaciones que produzcan gráficos de computadoras en 2D y 3D escrito en el lenguaje C.

La interface consiste en más de 250 llamadas de funciones distintas que pueden ser usadas para dibujar escenas tridimensionales complejas partiendo de sencillos recursos.

Conociendo la especificación OpenGLConociendo la especificación OpenGL


En los años 1980’s era todo un desafío desarrollar software que aprovechara la diversidad de hardware gráfico. Resultaba muy costoso y había mucha duplicidad de esfuerzos.

A principios de los años 1990’s, Silicon Graphics con su API IRIS GL eran los líderes en gráficos para Workstations, debido a su facilidad de implementación y renderizado inmediato (no usando double-buffering) el cual permitía a los programadores un mayor control de la pantalla.

Conociendo la especificación OpenGL - Conociendo la especificación OpenGL - HistoriaHistoria


Sin embargo, ya empezaba a surgir una serie de competidores (Sun Microsystems, Hewlett-Packard e IBM) con otros hardware en 3D empleando el otro estandar disponible en la fecha, llamado PHIGS.

Frente a esto, SGI tomó la iniciativa de convertir el API IRIS GL a código abierto (OpenGL) para romper las barreras del licenciamiento y patentes y permitir a más desarrolladores y fabricantes de Hardware 3D explotar los potenciales de esta API.

Esto resultó exitoso, hasta el 1995 cuando Microsoft lanzó Direct3D, principal competidor de OpenGL.



El 17 de diciember del 1997, Microsoft y SGI iniciaron el proyecto Fahrenheit, con el propósito de unificar OpenGL con las interfaces de Direct3D.

Poco tiempo después, en el 1998, Hewlett-Packard se une al proyecto y todo aparentaba resultar en un aliento por traer el orden en el mundo de las API’s gráficas de la computación 3D.

Lamentablemente en el 1999 es abandonado el proyecto debido a restricciones económicas de SGI, razones estratégicas de Microsoft y la falta de soporte de parte de la industria.



Algunos Famosos Juegos que Emplean Algunos Famosos Juegos que Emplean OpenGLOpenGL

Arkanoid: Space Ball Call of Duty CommandosCounter-Strike Darwinia Deus ExDoom 3 Doom 4 Far CryHalf-Life Half-Life 2 Heretic IIHitman Max Payne Quake (todas las series)Return to Castle Wolfenstein Second Life SporeStarCraft II Tux Racer Unreal TournamentUnreal Tournament 2004 Warcraft 3 WolfensteinWorld of Warcraft


Permite sacar provecho a la renderización de aceleración gráfica en el hardware aplicando principalmente la versión 4.x del API de Allegro.

El API de Allegro puede usar comandos OpenGL para ejecutar el renderizado en la pantalla y mapas de bits. Se requiere instalar el AllegroGL junto con el API de Allegro, pero no exige de ningún conocimiento sobre OpenGL.

Allegro con Aceleración de Hardware Allegro con Aceleración de Hardware (AllegroGL)(AllegroGL)


Para poder sacarle el provecho a AllegroGL es necesario tener la implementación de OpenGL en el computador, lo cual consiste en tener una tarjeta gráfica compatible con OpenGL y unos controladores (drivers) actualizados.

AllegroGL - RequerimientosAllegroGL - Requerimientos


Allegro 4.2.1 o mayor + AllegroGL 0.4.2 o mayor:

AllegroGL se puede descargar como un paquete por separado para ser instalado después de instalar el Allegro.

Allegro 4.4.x con AllegroGL habilitado:

Antes de la salida oficial de Allegro 5, esta es la versión de Allegro más estable actualmente disponible. Contiene las librerías de AllegroGL dentro del paquete.

AllegroGL - RequerimientosAllegroGL - Requerimientos



#include <alleggl.h>

int main() {

if (allegro_init() != 0) {

return 1;

}

if (install_allegro_gl() != 0) {

return 1;

}

install_keyboard();

install_timer();

allegro_gl_set(AGL_DOUBLEBUFFER, 1);

allegro_gl_set(AGL_WINDOWED, TRUE);

allegro_gl_set(AGL_COLOR_DEPTH, 32);

allegro_gl_set(AGL_SUGGEST, AGL_DOUBLEBUFFER | AGL_WINDOWED | AGL_COLOR_DEPTH);

if(set_gfx_mode(GFX_OPENGL, 800, 600, 0, 0)) {

allegro_message ("Error al configurar el modo grafico de OpenGL:\n%s\n"

“Error de Allegro GL: %s\n",

allegro_error, allegro_gl_error);

exit(0);

}

allegro_gl_set_allegro_mode();

textout_ex(screen, font, “Hola Mundo!", 50, 100, makecol(255, 0, 0), -1);

allegro_gl_unset_allegro_mode();

allegro_gl_flip();

readkey();

return 0;

}

END_OF_MAIN()

AllegroGL – “Hola Mundo” AllegroGL – “Hola Mundo” Tomado Tomado desde allegro.ccdesde allegro.cc


Todas las funciones que están anteriores al textout_ex() son parte del código que siempre se encuentra en cualquier tutorial de AllegroGL.

Realizan la siguiente configuración: en modo de ventana, double-buffered y modo GFX de 32 bits.

El código debajo del allegro_gl_flip se encarga de intercambiar el buffer con la pantalla (ya que estamos usando el double-filtering) y luego espera que se presione una tecla.

AllegroGL – “Hola Mundo” AllegroGL – “Hola Mundo” Funciones Funciones UsadasUsadas


No importa qué tan complicado vaya a ser el videojuego, estas líneas de código de configuración serán necesarias para emplear la especificación OpenGL.

textout_ex() es una función típica del API de allegro, sólo que hemos configurado para utilizar los comandos de OpenGL.

Cualquier función de Allegro que utilicemos entre allegro_gl_set_allegro_mode() y allegro_gl_unset_allegro_mode() que dibuje en un mapa de bits (BITMAP*) o en la pantalla utilizará los comandos de OpenGL para renderizado.

AllegroGL – “Hola Mundo” AllegroGL – “Hola Mundo” Funciones Funciones UsadasUsadas

Programación Aplicada - Tema 2

Documents

Transcript of Programación Aplicada - Tema 2