Curso programacion de videojuegos en c++

8/14/2019 Curso programacion de videojuegos en c++

1/109

CURSO DE PROGRAMACI NDE VIDEJUEGOS CON C++ YALLEGRO

Copyright (c) 2001-2002 Daniel Acua [email protected]

http://artebinario.cjb.net http://artebin.sf.net

ARTEBINARIO. PROGRAMACIN DE JUEGOS.


2/109

2

Permission is granted to copy, distribute and/or modify this documentunder the terms of the GNU Free Documentation License, Version 1.1 or

any later version published by the Free Software Foundation; with noInvariant Sections, with no Front-Cover Texts, and with no Back-Cover

Texts.

Revisa la nueva seccin Introduccin::Licencia eIntroduccin::Agradecimientos y Dedicatorias


3/109

3

INTRODUCCIN................................................... ...................................... 6

LICENCIA...................................................... ........................................................ ................... 6

AGRADECIMIENTOS Y DEDICATORIAS ................................................ ...................................... 6MOTIVACIN................................................ ........................................................ ................... 6REQUISITOS.................................................. ........................................................ ................... 6OBJETIVOS ................................................... ........................................................ ................... 7C++:EL LENGUAJE ............................................... ........................................................ .......... 7COMPILADORES DE C++.................................................. ....................................................... . 8AMBIENTES DE DESARROLLO INTEGRADOS (IDES)................................................................. . 8HERRAMIENTAS DE DESARROLLO PARA ALLEGRO ................................................ ................... 8

CREANDO NUESTRO PRIMER JUEGO ................................................... . 9

CREANDO UN ESPACIO DE TRABAJO

................................................... ...................................... 9ESTABLECIENDO UN ESTNDAR EN EL DESARROLLO ...................................................... ........ 12ESTABLECIENDO LOS REQ UERIMIENTOS DE NUESTRO PROYECTO .......................................... 13PRIMER PEDAZO DE CDIGO: UN RPIDO VISTAZO PARA ALIMENTAR LAS ES PERANZAS . ........ 13DIBUJANDO UNA IMAGEN, NUESTRA NAVE.................................................................................14COORDENADAS DE LA PANTALLA: EL MUNDO AL REVS .............................................................15DANDO MOVIMIENTO A LA NAVE............................................... ............................................. 16LEYENDO DESDE EL TECLADO ...................................................................................................16 ESTABLECIENDO LAS TECLAS NECESARIAS ................................................................................17ESTABLECIENDO LAS DIRECCIONES DE MOVIMIENTOS ................................................................17DIBUJANDO LA NAVE EN MOVIMIENTO ......................................................................................18 RESUMEN ...................................................... ........................................................ ................. 21

PROGRAMACIN ORIENTADA AL OBJETO, EL NUEVOPARADIGMA....................................................... ........................................................ ........ 22

EL PROGRESO DE LA ABSTRACCIN ................................................... .................................... 22CARACTERSTICAS DE LA POO................................................. ............................................. 23UN OBJETO TIENE UNA INTERFAZ...............................................................................................23LA IMPLEMENTACIN EST OCULTA..........................................................................................23 OCUPANDO NUEVAMENTE LA IMPLEMENTACIN........................................................................24RELACIN ES-UN VS. ES-COMO-UN ............................................................................................25 RESUMEN ...................................................... ........................................................ ................. 26

ANLISIS Y DISEO ORIENTADO A OBJETOS.......... ...... ..... ...... ..... .... 27

FASE 0:CONSTRUIR UN PLAN .................................................... ............................................. 28ESTABLECER UNA MISIN .........................................................................................................28 FASE 1:QU ESTAMOS HACIENDO?.................................................. .................................... 28FASE 2:CMO CONSTRUIREMOS ESO? ...................................................... ........................... 29CINCO ETAPAS EN EL DISEO DE OBJETOS..................................................................................30DIRECTRICES PARA EL DESARROLLO DE OBJETOS.......................................................................30FASE 3:CONSTRUYENDO EL NCLEO. ................................................ .................................... 31FASE 4:ITERANDO LOS CASOS DE USO................................................ .................................... 31FASE 5:EVOLUCIN............................................... ........................................................ ........ 31

RESUMEN ...................................................... ........................................................ ................. 32

ESTABLECIENDO LOS REQUERIMIENTOS Y ANLISIS INICIALESDEL JUEGO ................................................ ........................................................ ................. 33

REQUERIMIENTOS DEL SISTEMA (FASE 0 Y FASE 1) ................................................................ 33ANLISIS ORIENTADO AL OBJETO (FASE 2) ............................................................................ 34


4/109

4

CASOS DE USO .........................................................................................................................35 DESCRIPCIN INFORMAL EN LENGUAJE NATURAL.......................................................................36TARJETAS CRC........................................................................................................................37 RESUMEN ...................................................... ........................................................ ................. 39

MARCO DE TRABAJO PARA UN JUEGO ............................................... 40

QUE ES UN MARCO DE TRABAJO? ..................................................... .................................... 40CREANDO EL CORAZN DEL MARCO DE TRABAJO ................................................. ................. 41CLASE ACTOR..........................................................................................................................41 CLASE ACTORMANAGER..........................................................................................................43 CLASE STAGEMANAGER...........................................................................................................44 CLASE GAME...........................................................................................................................46 CREANDO NUESTRO PRIMER JUEGO II................................................ .................................... 49PROBANDO EL POTENCIAL DEL MARCO DE TRABAJO ...................................................... ........ 50RESUMEN ...................................................... ........................................................ ................. 54

VELOCIDAD CONSTANTE DE JUEGO............... .................................... 55

SOLUCIONANDO EL PROBLEMA DE LA VELOCIDAD ................................................ ................. 55SALTO DE CUADROS.................................................................................................................56 IMPLEMENTACIN EN ALLEGRO ............................................... ............................................. 57LOS CICLOS GRFICOS : CUADROS POR SEGUNDO .................................................. ................. 59RESUMEN ...................................................... ........................................................ ................. 60

MANEJO DE LOS CONTROLES............................................................... 61

DIFERENCIA ENTRE UN CONTROL Y UN PERIFRICO ....................................................... ........ 61CMO TRABAJA EL CONTROLADOR DE CONTROLES ....................................................... ........ 62DISEO DEL CONTROLADOR DE CONTROLES ............................................... ........................... 63PERIFRICO..............................................................................................................................63 OBJETO CONTROLABLE ............................................................................................................64 CONTROL.................................................................................................................................65 CONTROLADOR DE CONTROLES ................................................................................................68 AGREGANDO EL NUEVO CONTROLADOR A NUESTRO MARCO DE TRABAJO .............................. 71INTEGRANDO LAS NUEVAS CARACTERSTICAS A NUESTRO JUEGO .......................................... 72DEFENSA DE LA HERENCIA MLTIPLE (O HGANME CASO O SUGIERAN ALGO MEJOR)................72LA NUEVA CLASE AIRCRAFT.....................................................................................................73 CREANDO EL PERIFRICO TECLADO...........................................................................................74 COMBINANDO TODO Y AGREGNDOLO AL JUEGO TESTFRAMEWORK ..........................................75

RESUMEN ...................................................... ........................................................ ................. 77

SEPARACIN DE GRFICA Y CONTROL.......... ...... ..... ...... ..... ...... ...... .. 78

ANLISIS Y DISEO DE LA GRFICA DEL ACTOR .................................................... ................. 78IMPLEMENTACIN DE LA CLASE ACTORGRAPHIC.......................................................................79MODIFICACIONES NECESARIAS EN EL MARCO DE TRABAJO .................................................... 80MODIFICACIN DE LA CLASE ACTOR .........................................................................................80 MODIFICACIN DE ACTORMANAGER ........................................................................................83 CREACIN DE DISTINTOS GRFICOS PARA ACTORES ...................................................... ........ 83CLASE BITMAP.........................................................................................................................85

PROBANDO EL POTENCIAL DE LAS REPRES ENTACIONES GRFICAS ......................................... 87CLASE SPRITE..........................................................................................................................88 RESUMEN ...................................................... ........................................................ ................. 92

DETECCIN DE COLISIONES.............................................. ................. 93

ANLISIS Y DISEO DEL ADMINISTRADOR DE COLISIONES ...................................................... 93


5/109

5

OCUPANDO SOLO LOS ADM INISTRADORES NECESARIOS ..............................................................93INTERFAZ DEL ADMINISTRADOR DE COLISIONES ................................................... ................. 95COMO SE REALIZA LA DETECCIN DE COLISIONES................................................ ................. 96MTODOBOUNDINGBOX..........................................................................................................96 MTODO DE COLISIN PERFECTA AL PXEL ...............................................................................96LA CLASE MASK.................................................... ........................................................ ........ 97

MODIFICACIN A ACTORGRAPHIC .......................................................................................101 PERFECCIONANDO EL CRITERIO DE DETECCIN....................................................................101MODIFICANDO LA CLASE ACTOR Y ACTORMANAGER ...........................................................101ACTOR ..................................................................................................................................101 ACTORMANAGER...................................................................................................................102


6/109

6

INTRODUCCIN

LicenciaEspero no hacer esta seccin muy relevante porque este manual lo entrego sin

fin de lucro, es casi un regalo, un acto de altruismo esperando a cambio un flujoconstante y creciente de sugerencias, de expansin, de colaboracin, de correcciones.

Tambin espero que menciones el sitio desde donde lo sacaste(http://artebinario.cjb.net), que te hagas miembro de la lista de correo(http://www.elistas.net/lista/programacion_juegos) y que juegues mucho.

Agradecimientos y dedicatorias

Agradecimientos a todas las personas que han descargado este curso que sehan pasado el dato de boca en boca. A las personas que desarrollan Allegro, Djgpp,RHIde, Linux, allegro.cc, Pixelate, a los creadores del libro Cutting Edge: Java GameProgramming, a mirax y en general a todos los que han prestado ayuda a Artebinariodesde sus albores.

Una especial dedicatoria al amor de mi vida, su nombre empieza con E yprefiere de todas maneras el anonimato (no es tan eglatra como yo :), le pidodisculpas por las horas que no le dedico en pos de este curso.

Motivacin

He visto muchas pginas (demasiadas) relacionadas con la programacin de

videojuegos, casi todas estn en ingls y no son comprensibles muchos de los trminosque utilizan. De los sitios que he visto en castellano sobre programacin devideojuegos muchos se quedan en "esta pgina est en construccin", "prximamentems artculos", etc. eso no me gusta y yo no quiero caer en ese tipo de temtica. Estecurso lo terminar y les entregar a Uds. todos los conocimientos que he adquiridohasta ahora, as como los libros e incluso aportes de muchos navegantes. Quieroterminar este curso tambin a la par de la primera versin del juego ADes, porque losque han seguido de cerca el proyecto saben que queda totalmente estancado en lossemestres de clases y muchas veces tambin en las vacaciones, yo les digo a ellos queahora tengo ms documentacin y motivacin para emprender esta tarea, he conocidoms sobre el diseo de videojuegos: frameworks para videojuegos, UML, tarjetas CRC,etc. Muchas cosas que t tambin aprenders.

Buena suerte a mi y a todos los que quieren emprender este desafo (desafo

99... solo algunos saben lo que significa eso) ;-)

Requisitos


7/109

7

Antes que todo, Uds. deben saber los requisitos para que avancemos a un ritmoconsiderable. Lo ms importante es tener ganas y saber C, pero ni siquiera eso,porque los que son demasiado "maestros" en C tienden a encontrar dificultades paraaprender programacin orientada al objeto:

Conocimiento de C Conocimiento de la programacin orientada al objeto Conocimiento de Djgpp y las bibliotecas allegro Conocimiento del editor RHide (Opcional) Conocimiento de VC++ y compilacin con DirectX. (Opcional) Conocimiento de editores de imgenes tales como PhotoShop,PaintShop Pro, Fireworks, etc.

Objetivos

Aqu viene la parte en que Ud. se entusiasman y empiezan a aportar en esteproyecto, es la parte en que suean con algn da hacer un juegos desde el principio

hasta el final Los objetivos son: Comprender que es el diseo orientado al objeto, orientado a losvideojuegos Aprender a crear un espacio de trabajo Conocer como trabaja Allegro y Djgpp Aprender a compilar, ejecutar y depurar un programa con Allegro yDjgpp Aprender a ocupar el editor RHIDE Aprender a implementar el diseo de las clases Crear un videojuego basado en la orientacin a objetos.

Creo que esos son los principales objetivos de mi sitio y de este curso. Deboadvertirles adems que principalmente me orientar a la programacin de juegos denaves (shoot'em up) como ADes, pero con los frameworks (ya vern lo que eso) notendrn problema para adaptarlo a su propio videojuego.

C++: El Lenguaje

Tendra que esforzarme demasiado para decir algo nuevo sobre C++,probablemente repetir lo que he venido diciendo durante mucho tiempo o lo quesiempre leo: "C++ es un lenguaje orientado al objeto ocupado en la mayora de lasaplicaciones de diseo de software. El caso de nuestro objetivo lo ocuparemos paraprogramar unos videojuegos, de cualquier tipo, ya sea de scroll, de luchas (streetfighter!) o 3d.

Si aprenden C++ bien sern parte de una comunidad de elite dentro de los

programadores incluso podrn ganar mucho dinero creando software de bajo nivel,desde los cuales se sustentarn sistemas mucho ms complejos. Pero, nuevamente,los voy a traer hasta nuestra realidad: establecer una base para crear nuestros futurosvideojuegos. Ahora que nombre esto de "crear una base para nuestros futurosvieojuegos" les paso a explicar la ventaja ms excitante de programar orientado alobjeto. Si nosotros creamos un diseo relativamente bueno que sustente a nuestrovideojuego podremos en un futuro seguir ocupando estas "clases" de objeto (yaveremos este concepto), es decir, no tendremos que invertar la rueda de nuevo (unerror frecuente en un programador). Otra caracterstica de C++ es que ofrece larobustez de nuestro diseo mediante la ocultacin de informacin, es decir, no todaslas personas que ocupen nuestro cdigo podrn acceder a todo el cdigo. Por ejemplo,no podrn acceder a las estructuras que guardan la informacin en un tipo de datolista, podremos restringuir el acceso del programador que ocupar nuestras clases a

las funciones cannicas insertar, eliminar o borrar un elemento. Bueno, mejor lenseun libro o visiten la pgina de un tipo que escribi el mejor libro de C++ y lo dejabierto para ser ledo gratuitamente (http://mindview.com) y el libro se llama"Thinking in C++" y est en dos tomos. Yo les recomiendo de todas formas leerse unlibro o por lo menos saber los conceptos de la programacin orientada al objeto.

Si sabes programar en algn otro lenguaje orientado a objetos como SmallTalk,Java no deberas tener problemas con C++.


8/109

8

Compiladores de C++

Hay muchos compiladores para el lenguaje C++ en todos los sistemasoperativos (todos), porque casi todos los sistemas operativos estn hechos en C oC++. Sin embargo, solo algunos de ellos se pueden usar conjuntamente con Allegro ensu versin ms reciente (3.9.35) algunos de ellos son Djgpp, Visual C++, Watcom yBorland C++. En todo caso si vas al sitio Allegro (http://alleg.sourceforge.net/) puedesver todos los compiladores que soporta Allegro.

Yo personalmente me voy ha basar en el compilador Djgpp ya que es gratuito ytiene una comunidad grande de personas que lo ocupan, adems de que se basa en elcompilador de Unix, es decir, puedo pasar compilar fcilmente un programa hecho enDjgpp en Unix y por consecuencia en Linux. Djgpp tambin trata de estar siempreacorde con la estandarizacin ANSI. El cdigo fuente tratar de que sea compatible contodos los siguientes compiladores: GCC Uns, Visual C++ y Djgpp.

Ambientes de Desarrollo Integrados (IDEs)

Un IDE (Integrated Development Enviroment), como se conoce comnmente aun editor, permite integrar varias herramientas de desarrollo tales como: compilador,enlazador (linkeador) y depurador. Adems tambin puede permitir crear proyectos yescribir los archivos que luego realizaran automticamente las tareas de compilacin(archivo de makefile).

Yo tambin dar mis ejemplos en el IDE RH (RHIde) creado por Robert Hhneque permite hacer todo lo que les dije anteriormente. Ah crearemos el proyecto yterminaremos creando el ejecutable.

Visual C++ tiene un potente IDE y no debera ser problema aplicarlo a esteproyecto.

Herramientas de desarrollo para Allegro

Adems de ocupar las bibliotecas de Allegro para las primitivas en nuestrojuego (lneas, puntos, tringulos, rellenos, sprites, msica, etc.) tambin ocuparemoslas herramientas de desarrollo que trae Allegro que nos permitirn configurar elsonido, los perifricos y todo lo que se necesitar para jugar nuestro juego, adems deuna magnfica herramienta que nos permitir comprimir todos nuestros elementos deAllegro (msica, imgenes, texto, sonido) en un solo archivo y adems comprimirlo.

No te alarmes por todas estas cosas que he presentado, todas ellas le iremosviendo a su debido tiempo.


9/109

9

CREANDO NUESTRO PRIMER JUEGO

Creando un espacio de trabajoLo primero que debes aprender al empezar un proyecto medianamente grande

es ser organizado, y creme: cuesta mucho aprender a serlo. Yo te puedo dar algunosconsejos, no hay problema, pero t debes continuar y hacer del orden tu forma de vivirpor lo menos en la programacin porque ante todo te permitir mantener en un lugarseguro todos los activos de tu proyecto, fciles de ubicar, fciles de rehusar, fciles dearreglar, en general, fciles de mantener.

Estos algunos de los pasos que yo te recomiendo y que tambin seguir en miproyecto de juego, as tambin estarn ubicados los cdigos y encabezados de miproyecto. Esta organizacin se puede dar como una especie de rbol comnmenteconocido como directorio. Por ejemplo,

Figura 1

El directorio raz de nuestro proyecto puede estar en cualquier parte de nuestrodisco duro o disco de red. Adems dentro del directorio cdigos puede considerarseuna subclasificacin entre las versiones de nuestro proyecto, por ejemplo la versin 1,versin 1.2, etc.


10/109

10

Figura 2

Ahora que tenemos creado la estructura de directorios entonces creamos elproyecto en RHIDE.

Desde ahora en adelante me referir a los directorios en forma relativaal directorio raz d el proyecto, por ejemplo, si hablo del archivo

cdigos/ prueba.cpp entonces me referir al archivo que est, en el caso mo,en c:\ djgpp\ juegos\ Ades\ codigos\ prueba.cpp (MS-DOS)

Entramos al directorios cdigo y escribimos RHIDE.

Figura 3

Ahora que nos encontramos dentro de RHIDE podemos ver varios mens, unode ellos es el men de proyectos->abrir proyecto (proyect->open proyect, desdeahora no traducir los mens por lo que tu debes entender de cual estoyhablando). Entonces saldr un dialogo que nos preguntar cual es el nombre delproyecto. Este debe ser un nombre explicativo, que diga algo, por ejemplo a mi

proyecto le pondr ades y el archivo correspondiente ser ades.gpr.Para editar los cdigos fuentes yo te recomiento personalmente usar las

siguientes opciones: anda al men opciones->ambiente->opciones del editor y haz clicen las siguientes y deja el tamao de la tabulacin as:


11/109

11

Figura 4

Ahora, para compilar nuestro cdigo con las bibliotecas Allegro le diremos alcompilador que las enlace a nuestro proyecto. En el men opciones ->bibliotecasingresamos el nombre alleg y dejamos seleccionada la casilla, tal como lo muestra laFigura 5.

Figura 5

Luego de ingresar el nombre aparecer una ventana del proyecto que en unfuturo mostrar todas las fuentes involucrados en el proyecto. Por ahora crearemos unnuevo archivo desde el men archivo->nuevo.

Ahora introduciremos un cdigo ms o menos cannico para comprobar quetodo est trabajando en Allegro. Introduce lo siguiente:


12/109

12

Cdigo Fuente 1.

#include #include

#include

int

main()

{ allegro_init();

install_keyboard();if(set_gfx_mode(GFX_AUTODETECT,320,200,0,0)agregar tem y selecciona el archivo que acabas deguardar, luego anda opciones->bibliotecas y agrega la biblioteca alleg (todos estospasos son explicados con ms detalles en la pgina Artebinario, como parte de lainstalacin y ejecucin de un programa en Allegro). Anda a compilar->construir todo yya tienes listo el programa para ejecutarlo en ejectuar->ejecutar. Deberas ver algocomo esto:

Figura 6

Ahora cada vez que entres a RHIDE desde el directorio de cdigos se abrir pordefecto el proyecto.

Estableciendo un estndar en el desarro llo

Es bueno siempre establecer un estndar a travs del desarrollo, esto quieredecir que se debe explicitar cuales son los formatos de archivo, cuales son lasextensiones de cada tipo, cuales son las bibliotecas que se usarn, cuales son lasopciones de compilacin, que no se permitir, etc. Todo esto sirve cuando se trabajacon muchas personas, un grupo de programadores sobre un mismo proyecto. Como

hacer que un programador no se intrometa en mi cdigo y como yo no me intrometoen su cdigo o en la parte del proyecto que el est actualmente desarrollando.En Internet hay muy buenos artculos sobre como comentar, indentar y

documentar nuestro cdigo, nuestras clases o en un futuro nuestras propias bibliotecasde desarrollo.

A modo de ejemplo yo establecer las extensiones y directorios que tendr cadaparte de mi proyecto.

Los cdigos fuentes en C++ tendrn la extensin .cpp.


13/109

13

Los cdigos fuentes en C tendrn la extensin .c . Los archivos de inclusin que van en la cabecera tendrn la extensin .h Etc.

Lo anterior fue un pequeo ejemplo de cmo establecer tus propias directivasen el desarrollo de un proyecto. Ms adelante se vern algunas reglas ms especficas,pero desde ahora debes ir pensando en tu propia estandarizacin.

Estableciendo los requerimientos de nuestroproyecto

Quiz antes de empezar a probar que si Allegro funciona, que laestandarizacin, que esto y que lo otro, sera mejor establecer que es lo quequeremos hacer. A simple vista puede parecer una pregunta sencilla, pero muchosde los que han programado y estn empezando recin a crear su juego se encuentranante un gran abanico de posibilidades de desarrollo de entre las cuales son muy pocaslas que parecen desechables, es decir, queremos que nuestro juego tenga todas lascaractersticas, todos los modos de juego, todos gneros, ocupe todos lo perifricos,

etc. Sera mucho mejor establecer un objetivo final como por ejemplo lo sera miproyecto: ADes es un juego de naves con deslizamiento (scroll) vertical en 2D. 1 o 2 jugadores El juego se divide en misiones Varios tipos de armas con niveles de poder. Soporte de distintos perifricos como control Mltiples capas de juego, incluye agua, tierra y aire. Efectos de sombre, luces, huella y polvo.

Ud. dirn Pero todava es demasiado pedir para mi proyecto!, yo les digo: s,es demasiado pedir. Pero quien les ha dicho que haremos todo de una vez, para eso seinvent el tiempo, para gastarlo, gastarlo de buena forma. Lo que fije anteriormentefueron los objetivos, que es lo que yo espero que tenga el juego final. Deben sabes

que muchos de los videojuegos comerciales quiz nunca alcanzan el objetivo inicial quefue fijado y todava estn a mucha distancia de hacerlo, pero en eso se trabaja y esetrabajo es lo que se denomina la versin de un juego .

Dentro de nuestros objetivos nosotros estableceremos metas de corto plazo,por ejemplo para este juego la primera meta ser sencilla: hacer que aparezca unanave en pantalla y que pueda moverse con el teclado. Esa si que es una meta sencillapara alcanzar un objetivo. Trabajemos en eso.

Primer pedazo de cdigo: un rpido vistazopara alimentar las esperanzas.

Muchas veces en el transcurso de mi aprendizaje me he topado con gente quedice que primero que todo hay que sentarse en un escritorio, tomar papel y lpiz ycrear un buen diseo. Muy bien, felicito a la persona que puede hacerlo, pero yo cmobuen programador no me puedo pasar la vida esperando ver mi nave o mi personajesurcar la pantalla al son de las teclas.

Un justificacin un poco ms elaborada para esta seccin sera decir quealentar al ansioso lector a seguir con est insondable tarea de crear juegos.

Ya tenemos nuestro cdigo que permite iniciar el espacio de trabajo de Allegro,bueno ahora seguiremos extendiendo eso para permitir una pequea nave enmovimiento. Separaremos las secciones de iniciacin y trmino de las Allegro en dosprocedimientos iniciar y terminar.


14/109

14

Cdigo Fuente 2.

intiniciar()

{

allegro_init();

install_keyboard();/* nos permitira utilizar el teclado */set_color_depth(16);

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


15/109

15

Cdigo Fuente 4.

voidrealizar_juego()

{

BITMAP*nave;

PALETTE*paleta;

nave=load_bitmap("../recursos/nave.pcx",paleta);draw_sprite(screen,nave,0,0);

readkey();

destroy_bitmap(nave);

}

Nuestro procedimiento realizar_juego entonces cargar la nave y la mostrar enpantalla mediante la funcion draw_sprite en la posicin (0,0) de la pantalla (screen esun puntero a la posicin de memoria de video que contiene la pantalla visual). Esimportante entender como son las coordenadas en la pantalla, cosa que veremos en laprxima seccin.

Coordenadas de la pantalla: el mundo al revs

Las personas que han tenido cursos de matemticas vectoriales muy bien saben

que el plano cartesiano se divide en 4 seccin: x>0 & y>0, x0, x


16/109

16

Figura 8

Tal como vez en la Figura 8 tenemos tres puntos. El primero en la esquinasuperior izquierda que tiene la coordenada x=20 & y=10, es decir, suponiendo que lapantalla empieza en los bordes superior izquierdo de la figura entonces ese puntoestara 20 pixeles por debajo del borde superior y 10 pixeles a la derecha del bordeizquierdo. As esta cuadriculada la pantalla, en pixeles; la unidad mnima grfica.

Por otro lado vemos a la nave en x=150 & y=90 pero ella continaimprimindose ms bajo de esa coordenada, eso es porque la imagen de la nave tienevarios pixeles de ancho y largo. Siempre que le decimos a un grfico que se dibujedamos a la coordenada superior izquierdo del grfico.

Es decir el mundo al revs, vemos el primer cuadrante del plano cartesiano(cuando x>0 & y>0) al revs, si la nave se mueve a la izquierda su coordenada xdisminuye hasta llegar a cero o incluso seguir disminuyendo a travs de nmeronegativos, en tanto la coordenada y disminuye si la nave se mueve hacia arriballegando a nmeros negativos.

Ahora, por notacin debes aceptar que cuando hablo de (0,0) estoy diciendoque x=0 & y=0 y cuando hablo de (4,2) estoy diciendo x=4 & y=2.Muy bsico?. S,pero no volver a hablar de x=? e y=?. Si te manejas bien con el clculo vectorial nodeberas tener problemas de ninguna clase cuando luego resolvamos el problema dedirigir las balas de nuestros enemigos a nuestra nave. Si no entendiste no importa,porque es otro intento de alentarte a seguir en este desafio99.

Dando movimiento a la nave

Ahora que ya entiendes como son las coordenadas de la pantalla (o del monitorpara los ms duros de cabeza) intentaremos decirle que responda a algn perifrico,por el momento ser nuestro teclado.

Leyendo desde el teclado

Cuando inicializamos Allegro llamamos al procedimiento install_keyboard que loque hace es instalar una interrupcin que revisa a cada instante los eventos delteclado. Al llamar a este procedimiento tambin dejamos inutilizadas las funcionespropias de C/C++ como gets, scanf, etc. Pero no te preocupes porque Allegro lasreemplaza con otras que se adaptan perfectamente a nuestras necesidades.

Te haz fijado que cuando lees del teclado no puedes hacerlo continuamente?.Eso es porque el teclado no est programado inicialmente para leer varias cientos de

veces por segundo, es decir, si mantenemos presionada una tecla esta tendr unretardo y luego una repeticin con un retardo demasiado grande entre cada carcter,esto no es usable en un juego. Por eso, al instalar el teclado dejamos una interrupcinque nos permite leer cientos de veces por segundo el estado del teclado.


17/109

17

Para leer desde el teclado se necesita consultar un arreglo global que tieneAllegro, es decir, que es alcanzable por cualquier funcin o procedimiento en cualquierparte de nuestro cdigo. Este arreglo es key que contiene 256 posiciones desde el 0 al255. Pero nosotros no necesitamos aprendernos cada uno de los cdigos de las teclas,para eso estn definidos, globalmente tambin, algunas teclas comunes. ltimamentetambin se soportan caracteres UNICODE con lo que se permiten hasta 65536

diferentes teclas.Por ejemplo si queremos saber si la tecla Enter est presionada entonceshacemos el siguiente cdigo:

Cdigo Fuente 5.

if(key[KEY_ENTER])

{

printf("Tecla enter fue presionada\n");

}

Muy fcil!. Si dejamos esta sentencia dentro de un bucle, por ejemplo while seimprimir muchas veces en la pantalla, sin retardo y sin espera por el retardo.

Estableciendo las teclas necesarias

En esta seccin estableceremos las teclas que ocupar nuestro pequeo primerjuego, ms adelante todas estar opciones pueden estar automatizadas con algn mende configuracin en nuestro juego.

Las teclas de movimiento sern arriba, abajo, derecha e izquierda, y la tecla desalida de nuestro juego ser la tecla de escape. Enumeradas en los cdigos de Allegroseran:

Arriba: KEY_UP Abajo: KEY_DOWN Derecha: KEY_RIGHT Izquierda: KEY_LEFT Escape: KEY_ESC

Como pueden ver los nombres son muy intuitivos por lo que no deberan haber

mayores problemas. El formato a seguir es lgico, algunos ejemplo: Tecla A hasta la Z: KEY_A ... KEY_Z Tecla 0 hasta el 9: KEY_0 ... KEY_9

Estableciendo las direcciones de movimientos

Voy a hacer una revisin exhaustiva de cmo debe moverse la nave o quevalores deben darse a las variables cada vez que se presione una u otra tecla.

Declaramos dos variables que contendrn la posicin x e y de la nave en lapantalla:

Cdigo Fuente 6.


{

BITMAP*nave;

PALETTEpaleta;intx,y,

...

Pensemos, Qu pasa si presiono la flecha hacia arriba en miteclado?.Intuitivamente concluimos que la nave debera moverse hacia arriba, peroEn que se traduce esa frase moverse hacia arriba?. Claro!, en cambiar el valor dela variable y de algn modo.

Figura 9


18/109

18

Supongamos que la posicin inicial de la nave es (80,150), como lo muestra laFigura 9, entonces cuando presionemos la flecha arriba, es decir, cuando seaverdadera la expresin key[KEY_UP] debera disminuir el valor de la variable y(recuerda que en la pantalla el mundo es al revs, si algo sube su posicin en lapantalla disminuye). Si no entendiste te recomiendo que repases esta parte porque esmuy importante ver la relacin entre el movimiento en la pantalla y las variables,

imagina como se complica esto en un entorno en 3D en donde hay tres variables deposicin (x, y, z).Entonces el pedazo de cdigo que ejecute lo requerido debera ser algo as:

Cdigo Fuente 7.

...if(key[KEY_UP])

y--;

...

Ahora hagmoslo para todas las direcciones: Baja la nave: y++ Hacia la derecha: x++ Hacia la izquierda: x

Cdigo Fuente 8.

...if(key[KEY_DOWN])

y++;if(key[KEY_LEFT])

x--;if(key[KEY_RIGHT])

x++;

...

Todo esto ira dentro de un loop hasta que presionaramos la tecla Escape. Esdecir:

Cdigo Fuente 9.

...while(!key[KEY_ESC])

{

/* codigo para modificar las variables */

}

...

Dibujando la nave en movimiento

Ahora que tenemos todo listo para que nuestra nave se mueva por la pantallasolo necesitamos dibujarla. Como en el ejemplo anterior la nave permaneca estticaen la posicin (0,0) no nos preocupbamos de actualizar el dibujo.

Cuando actualizamos la pantalla para que la nave aparezca en otra posicin nosdebemos preocupar de que el dibujo anterior se borre porque recuerden que lapantalla que vemos en el monitor es solo memoria de video que puede almacenarsemientras estemos en ese modo grfico, es decir, necesitamos de algn modo borraresa memoria para dibujar la nueva imagen. En el mercado existen muchos mtodospara realizar esto pero por el momento solo guardar la parte de la pantalla que voy amodificar para luego reponerla. Ms adelante se vern con ms detalles otrosalgoritmos que realicen en forma eficiente (lo ms rpido posible) este trabajo.

Se declarar otra variable que guardar la seccin de la pantalla que modificcon draw_sprite:

Cdigo Fuente 10.

voidrealizar_juego(){

/* demas variables */

BITMAP*buffer;...


19/109

19

Este buffer debe tener las mismas dimensiones que la imagen que guardar, eneste caso la variable nave. Para obtener las dimensiones de esta imagen se hace usodel campo h (height, alto) y w (width, ancho) luego de que esta se ha cargado porsupuesto. La funcin de Allegro que permite crear una imagen con un formatoespecfico es create_bitmap.Voy a mostrar todo el cdigo del procedimientorealizar_juego hasta aqu:

Cdigo Fuente 11.


{

BITMAP*nave;

PALETTEpaleta;intx,y;

BITMAP*buffer;

nave=load_bitmap("../recursos/nave.pcx",paleta);

buffer=create_bitmap(nave->w,nave->h);

clear(buffer);

Luego de crearlo lo limpiaremos porque puede tener basura la posicin dememoria que le fue asignada, esto lo hacemos mediante la funcin clear. Alguno dirPero si no se carg correctamente el archivo a la variable imagen, como lo sabremos,excelente acotacin. Antes de trabajar con cualquier imagen deberamos comprobarque carg correctamente. As lo haremos:

Cdigo Fuente 12.

...

nave=load_bitmap("../recursos/nave.pcx",

paleta);

if(nave==NULL)terminar();


if(buffer==NULL)terminar();

...

En general para cualquier funcin de Allegro que cree memoria, retornar NULL

si ha fallado. Pero alguien dir Pero que prdida de tiempo!, en absoluto. Siempre esbueno dejar cerrado el crculo de desarrollo, es decir, comprobar que todo esttrabajando bien para encapsular esta parte del cdigo, dejarla tranquila por el resto delproyecto.

Razonemos. Siempre debemos mantener la pantalla limpia, es decir, tal comoempez al iniciar el modo grfico. Entonces lo que debemos hacer primero es guardarlo que se nos entreg antes de hacer alguna modificacin. Declararemos dos variablesque guardarn la posicin anterior del sprite. Expresado en cdigo sera:

Cdigo Fuente 13.

...

blit(screen,buffer,x_anterior,y_anterior,0,0,buffer->w,buffer->h);

draw_sprite(screen,nave,x,y);

...

La primera lnea copia el pedazo de pantalla que ocupar nuestra nave y lo llevaa buffer. La funcin blit permite copiar una seccin de la pantalla completamente sinsaltarse los pxeles transparentes (mximo rojo y azul en ms de 256 colores, es el uncolor fucsia). Ahora que tocamos ese tema lo explicar mejor.

Si ya has probado la funcin draw_sprite debes saber que ella dibuja un imagenen la pantalla pero saltndose los pxeles transparentes dando la sensacin de que noes una imagen cuadrada. Si quieres puedes abrir la imagen nave.pcx en un editorcomo Photoshop o Fireworks y vers que los pxeles que no aparecen con la funcindraw_sprite son fucsias. En el caso de los modos a 256 colores (viejos modo, pero muyusados y prcticos) este color es el que est ubicado en la posicin cero de la paleta(paleta[0]). Puedes tambin probar como funciona esto enviando a la pantalla las

imgenes con las dos funciones blit y draw_sprite para que veas la diferencia.Entonces ocupamos blit porque nos permite copiar todo, sin distincin de pxeles.

Ahora debemos pensar en la posibilidad de que movamos la nave hasta queesta se salga de la pantalla por cualquiera de los cuatro bordes. Con algo dematemtica bsica llegamos a las siguientes conclusiones.

Cuando llegue al borde izquierda entonces suceder que:


20/109

20

Cdigo Fuente 14.

xSCREEN_W-nave->w

Cuando llegue al borde superior:Cdigo Fuente 16.

ySCREEN_H-nave->h

Si te resulta complicado recuerda que la nave se representa por un punto en la

pantalla (que en este caso esta en la esquina superior izquierda de la imagen) quetiene una coordenada (x, y). Lo que debe hacer finalmente la nave cuando se enfrentea cualquiera de estas situaciones es mantenerse ah mismo, es decir:

Cdigo Fuente 18.

if(xSCREEN_W-nave->w)x=x_anterior;if(ySCREEN_H-nave->h)y=y_anterior;

Finalmente todo el procedimiento es as:

Cdigo Fuente 19.

voidrealizar_juego(){

BITMAP*nave;

PALETTEpaleta;

intx,y,x_anterior,y_anterior;

BITMAP*buffer;

nave=load_bitmap("../recursos/nave.pcx",paleta);

set_palette(paleta);if(nave==NULL)terminar();


clear(buffer);if(buffer==NULL)terminar();

x=SCREEN_W/2;

y=SCREEN_H/2;

while(!key[KEY_ESC]){

if(key[KEY_UP])

y--;if(key[KEY_DOWN])

y++;if(key[KEY_LEFT])

x--;

if(key[KEY_RIGHT])

x++;if(xSCREEN_W-nave->w) x=x_anterior;if(ySCREEN_H-nave->h)y=y_anterior;if((x_anterior!=x)||(y_anterior!=y))

{blit(buffer,screen,0,0,x_anterior,y_anterior,buffer->w,buffer-

>h);

blit(screen,buffer,x,y,0,0,buffer->w,buffer->h);

draw_sprite(screen,nave,x,y);

}

x_anterior=x;y_anterior=y;

}

}


21/109

21

Si compilas todo lo que llevamos hasta ahora te dars cuenta que al moverla lanave esta tintinea. Cmo solucionamos eso?. Lo veremos mucho ms adelante. Porahora me parece bien haberte mostrado estos pedazos de cdigos para entusiasmarte.

Resumen

En este captulo vimos paso a paso el inicio de un proyecto, como crearlo enRHIDE y configurar correctamente todas las partes que tendr. Adems me permitmostrar como hacer un cdigo utilizando las bibliotecas Allegro.


22/109

22

PROGRAMACIN ORIENTADA ALOBJETO, EL NUEVO PARADIGMA

Sabes y entiendes lo que realmente te entrega la programacin orientada alobjeto?. En este captulo tratar de convencerte de las inmensas buenas caractersticasque te entrega el paradigma de POO.

El progreso de la abstraccin

Todos los lenguajes de programacin proveen de abstracciones. Se puedediscutir que la complejidad del problema que ests tratando de resolver estarelacionado directamente con el tipo y calidad de la abstraccin. Por tipo yo entiendo,Qu es lo que estoy abstrayendo?, por ejemplo el lenguaje ensamblador es una

pequea abstraccin de la mquina subyacente. Hay muchos lenguajes llamadosimperativos que siguen lo que fue esta abstraccin de la mquina (tales comoFortran, Basic y C). Estos lenguajes tienen grandes mejoras sobre el lenguajeensamblador, pero esa abstraccin primaria contina requiriendo que tu pienses entrminos de la estructura del computador ms que la estructura del problema queests tratando de resolver. La programacin debe establecer una asociacin entre elmodelo de la mquina (en el espacio de la solucin, la modelacin del problema,como un computador por ejemplo) y el modelo del problema que esta actualmenteresolvindose (en el espacio del problema, donde el problema existe). El esfuerzorequerido para realizar este mapeo y el hecho que esto es intrnseco al lenguaje deprogramacin, produce programas que son difciles de escribir y caros de mantener.

La aproximacin orientada al objeto va un paso ms all proveyendo

herramientas para que el programador represente los elementos del espacio delproblema. Esta representacin es generalmente suficiente para que el programador noest limitado para ningn tipo particular de problema. Nos referimos a los elementosen el espacio del problema y las representaciones en el espacio de la solucin comoobjetos (Por supuesto que tambin necesitamos otros objetos que no tengananalogas en el espacio del problema). La idea es que el programa tenga permitidoadaptarse l mismo al idioma del problema agregando nuevos tipos de objetos, ascuando t leas el cdigo describiendo la solucin, estars leyendo la solucin quetambin expresa el problema. Esto es ms flexible y poderoso que la abstraccin dellenguaje que tenamos antes. As, la POO te permite describir el problema en trminosdel problema ms que en trminos del computador en donde la solucin se ejecutar.Sin embargo, all todava hay una conexin con un computador. Cada objeto se puedever como un pequeo computador, tiene un estado y tiene operaciones que tu puedes

saber y realizar. Sin embargo, no parece una mala analoga comparar los objetos conel mundo real; ellos tienen caractersticas y comportamientos.

Todo es un objeto. Piensa en un objeto como una variable imaginaria;ella guarda datos, pero tu puedes hacer consultas a ese objeto, realizandoestas operaciones sobre si mismo cuando le preguntas. Puedes tomarcualquier componente conceptual del problema que ests tratando deresolver (perros, construcciones, servicios, naves, tanques, etc. ) yrepresentarlos como un objeto en el programa.


23/109

23

Un programa es un conjunto de objetos dicindole a otro quhacer con el mensaje que le enviaste. Para hacer una peticin a unobjeto, tu envas un mensaje a ese objeto. Ms concretamente, puedespensar un mensaje como un requerimiento para llamar a una funcin quepertenece a un objeto particular. Cada objeto tiene su propia memoria apa rte de otro objeto . Desdeotro punto de vista, t creas un nuevo tipo de objeto para hacer un paqueteque contiene un objeto existente. As, tu puedes construir complejidad en unprograma mientras escondindolo detrs de objetos simples. Todos los objetos tienen un tipo. Cada objeto es una instancia de unaclase, en la cual clase es sinnimo de tipo. La ms importantecaracterstica que se puede distinguir de una clase es Qu mensaje puedoenviarle?. Todos los objetos de un tipo particular pueden recibir el mismomensaje . Por ejemplo, un objeto de tipo crculo es tambin un objeto detipo figura, un circulo garantiza que puede recibir mensajes que una figuraacepta. Esto significa que puedes escribir cdigo que le hable a una figura yautomticamente enganche cualquier cosa que se ajuste a la descripcin defigura. Esta sustitubilidad es uno de los ms poderosos conceptos en la POO.

Caractersticas de la POO

Un objeto tiene una interfaz.

La interfaz establece que solicitudes se pueden hacer a un objeto en particular.Sin embargo, debe haber un cdigo en alguna parte que satisfaga esa solicitud. Esto,junto con los datos escondidos, comprenden la implementacin. Desde un punto devista de programacin procedural, esto no es tan complicado. Un tipo tiene una funcinasociada para cada posible solicitud y cuando tu hacer una solicitud particular a unobjeto, esa funcin es llamada. Este proceso es usualmente resumido diciendo queenvas un mensaje (haces una solicitud) a un objeto y el objeto entiende que hacer

con ese mensaje (ejecuta el cdigo).La implementacin est oculta

Antes de continuar haremos una distincin entre el creador de la clase y elprogramador cliente. El primero es el que crea el nuevo tipo de dato(la clase) y elsegundo es el que consume la clase, quien usa los tipos de datos en sus aplicaciones.La meta de un programador cliente es coleccionar una caja de herramientas llenas declases para usarlas en el rpido desarrollo de aplicaciones. La meta del creador de laclase es construirlas exponiendo solo lo que es necesario que el programador clientesepa, manteniendo todo lo dems escondido. Porqu?. Porque si esta escondido elprogramador cliente no puede usar eso que esta escondido lo cual significa que elcreador de la clase puede cambiar la porcin escondida en el futuro sin que lepreocupe el alguien ms ese cambio. La porcin escondida representa usualmente lo

ms delicado de un objeto que podra fcilmente ser corrompido por un programadorcliente descuidado o sin informacin, as la implementacin oculta reduce los errores.

En cualquier relacin es importante tener lmites que son respetados por todaslas partes involucradas. Cuando creas una biblioteca, estableces una relacin con elprogramador cliente, quien es tambin un programador, pero que est comb inando enuna aplicacin tus bibliotecas posiblemente para construir una ms grande.

Si todos los miembros de una clase estn disponibles para cualquiera, entoncesel programador cliente puede hacer cualquier cosa con esa clase y no habra forma deestablecer reglas. An cuando podras realmente preferir que el programador clienteno manipule directamente alguno de los miembros de tu clase, sin control de acceso nohay forma de impedirlo. Todo est desnudo ante el mundo.

De esta forma, la primera razn para tener control de acceso es mantener al

programador cliente con las manos fuera de la porcin que no puede tocar, partes queson necesariamente para la maquinacin interna del tipo de dato pero no de la interfazque el usuario usar para resolver un problema particular. Esto es actualmente unservicio para los usuarios porque ellos pueden fcilmente ver que es importante paraellos y que pueden ignorar.


24/109

24

La segunda razn para controlar el acceso es permitir al diseador de lasbibliotecas cambiar el trabajo interno de la clase sin preocupase sobre como estoafectara al programador cliente. Por ejemplo, puedes implementar una clase particularde una manera simple y luego descubrir que necesitas rescribirlo para hacer que seejecute ms rpido. Si la interfaz y la implementacin estn claramente separadas yprotegidas puedes hacerlo fcilmente y requerir solo de un reenlace por el usuario.

C++ usa tres palabras claves explcitas para establecer los lmites en una clase:p u b l i c , p r i v a t e y p r o t e c t e d .Si alguien trata de acceder a un miembro p r i v a t e , lobtiene un error en tiempo de compilacin. Pro tec ted actual como p r i v a t e , con laexcepcin de que una clase heredada tiene acceso a miembros p r o t e c t e d , pero no amiembros p r i v a d o s . La herencia ser introducida luego.

Ocupando nuevamente la implementacin

Una vez que la clase est creada y testeada, esto podra (idealmente)representar una unidad de cdigo til. Esto significa que re-usar el cdigo nos puedeayudar de alguna forma, este pedazo de cdigo toma experiencia y comprensinproduciendo un buen diseo. El cdigo re-usado es una de las ms grandes ventajasque los LOO proveen.

Por ejemplo, una maquina recicladora de basura ordena pedazos de basura. Eltipo base es basura y cada pedazo de basura tiene un alto, un valor y assucesivamente, y estos pedazos pueden ser rotos, fundidos o descompuestos. Des all,tipos ms especficos de basura pueden ser derivados y podran tambin tenercaractersticas (una botella tiene un color) o comportamientos adicionales (el aluminiopuede ser roto o un imn puede estar magnetizado). Usando la herencia, puedesconstruir tipos de jerarqua que expresan el problema que estas tratando de resolveren trminos de sus tipos.

Un segundo ejemplo es el clsico de la figura, quiz usado en diseo desistemas asistido por computador o simulacin de juegos. El tipo base figura y cadafigura tiene un tamao, un color, una posicin y as sucesivamente. Cada figura puedeser dibujada, borrada, movida, coloreada, etc. Desde aqu, un tipo especfico de figurapuede ser derivado (heredado): circulo, cuadrado, triangulo, y as, cada uno de los

cuales puede tener caractersticas y comportamientos adicionales. Ciertos tipos defiguras pueden ser rotados, por ejemplo. Algunos comportamientos pueden serdiferentes, tal como cuando quieres calcular el rea de una figura. El tipo de jerarquacontiene las similitudes y diferencias entre las figuras.

Cuando tu heredas creas un nuevo tipo. Este nuevo tipo contiene no solo todolos miembros del tipo existente (aunque los private estn escondidos e inaccesibles),pero ms importante es duplicar la interfaz de la clase base. Esto es, todos losmensajes que puedes enviar al objeto de la clase base puedes tambin envirselo alobjeto de la clase derivada. Sabemos el tipo de una clase por los mensajes quepodemos enviarle, esto significa que una clase derivada es del mismo tipo que la clasebase. En un ejemplo anterior, un crculo es una figura. Este tipo de equivalencia vaherencia es una de las entradas fundamentales para entender el significado de la

programacin orientada al objeto.Desde que la clase base y la derivada tiene la misma interfaz, debe haber

alguna implementacin para acceder a esa clase. Esto es, debe haber algn cdigo queejecutar cuando un objeto recibe un mensaje particular. Si tu simplemente heredasuna clase y no haces nada ms, los mtodos desde la interfaz de la clase base estnexactamente en la clase derivada. Esto significa que los objeto derivados no solotienen el mismo tipo, ellos tambin tienen los mismo comportamientos, lo cual no esparticularmente interesante.


25/109

25

Tienes dos formas para diferenciar tus nuevas clases derivadas de la clase baseoriginal. La primera es fcil: simplemente agregas marcas a las nuevas funciones de laclase derivada. Estas nuevas funciones no son parte de la interfaz de la clase base.Esto significa que la clase base simplemente no hace tanto como lo que quieres, asagregas ms funciones. Este simple y primitivo uso de la herencia es, a veces, lasolucin perfecta para tu problema. Sin embargo, deberas mirar ms de cerca la

posibilidad de que tu clase base necesite tambin esas funciones. Este proceso dedescubrimiento e iteracin de tu diseo sucede regularmente en la POO.

Aunque la herencia puede a veces implicar que agregas nuevas funciones a lainterfaz, no es necesariamente simpre verdadero. La segunda y ms importante formade diferenciar tus nuevas clases es cambiando los comportamientos de una funcin dela clase base que existe. Esto es referido como sobrescribir esa funcin.

Para sobrescribir una funcin, simplemente crea una definicin para la funcinen la clase derivada. Estars diciendo, Estoy usando la misma interfaz de la funcinaqu, pero espero hacer algo diferente para mi nuevo tipo.

Relacin es-un vs. es-como-un

Hay cierto debate que puede ocurrir acerca de la herencia: Debe la herenciasobrescribir solo funciones de la clase base (y no agregar nuevas funciones miembrosque no estn en la clase base)? Esto podra significar que el tipo derivado esexactamente el mismo tipo que la clase base desde que sta tiene exactamente lamisma interfaz. Como resultado, puedes sustituir exactamente un objeto de la clasederivada por un objeto de la clase base. Esto se puede pensar como una sustitucinpura, y es referido a veces como principio de sustitucin. En un sentido, esta es laforma ideal de tratar la herencia. A veces nos referiremos a la relacin entre la clase

base y las clases derivadas, en este caso, como una relacin es-un, porque tu dirs uncirculo es una figura. Una prueba para la herencia es determinar si puedes enunciar larelacin es un respecto de las clases, y que tenga esto sentido.


26/109

26

Hay veces en que debes agregar nuevos elementos a la interfaz de un tipoderivado, de esta forma extiendes la interfaz y creas un nuevo tipo. El nuevo tipopuede continuar siendo substituido por el tipo base, pero la sustitucin no es perfectaporque tus nuevas funciones no son accesibles desde el tipo base. Esto puede serdescrito como una relacin es-como-un; El nuevo tipo tuvo la interfaz del antiguo tipopero este tambin contiene otras funciones, no puedes realmente decir que es

exactamente lo mismo. Por ejemplo, consideremos un sistema de aire acondicionado.Supone que tu casa est cableado con todos los controles para el enfriador; es decir,tiene una interfaz que te permite controlar el enfriador. Imagina que el sistema de aireacondicionado se avera y lo reemplazas con un nivelador de temperatura, el cualpuede calentar y enfriar. El nivelador de temperatura es-como-un sistema de aireacondicionado, pero puede hacer ms. Porque el sistema de control de tu casa estdiseado solo para controlar el enfriamiento, esta restringido a comunicarse con solo laparte enfriadora del nuevo objeto. La interfaz del nuevo objeto est extendida, y elsistema existente no entiende sobre nada excepto la interfaz original.

Por supuesto que una vez que veas este diseo ser claro que la clase basesistema de enfriado no es suficientemente general, y debera ser renombrada como

sistema controlador de temperatura, as este tambin puede incluir el calentador en donde funcionara el principio de sustitucin. Sin embargo, el diagrama de arriba esun ejemplo de lo que puede suceder en el diseo y en el mundo real.

Resumen

En este captulo aprendimos algunas de las formas ms comunes de pensar enel sentido de los objetos. Ver todo como un objeto que pertenece a una clase y quetiene comportamientos y datos especficos y separados de otros objetos nos permiteencapsular mucho mejor nuestro problema al compararlo con el enfoque procedural delos antiguos lenguajes de programacin.

Tambin se vieron algunos ejemplos de la herencia y de las relaciones es un y

es como un.


27/109

27

ANLISIS Y DISEO ORIENTADO AOBJETOS

El paradigma orientado al objeto es una nueva y diferente forma de pensar enla programacin y muchos amigos han tenido problemas al hacer proyectos con estametodologa. Una vez que sabes todo lo que supone un objeto y aprendes a pensarms en el estilo orientado a objeto, puedes empezar a crear buenos diseos queaprovechan todos los beneficios que la POO ofrece.

Un mtodo (o llamado metodologa) es un conjunto de procesos y heursticasusadas para reducir la complejidad de un problema programable. Muchos mtodos dela POO han sido formulados desde la aparicin de este paradigma. Esta seccinorientar para que trates de terminar (porque muchos proyectos no terminan) cuandousas un mtodo.

Especialmente en la POO la metodologa es un campo muy experimental, y es

importante entender qu problema est tratando de resolver el mtodo antes deconsiderar adoptar uno. Esto es particularmente cierto en C++, en el cual el lenguajede programacin es reduce la complejidad (comparado con C) envuelta en expresar unprograma. Esto puede en efecto aliviar la necesidad de metodologa cada vez mscomplejas.

Es tambin importante realzar que el trmino metodologa es a vecesdemasiado grande y prometedor. Lo que sea que tu uses cuando diseas y escribes unprograma ahora, es un mtodo. Este podra ser tu propio mtodo y podras no serconsciente de lo que hace, pero es lo que sucede cuando ests creando. Si no es unproceso efectivo, podra necesitar una pequea afinacin para trabajar con C++. Si noests satisfecho con la productividad y la forma en que tus programas resultan,esperars considerar una metodologa formal o elegir partes de algunos mtodos

formales.Mientras ests en el proceso de desarrollo, la cosa ms importante es esto: note sientas perdido. Es fcil caer en eso. Muchos de los mtodos de anlisis y diseo sonhechos para problemas muy generales. Recuerda que la mayora de los proyectos nose ajustan a esa categora, de esta forma puedes tener un diseo y anlisis con unpequeo subconjunto del mtodo recomendado.

Es fcil quedarse pegado, caer dentro del parlisis en el anlisis, dondesientes que no puedes avanzar porque no sellaste todos los pequeos detalles de laetapa actual. Recuerda, no importa cuanto anlisis hagas, hay algunas cosas sobre elsistema que no se relevarn hasta el proceso de diseo e incluso algunas cosas nosern reveladas hasta escribir el cdigo, o hasta que el programa est efectivamenteejecutndose. A causa de esto, es crucial avanzar rpidamente a travs del anlisis yel diseo, e implementar una prueba del sistema propuesto.

Si ests buscando una metodologa que contenga sendos detalles y que sugieramuchos pasos y documentos, contina siendo dificultoso el saber cuando detenerse.Mantn en mente que ests tratando de descubrir:

1. Cules son los objetos? (Cmo dividir tu proyecto en sus partescomponentes?)

2. Cules son las interfases? (Qu mensajes necesitas tener disponiblespara enviar a cada objeto?)


28/109

28

Si tu te encuentras en estos momentos, con nada ms que objetos y susinterfases, puedes escribir un programa. Por varias razones necesitars de msdescripciones y documentos que eso.

El proceso puede ser abordado en cinco fases y una fase 0 que solo es elcompromiso inicial para usar algn tipo de estructura.

Fase 0: Construir un plan

Debes primero decidir que pasos dars en tu proceso. Esto suena simple (dehecho, todo esto suena simple) y todava hay gente que a veces no tiene ningn planantes de empezar a escribir el cdigo fuente. Si tu plan es sentarse y empezar aescribir, esta bien. (Muchas veces esto es apropiado cuando tu problema lo entiendesa cabalidad). A lo menos debes estar de acuerdo en que esto es un plan.

Puedes tambin decidir en esta fase que estructuras adicionales son necesariaspara el proceso, pero no todo. Hay cosas comprensibles, como por ejemplo, que aalgunos programadores les guste trabajar en el modo vacacin, donde no hay unaestructura impuesta en el proceso de desarrollo de su trabajo; esto terminar cuandotermine. Puede ser atractivo por algn momento, pero he encontrado que es bueno

establecer ciertas metas dentro del proyecto en vez de pensar en una gran meta finalllamada terminar el proyecto. En suma, dividir el proyecto en piezas ms pequeas yhacer que parezcan menos amenazantes (adems, las metas ofrecen msoportunidades para celebrar).

Cuando empec a estudiar una estructura de una historia para un libro (cuandoescrib una novela), me resist inicialmente a la idea de estructura, porque senta quecuando escribo simplemente dejo fluir mis pensamientos a travs de las pginas. Perodespus de realizado esto, cuando escrib sobre los computadores, la estructura estabalo suficientemente clara, as que no pensaba mucho en eso. Pero continoestructurando mi trabajo, a pesar de que est inconscientemente en mi cabeza, an sipiensas que tu plan es solo empezar a programar.

Establecer una misin

Cualquier sistema que construyas, no importa cuan complicado, tiene unpropsito fundamental, una necesidad bsica que ser satisfecha. Si puedes mirardetrs de la interfaz de usuario, el hardware o los detalles especficos del sistema, elcdigo fuente de los algoritmos y los problemas de eficiencia, eventualmenteencontraras el corazn de la existencia del sistema. Como es llamado en Hollywood, elconcepto superior, la descripcin en una o dos oraciones. Esta pura descripcin es unpunto de partida.

El concepto superior es muy importante porque le da el rumbo a tu proyecto; esel establecimiento de una misin. Quiz no tendrs este concepto claro la primer vez(ms tarde en tu proyecto puede ser todo muy claro), pero mantente intentando hastaque sientas que lo encontraste. Por ejemplo, en un sistema de control de trfico areopuedes empezar con un concepto superior enfocado sobre el sistema que estas

construyendo: El programa de la torre administra las pistas de los aviones. Peroconsidera lo que sucede cuando disminuye el sistema a un pequeo aeropuerto; quizhay solo un humano controlando o quiz nadie. Un modelo ms prctico que no sepreocupe de la solucin que ests creando tanto como se describe en el problema:Las aviones arriban, descargan, recargan y emprenden el viaje, ese podra ser unmejor concepto superior.

Fase 1: Qu estamos haciendo?


29/109

29

En la generacin anterior del diseo de un programa (llamado diseoprocedural), lo que estamos haciendo es llamado creando el anlisis de losrequerimientos y especificacin del sistema. Esto, por supuesto, fue hecho paraperder; documentos con nombres que intimidan. Sin embargo, su intencin fue buena.El anlisis de los requerimientos deca Haz una lista de directivas que ocuparemospara saber cuando el trabajo este listo y el consumidor est satisfecho. La

especificacin del sistema deca Aqu hay una descripcin de que har el programa(no como) para satisfacer los requerimientos. El anlisis de los requerimientos esrealmente un contrato entre tu y el consumidor (aun si el consumidor trabaja en tucompaa o es algn otro objeto o sistema). La especificacin del sistema es unaexploracin de alto nivel dentro del problema y en algn sentido es un descubrimientode que tanto este puede hacer y cuanto t iempo tomar en hacerlo. Desde que ambascosas requieren consenso entre la gente (y porque esas personas tendrn pocotiempo), pienso que es mejor mantenerse tan abierto como sea posible para ahorrartiempo. Quiz lo ms importante es empezar un proyecto con un montn deentusiasmo.

Es necesario mantener enfocado en nuestro corazn lo que ests tratando delograr en esta fase: determinar lo que el sistema se supone que hace. La herramientams valiosa para esto son los casos de uso. Los casos de uso identifican

caractersticas claves en el sistema que revelarn algunas de las clases fundamentalesque usars. Se encuentran esencialmente respuestas descriptivas a preguntas como:

Quin usar el sistema? Qu pueden esos actores hacer con el sistema? Cmo lo hace este actor para hacer esas cosas? Los mismos actores tienen un objetivo diferente? (se revelanvariaciones) Qu problemas pueden pasar mientras haces cosas con el sistema? (serevelan excepciones)

Fase 2: Cmo construiremos eso?

En esta fase debes aparecer con un diseo que describa lo que las clases son ycomo interactuarn. Una tcnica excelente para determinar las clases e interaccionesson las tarjetas de Clase-Responsabilidad-Colaboracin(CRC). Parte del valor de estaherramienta es que es de baja tecnologa: comienzas con una serie de tarjetas blancasde 3 por 5 y escribes sobre ellas. Cada tarjeta representa una clase simple y sobre laella escribes:

1. El nombre de la clase. Es importante que el nombre capture la esenciade lo que la clase hace.

2. Las responsabilidades de las clases: qu deberan hacer. Pueden serlistadas solo con los nombres de las funciones miembro (puesto que losnombre deberan ser descriptivos en un buen diseo), pero no prohbeotras anotaciones. Si necesitas empezar el proceso de escribir las clases,

piensa en esto: Qu objetos podras querer que aparecieranmgicamente para resolver tu problema?3. Las colaboraciones de las clases: Qu otras clases interactan con la

actual? Interactuar es un trmino dicho intencionalmente; esto podrasignificar agregar un mtodo o simplemente otro objeto existente quenos provea servicios para un objeto de la clase. Por ejemplo, si estascreando la clase fuego artificial, quin ir a observarla?, Un qumico oun espectador? El primero querra saber que qumicos van dentro de laconstruccin, y el ltimo respondera que colores y figuras se forman alexplotar.

Podras pensar que las tarjetas deberan ser un poco ms grandes para toda lainformacin que quieres poner ah, pero ellas son intencionalmente pequeas, no solopara mantener tus clases pequeas sino para mantener todos los detalles alejados deldiseo. Si no puedes ajustar todo en una sola tarjeta, tu diseo es demasiadocomplejo (o bien, ests siendo demasiado detallista o deberas crear ms clases). Laclase ideal es entendida a primera vista. La idea de las tarjetas CRC es asistirte alempezar con el primer diseo para as tener una idea global para luego refinar tudiseo.


30/109

30

Uno de los grandes beneficios de las tarjetas CRC es la comunicacin. Esrealmente en tiempo real, en un grupo, sin computadores. Cada persona tomaresponsabilidades de muchas clases (las cuales empiezan sin nombre u otrainformacin). Realizas una simulacin real resolviendo un escenario a la vez,decidiendo qu mensajes son enviados a los dems objetos satisfaciendo de estaforma cada uno de esos escenarios. Como tu estars en este proceso, descubrirs las

clases que necesitas, con sus responsabilidades y colaboradores, y llenars tu tarjetacon esa informacin. Cuando te revises todos los casos de uso, podras tener uncompleto primer acercamiento de tu diseo.

Cinco etapas en el diseo de objetos

El tiempo de vida del diseo de un objeto no est limitado a la poca en queescribiste el programa. Los objetos, tambin tienen sus patrones que emergen a travsdel conocimiento, el uso y el re-uso.

1. Descubrimiento del o bjeto. Esta etapa sucede durante el anlisisinicial de un programa. Los objetos pueden ser descubiertos observandofactores externos y lmites, duplicacin de elementos en el sistema y laspequeas unidades conceptuales. Algunos objetos son obvios si lostienes listos en una biblioteca de clases. Comnmente las clases bases ylas herencias pueden aparecer al instante o despus en el proceso dediseo.

2. Ensamblaje del objeto. Como estas construyendo un objetodescubrirs la necesidad de un nuevo miembro que no aparece duranteel descubrimiento del objeto. La necesidad interna de un objeto puederequerir otras clases que soporten esas necesidades.

3. Construccin del sistema. De nuevo, otros requerimientos para unobjeto pueden aparecer en esta tarda etapa. La necesidad porcomunicar e interconectarte con otros objetos en el sistema puedecambiar las necesidades de tus clases o requerir nuevas clases. Porejemplo, puedes descubrir la necesidad por clases que te ayudan, talescomo listas enlazadas, y que contienen informacin pequea o sin estado

y simplemente ayudan a otras clases.4. Extensin del sistema. Al agregar nuevas caractersticas a tu sistema,puedes descubrir que el anterior diseo no soporta extensiones simplesdel sistema. Con esa nueva informacin, puedes re-estructurar las partesdel sistema, posiblemente agregando nuevas clases o derivando.

5. Reutilizacin del objeto. Este es la prueba real ms dura para unobjeto. Si alguien trata de re-usarlo en una situacin enteramentenueva, probablemente descubrir algunos defectos. Al cambiar la clasepara adaptarla a nuevos programas, los principios generales de la clasesern claros y finalmente tendrs un tipo realmente reusable. Sinembargo, no anticipars que ms objetos en el diseo del sistema sonreusables esto es perfectamente aceptable para un diseo de objetosrealizado especficamente para un solo sistema. Los tipos reusables

tienen a ser menos comunes, y ellos deben resolver problemas msgenerales para ser ms reusables.

Directrices para e l desarrollo de objetos

Estas etapas siguieren algunas directrices cuando piensas en el desarrollo detus clases:

1. Deja a un problema especfico generar una clase, luego deja a la clasecrecer y madurar durante la solucin de otros problemas.

2. Recuerda: descubrir las clases que necesitas (y sus interfases) es elmayor trabajo que debes realizar en el diseo de un sistema. Si yatienes estas clases, este podra ser un proyecto fcil.

3. No te fuerces a ti mismo para saber todo desde un comienzo; aprende amedida que avanzas. Esto suceder de todas formas en algn momento.4. Parte programando; toma algn trabajo para as poder aprobar odesaprobar tu diseo. No temas si terminas con un tipo de cdigo alestilo procedural. Las clases malas no se vuelven mgicamente buenasclases.


31/109

31

5. Siempre mantn todo lo menos complicado posible. Objetos pequeos yclaros con una utilidad obvia ms que grandes y complicadas interfases.Cuando los puntos de decisin aparecen, usa esta aproximacin:considera las alternativas y selecciona la que es ms simple, siempre lasclases ms simples sern las mejores. Empieza simple y poco detallado,y podrs expandir las interfases de las clases cuando las entiendas

mejor, pero como el tiempo corre, es difcil remover elementos desdeuna clase.

Fase 3: Construyendo el ncleo.

Tu meta es buscar el corazn de la arquitectura de tu sistema que necesita serimplementada de tal forma de generar un sistema que corra, no importando cuanincompleto este el sistema inicialmente. Puedes estas creando un marco de trabajo(framework) para todo tu sistema, que se ejecute y realice iteraciones. Probablementetambin descubrirs cambios y mejoras que puedes hacer a tu arquitectura original cosas que podran no haber aprendido si no implementabas el sistema.

Asegrate de que tu prueba verifica los requerimientos y casos de uso. Cuando

el ncleo del sistema este estable, ests listo para seguir adelante y agregar msfuncionalidad.

Fase 4: Iterando los casos de uso.

Una vez que el marco de trabajo ncleo est ejecutndose, cada conjunto decaracterstica que agregas es un pequeo proyecto por si mismo. Agregascaractersticas durante la iteracin, un periodo razonablemente corto de desarrollo.

Cun grande es una iteracin?. Idealmente, cada iteracin toma una o dossemanas (esto puede variar de acuerdo al lenguaje de implementacin). Al final de eseperiodo tienes un sistema integrado y probado con ms funcionalidad que antes. Perolo que es particularmente importante para la iteracin: ya agregaste un simple caso deuso. No solo esto hace darte una mejor idea del alcance de tu caso de uso, sino quetambin da ms validacin a la idea del caso de uso desde que el concepto no esdescartado despus del anlisis y diseo, en lugar de eso es una unidad fundamentalde desarrollo a lo largo del proceso de construccin del software.

Tu terminas de iterar cuando funcionalmente logras apuntar o llegar a unafecha de tope y el consumidor puede estar satisfecho con la versin actual. (Recuerda,el software es un negocio de suscripcin.) Ya que el proceso es iterativo, tienesmuchas oportunidades para enviar un producto que todava puede seguirextendindose; los proyectos de cdigo abierto trabajan exclusivamente en unambiente iterativo y de alta retroalimentacin en el cual es preciso hacer estocorrectamente.

Un proceso de desarrollo iterativo es vlido por muchas razones. Puedes

advertir y resolver riesgos tempranamente, los consumidores tendrn una ampliaoportunidad de cambiar sus mtodos, la satisfaccin del programador es alta y elproyecto puede ser guiado con ms precisin.

Fase 5: Evolucin

Este es el punto en el ciclo de desarrollo que es tradicionalmente llamadomantencin, un trmino que puede significar todo desde poner a trabajar elprograma en la forma en que fue ideado inicialmente hasta agregar caractersticasque los consumidores olvidaron mencionar o hasta cosas ms tradicionales comoreparar errores. Quiz halla un termino mejor para describir esto.

Usar el trmino evolucin. Esto es, No podrs tenerlo todo la primera vez, as

tendrs la latitud para aprender, volver atrs y realizar cambios. Puedes necesitarhacer un montn de cambios y as, aprender y entender ms profundamente elproblema.


32/109

32

Quiz la ms importante cosa que debes recordar es que por defecto realmente por definicin si modificas una clase, luego sus superclases y subclasescontinan funcionando. Necesitas hacer modificaciones sin miedo (especialmente sitienes un conjunto dentro de una unidad de prueba que verifica el correctofuncionamiento de tus modificaciones). Las modificaciones no necesariamentedestruirn el programa y cualquier cambio en el resultado estar limitado a la subclase

y/o a colaboradores especficos de la clase que cambiaste.

Resumen

En este captulo se abordaron temas importantsimos a la hora de hacer elanlisis y diseo de un software de calidad basado en la orientacin a objetos.

Se dan pasos especficos y de mucha ayuda a la hora de empezar un proyecto:como empezar y como termina.

Algunas herramientas conocidas y recomendadas son los casos de uso y lastarjetas CRC .

Por ltimo, este captulo nos hace recordar las estadsticas: ms del 70% de losproyectos nunca se terminan.


33/109

33

ESTABLECIENDO LOSREQUERIMIENTOS Y ANLISIS

INICIALES DEL JUEGO

En esta seccin intentaremos definir los requerimientos del sistema, en nuestrocaso un juego de video, tal como si se tratase de un cliente que nos pide esta tarea.Por supuesto que la ventaja principal de ser nosotros mismos nuestro cliente es queconocemos todo con mucho detalle, una ventaja que un programador siempre desearatener. Solo quiero dejar en claro que todo esto es preliminar y se ira aumentando lacomplejidad en un proceso iterativo de desarrollo.

Lo que se denomina como requerimientos del juego es como el ao cero en elproceso de desarrollo del software. Aqu se establece qu esperamos de nuestro juego,

conocido como quiero que en mi juego mi nave este eludiendo proyectiles comoloco!, eso ya es un requerimiento... y muy complejo.En esta etapa de especificacin de requerimientos se puede producir muchas

veces en un juego. Por ejemplo, en Street Fighter 1 el requisito era hacer un juego depeleas y vagar por el mundo con Ryu en busca de contrincantes, luego en la ltimaversin quiz se este pensando en seleccionar de entre n jugadores y tener comocontrincantes m peleadores que dependan del personaje elegido, desarrollndose laaccin en un entorno tridimensional... bla, bla, bla. Como pueden ver el juego siguesiendo el mismo y a lo largo de los aos se han definido distintos requerimientos oparchando errores haciendo aumentar el nmero de la versin y de la revisinrespectivamente y, porque no, la entretencin.

Requerimientos del sistema (Fase 0 y Fase1)

Ahora nos pondremos en el caso de una compaa que pide que le hagan unvideo juego, ella exige lo que quiere y el desarrollador le entrega el producto dentro deun plazo razonable.

Comencemos:El nombre del juego es Alfa Destructio, Interventor y Alfa hace alusin a la

versin. Si vemos que el juego a quedado bien entonces haremos la versin Beta, esdecir, Beta Destructio, Interventor. Desde ahora en adelante abreviar AlfaDestructiocomo ADES.

ADES ser un juego de naves del gnero conocido popularmente como

shootem up. Se podr jugar de hasta dos personas.Cada persona controlar una nave en la pantalla. La nave que controlamos es

del modelo denominado Destructio (ficcin) y tiene energa , distintos tipos de arma ycada arma con distintos niveles de poder.

Estas naves deben ir avanzando a travs de etapas enfrentndose a distintasclases de unidades enemigas tales como tanques, naves, lanchas, helicpteros, etc.


34/109

34

Las etapas estarn creadas con un editor de etapas. Este editor de etapasestablecer dnde y cundo aparecer una nave enemiga y qu recorrido har por lapantalla. Tambin en l se crearn los elementos de juego, es decir, unidadesenemigas, unidades aliadas, proyectiles, tems de energa, tems de poder, etc.

Ahora que ya se han especificado los requerimientos iniciales del sistema eneste pequeo documento debemos empezar el trabajo del anlisis, luego el diseo,

luego la implementacin y las pruebas; la integracin y el lanzamiento de la esperadaprimera versin.Por supuesto que para cumplir con todos estos requisitos debemos crear casi un

juego completo. Entonces, Qu hacemos?. Tal como se explica en el captulo anteriordebemos crear pequeas metas para cumplir el objetivo final del programa que cumplecon todos estos requisitos iniciales, es decir, debemos crear sub requisitos, ir iterandoa travs del tiempo e integrando nuevas caractersticas a nuestro programa.

Por ejemplo, en una primera realizacin podramos tener la pantalla en modogrfico y nada ms. Eso ya sera un avance si esa seccin del juego funcionaperfectamente. No habra porque seguir preocupndose de la seccin inicializacin delmodo grfico.

Entonces lo que tendr esta primera versin del juego ADES sern loosrequerimientos anteriormente definidos: la versin 1.0 . El decimal se incrementar a

medida que avancemos hasta el entero. Definiremos de algn modo qu secciones deljuego, al ser desarrolladas, permitirn avanzar el decimal algunas unidades. Porejemplo, si desarrollamos el sistema de controles, avanzaremos el decimal en 0.2

Para que les quede claro como es el proceso de desarrollo de un programa, lesmostrar este diagrama:

Siempre para desarrollar una versin se parte desde la especificacin derequisitos, luego se produce el anlisis, el diseo, implementacin, integracin y sale aluz una nueva versin del software.

Haciendo un resumen y comparando con los pasos sugeridos en el captuloanterior, podemos ver que la fase denominada 0 es en la cual hacemos un plan detrabajo individual o en un grupo de personas. Mi plan es terminar el juego (versin 1)junto con este curso antes de 3 meses trabajando semanalmente en conjunto conotras personas que puedan aportan ideas tanto al diseo del juego como a laprogramacin misma. La fase 1 entonces es el anlisis de los requerimientos quepresent anteriormente como si un cliente nos pidiera que desarrollramos el juego.

Anlisis orientado al objeto (Fase 2)


35/109

35

Ahora viene la fase 2 en la que analizamos el sistema para encontrar las clasesy las relaciones entre las clases que puedan existir.

Existen varias tcnicas para llevar a cabo esta etapa. Ocuparemos las tres mssencillas para hacer un anlisis de los requerimientos. Estas tres tcnicas son:

Casos de Uso:

Es una tcnica de modelado utilizada para describir lo que un nuevosistema debe hacer o lo que un sistema existente ya hace. Los casos de uso representan una vista externa del sistema. Un modelo de casos de uso se construye mediante un proceso iterativodurante las reuniones entre los desarrolladores del sistema y los clientes(y/o los usuarios finales) conduciendo a una especificacin de requisitossobre la que todos coinciden. Un caso de uso captura algunas de las acciones y comportamientos delsistema y de los actores. El modelado con casos de uso fue desarrollado por Ivar Jacobson.

Descripcin informal en lenguaje natural Subrayar los nombre y verbos de la descripcin del problema Los nombres representan los objetos candidatos Los verbos representan las operaciones candidatas.

Tarjetas CRC (Clases/ Responsabilidades/ Colaboradores) Es una forma simple de analizar escenarios Son muy tiles para la enseanza del AOO, DOO y POO Facilitan las tormentas de ideas y la comunicacin entredesarrolladores Las tarjetas CRC pueden disponerse espacialmente para representarrelaciones de colaboracin Las tarjetas CRC tambin se pueden colocar para expresar jerarquas degeneralizacin / especializacin

Casos de UsoEmpecemos entonces con los casos de uso de nuestro juego.

1. Caso de Uso 1: El jugador inicia el juegoa. El jugador ejecuta el juegob. Selecciona desde un men empezar a jugar o elegir algunas

opcionesc. Si elige jugar, realizar el juego hasta que se le acaben las vidas.d. Vuelve al men principal.

Como ven ah tenemos nuestro primer caso de uso, totalmente primitivo yabstracto, pero siguiendo los prcticos consejos de sencillez lograremos irprofundizando en el concepto final.

Supongamos ahora que el usuario quiere seleccionar algunas opciones. Algunasde ellas sern por el momento nivel de dificultad y seleccin de los controles del juego:

2. Caso de Uso 2: El jugador selecciona el men de opcionesa. Se muestra en pantalla otro men con las opciones de cambiar

controles o cambiar nivel de dificultad.b. Si cambia alguna de los parmetros para las opciones, entonces

se procede a actualizar el juego con los nuevos parmetros.c. Se vuelve al men principal

Nuevamente la sencillez. Lo ms tranquilo posible. Ahora analizaremos el tercercaso de uso: empieza a jugar.

3. Caso de uso 3: Empieza a jugar.a.

Se establece el nmero inicial de vidas y energa por cada vida.b. Empieza la etapa inicial desde el principio con cero puntaje yalgunos proyectiles secundarios

c. La nave se sita en medio de la pantalla mirando hacia arriba.Un ltimo caso de uso es cuando el usuario dentro del juego presiona la tecla

escape.4. Caso de uso 4: El jugador presiona la tecla escape dentro del juego


36/109

36

a. Se despliega un dialogo en pantalla que pregunta si el jugadorquiere salir del juego actual.

b. Si selecciona si, el juego termina y se vuelve al men principal,sino se borra el dilogo y se contina con la ejecucin del juego.

Por ahora tenemos lo que se llama el armazn principal del juego: El inicio, elmedio y el final. Cada uno de los casos de uso representa un que pasa cuando y nos

ayudarn ms adelante a descubrir tanto nuevo objetos como nuevasresponsabilidades de estos.

Descripcin informal en lenguaje natural

Procederemos con la tcnica de la descripcin informal en lenguaje naturaldestacando los s u j e t o s que representan objetos candidatos y verbos que representanope rac i ones candidatas.

Este anlisis de sujetos y verbos se puede aplicar a algn anlisis independienteo incluso sobre los casos de uso. En nuestro caso lo aplicaremos a los casos de uso, esdecir, encontraremos los sujetos y verbos existentes en los 4 casos de usos anteriores.

La lista de sujetos es la siguiente: Jugador Juego Men Vidas Pantalla Controles Dificultad Energa Puntaje Proyectiles Tecla Dilogo

La lista de operaciones candidatas (obtenida de los verbos) son los siguientes: Iniciar el juego Ejecutar el juego Seleccionar desde men Realizar el juego Mostrar en pantalla Cambiar controles Cambiar nivel de dificultad Actualizar el juego Establecer nmero de vidas Establecer nivel de energa Situar la nave Presionar la tecla

Ahora que tenemos la lista completa de posibles candidatos a clases y

operaciones candidatas procedemos en una primera instancia a hacer una refinacineliminando o reemplazando los nombres para hacerlos ms descriptivos.

Jugador Juego Men Vidas Pantalla Controles Control Dificultad Nivel de Dificultad Energa Puntaje

Proyectiles

Proyectil Tecla Componente de perifrico Dilogo Men

Se han cambiado algunos nombres de operaciones candidatas para hacerlasms entendibles. Controles pasa ha ser una clase genrica llamada Control. Tecla apasado a ser un componente de perifrico como por ejemplo el clic derecho sera uncomponente del mouse. Dilogo tambin es de tipo men.


37/109

37

La segunda fase es eliminar cualquier frase que describa cosas fuera delsistema, sobre las cuales el sistema no tiene control:

Jugador (X)Pero reemplazamos la clase Jugador con Unidad Controlable, que es la

representacin en el juego del humano que manipula la unidad. Para que quede ms

claro a

Curso programacion de videojuegos en c++

Documents

Transcript of Curso programacion de videojuegos en c++