TESIS LICENCIATURA EN COMPUTACION …148.206.53.84/tesiuami/UAMI11025.pdf2 Agradecimientos Martínez...

LICENCIATURA EN COMPUTACION

UNIDAD IZTAPALAPA CBI

“CD ROM Interactivo en Java

sobre el lobo mexicano”

Realizado por:

Martínez Ramírez América Marcela Figueroa González Rogelio Corona Trenado Daniel Hernández Romero Claudia Elizabeth

Asesor: Luis Martín Rojas Cárdenas

Realizada en: El Laboratorio de Técnicas y Aplicaciones

para la Multimedia Distribuida

TESIS

2

Agradecimientos

Martínez Ramírez América Marcela

Gracias a Dios por permitirme llegar a la culminación de mi carrera y por ser la fortaleza que siempre me inspira y acompaña.

A mis padres por su apoyo incondicional y caminar siempre a mi lado por brindarme luz cuando se veía todo obscuro y porque son mi fuente de inspiración y lo que me anima a seguir adelante, este título también es suyo.

A mi angelito (Anamar) por su paciencia y comprensión, espero seguir siendo un buen ejemplo así como tú lo eres para mí.

A mis tíos, tías y primos por su apoyo incondicional, comprensión, ayuda y tolerancia.

A mis amigos Rogelio y Daniel a quienes considero como de la familia, gracias por permitirme compartir esta carrera con ustedes, somos un buen equipo.

Al Dr. Luis Martín Rojas por ser nuestra guía en este trabajo y por convertirse en un amigo para nosotros.

Y por ultimo a todas esas personas que sin ser nombradas ocupan un lugar muy especial en mi corazón, gracias porque sin su influencia no hubiera podido llegar hasta donde me encuentro hoy. Figueroa González Rogelio

Hay muchas personas a las que quiero agradecer, a mis amigos, a mis profesores, a Dios y a mi familia pero en especial a mis padres: Julio y Maria del Carmen, a mis hermanos: Joel, Maria Victoria y Rigoberto, y a mis tíos: Jesús y Rosalinda.

Les doy las gracias por todo lo que me han dado, por su cariño, apoyo y comprensión. Este triunfo se los dedico con mucho cariño, cada uno de ellos forma parte del motor que me impulsa a seguir adelante y junto con Dios me dan la fuerza que necesito en los momentos difíciles. Gracias por estar con migo y a Dios por esta oportunidad.

3

Corona Trenado Daniel

Para llegar a la culminación de mi carrera profesional ha sido muy importante la ayuda de mi mamá Leonor, ya que ella me ha dado todo su apoyo de manera incondicional y ha estado conmigo en todo momento, todas las palabras de agradecimiento que ponga son pocas para agradecerle todo lo que ha hecho por mí. También agradezco la comprensión y ayuda de mis hermanos Carlos y Fernando a los cuales va dedicado el presente trabajo.

De manera especial dedico el presente y agradezco de corazón el apoyo y la ayuda de mi tío Marcos y mi tía Teresa, así también a mis tías: Lucia, Guadalupe y Patricia.

Agradezco al Dr. Luis Martín Rojas Cárdenas la comprensión y el apoyo que nos dio durante la realización del proyecto terminal.

A todos los profesores de la UAM-I por haberme formado académicamente y por el esfuerzo que hacen constantemente en la investigación y en la formación de los estudiantes universitarios.

Por ultimo gracias por el apoyo y ayuda de mis amigos: Juan, Miguel, Marcela y Rogelio, gracias por su amistad. Hernández Romero Claudia Elizabeth

Estas líneas se las dedicó a las personas que colaboraron para alcanzar una meta más en mi vida profesional.

A mi madre María Teresa Romero Silva por darme todo ese apoyo moral y estar siempre a mi

lado para llorar o sonreír juntas.

A mi padre Crescencio Hernández Gutiérrez por sus regaños y darme la libertad de dejarme ser quien soy.

A mi hermanita Diana Teresa Hernández Romero por sus consejos y escucharme cuando necesitaba hablar con alguien.

A José Francisco Díaz Castillo por enseñarme a amar la vida y a él, darme la fuerza y el coraje

para seguir adelante y enseñarme a luchar hasta el final por las cosas que quiero. A la profesora Elizabeth Pérez Cortés por creer en mi, y ser un ejemplo a seguir.

Gracias a cada uno de ellos porque son parte importante de mi existencia y han llenado mi vida

de momentos verdaderamente felices e inolvidables. "Haz que cada día de tu vida sea extraordinaria. Carpe Diem. " De la película: "La sociedad de los poetas muertos".

4

Índice Capitulo 1. Introducción...............................................................................................................................5 Capitulo 2. Descripción del sistema a realizar..............................................................................................6

2.1 Características generales ...........................................................................................................6 2.2 Características del sistema huésped...........................................................................................7 2.3 Descripción general del funcionamiento ...................................................................................7

Capitulo 3. Solución propuesta...................................................................................................................10

3.1 Selección de la herramienta de desarrollo ...............................................................................10 3.1.1 Lenguajes de Programación.......................................................................................................10 3.1.2 Paquetes.....................................................................................................................................11 3.1.3 Porque se utilizó el lenguaje Java. .............................................................................................11

3.2 Desarrollo. ...............................................................................................................................12 3.2.1 Introducción...............................................................................................................................12 3.2.2 Menú Cubo ................................................................................................................................13 3.2.3 Primos del lobo mexicano .........................................................................................................15 3.2.4 Videojuego del Lobo .................................................................................................................40 3.2.5 Anatomía del lobo mexicano.....................................................................................................53

5

Capitulo 1. Introducción La situación actual del país está impulsando a la mejora de las técnicas de enseñanza –aprendizaje,

renovando la manera de adquirir conocimientos llevándonos a una mejor educación ya que ésta compete a todas las partes integrales de la sociedad, es por esto la preocupación de diferentes organismos por la educación en el sector infantil.

Debido a que la educación no sólo es impartida en las aulas educativas, si no también en otros sitios de recreación y diversión como es un zoológico, se tuvo la preocupación de enseñar a los niños sobre una especie animal que se encuentra en peligro de extinción. Este proyecto surge para apoyo en las actividades escolares de los niños.

El lobo es una especie muy interesante pero a la vez muy temida por toda la temática desarrollada alrededor del mismo, por mostrarlo como un animal salvaje y peligroso. Existen diferentes leyendas donde el actor principal o hasta el antagónico siempre se muestra como un lobo lo cual no es cierto.

Desconocemos muchos aspectos de la naturaleza, pero realmente es lamentable saber que la falta de información es uno de los factores por lo que distintas especies se encuentren a los márgenes de la extinción. Aunado a esto y con el auge que han tenido las técnicas multimedia para la difusión de la información es que se ha desarrollado esta aplicación, cuyo contenido se basa en imágenes, audio, vídeos y animaciones los principales elementos visuales y auditivos para poder capturar la atención de los niños a los cuales va dirigido.

El programa contenido en el CDROM ”El lobo mexicano” ha sido desarrollado bajo el lenguaje Java, debido a que él facilita la programación para crear las animaciones, reproducir el audio y video necesarios, además de aprovechar su entorno orientado a objetos.

Es importante recalcar que el presente proyecto se hizo en colaboración con el departamento de Biología perteneciente a la División de Ciencias Biológicas y de la Salud , y en particular con la colaboración del Dr. Armella, quienes están trabajando en conjunto con el zoológico de Guadalajara, quien fue el interesado en el desarrollo del software.

6

Capitulo 2. Descripción del sistema a realizar

2.1 Características generales

El proyecto está enfocado al sector infantil, más específicamente a niños entre seis y ocho años, con la finalidad de apoyar la enseñanza y fomentar la educación en lo que respecta a la naturaleza. Para capturar la atención de los niños, la aplicación se basa en gráficos, animaciones, video y sonido.

Con el afán de fomentar una conciencia ecologista sobre la fauna silvestre. Esta aplicación muestra a los niños que el lobo mexicano puede ser su amigo siempre y cuando no sea provocado, además de crear una conciencia sobre esta especie que se encuentra en peligro de extinción y que mejor que enfocar este esfuerzo al sector infantil para que desde niños cuiden la naturaleza ay por ende el medio que los rodea.

El término interactivo va muy bien con este proyecto ya que en todo momento el usuario es el que dirige el curso de lo que quiere aprender. La información que se presenta corresponde a la fisiología del lobo mexicano, a conocer el habitat de éste y los hábitos alimenticios de esta especie. Esta información esta contenida en un CD-ROM configurado en modo “autorun”, el cual permite ejecutar los programas ahí contenidos sin necesidad de indicarlo explícitamente. En efecto, sólo basta introducir el CD ROM para que el programa comience.

7

2.2 Características del sistema huésped

Estando desarrollada esta aplicación sobre plataformas Windows con el lenguaje

Java, los requerimientos mínimos son los siguientes:

Hardware Procesador Pentium 166MHz . Monitor de 14” Indispensable bocinas

Sistema operativo

Windows 98

Software JDK 1.3 mínimo. JMF. Internet Explorer v. 4

Memoria 128 MB de RAM.

Disco duro 120 MB de espacio disponible en disco duro para una instalación del JDK1.3 ; los requerimientos de espacio en el disco duro varían de acuerdo a la versión del JDK instalado.[También se puede descargar el JSK en cualquiera de sus versiones posteriores a la tres].

Unidades de disco

Unidad de CD-ROM drive.

Monitor Monitor que pueda mostrar 256 colores y una resolución de 800 x 600 o mayor.

Tabla 1. Requerimientos mínimos

Cabe mencionar la importancia de que se tenga como navegador el Internet Explorer, ya que la aplicación trabaja a partir de éste.

Todo el audio utilizado en la aplicación tiene formato MP3 ya que consigue combinar calidad de sonido con un tamaño de archivo pequeño.

Para mantener la calidad de toda la aplicación los videos que se despliegan son formato MPEG, estos son una combinación de imagen y sonidos digitales embebidos en un solo archivo digital. Se escogió este tipo de archivo por ser un algoritmo normalizado, características que favorece encontrar sin gran esfuerzo software libre de codificación, manipulación, decodificación, etc.

2.3 Descripción general del funcionamiento

La aplicación comienza cuando el CD-ROM se introduce en la unidad lectora, por

acción del autorun, pasando a una breve introducción sobre el tema de la aplicación,

8

al finalizar se muestra un cubo girando que tiene la función de un menú donde en sus diferentes caras se muestran las diferentes opciones a las que puede accesar el usuario.

Estas secciones son:

Primos del lobo mexicano

Juega con el lobo

Anatomía del lobo

Video del lobo

Otros sitios del lobo

Mapa del sitio

En la sección “Anatomía del lobo” se muestra una imagen donde se tiene una función tipo zoom, es decir, cada vez que se da clic en un lugar de la fotografía se amplia el espacio alrededor; cuando se da clic en la panza del lobo se abre un panel donde a través de una barra de desplazamiento se muestra un esquema de los huesos del lobo. Si se da clic en los ojos del lobo se muestra un video referente a esta especie.

En “Primos del lobo” muestra un planisferio y la localización de los diferentes puntos de las regiones donde habitan más especies de lobo, estas se concentran en el hemisferio norte del planeta. Cada vez que se da clic en estas zonas se amplia la imagen y muestra un video.

La parte más interactiva de la aplicación es un juego de cacería donde el lobo mexicano es el protagonista, siendo el objetivo de éste la sobrevivencia de nuestro personaje, realizando dicha actividad atrapado conejos(parte de la pirámide alimenticia de los lobos) y llevándolos hasta su cueva siempre escapando de la escopeta del cazador.

“Video del lobo” despliega un video de la vida del lobo mexicano en su ambiente en el zoológico de Guadalajara.

En “Otros sitios del lobo” se muestran unas ligas a otros sitios de interés para aquellos fanáticos del tema.

En “Mapa del sitio”, se muestra un esquema de cómo está conformado esta aplicación.

9

Cabe mencionar que toda la aplicación está montada en paginas html por lo que los botones de cerrar y volver a atrás, están bajo la influencia de programación web, específicamente html y javascript.

La estructura de la aplicación se especifica en la siguiente figura y el modo de terminar con la aplicación es a través de botones que permiten cerrar la ventana en la que es desplegada la aplicación :

Figura 1. Diagrama de la estructura del software

10

Capitulo 3. Solución propuesta

Este capítulo tiene la finalidad de plantear las necesidades de cada sección de la aplicación, así como de proporcionar la solución desarrollada para cada una de ellas, el orden de la solución corresponde al de la Figura 1.

3.1 Selección de la herramienta de desarrollo

Para garantizar un buen desarrollo de la aplicación es conveniente elegir bien los instrumentos o herramientas de trabajo y para seleccionarla se tienen que tomar en cuenta los siguientes aspectos:

La herramienta debe cubrir todos los requerimientos especificados.

El dominio que tengan los programadores sobre la herramienta va a contribuir a la productividad y beneficio de todos los recursos (tiempo, calidad y esfuerzo principalmente).

Costo de la licencia del software a utilizar

3.1.1 Lenguajes de Programación.

A continuación se muestran los lenguajes programación que se evaluaron para

desarrollar el sistema multimedia.

Pascal

C

C++

Visual Basic

Visual C

11

Visual C++

Java

3.1.2 Paquetes.

El paquete que se evaluó para el desarrollo de la aplicación fue Flash, que es una herramienta completamente gráfica diseñada para crear animaciones básicamente.

3.1.3 Porque se utilizó el lenguaje Java.

Las razones por las que se eligió este lenguaje es por ser:

Independiente de Plataforma. Es decir que una aplicación java se puede ejecutar en

diferentes sistemas operativos.

Orientado a Objetos. Soporta las tres características del paradigma Orientado a Objetos que son: Herencia, encapsulación y polimorfismo.

Multihilo. El beneficio de ser multihilo consiste en un mejor rendimiento interactivo y mejor comportamiento en tiempo real.

Soporte para desplegar videos bajo la norma mpeg.

Gratuito. No se paga licencia.

12

3.2 Desarrollo.

3.2.1 Introducción

La aplicación comienza la ejecución del autorun que no es más que un archivo de

texto donde se especifica un icono y la acción de abrir el navegador de Internet además de especificarle cual es la pagina de inicio, tiene la siguiente apariencia:

[autorun]

OPEN=C:\windows\explorer.exe Pagina_inicio.htm

ICON=Nombre_del icono imagen.ico

La primera acción del programa es abrir la pagina en el navegador, lo cual e configuró para que la aplicación corriera en modo pantalla completa. El lenguaje que permite establecer dicha modalidad con la que se abrirá la pagina es “Javascript”.

Javascript es una lenguaje que nos permite interactuar con el navegador de manera dinámica y eficaz, proporcionando a las páginas web dinamismo, está basado en guiones(scripts), objetos y guiado por eventos.

El objeto de mayor jerarquía es window donde a través de sus propiedades y sus métodos se puede configurar la pantalla de nuestra aplicación. La función open tiene la siguiente estructura:

open(URL,nombre,caracteristicas)

las características que se pueden configurar son las siguientes:

height: especifica la altura en pixels de la ventana creada.

menubar: si su valor es yes, crea una barra de menú en la parte superior de la ventana.

resizable: si su valor es yes, permite al usuario cambiar el tamaño de la ventana.

scrollbars: si su valor es yes, crea barras de desplazamiento vertical y horizontal cuando el tamaño del documento sea mayor que el de la ventana.

toolbar: si su valor es yes, crea una barra de herramientas estándar con botones.

width: especifica la anchura en pixels de la ventana creada.

fullscreen: si se especifica yes el navegador abrirá la pantalla en modo completo.

13

3.2.2 Menú Cubo

Con afán de tener algo llamativo antes de entrar a las actividades del software, se creó un menú animado, en forma de cubo que gira en todas direcciones con influencia de la posición del ‘ratón’, en donde cada una de sus caras es un ‘link’ para ir a las diferentes secciones.

EL programa se denomina cubo.java y los pasos que realiza son:

Obtención de las imágenes para las caras

Creación de buffer’s para las mismas

Obtención de los parámetros como: color de fondo, velocidad de giro, color de la

fuente, links, etc.

Manipulación de los píxeles de cada una de las imágenes.

Construcción del cubo

Cuestiones de giro

Obtención de coordenadas y atención al evento doble clic para ir a las diferentes secciones.

Cuando un applet necesita obtener parámetros externos generalmente los obtiene de la pagina web donde está incrustado utilizando las etiquetas tradicionales de html se prosigue de la siguiente manera:

<applet code=<”nombre_del_apple t.class” width="ancho_px" height="alto_px" align="middle">

<param name="nombre de la variable" value="valor">

…

</applet>

Se pueden enlistar todos los parámetros que sean necesarios.

En el método init() se inicializan las variables a través del método ‘Obtiene_parametros()’ donde se establecen las seis imágenes, la velocidad para el giro del cubo, así como el tamaño del mismo. Estos se establecen en variables globales que se utilizarán a lo largo del programa.

El tamaño del cubo es relativo a las dimensiones del applet, a través del método size() se calcula el ancho y el largo de este.

La aplicación corre a traves de un hilo de ejecución que va captando los eventos durante la ejecución del applet y atiende los eventos como si la ventana se

14

cierra o se traslapa con alguna otra para lograr un buen despliegue de las imágenes del cubo girando.

La parte medular del cubo es la obtención de las imágenes y el tratamiento que se les da, gracias a las matrices de pixelaje que se forman a cada una de ellas para al momento de los giros tener exactamente la inclinación y el ángulo que hacen que no se distorsionen las imágenes al momento del giro y al atender los eventos del ratón.

Cabe mencionar que el tratamiento geométrico para que el cubo pudiera girar se obtuvo del codigo fuente encontrado en la liga http://atenea.udistrital.edu.co/estudiantes/oleon/page2.htm que es de donde se basó para la realización de este menú.

Los métodos de gestión del ratón definidos en este applet son los siguiente:

mouseDown Este método se ejecuta cuando se pulsa un botón del ratón. En este caso se realiza

una validación de la posición del ratón el cual debe de estar contenido entre los valores si la variable Movimiento tienen valor verdadero Tamaño.heigth menos la posición sobre el eje de las y es menor que treinta y dos que es la cantidad que delimita el marco de cada una de las imágenes. En caso que la validación haya sido exitosa se procede a la validación del URL (linked) para mostrar la siguiente página atendiéndola argumento “target”.

Dentro de un applet se puede visualizar otro documento con el método Showdocument tiene dos constructores, y no marca error en caso de una falla por lo que fue necesario comprobar los URL’s en otra parte del codigo.

La sintaxis es:

showDocument (url, posición)

donde url, es la especificación de la página o archivo a mostrar y posición se refiere a la posición dentro de la ventana del navegador, las opciones para este atributo son:

_self =muestra en el marco actual

_parent=mostrar en el marco padre

_blank=en una ventana nueva del navegador

La aplicación siempre muestra en el marco actual.

mouseEnter Cuando el ratón entra a la ventana se ejecuta este método y entonces se pone la

variable que controla al hilo en ‘true’ para que continúe el giro del cubo.

15

mouseExit Hace lo contrario que el método MouseEnter pone en falso la variable para indicarle al hilo que el ratón se encuentra fuera dela región de la ventana y por lo tanto del applet.

mouseMove La variable que habilita el hilo se pone en true, se comprueba que la variable Movimiento sea verdadera también y se procede a evaluar la posición del ratón que es restada a la mitad del tamaño del applet y es dividida por el ancho multiplicada por el doble de la velocidad (que es uno de los parámetros obtenidos desde la pagina html). Esto proporcional efecto que cuando la posición del ratón restada del centro del applet disminuye la velocidad ya que indica que probablemente se tienda a pulsar sobre alguna de las imágenes y cuando la posición es alejada lo que permite que el cociente de la división sea mayor la velocidad aumenta y podemos ver esto reflejado en los giros del cubo.

Problemática

Se tuvo la necesidad de incluir código en javascrip para hacer la ventana “pantalla completa”, ya que java no me permite esa habilitación para la ventana.

Otro problema, para las direcciones de las ligas es que no opera con direcciones relativas, es decir se tiene que especificar la pagina o documento a abrir desde raíz.

3.2.3 Primos del lobo mexicano

El objetivo de este applet en el sistema multimedia descrito, es el de informar al usuario acerca de las diferentes especies de lobos que existen en el mundo.

Requerimientos del Applet “EspeciesLoboMundo” correspondiente al módulo “Primos del lobo mexicano”.

El applet está compuesto por tres ventanas, las cuales se describen a continuación. Al inicio el applet desplegará al usuario la ventana uno que muestra al planeta tierra en el espacio. En esta ventana el usuario podrá realizar lo siguiente:

1. Rotar al planeta tierra, a la derecha ó izquierda sobre su propio eje, arrastrando el

ratón. Con esto el usuario podrá ver todas las regiones continentales del planeta tierra.

2. Dar un clic en alguna de las regiones del planeta tierra donde habitan las diferentes

especies de lobo.

Si se da un clic en una región del planeta donde hay lobos, el applet debe desplegar una animación de esa región para llegar a la ventana dos, la cual realiza un zoom(acercamiento) a la zona marcada por lo que al final se tiene la imagen abarcando

16

toda la pantalla. Una vez concluida la animación, la ventana dos está constituida por:

a)Una imagen en grande de la región continental donde se dio el clic, además de estar marcadas con elipses las zonas de la región donde habitan los lobos. b)Una imagen situada en la parte inferior izquierda la cual servirá para regresar a la ventana uno.

En la ventana dos el usuario puede realizar lo siguiente:

1. Dar un clic en la imagen que se encuentra en la parte inferior izquierda de la pantalla para regresar a la ventana uno en donde se muestra el planeta tierra en el espacio.

2. Dar un clic en alguna región elíptica de la región continental del planeta tierra

donde se muestra el video del lobo correspondiente a dicha región en una nueva ventana que también contendrá una imagen que permita regresar a la ventana anterior.

Solución a los requerimientos Para explicar la solución propuesta para este applet dividiremos esta sección en las cuatro partes siguientes: Ventana 1. En esta sección se hablará de los elementos que componen a esta ventana

así como la solución propuesta para:

-Rotación del Planeta Tierra.

-Validación de Regiones Continentales

-Animación de Acercamiento a Región Continental.

Ventana 2. En esta parte se hablará de los elementos que componen a esta ventana así como la solución propuesta para:

-Validación de Regiones elípticas y Región de Regreso a ventana1.

Ventana 3. En esta sección se hablará de los elementos que componen a esta ventana así como también de:

-Despliegue de Vídeo en Java bajo la norma mpeg video.

Aplicación Completa. En esta sección se explicará:

-Cada una de las clases que componen a la aplicación completa así como el objetivo de

cada una de ellas.

-Diagrama de Clases

17

Es importante mencionar que aquí sólo se explicará la solución dada a los requerimientos explicados anteriormente por lo que sí se desea consultar todo el código del Applet “EspeciesLoboMundo” será necesario pasar a la sección Anexo A.

Ventana uno.

Esta ventana muestra inicialmente el planeta tierra en el espacio para lo cual se utilizaron dos imágenes, una del espacio que se despliega como fondo y la otra del planeta tierra al frente ubicado en el contiuenete americano. Para realizar esto en Java se debe dibujar las imágenes en el orden mencionado (Ver figura 1).

Imagen del Espacio Imagen del Planeta Tierra.

Ventana 1

Figura 2. Constitución de la ventana 1 del applet “EspeciesLoboMundo”.

Rotación del Planeta Tierra.

Para rotar el planeta tierra el usuario deberá arrastrar el ratón en la dirección que se desee ya sea izquierda o derecha, para lograr el efecto es necesario tener un número adecuado de imágenes del planeta tierra en secuencia (tantas como calidad y presentación se desee) para desplegarlas una después de otra con cierto intervalo de tiempo para concluir la rotación.

El algoritmo para la rotación del planeta tierra.

18

Para explicar este algoritmo se utilizarán tres imágenes del planeta tierra mostradas

en la figura 3. Es importante mencionar que las imágenes ocupadas para la rotación de la tierra están ordenadas de la misma forma que las imágenes que se muestran en la figura 3.

Imagen 0 Imagen 1 Imagen 2

Figura 3. Imágenes del Planeta Tierra para la rotación.

Supongamos que inicialmente se muestra en pantalla la imagen 0. Si el usuario

arrastra el ratón a la derecha la siguiente imagen que se debe mostrar en pantalla es la 1. De otra forma si el usuario arrastra el ratón a la izquierda la siguiente imagen que se debe mostrar en pantalla es la 2.

Realizando un análisis y tomando en cuenta lo explicado anteriormente se construyo la tabla 1, la cual se muestra a continuación:

Imagen Actual # de imagen después de

arrastrar el ratón a la izquierda.

# de imagen después de arrastrar el ratón a la derecha.

0 2 1 1 0 2 2 1 0 TABLA 2. Tabla de rotación del planeta Tierra para las tres imágenes de la figura 2.

Para atender los movimientos de rotación del planeta se implementaron dos funciones que soportan este algoritmo denominado RotacionImDer( ) que atiende al evento del ratón cuando es arrastrado a la derecha y para el movimiento contrario se tiene a la funcion RotacionImIzq( ).

A continuación mencionemos los aspectos técnicos de Java que consideramos

necesarios para la comprensión del código mostrado en el Anexo A, que atendieron la solución de este applet. En Java hay muchos tipos de eventos generados por el teclado, por botones o por el ratón cuando es arrastrado, cuando entra en la ventana o sale de ella, entre otros.

Dado que nos interesa recibir notificaciones cuando se arrastra el ratón ya que el planeta debe rotar se implementará la interfaz “MouseMotionListener” que

19

define dos métodos para recibir notificaciones, uno para cuando se mueve y otro para cuando se arrastra el ratón. El método “mouseDragged”, nos indica cada cuando es arrastrado el ratón por el usuario, lo que queda por determinar es que dirección tiene el arrastre para darle orientación a la rotación por lo que es necesario implementar la interfaz “MouseListener” la cual define cinco métodos para recibir notificaciones, uno para cuando se presiona y libera el ratón en el mismo punto, otro para cuando se introduce al ratón en un componente, otro para cuando el ratón sale de un componente, uno para cuando se presiona el ratón y uno para cuando se libera. De los cinco métodos anteriores el que nos ayuda a resolver la pregunta anterior es el método “mousePressed”, el cual se llama cada vez que el usuario presiona el ratón. Es importante observar que cada vez que se arrastra el ratón se sigue el comportamiento del autómata mostrado en la figura 3, la cual se muestra a continuación:

mouseDragged( ) mousePressed( ) mouseDragged( ) moseReleased( )

Figura 4. Autómata que se sigue cuando se arrastra el ratón.

Para identificar hacia donde el usuario ha arrastrado el ratón, primero se guarda la posición x en una variable, posx_pressed en el instante que ja sido presionado el ratón (dentro del metodo “mousePressed”) y por ultimo se salva la posición x en posx_dragged dentro del método “mouseDragged” que se ejecuta cuando el ratón está siendo arrastrado , entonces:

Si posx_pressed > posx_dragged entonces

//Se arrastro el ratón a la izquierda. RotacionImIzq( ); // Se produce una rotación a la izquierda

Otro //Se arrastro el ratón a la derecha.

RotacionImDer( ); // Se produce una rotación a la derecha Así se concluye la orientación de la rotación del planeta tierra.

Validación de Regiones Continentales.

Una vez hecha la rotación del planeta tierra, el paso siguiente es la validación de las regiones continentales para que cuando se dé un clic en alguna de ellas se obtenga la información correspondiente. Las tres regiones donde habitan todas las especies de lobos se muestran en la figura 4 sombreadas.

20

EuroAsia1 EuroAsia2 América del Norte

Figura 5. Regiones donde habitan todas las especies de lobos en el mundo.

La problemática sobre la validación de las regiones

Las regiones continentales a validar se encuentran sobre la superficie esférica del planeta tierra.

El planeta tierra puede rotar, con lo cual la imagen actual cambia constantemente.

Cada una de las regiones continentales abarca un conjunto de imágenes, esto debido a la extensión ó tamaño de la región continental .

A manera de ejemplo veamos lo siguiente:

Se desea validar la región continental de América del Norte tomando el conjunto de imágenes correspondientes donde cada una de ellas tendrá un rectángulo el cual servirá para validar de manera individual una imagen y con lo cual se podrá validar de manera global la región continental completa. En la figura 6 se muestran las imágenes que abarca la región continental de América del Norte, acomodadas como en la aplicación real. De la Imagen 3 a la 15 corresponden a las otras regiones continentales.

21



Figura 6. Imágenes que abarca la Región Continental de América del Norte.

Se requiere de una variable en él modulo principal con la cual se controle el índice

de la imagen actual en pantalla, ya que esta variable nos servirá para detectar de manera rápida en que región continental fue dado el clic. Por ejemplo, considerando las imágenes anteriores, si el usuario da un clic en la ventana uno y él índice de la imagen actual es el siete, es obvio que el clic no fue dado en la región continental de América del Norte, pues este índice no está en el conjunto de índices que abarca dicha región. Por esto cada una de las regiones continentales está integrada por un conjunto de índices de sus correspondientes imágenes.

Cada una de las regiones continentales, estará representada por:

Un conjunto de zonas rectangulares(rectángulos).

Un conjunto de índices de imágenes.

Para ejemplificar la validación de un rectángulo en la figura 7 se muestra uno cuyas dimensiones son 100 unidades de ancho y 200 unidades de largo, el cual se encuentra dentro de una ventana de tamaño 400 unidades de ancho y largo.

22

0 100 200 300 400 (x)

0 100

200 Ventana 1

300 400

(y) Rectángulo.

Los puntos contenidos dentro del rectángulo son aquellos donde { (x , y) con x entero, y entero | x >= 100, x <= 200, y >= 100, y <= 300 }

Figura 7. Validación de un Rectángulo.

Una vez analizado lo anterior fue necesario tener una clase en la cual almacenar cada una de las regiones continentales. Dicha clase será: “RegCont” que guarda la siguiente información:

Variables miembro

//Arreglo para almacenar el conjunto de índices que abarca una región Continental.

int imagenes[]; //Coordenadas de los rectángulos. int p1x[]; Coordenada x del punto superior izquierdo del rectángulo int p1y[]; Coordenada y del punto superior izquierdo del rectángulo int p2x[]; Coordenada x del punto inferior derecho del rectángulo int p2y[]; Coordenada y del punto inferior derecho del rectángulo //Número de rectángulos que corresponden a la región continental int num_rect; Los métodos de la clase “RegCont” son los siguientes: Un método constructor para inicializar las variables miembro.

Un método para guardar los rectángulos e índices de la región continental.

Un método para validar si un punto (x, y) esta dentro ó fuera de un rectángulo de dicha región continental

Un método para validar de manera global si un punto(x, y) esta dentro ó no de la región continental

23

Animación de acercamiento a región continental.

Una vez que el usuario ha dado un clic en una región continental se lanza una animación de acercamiento que abarcará toda la pantalla, la cual está compuesta por dos animaciones:

Despliegue en forma de Cartel de una Imagen.

Acercamiento a una Imagen.

El objetivo principal de esta animación es el de desplegar la imagen de la Región Continental de manera secuencial en un determinado tiempo tal como se muestra en la siguiente figura.

Tiempo 1 Tiempo 2 Tiempo 3

Figura 8. Animación despliegue en forma de cartel de una imagen en tres pasos.

Ya que se cuenta con la imagen a desplegar, esta se almacena en fragmentos tantos como el número de pasos en los que se va a ir formando el cartel.(Ver figura 9) Supongamos que se desea desplegar en forma de cartel una imagen en 3 pasos.

ancho

largo / numero de pasos largo Imagen

Figura 9. Paso 1 para realizar la animación despliegue en forma de cartel

fragmento 1 fragmento 2 fragmento 3

24

Una vez guardados cada uno de los fragmentos en un arreglo de imágenes, la

siguiente figura muestra el segundo paso a realizar.

Tiempo 1. Tiempo 2. Tiempo 3.

Figura 10. Segundo paso el despliegue en forma de cartel.

Para este despliegue se utilizó la clase “CropImageFilter” que se ocupa del

tratamiento de imágenes en Java filtrando una imagen origen con el fin de extraer una región rectangular obteniendo los fragmentos de las diferentes imagenes.

Algoritmo para Realizar el Despliegue en forma de Cartel de una Imagen.

1. Se obtiene la imagen a ser desplegada en forma de cartel. 2. Se obtiene el numero de pasos(num_pasos) en los que se desea desplegar la imagen. 3. Se obtienen las posiciones de despliegue(x_desp y y_desp). 4. Se obtiene el ancho y el largo de la imagen. 5. Se obtiene el paso _ largo, el cual se calcula de la siguiente manera:

paso _ largo = largo / num_pasos 6. Se obtienen los pedazos de imagen de la imagen origen y se guardan en un arreglo

de imágenes. Tantos pedazos como el valor de numero de pasos. Para obtener los pedazos de imagen se utilizó la clase CropImageFilter del paquete java.awt.image de Java.

7. Por último se van desplegando los pedazos de imagen en forma de cartel de arriba hacia abajo cada periodo de tiempo.

El método:

void DespCart(int num_pasos, int xini, int yini, Image imag)

contiene la animación del despliegue en forma de cartel de una imagen en el applet y pertenece a la clase “EspeciesLoboMundo”.



25

Acercamiento a la región continental. La siguiente imagen representa la secuencia del acercamiento de la imagen.

Paso 1. Paso 2. Paso 3. Paso 4. Paso 5.

Figura 11. Animación de Acercamiento a una Imagen

Como se observa en la figura 11, la animación de acercamiento a una imagen

consiste en desplegar en pantalla cada determinado tiempo una imagen más grande que la imagen que se encontraba en pantalla hasta llegar a cubrir la pantalla completa. Esta animación se llevará a cabo en 5 pasos, por lo que serán necesarias el mismo número de imágenes para cada una de las regiones.

Algoritmo para Realizar Acercamiento a una Imagen.

1. Se obtienen las posiciones iniciales de despliegue (puntoinix y puntoiniy). 2. Se obtiene el índice de la imagen desde la cual va a empezar la

animación(indiceimagpartir). 3. Se pone inicio = indiceimagpartir y fin = indiceimagpartir + 5 4. Se obtiene pasox = puntoinix / 4 y pasoy = puntoiniy / 4. 5. Se pone coordxzoom = puntoinix y coordyzoom = puntoiniy 6. Mientras( inicio < fin ) haz 7. Comienza 8. imagactual = zoom_imag[inicio]; 9. Repintar_pantalla( ); 10. Si inicio = = indiceimagpartir entonces 11. Duerme(1000); /* El applet se duerme 1000 ms. */ 12. Otro 13. Duerme(100); 14. Fin_si

26

15. inicio++; 16. coordxzoom = coordxzoom - pasox; 17. coordyzoom = coordyzoom - pasoy; 18. Termina 19. Fin_Mientras 20. Fin

Aclaraciones acerca del algoritmo anterior:

a)zoom_imag es un arreglo de imágenes en el cual se encuentran almacenadas todas las imágenes de zoom de cada una de las regiones continentales. Las imágenes de acercamiento de América se encuentran almacenadas de la posición 0 hasta la 4, las imágenes de EuroAsia1 se encuentran de la posición 5 hasta la 9 y las imágenes de acercamiento de EuroAsia2 se encuentran de la posición 10 hasta la 14. b)Cada imagen de acercamiento es desplegada cada 100 ms. Al principio se esperan 1000 ms para desplegar la siguiente imagen. c)Las variables coordxzoom y coordyzoom especifican donde se despliegan las imágenes de acercamiento.

Basándose en el algoritmo anterior se desarrollo el método:

void ZoomRegion(int puntoinix, int puntoiniy, int indiceimagpartir)

Ventana dos.

La ventana dos es la ventana a la que se llega al terminar la Animación de acercamiento a región continental y contiene dos imágenes, la principal y una más para regresar a la ventana uno, la cual se localiza en la parte inferior izquierda de la pantalla.

Validación de regiones elípticas y región de regreso a ventana uno

Cuando el usuario se encuentra en la ventana dos, lo único que podrá realizar para interactuar con el applet es dar un clic ya sea en alguna región elíptica de la región continental ó en la imagen secundaria del lobo. La pregunta aquí es la siguiente:

¿Cómo identificar que el usuario ha dado un clic en la imagen del lobo?

Lo que se tiene que validar son las coordenadas del cuadrado (ó sea la imagen del lobo) y una vez que nos encontremos en la ventana dos cada vez que el usuario de un clic debemos de guardar las coordenadas donde se llevó a cabo el clic para saber si fue dentro de la imagen ó no. En la figura 12 se muestra la ventana dos y el cuadrado de color verde, el cual representa la imagen del lobo.

27

Figura 12. Ventana dos del Applet EspeciesLoboMundo.

Para validar si se ha dado clic en la imagen del lobo, hacemos lo siguiente:

a)Se guarda en dos variables, clickx y clicky, la posición en la cual el usuario dió el clic. b)Si ( (clickx >= 0) && (clickx <= 50) && (clicky >= 250) && (clicky <=300) ) entonces /* El clic fue dado dentro de la imagen del lobo */ Se regresa a desplegar la ventana uno. Otro /* El clic fue dado fuera de la imagen del lobo. */

Además de la imagen del lobo, las elipses que se muestran en la imagen de la región

continental son sensibles a un clic del usuario, cuando se de en alguna de las elipses que se muestran en la región continental, el applet deberá mostrar el video del lobo correspondiente en otra pantalla. Para validar las elipses (regiones elípticas) de una región continental lo más conveniente fue crear una clase “Elipses” en la cual se almacenan todas las regiones elípticas por región continental. Así como tener métodos para validar si se ha dado un clic dentro de éstas.

Validación de las elipses A continuación se muestra la figura 13, donde se muestra la gráfica de la elipse y su fórmula general: anchox anchoy k h Donde: (h, k) representan el centro de la elipse. anchox (es el ancho de la elipse en x)/2 anchoy (es el ancho de la elipse en y)/2

Figura 13. Grafica y fórmula de una elipse.

1)(

)()(

)(2

2

2

2

=−

+−

anchoyky

anchoxhx

28

Considerando las dos elipses que se muestran en la figura 13, se obtendrá la ecuación de cada una de las elipses y se mostrará cuando un punto esta dentro ó fuera de una elipse. y Elipse 1 Elipse 2 5 y 5 3 3 1 1 x x 1 2 3 1 4 7

Figura 14. Elipses de Ejemplo

Ecuación de la Elipse 1 Ecuación de la Elipse 2.

1)2(

)3()1(

)2(2

2

2

2

=−

+− yx

1)2(

)3()3(

)4(2

2

2

2

=−

+− xx

Para constatar que un punto está contenido en el área de una elipse se evalúa una

desigualdad.

Un punto (x, y) estará dentro Un punto (x, y) estará dentro de la elipse 1 sí: de la elipse 2 sí:

1)2(

)3()1(

)2(2

2

2

2

≤−

+− yx

1)2(

)3()3(

)4(2

2

2

2

≤−

+− xx

La Clase “Elipse” deberá guardar la siguiente información:

/* Variables miembro */ anchox (ancho de la elipse en x)/2 anchoy (ancho de la elipse en y)/2 (xcentro, ycentro) son las coordenadas donde se encuentra el centro de la elipse. //Métodos -Inicializar las variables miembro. (Constructor) -Guardar una elipse. -Validar si un punto (x, y) esta dentro ó fuera de la elipse.

Se tuvo la necesidad de tener una clase que hiciera más general a la clase “Elipse” denominándola con su plural “Elipses”, la cual contiene las siguiente variables miembro:

29

Elipse ob_elipses[]; /* Arreglo de objetos elipses */ int num_elipses; /* Variable para saber cuantas elipses hay en la clase Elipses */ Los métodos que deberá tener la clase “Elipses” son los siguientes: -Un método constructor, para inicializar variables miembro. -Un método para guardar las elipses en este objeto. -Un método para validar si un punto (x, y) se encuentra dentro de alguna de las elipses almacenadas en este objeto Elipses.

Ventana tres.

La ventana tres es a la cual se llega después de que el usuario ha dado un clic en alguna de las elipses de alguna región continental en la ventana dos. La ventana tres esta compuesta por una imagen del lobo en la parte inferior izquierda y por una pantalla en el centro donde se desplegará video bajo la norma mpeg.

Despliegue de Vídeo en Java bajo la norma MPEG video

La Norma de Codificación MPEG(Motion Pictures Experts Group) es actualmente una de las mas utilizadas para desplegar video debido a la alta calidad y desempeño. Java a través del paquete Java Media Framework proporciona soporte para desplegar este tipo de video. Desplegar archivos de multimedia es muy simple usando JMF, las clases principales para desplegar archivos multimedia son “Manager” y “Player”.

La clase “Manager” tiene una serie de métodos que cada uno regresa un “Player”. Después de que se crea un “Player” lo que se hace es iniciar el despliegue de la media. Para el despliegue de audio, todo lo que se tiene que hacer es lo siguiente:

Player player = Manager.createPlayer(resource); player.play( );

Donde comúnmente ‘resource’ es el URL(Uniform Resource Locator) donde se localiza el archivo de media a desplegar. El proceso anterior no es suficiente si se desea desplegar video, ya que solo se tendrá el sonido pero no se podrán ver imágenes. Para poder visualizarlo es necesario realizar trabajo extra, tal como registrar un “ControllerListener”. El “Player” es un tipo de Controlador y los controladores permiten registrar un “ControllerListener” el cual es un método público:

void controllerUpdate(ControllerEvent event)

Este método es usado para detectar eventos que suceden con la media, tal como el

fin del archivo de video, cuando el archivo de audio ha sido cargado, etc. Para responder a estos tipos de eventos se usa la clase “ControllerAdapter” que ofrece más de treinta métodos diferentes para responder a un tipo específico de evento. Un evento que es

30

particularmente importante es “RealizeCompleteEvent” que cuando ocurre, el “ControllerAdapter” delega la administración del evento al método “realizeComplete”.

Sobrescribiendo el método “ControllerUpdate”, se permite obtener un componente visual para el video y el componente panel de control para el despliegue de audio y video. El panel de control es donde se puede controlar el volumen del audio, e iniciar ó detener el video. También es importante mencionar que un “Player” puede estar en uno de seis estados: Unrealized, Realizing, Realized, Prefetching, Prefetched y Started. A continuación se muestra en la figura 15 un autómata que muestra los seis estados de un “Player”.

realize RCE prefetch deallocate

deallocate PFCE Eventos de Transición: stop RCE: RealizeCompleteEvent PFCE: PrefetchCompleteEvent SE SE: StopEvent

Figura 15. Estados de un “Player”.

En operación normal, un “player” pasa a través de cada uno de los estados

mencionados anteriormente en el diagrama anterior hasta que éste alcanza el estado Started. A continuación se explica cada uno de los estados del “Player”.

Un “Player” en el estado “Unrealized” ha sido instanceado, pero no se sabe nada aún

de la media. Cuando un media “Player” es creado, se encuentra en “Unrealized”.

Cuando “Realice” es llamado, el “Player” se mueve del estado “Unrealized” al estado “Realizing”.

Cuando el “Player” finaliza “Realizing”, se mueve al estado “Realizad”. Un “Player” “Realizad” sabe que recursos necesita y sabe información acerca del tipo de media a desplegar.

Cuando “Prefetch” es llamado, un “Player” se mueve del estado “Realizad” al estado “Prefetching”. Un “Player” “Prefetching” esta preparado para presentar la media. Durante esta fase el “Placer” precarga los datos de la media.

Cuando el “Player” finaliza “Prefetching” se mueve al estado “Prefetched”. Un “Player” “Prefetched” esta listo para ser iniciado.

Llamando ‘start’ el “Player” se va al estado “Started”.

Unrealized Realizing

Realized

Prefetching

Prefetched Started

31

Con ayuda de todos los conceptos anteriores se desarrollaron los métodos que se encargan de inicializar, mostrar y liberar recursos del video. Además también es importante mencionar que se utilizó una Clase llamada “Vídeo” la cual tiene almacenados el nombre del archivo de video y él titulo del mismo, además de poseer métodos para inicializar estas variables así como para obtener sus valores.

Lo necesario para desplegar video está contenido en los siguientes métodos:

Método: void InicializaPlayer(Video vid) Se encarga de inicializar el “Player” para mostrar video. Método: void MuestraVideo() Este método se encarga de mostrar el video bajo la norma mpeg. Método: void LiberaRecursoVideo() Se encarga de liberar recursos y remover componentes ocupados por el “Player” actual.

Aplicación Completa Primos del lobo.

El objetivo de esta sección es explicar cada una de las clases que se utilizaron para desarrollar la aplicación completa, así como también mostrar como interactúan todas las clases para mostrar el funcionamiento de la aplicación completa.

Clases que componen a la aplicación Primos del lobo

Para el desarrollo del Applet “EspeciesLoboMundo” se utilizaron cinco clases, las cuales se explican a continuación:

Clase: Video

Esta clase proporciona los métodos necesarios para almacenar atributos de un archivo de video. Básicamente esta clase se encargará de almacenar el nombre de un archivo de video mpeg y el titulo del video mpeg.

Constructor Video(String n_video,String tit_video)

Se encarga de almacenar el nombre del archivo del video y el titulo del video mpeg.

Parámetros de Entrada:

32

n_video: Es el nombre del archivo de video mpeg.

tit_video: Es el titulo del video mpeg.

Parámetros de Salida: Ninguno.

Métodos String getVideoName( )

Este método se encarga de obtener el nombre del archivo de video mpeg.

Parámetros de Entrada: Ninguno

Parámetros de Salida: Un String en el cual se encontrará almacenado el nombre del archivo de video mpeg.

String getVideoTitle( )

Este método se encarga de obtener el título del video mpeg.

Parámetros de Entrada: Ninguno.

Parámetros de Salida: Un String en el cual se encontrara almacenado el título del video mpeg.

Clase: Elipse Constructor. Elipse( )

Este constructor se encarga de inicializar las variables miembro de la clase Elipse al valor cero. Parámetros de Entrada: Ninguno

Parámetros de Salida: Ninguno

Métodos void GuardaElipse(int ax,int ay,int xcent,int ycent)

Este método se encarga de almacenar una elipse. Parámetros de Entrada:

33

ax: Es el ancho de la elipse en x dividido entre dos. ay: Es el ancho de la elipse en y dividido entre dos. xcent: Es la coordenada x del centro de la elipse. ycent: Es la coordenada y del centro de la elipse.

Parámetros de Salida: Ninguno

int ValidaPuntoElipse(int x, int y)

Este método se encarga de validar si un punto(x, y) se encuentra dentro de la elipse. Parámetros de Entrada: x: Coordenada x del punto a validar. y: Coordenada y del punto a validar Parámetros de Salida: Regresa -1 Si el punto esta fuera de la elipse ó Regresa 1 Si esta el punto dentro de la elipse.

Clase: Elipses

Esta clase proporciona las clases y los métodos necesarios para almacenar y validar un conjunto de elipses.

Constructor. Elipses( )

Este constructor se encarga de inicializar la variable miembro num_elipses a cero. Parámetros de Entrada: Ninguno. Parámetros de Salida: Ninguno.

Métodos. void GuardaElipses(int anx[],int any[],int xcent[],int ycent[],int n_eli)

Este método se encarga de almacenar varias elipses, esto de acuerdo al valor de n_eli.


34

anx[]: Arreglo de enteros el cual posee todos los anchos en x divididos entre dos de las elipses. any[]: Arreglo de enteros el cual posee todos los anchos en y divididos entre dos de las elipses. xcent[]: Arreglo de enteros el cual posee las coordenadas x del centro de las elipses. ycent[]: Arreglo de enteros el cual posee las coordenadas y del centro de las elipses. n_eli: Entero el cual posee el número de elipses que se almacenarán. Parámetros de Salida: Ninguno.

int ValidaPuntoElipses(int cx, int cy)

Este método se encarga de validar si el punto(cx, cy) se encuentra dentro del conjunto de las elipses almacenadas. Parámetros de Entrada: cx: Coordenada x del punto a validar.. cy: Coordenada y del punto a validar.. Parámetros de Salida: Regresa -1 Si el punto no esta dentro de ninguna elipse ó en otro caso Regresa el índice de la elipse donde el punto esta dentro.

Clase: RegCont Esta clase proporciona los métodos necesarios para almacenar y validar las regiones

continentales.

Constructor.

RegCont( )

Este constructor se encarga de inicializar la variable miembro num_rect a cero.

Parámetros de Entrada: Ninguno. Parámetros de Salida: Ninguno.

Métodos. void GuardaRect(int imag[], int P1X[],int P1Y[],int P2X[],int P2Y[],int numrect)

Este método se encarga de almacenar todos los rectángulos, así como las imágenes correspondientes a una región continental. Parámetros de Entrada:

35

imag[]: Arreglo de enteros el cual posee los índices de las imágenes que corresponden a dicha región continental. P1X[]: Arreglo de enteros el cual posee las coordenadas x de las esquinas superiores izquierdas de cada uno de los rectángulos. P1Y[]: Arreglo de enteros el cual posee las coordenadas y de las esquinas superiores izquierdas de cada uno de los rectángulos. P2X[]: Arreglo de enteros el cual posee las coordenadas x de las esquinas inferiores derechas de cada uno de los rectángulos. P2Y[]: Arreglo de enteros el cual posee las coordenadas y de las esquinas inferiores derechas de cada uno de los rectángulos. numrect: Este parámetro deberá contener el número de rectángulos que corresponden a dicha región continental. Parámetros de Salida: Ninguno

int ValidaPunto(int ind_imag,int x,int y)

Este método se encarga de validar si un punto(x, y) se encuentra en un rectángulo dado(ind_imag)


ind_imag: Es el índice del rectángulo a validar. x: Es la coordenada x del punto a validar. y: Es la coordenada y del punto a validar. Parámetros de Salida: Regresa –1 si el punto no se encuentra en dicho rectángulo. En otro caso, regresa 1 si el punto se encuentra en dicho rectángulo. int ValidaRegCont(int imagact, int x,int y)

Este método se encarga de validar si el punto(x, y) se encuentra en la región continental. Parámetros de Entrada: ind_imag: Es el índice del rectángulo a validar.

x: Es la coordenada x del punto a validar. y: Es la coordenada y del punto a validar. Parámetros de Salida:

Regresa 1 si esta en la RegCont Regresa -1 si no esta.

EspeciesLoboMundo.

Esta es la clase principal, proporciona los métodos necesarios para llevar a cabo: la rotación del planeta tierra, animación de acercamiento a región continental y

36

despliegue de video bajo la norma mpeg.

Constructor. public void init()

Este método constructor se encarga principalmente lo siguiente: -Inicializar variables miembro de la clase EspeciesLoboMundo. -Crear e Inicializar objetos de la clase RegCont para guardar las regiones continentales. -Crear e Inicializar objetos de la clase Elipses para guardar las regiones elípticas. -Crear e Inicializar objetos de la clase Video para guardar los nombres de los archivos de video, así como también el titulo del video.


public void start()

Este método se encarga de lanzar el hilo que controlará la ejecución del applet.


public void stop()

Este método se encarga de detener el hilo que controla la ejecución del applet.


public void run()

Este método se encarga de llevar el control de todo el applet. Se encarga de principalmente de administrar las ventanas, llevar el control de la animación de acercamiento a cartel y despliegue de video mpeg. Parámetros de Entrada: Ninguno. Parámetros de Salida: Ninguno.

public void paint(Graphics g)

Este método se encarga de dibujar en la pantalla del applet, este método se encarga de pintar imágenes de acuerdo a la ventana en la que se encuentre el usuario y a los eventos producidos por el usuario.

37

Parámetros de Entrada: g: Objeto Graphics utilizado para dibujar las imágenes en este método. Parámetros de Salida: Ninguno.

public void update(Graphics g)

Este método se encarga de implementar un Double Buffering para que las animaciones se vean bien y no se dañe la calidad de la presentación de las imágenes en las animaciones, es utilizado principalmente para eliminar el parpadeo en las animaciones.

Parámetros de Entrada: g: Objeto para dibujar en la pantalla del applet.. Parámetros de Salida: Ninguno.

public void RotacionImIzq()

Este método se encarga de realizar la rotación del planeta tierra a la izquierda una imagen.


public void RotacionImDer()

Este método se encarga de realizar la rotación del planeta tierra a la derecha una imagen.


public void mouseDragged(MouseEvent me)

Este método se llama cada vez que el usuario arrastra el ratón en la ventana del applet. Este método se encarga de llamar a los métodos de rotación del planeta tierra siempre y cuando el usuario se encuentre en la ventana 1 del applet..

Parámetros de Entrada: me: Objeto que se genera cuando un usuario arrastra el ratón en la pantalla del applet, sirve para obtener las coordenadas de donde se arrastro el ratón. Parámetros de Salida: Ninguno.

void DespCart(int num_pasos, int xini, int yini, Image imag)

Este método se encarga de desplegar una imagen de arriba hacia abajo por pedazos. La imagen se pasa por parámetro en imag, con la variable num_pasos se determina en cuantos pedazos desea que se divida la imagen para que esta aparezca de arriba hacia abajo. Las coordenadas xini, yini son la esquina superior de donde la imagen comenzará a ser desplegada por pedazos.

38

Parámetros de Entrada: num_pasos: Parámetro de entrada que determina en cuantos pedazos se desplegará la imagen imag de abajo hacia arriba. xini: Coordenada x donde la imagen imag comenzara a ser desplegada. yini: Coordenada y donde la imagen imag comenzara a ser desplegada. Imag: Imagen a ser desplegada por pedazos de arriba hacia abajo. Parámetros de Salida: ninguno

void ZoomRegion(int puntoinix,int puntoiniy,int indiceimagpartir)

Este método se encarga de realizar un acercamiento a una región continental dada.

Parámetros de Entrada: puntoinix: Coordenada x donde comienza el acercamiento a la región continental. puntoiniy: Coordenada y donde comienza el acercamiento a la región continental. indiceimagpartir: Índice para indicar con que imagen se comienza la animación. Parámetros de Salida: ninguno

int PosDentroPlaneta(int radiocir,int centrox,int centroy, int pospuntox,int pospuntoy)

Método para validar si el clic dado por el usuario fue dado dentro del planeta tierra. Parámetros de Entrada: radiocir: Es el radio de un circulo, en este caso el radio del planeta tierra. centrox: Coordenada x del centro del circulo, en este caso del planeta tierra. centroy: Coordenada y del centro del planeta tierra. pospuntox: Coordenada x de un punto a validar. pospuntoy: Coordenada y de un punto a validar. Parámetros de Salida: Regresa -1 Fuera del circulo ó planeta tierra. Regresa 1 Dentro del planeta tierra.

public void mousePressed(MouseEvent me)

Este método se llama cada vez que se presiona un botón del ratón. Parámetros de Entrada: me: Objeto que se genera cuando se ha presionado un botón del ratón, este parámetro sirve principalmente para obtener las coordenadas donde se llevo a cabo el clic. Parámetros de Salida: Ninguno.

public void mouseReleased(MouseEvent me)

Parámetros de Entrada: me: Objeto que se genera cuando se ha liberado un botón del ratón, este parámetro sirve principalmente para obtener las coordenadas donde se llevo a cabo la liberación del botón del ratón.

39

Parámetros de Salida: Ninguno.

void InicializaPlayer(Video vid)

Este método se encarga de inicializar un objeto player para mostrar video.

Parámetros de Entrada: vid: Objeto en el cual esta almacenado el nombre del archivo del video a desplegar. Parámetros de Salida: Ninguno. void MuestraVideo( )

Este método se encarga de mostrar el video mpeg.

void LiberaRecursoVideo( )

Este método se encarga de liberar recursos y remover componentes ocupados para desplegar el video mpeg.

Parámetros de Entrada: Ninguno. Parámetros de Salida: Ninguno. public synchronized void controllerUpdate(ControllerEvent event)

Este método se encarga de desplegar los componentes visuales necesarios para la manipulación del video cuando se muestra video.

Parámetros de Entrada: ninguno. Parámetros de Salida: ninguno.

Figura 16. Diagrama de clases

EspeciesLoboMundo

RegCont Elipses

Elipse

Video

40

3.2.4 Videojuego del Lobo

Descripción y objetivos del modulo llamado juego de video. Características principales del módulo: El juego debe tener un ambiente de bosque donde se desarrollará todo el juego, éste

incluirá árboles, plantas, piedras, y una cueva que será la guarida del lobo.

En el ambiente habrá animales que sirvan de alimento para el lobo, saliendo continuamente de entre los árboles donde se refugian.

Habrá un cazador oculto, cuyo objetivo es el lobo. Este será estático, es decir, estará siempre en el mismo lugar, tendrá una área de visibilidad en la cual podrá disparar al lobo.

Inicialmente el lobo saldrá de la cueva, podrá caminar siguiendo los puntos que se le indiquen con el botón derecho del ratón y atrapará a los animales del bosque para después llevarlos a su guarida de la cual puede entrar y salir de esta a voluntad.

El juego lleva un conteo de los animales que ha capturado el lobo ya que cada uno de estos incrementa su tiempo de vida. Si el lobo no captura ningún animal en determinado tiempo morirá.

El juego será en 2D(Dos dimensiones) y se tendrá una vista aérea del ambiente donde se desarrolla el juego. El juego inicia dando doble clic en la pantalla con el botón derecho del ratón.

Descripción general del juego:

Este applet es un video juego que tiene como objetivo mostrar muy superficialmente la vida de el lobo. Aquí se podrá ayudar al lobo a alimentarse y deberemos protegerlo del cazador.

41

Este juego se desarrolla en un ambiente de bosque, en el que hay árboles, arbustos, etc. Y una cueva que es el hogar del lobo. En el bosque hay pequeños arbustos y piedras sobre los cuales el lobo no puede caminar.

El lobo es controlado mediante el botón derecho del ratón, con este botón se le indica la trayectoria que debe de seguir. Si el lobo encuentra en su camino un árbol, arbusto o piedra, detendrá su trayectoria y se escuchara un sonido simulando un golpe. El lobo podrá entrar y salir de su cueva cuantas veces sea necesario, para esto solo se debe dar clic en la parte superior de la cueva y el lobo entrara y saldrá automáticamente.

En el bosque existen animales que el lobo deberá capturar para alimentarse y también existe un cazador que tratara de eliminar al lobo. El cazador solo podrá dispararle al lobo si este se acerca lo suficiente.

Si el lobo no captura una presa en determinado tiempo morirá, y el juego llevara el conteo de los puntos de el jugador, así como el tiempo de vida de el lobo y el número de conejos atrapados.

La solución para este módulo es tener varias clases para el juego una clase para el lobo, una para el cazador, para el conejo, y para llevar el conteo de los puntos y tiempo de vida que le resta al jugador.

Se utilizaron imágenes para realizar las animaciones en las que: el lobo camina, el conejo camina, el cazador apunta y dispara al lobo, etc. También se utilizaron imágenes para representar el ambiente en el que se desarrollara el juego.

Se tienen imágenes que describen el movimiento que hace el lobo y el conejo al caminar y el que hace el cazador al disparar. Estas imágenes se manipulan para crear las animaciones el juego. Por ejemplo, para dar el efecto de un conejo caminando, se usará una secuencia que describe su movimiento, cada imagen será mostrada en un orden específico y se cambia el punto de impresión de la imagen para dar efecto de avance al caminar.

Ejemplo:

Figura 17. Secuencia de movimientos del conejo.

En el caso en que el desplazamiento sea diagonal usaremos métodos y funciones que permiten manipular las imágenes para formar estas animaciones, estas funciones se pueden ver en el anexo C.

42

Solución propuesta.

El programa principal hace uso de varias clases que se explican en el anexo para satisfacer los requerimientos del videojuego. El siguiente autómata es la estructura de la construcción del applet del juego del lobo:

Figura 18. Autómata completo del juego de video.

Este autómata sirve para llevar el control de los movimientos del lobo. En un principio, en el estado de J_I, se encuentra el juego inactivo, cuando se da doble clic en la pantalla se pasa al estado S_C, que es donde el se ejecuta la secuencia en la que el lobo sale de su cueva. Una vez que el lobo ha salido completamente de su cueva, se pasa a un estado de L_I, en el que el lobo no hará nada hasta que se le indique una trayectoria con el ratón.

bandera_runing = false

INICIO

J_I Juego inactivo. S_C Lobo sale cueva. L_I Lobo inactivo. L_C Lobo camina. E_C Lobo entra cueva. D_I Despliega información

lobo. EstadoLCa() = false

D_I

Mueve_CA=true ∧

d CA

Mueve_CA=true ∧

d CA

Mueve_CA=true ∧

d CA

L_I

L_C

lobo. EstadoLCa() = lobo. EstadoLCa() =

E_C

Valida(lobo)=0

lobo. EstadoLEnC() =

lobo. EstadoLEnC() =

INICIO

J_I

Lobo.Habilita SaleCue

Bandera_runing=true

S_C

lobo. EstadoLSaC()

lobo. EstadoLSaC()

lobo.EstadoLEnC()=fa

43

Una vez que hay una trayectoria que seguir, pasamos del estado L_I al estado L_C y se permanecerá ahí hasta que el lobo cumpla la trayectoria que se le marco. Estando en el estado L_I, se puede indicar que el lobo entre a su cueva, por lo que se pasara al estado E_C y se permanecerá ahí hasta que se cumpla esta animación, una vez que el lobo ha entrado a la cueva se pasará automáticamente a el estado S_C y luego al estado L_I. Estando en los estados L_C, L_I, L_E puede ser que el lobo muera, por lo que pasara al estado D_I, donde se despliega la puntuación del jugador y se pasa al estado inicio, lo que indica que el juego ha terminado.

Las funciones que aparecen en el autómata son explicadas con detalle dentro del anexo C.

Pasos que se siguieron para realizar el módulo del videojuego

Es importante saber antes de comenzar a desarrollar la solución del juego, como se

toman las coordenadas en la pantalla de un applet para ubicar nuestra posición mediante coordenadas. Una vez que se ha desplegado una pantalla, la podemos ver como un eje cartesiano, como se muestra a continuación:

Figura 19. Coordenadas en el applet.

De este modo se ubica el espacio que ocupa la imagen al imprimirla en unas coordenadas (x. y) de la pantalla y el hecho de que el área de la pantalla se maneje como un eje cartesiano facilitará crear trayectoria para darle desplazamiento a las animaciones.

Para poder trazar una trayectoria, lo primero que se debe saber es el punto de origen de nuestra imagen y después es necesario saber el punto de destino, y éste se indica al dar clic en la pantalla del applet con el botón derecho del ratón.

44

Donde: Xo= coordenada x de el punto origen.

Yo=Coordenada y de el punto origen Xd=coordenada x de el punto destino

De este modo tendremos dos puntos en el espacio y a partir de estos se puede calcular la trayectoria que deberá seguir la animación para desplazarse.

Eje +X (xo,yo) (xd,yd)

Figura 20. Trayectoria sencilla

Ahora con los puntos de origen y destino podemos calcular la ecuación que describa la trayectoria a seguir como se indica a continuación:

m

De este modo tenemos la ecuación de la trayectoria y a partir de esta podemos calcular una serie de puntos que estarán sobre la misma. Si se incrementa la x origen de 4 en 4 hasta llegar al valor de la xd y se calcula el valor de su coordenada y correspondiente, con la ecuación de nuestra recta, se obtienen los siguientes puntos.

y = mx + b donde: m es la pendiente de nuestra recta. b es la ordenada al origen

xoxdyoydm

−−

=

Suponiendo que xo =15, yo = 20 , xd =65 , yd = 80 tenemos que:

2.115652080

=−−

=m y b = y – mx = 80 – (1.2 * 65) = 2

Eje +Y

45

Figura 21. Gráfica de coordenadas.

Todos los puntos que se calcularon están dentro de la trayectoria. Ahora sólo resta

proyectar las imágenes, que describen el movimiento de nuestra animación, en el orden correcto y en los puntos calculados para dar el efecto de movimiento. Ejemplo:

Figura 22. Movimiento del conejo en los puntos calculados

Ahora, si se dan varios clic’s en la pantalla se registrarán varios puntos de destino y

un solo punto de origen (el que ocupa la imagen actual de la animación). A partir de los múltiples puntos de destino se puede generar una trayectoria a la que llamaremos ‘trayectoria compuesta, y está formada por todos los puntos destinos y se irán recorriendo en el orden en que fueron obtenidos.

46

P1 P3 P2 P4

Así la trayectoria estará compuesta por los puntos P1, P2, P3 y P4 .

Figura 23. Trayectoria compuesta desde origen.

Para formar la trayectoria compuesta, dentro de nuestro programa se guarda cada punto de destino en una cola (el primer elemento en entrar es el primero en salir) e iremos sacando cada punto de destino según se requiera. Inicialmente obtendremos el punto P1, así tendremos un origen y un destino y trazaremos la recta que nos llevara hasta el punto P2 como se vió anteriormente. Una vez que se ha trazado la recta y que hemos llegado al punto destino, es decir estamos en el punto P1, nuestro origen cambiará y ahora será el punto P1.

Origen P3 P2 P4

Figura 24. Trayectoria compuesta con nuevo origen.

De nuevo, se saca otro elemento de la cola (toca turno al punto P2) y de nuevo

tenemos un origen y un destino y calculamos la recta para llegar al punto destino. Este procedimiento se realiza hasta que la cola esté vacía, es decir, hasta que ya no haya más puntos que recorrer.

Eje x

Eje y

Origen

Eje y

47

Obteniendo las coordenadas del clic del ratón.

Las animaciones son el paso siguiente ya que se sabe como trazar las trayectorias y que éstas son marcadas por el clic derecho del ratón. Como nuestro juego será un applet , hacemos uso de una clase que nos permite obtener los eventos(cambio de estado en una fuente) que genera el ratón, así como de una fuente de eventos que generalmente es un objeto.

Una fuente de eventos tiene que ir acompañada de auditores para que estos reciban notificaciones sobre el tipo específico de evento; cada uno de ellos tiene su propio método de registro. La forma general es:

public void addTypeListener (typeListener ref)

Donde el parámetro type es el nombre del evento y el ref una referencia al auditor. Por ejemplo, el método que registra o acompaña a un auditor de evento de teclado es addKeyListener(). El método que registra o acompaña un auditor de movimiento de ratón es addMouseMotionListener(). Cuando ocurre un evento, se notifica a todos los auditores registrados.

Un auditor es un objeto que es avisado cuando ocurre un evento. Tiene dos requisitos principales. Primero, tiene que ser registrado o ir acompañado por una o más fuentes para recibir notificaciones sobre los tipos específicos de eventos. Segundo, tiene que implementar métodos para recibir y procesar esas notificaciones.

A continuación describimos los métodos de nuestra interfaz MouseListener.

La interfaz MouseListener.

Esta interfaz define cinco métodos. Si se presiona y se libera el ratón en el mismo punto, se invoca a mouseClicked() . Cuando el ratón se introduce en un componente (ventana de nuestro applet), se llama al método mouseEntered(). Cuando el ratón sale del componente, se llama o mouseExited(). Los métodos mousePressed() y mouseReleased() se invoca cuando se presiona y se libera el ratón, respectivamente.

Las formas generales de estos métodos son las siguientes:

void mouseClicked(KeyEvent ke) void mouseEntered(KeyEvent ke) void mouseExited(KeyEvent ke) void mousePressed(KeyEvent ke) void mouseReleased(KeyEvent ke)

48

Así con esta interfaz y con estos métodos resolvemos los problemas de saber las coordenadas donde se ha dado clic con el ratón, ya que al dar clic se activa la función “mouseClicked()” y dentro de esta función podemos usar los métodos “getX()” y “getY()” como se explica a continuación:

public void mouseClicked (MouseEvent me) { mouseX =me.getX(); mouseY =me.getY(); } Y así obtenemos los puntos de destino para nuestra trayectoria.

Resolviendo el problema del parpadeo.

El problema del parpadeo se presenta cuando en un applet se despliegan imágenes grandes rápidamente. Esto es invocado el método “paint()” atraves del método “repaint()” la pantalla del applet es borrada completamente, por esta razón nosotros podemos ver por unos milisegundos una pantalla totalmente blanca. Para reducir el efecto del parpadeo en un applet podemos usar tres técnicas:

No borrar la pantalla por completo.

Borrar la pantalla sólo en la zona donde se presentan cambios.

Podemos usar un doble buffer.

Las imágenes de fondo y la gran cantidad de imágenes que se mostrarán son de tamaño considerable, además estaremos repintándolas en el applet varias veces.

Para resolver el problema usó la técnica del doble buffer que propone pintar todos los cambios de la pantalla dentro del método paint() en una imagen del tamaño del applet y una vez realizados todos los cambios en esta pantalla secundaria, mostrarla finalmente. A continuación describimos los pasos a seguir en esta técnica:

1. Generar una nueva imagen para la pantalla usando el método createImage y almacenar esta imagen en una variable.

2. Llamar al método getGraphics para generar un contexto grafico para esta imagen. 3. Dibujar totalmente (incluyendo borrar la pantalla completa) sobre la pantalla

secundaria. 4. Cuando termine, copiar esta imagen sobre la imagen existente en la pantalla.

49

Esta técnica propone que la pantalla esté ya pintada cuando sea desplegada. Cuando copien la imagen en frente, cada píxel anterior será substituido por uno nuevo. De este modo eliminaremos parpadeo en la pantalla pues ya no habrá más milisegundos en los que se pueda ver la pantalla totalmente blanca.

Otro problema que contribuye a que el parpadeo se presente, es que cada vez que

se va a mostrar una imagen, ésta es cargada en el momento en que se está mostrando en la pantalla. Java tarda unos milisegundos en cargarla totalmente y hasta que no lo esté no será mostrada y durante estos milisegundos que tarda en cargarse, la pantalla permanece en blanco.

Aunque la imagen se haya cargado la primera vez que se ha mostrado en la pantalla, las veces posteriores que se muestre en la pantalla será cargada de nuevo. Una forma de evitar que se cargue la imagen más de una vez es usar la clase MediaTracker. Esta clase permiten que la imagen permanezca cargada durante toda la ejecución del programa de modo que la imagen se cargue sólo una vez. Para usar esta clase en una imagen se ejecutarán los siguientes pasos:

1. Declarar un objeto de la clase “MediaTracker”. 2. Inicializar el objeto creado con el método “new MediaTracker(this)”; dentro del

método “init()” del applet. 3. Añadir al objeto “MediaTracker” las imágenes que se usarán con el método

“addImage(Image img, int id)”; 4. Verificar si las imágenes ya han terminado de cargarse en el objeto de la clase

MediaTracker usando el método “waitForID(int id)”. 5. Usar ya la imagen sin problema.

Para nuestro juego de video será necesario usar las dos técnicas descritas

anteriormente, debido a la cantidad de imágenes que usaremos y al tamaño de las mismas.

Clase conejo

Esta clase será utilizada para darle vida a los animales que el lobo deberá atrapar para su alimentación y sobre vivencia. Aunque esta clase se llama cConejo se puede utilizar para darle vida a cualquier tipo de animal del bosque que se desee. Todo depende de las imágenes que inserte en el objeto que use de esta clase.

• cConejo( float[] xo, float[] yo, float madriguera_x,float madriguera_y, Image[] imágenes, int n,

int m, float avance) • public void CargaImg(). • public void Habilitar() • public void Deshabilitar() • public boolean Estado(). • public void Mueve_conejo(). • float Get_xC(). • public float Get_yC(). • public Image Get_img().

50

• public float Get_xactC(). • public float Get_yactC(). • boolean Conejo_atrapado(cLobo lobo, cConejo conejo).

Clase cCazador.

Esta clase se usa para darle vida al cazador. Hay que aclarar que el cazador es estático, es decir, esta quieto en un solo lugar y sólo se mueve cuando le dispara al lobo. El cazador tiene una área de alcance, de tamaño arbitrario y sólo si el lobo entra en esa área, el cazador podrá dispararle. A continuación se enlistan los métodos de esta clase:

• public cCazador(float p_x, float p_y, float ax1,float ay1, float ax2, float ay2,Image[] imgca, int n_imgca).

• public void Carga_ImgCA(). • public void Set_sonidoCA(AudioClip son) • public boolean Estado_CA(). • public float Get_XCA(). • public float Get_YCA() • public boolean Mueve_CA(float xlobo, float ylobo) • public boolean Dentro_RCA(float xlobo, float ylobo) • public Image Get_ImgCA().

Clase cCoordenada.

Esta clase contiene las coordenadas que se usarán en el programa. Cada objeto de esta clase contiene una coordenada de la forma (x , y).

A continuación listamos los métodos de ésta clase.

• public cCoordenada(int x, int y). • public cCoordenada(). • public void Set_xy(int x,int y). • public int Get_x(). • public int Get_y().

Clase cListalineal.

Esta clase es en realidad una cola (primer elemento en entrar es el primero en salir) y es utilizada para guardar los puntos que debe recorrer el lobo, es decir, contiene los puntos que forman la trayectoria compuesta. A continuación se listan los métodos de ésta clase.

• public cListalineal(). • public void addprincipio(cCoordenada objeto).

51

• public void Vaciar(). • public cCoordenada Obtener(). • public int Num_elem().

Clase CValidacion.

Dentro del juego hay que tomar en cuenta que el lobo no puede caminar por todas partes, es decir, el lobo no podrá atravesar paredes, ni árboles, ni plantas, ni piedras. Entonces se debe conocer las regiones en las que el lobo podrá caminar. Para realizar esta función se creó la clase cValidacion. Esta clase se encargará de almacenar los datos de las regiones en las que no podrá caminar el lobo.

A continuación se listan los métodos de esta clase.

• void cValidacion(float[] x0,float[] y0,float[] x1,float[] y1, int num, float xi,float yi, float xd, float

yd). • public int Valida(cLobo lobo)

Clase ImageProc.

En esta clase se implementan métodos para la manipulación de imágenes que son necesarios para el juego. A continuación se listan los métodos de ésta clase:

• ImageProc(Image picture). • void InsertImage(Image picture). • Image createImage(). • void rotate(double angle).

Clase CPlayer

Con esta clase se llevará el conteo de los puntos que lleva el jugador, así como del tiempo de vida que le resta y el número de animalitos capturados. En el juego una variable se incrementa cada que el lobo atrapa un conejo. Si se tuviera más variedad de animales a capturar en el juego(conejos, serpientes, etc.), entonces, se modificaría los atributos de esta clase para que a cada animal le correspondiera una variable para llevar su conteo y se implementaría una función que incremente ese atributo cada que se captura un animal que corresponda a ese atributo. A continuación se listan los métodos de ésta clase:

• public cPlayer(). • public int Get_score(). • public int Get_capturas(). • public int Get_TV(). • public void Inc_capturas(). • public void Inc_score().

52

• public void Inc_TV(). • public boolean Dec_TV(). • public void Elimina_player(). • public boolean Estado_P().

Clase CFunciones.

Esta clase contiene métodos usados para cálculos matemáticos. Contiene métodos para calcular la pendiente de una recta, para calcular el ángulo de rotación de una imagen a partir de un punto de origen y uno de destino, un método para calcular la ordenada al origen de una recta y otros más. A continuación se listan los métodos de ésta clase:

• public cFunciones(). • public float Get_pendiente(float xo,float yo,float xd,float yd). • public float Get_b(float x,float y,float m). • public float Get_angulo(float xo, float yo, float xd, float yd). • public int Obtenregion(float posact_x,float posact_y,float px,float py).

Clase cLobo. Esta clase se usa para llevar el control de los movimientos del lobo, así como la

manipulación de sus imágenes. A continuación se listan los métodos de esta clase:

• public cLobo(Image[] Imagenes, float x_cueva,float y_cueva,float x_cent,float y_cent,int

num_img,float avance). • public void CaminaLobo(). • public void Sale_cueva(). • public void Entra_Cueva(). • public float Get_xL(). • public float Get_yL(). • public boolean EstadoLCa(). • public boolean EstadoLSaC(). • public boolean EstadoLEnC(). • public Image Get_ImagLobo(). • public void Inserta_recuadro(float r_x1,float r_y1, float r_x2,float r_y2). • public void CargaImgLobo(). • public void Set_Lobo(int x, int y). • public boolean Region5(). • public void ResetL(). • public float Get_xact(). • public float Get_yact(). • public void InsertImgLoboPresa(Image[] lobo_presa,int num_ILP). • public void Set_sonidoL(AudioClip son). • public void Habilita_SaleCueva(). • prívate int Distancia(int x1,int y1, int x2,int y2).

53

Todos los métodos descritos en esta sección se describen con profundidad en el anexo C.

Ultimas consideraciones

En la clase cLobo se tienen tantas banderas como estados del autómata para poder llevar el control, y saber en que estado se encontraba y a cual debía pasar , se le aplicaban métodos a nuestro objeto de la clase cLobo (métodos como: EstadoLCa(), EstadoLSaC(), EstadoLEnC()) y en base al resultado arrojado por esos métodos se tomaba la decisión siguiente. Un objeto de la clase cLobo tiene varios estados como son: caminando, estático, entrando a la cueva, saliendo de la cueva y muriendo (aunque este ultimo estado no este implementado aun )por lo que son necesarias tantas banderas.

El método InsertImgLoboPresa( ) en la clase cLobo se debe a la acción cuando el lobo atrapa a su presa, las imágenes del lobo que se muestran en la animación deben aparecer con la presa capturada, es decir en las manos del lobo. En este juego sólo usamos imágenes del lobo con la presa encima, lo que le quita mucha vista al juego, pero sólo se usaron para mostrar la funcionalidad del juego, en realidad deberían aparecer imágenes con el lobo cargando a su presa. Dentro del juego sólo se puede atrapar conejos y seria muy fácil agregar un nuevo atributo a la clase. Lobo para tener estas imágenes disponibles y así evitarse insertarlas en el objeto (solo serían necesarias seis imágenes más). Pero ¿qué pasaría si tuvieran 4 posibles presas que atrapar en lugar de sólo conejos?, el número de imágenes que se debería tener dentro del objeto lobo seria veinticuatro más seis en las que el lobo está sin su presa, lo cual da un total de treinta imágenes, de las cuales sólo seis estarían activas a la vez y veinticuatro inactivas. Es por esta razón que se decidió colocar sólo seis imágenes dentro de la clase cLobo y si se captura una presa, dependiendo de la presa capturada, se realiza un cambio de imágenes dentro del objeto.

3.2.5 Anatomía del lobo mexicano

El objetivo del presente trabajo es desarrollar una parte del software para ayudar a

eliminar el exterminio del lobo mexicano, este consiste en ilustrar a niños de diferentes edades algunas de sus principales características anatómicas y así lograr una mejor concientización de esta especie en peligro extinción .

La solución fue la creación de una parte del programa el cual muestra algunas de las características del lobo mexicano tal como su estructura ósea, escuchar su aullido y poder ver un poco de su comportamiento mediante un video.

Para la realización de este software se construyeron applets, pues nos ofrece una mayor flexibilidad para el manejo de imágenes, archivos multimedia y dar una mejor animación e interacción para lograr llamar la atención del usuario.

54

Se elaboró una clase principal en la cual se muestra una imagen del lobo. Aquí el usuario al hacer clic en cualquier parte de la imagen, se hará un pequeño zoom, desplegándose un área rectangular sobre la misma imagen. Al mismo tiempo, dependiendo de la zona en la que se haya dado el clic se escuchará el aullido del lobo, así como también podrá hacer la llamada a otra clase que puede desplegar un video o mostrar su estructura ósea.

Para la elaboración de “Anatomía del lobo”, se crearon tres clases:

ZoomLobo (Clase principal)

Esqueleto

VideoLobo.

En la Figura 42 se muestra la relación existente entre todas las clases, en ella podemos observar, como se mencionó anteriormente, que la clase principal se llama “”ZoomLobo”. Como aquí vemos la clase ZoomLobo hereda de la clase Japplet (Ver anexo A). ZoomLobo requiere de las clases Esqueleto y VideoLobo que se encuentran unidas a ella a través de líneas punteadas, cada una de estas clases se explicarán posteriormente para formar la estructura final de la anatomía del lobo.

ZoomLobo

Japplet

Esqueleto

MyCanvas

VideoLobo

MouseHandler

Figura 25. Relación entre clases

A continuación se dará una explicación de cada una de estas clases, mencionadas anteriormente.

55

CLASE ESQUELETO Está clase se encarga de desplegar la imagen1 que se encontrará en primer plano,

detrás de está se encontrará la imagen2 como segundo plano. Con la ayuda de una barra de desplazamiento el usuario modifica el grado de transparencia de la imagen1, para cuando esta se encuentre en su transparencia total muestre finalmente la imagen2 que contendrá la estructura ósea del lobo mexicano.

IMAGEN1

IMAGEN 2

Figura 26. Imagen de primer y segundo plano.

Como resultado final se obtuvo el siguiente applet, mostrado en la Figura 44, en la cual podemos observar que debajo del área donde se despliega la foto del lobo mexicano, se encuentra una barra de desplazamiento con la cual el usuario podrá tener el control sobre la transparencia de dicha imagen, para que pueda observar como imagen final el esqueleto del mismo lobo.

Figura 27. Applet Anatomía del lobo (Esqueleto)

56

Para entender está clase se explica cómo se hace la manipulación de las imágenes para lograr la transparencia a través de los píxeles de dichas imágenes.

Representación de imágenes a color. La pantalla del monitor esta repleta de píxeles. Cada píxel contiene un color que se basa en la combinación de tres colores: (R)Rojo, (G)Verde y (B)Azul, en resumen formato RGB.

Cada píxel tiene una profundidad de color, esto se refiere al número de colores diferentes que pueden contener los píxeles, esto depende del número de bits que puede almacenar un píxel. Para calcular la cantidad de colores que puede contener un píxel, se debe elevar el número dos a la cantidad de bits utilizados para almacenar el color en el píxel. A continuación se muestran algunos ejemplos para uno, cuatro y veinticuatro bits.

Si para cada píxel se tiene 1 bit y como para cada bit se puede almacenar solamente cero o el uno entonces tenemos 21=2 colores. Y la imagen se vería como la Fig. 45.

Figura 28. 1 bit

Si para cada píxel se tienen 4 bits, entonces tenemos 24=16 colores diferentes, por

lo que la imagen sería como la mostrada en la Fig. 46.

Figura 29. 4 bits

57

Si para cada píxel se tienen 24 bits, entonces tenemos 224= 16,777,216 colores

diferentes, así estaríamos utilizando 1 byte para el rojo, 1 byte para el verde y un byte para el azul, lo que significa que hay 256 niveles para cada componente. Esto último se muestra en la Fig. 47.

Figura 30. 24 bits.

La Figura 47 muestra la representación de un píxel de veitnicuatro bits, así como la

distribución de los colores.

Figura 31. Píxel de 24 bits.

Existen píxeles con profundidad de treinta y dos bits, estos ocho bits (1 byte)

añadidos de profundidad nos permiten almacenar la transparencia de la imagen, este byte añadido también es comúnmente llamado canal alpha, y almacena, en una imagen de 256 niveles de grises, diferentes valores de transparencia. Permitiendo así que el color del píxel de la imagen mostrada en segundo plano se vea influenciado por el grado de transparencia del píxel correspondiente a la imagen situada en primer plano. En la Figura 45 se muestra la representación de un píxel de32 bits.

Figura 32. Píxel de 32 bits.

ALPHA ROJO VERDE AZUL

ROJO VERDE AZUL

58

La información obtenida del canal alpha se interpreta como sigue:

Un valor alpha de 0 (color negro) indica transparencia total, es decir, que la zona del polígono afectada por este valor no se verá.

Un valor de 128 (color gris "puro") indica semitransparencia.

Un valor de 255 (color blanco) indica opacidad total.

En resumen para esta aplicación la profundidad de color que nos fue de utilidad es de 24 bits más el factor de transparencia (denominado canal alpha). Java hace uso de este canal alpha con el cual nos permitió realizar la transparencia de una primer imagen para mostrar como imagen final el esqueleto del lobo mexicano.

Para esta aplicación el formato que se eligió fue el JPEG(Joint Photographic Experts Group), pues este lo que hace es eliminar la información que el ojo humano no es capaz de distinguir, es esa la causa por la que se dice que posee un formato de compresión con pérdida, ya que elimina información.

Elaboración del código. Primero se creó un método que verifica que las imágenes ocupadas en este applet

sean cargadas correctamente. Una vez cargadas, se obtienen los píxeles de la imagen principal que es la foto del lobo. Para lograr la transparencia de la foto del lobo, se crea un arreglo llamado pixels, en el cual se almacenan los píxeles de la foto, pero en valores numéricos, estos valores son almacenados nuevamente en otro arreglo llamado píxeles, aquí es donde se agrega el factor de transparencia, este factor depende del valor que tenga en ese momento la barra de desplazamiento. Los valores de la barra de desplazamiento pueden ir desde 0 (que indica transparencia total) hasta 255 (indica opacidad total). Este factor de transparencia se aplica a la imagen mostrada en la Figura 4 . A partir del arreglo píxeles se vuelve a recrear la imagen con el método llamado createImage() que viene ya incluido en los paquetes de Java.

Figura 33. Imagen principal

Para dibujar la imagen recreada se creó un panel el cual contiene la barra de desplazamiento y un lienzo (denominado Canvas) en el cual se dibuja la imagen tanto de la foto del lobo como su esqueleto. Cada que se genera un evento de la barra de

59

desplazamiento, la imagen se redibuja en el lienzo creado.

La elaboración de la animación de la estructura ósea del lobo mexicano, denominada Esqueleto contiene los siguientes atributos:

height: Guarda la altura en píxeles de la imagen.

weidth: Guarda el ancho en píxeles de la imagen.

pixels[ ]: Este array de enteros, sirve para almacenar el valor de cada uno de los píxeles de la imagen.

pixeles[ ]: Una vez que los datos del array pixels se encuentran en formato numérico, con sus bytes correspondientes al canal alpha y los colores verde, rojo y azul, se modifica el byte alpha y se guardan en este arreglo, para posteriormente crear una nueva imagen a partir de este array numérico.

myImage1: La imagen que corresponde al primer plano, esta es a la cual se le transformará su formato para agregarle el componente alpha.

myImage2: Esta variable almacenará la imagen que se encontrará en segundo plano, en nuestro caso el esqueleto del lobo.

alpha: El valor de esta variable de tipo entera, se obtiene a partir de la barra de desplazamiento que contiene el applet y corresponde al nivel de transparencia de nuestra imagen que se encuentra en primer plano.

blue: El valor de esta variable de tipo entera, se obtiene del valor numérico del byte que corresponde al color azul de un píxel de nuestra imagen.

green: El valor de esta variable de tipo entera, se obtiene del valor numérico del byte que corresponde al color verde de un píxel de nuestra imagen.

red: El valor de esta variable de tipo entera, se obtiene del valor numérico del byte que corresponde al color rojo de un píxel de nuestra imagen.

offscreenG: Nos ayuda a almacenar un gráfico en el doble buffer para evitar el parpadeo.

offscreenIma: En esta variable se almacena la imagen, y también ayuda a evitar el parpadeo.

p1: Este es el panel el cual contendrá la barra de desplazamiento y el lienzo en el cual se dibujará la imagen.

60

sbalpha: Esta variable será nuestra barra de desplazamiento desde donde se tendrá el control de la transparencia de la imagen.

theCanvas: Aquí se dibujará y visualizará la imagen, también lo hará cada que está tenga que redibujarse.

Los métodos de la clase “Esqueleto” son los siguientes::

getRed: Recibe una variable entera, que es el valor que se obtuvo de un sólo píxel de

la imagen, y de esta se hace un corrimiento hacia la derecha de 16 bits para obtener el valor que tiene el píxel para el color rojo.

getBlue: Recibe como parámetro una variable de tipo entera, pues este es el valor que se obtiene de un sólo píxel de la imagen, y de esta variable entera se obtiene el valor que corresponde al color azul.

getGreen: Recibe una variable entera, que es el valor que se obtuvo de un sólo píxel de la imagen, y de esta se hace un corrimiento hacia la derecha de 8 bits para obtener el valor que tiene el píxel para el color verde.

getThePixels: Hace un llamado al método waitToOpenImage, para verificar que las imágenes se hayan cargado completamente, además de que convierte una imagen en un array de valores ( pixels[ ] ) que corresponden a sus píxeles y al final cada píxel lo almacena en el arreglo pixeles[ ] pero con su componente alpha.

handleEvent: Este método recibe como parámetro Event, consiste en identificar un evento, en nuestro caso la barra de desplazamiento esto sucede cuando se hace clic en una flecha de desplazamiento, cuando se mueve el cuadro de desplazamiento o cuando se hace clic en el área entre una flecha de desplazamiento y el cuadro de desplazamiento. Si esto ha sucedido ejecuta una acción en nuestro caso asignar el valor a alpha y repintar la imagen.

init: Este método hace uso de getThePixels y showImage, se encarga de cargar las imágenes y de crear los objetos panel, scrollbar(barra de desplazamiento) y MyCanvas (lienzo donde se visualizarán las imágenes).

showImage: Se encarga de crear una imágen a partir del array numérico pixeles [ ].

waitToOpenImage: Recibe las dos imágenes a ser visualizadas, y su objetivo es garantizar la carga completa de dichas imágenes.

La clase Esqueleto hace uso de la clase TheCanvas la cual contiene los siguientes métodos.

MyCanvas: Este procedimiento es el constructor de la clase, utiliza el método setAlpha, para inicializar a alpha.

paint: Recibe como parámetro un objeto gráfico. Este método hace uso de getThePixels, showImage y waitToOpenImage, se encarga de dibujar las imágenes del

61

lobo mexicano.

setAlpha: Recibe como parámetro un entero. Se encarga de asignar a alpha el valor pasado como parámetro.

update: Es la función que realmente se llama cuando se necesita una actualización de la pantalla.

CLASE VIDEOLOBO El objetivo de esta clase, como en su nombre hace referencia, es la de reproducir un

video acerca del lobo mexicano, en la cual el usuario puede tener un cierto control sobre este video, tal como pausar o reproducir el video, habilitar o deshabilitar el audio y observar solo unas propiedades de este, para esto se agregó una barra de control en la parte inferior de donde se despliega el video. En la siguiente figura se muestra un ejemplo de la visualización de este applet, en la cual se observa el área en la que se reproduce el video y su barra de control.

Para la manipulación de los archivos multimedia tal como el video y audio en la clase VideoLobo, se utilizó una herramienta denominada JMF (Java Media Framework). Esta se utilizó para la visualización del video del Lobo y el aullido del lobo. Para nuestros objetivos, era necesario reproducir video MPEG, pues este ofrece una buena calidad de video y audio en formato MP3. Por este motivo se decidió por hacer uso de esta herramienta, pues el JMF nos permite hacer este tipo de reproducción de video MPEG y audio en MP3.

Figura 34. Ejemplo de reproducción de un video mpeg

A continuación se explican los atributos así como los métodos utilizados para la construcción de la clase VideoLobo.

Atributos:

62

player: Esta variable de tipo Player es la que permite tener el control en todo el momento del video.

Sus métodos son:

init:

Cuando el applet inicia, este método se invoca automáticamente y ejecuta las siguientes tareas. Se construye un objeto URL que localiza un archivo media (video). Crea un objeto Player llamado player para el video y enseguida

start:

VideoLobo ejecuta este método para iniciar al objeto player siempre que el applet comienza.

stop:

Utiliza el método close( ) para detener la reproducción del video y también utiliza el método deallocate( ) para liberar los recursos utilizados por el video.

controllerUpdate:

Este método es de la interfaz ControllerListener y responde a los eventos accionados por los componentes del objeto.

destroy:

Cierra el objeto player cuando esté ha sido eliminado.

Para el despliegue del video se necesita un objeto player y su interfaz en ControllerListener. Se hace uso de un procedimiento llamado createPlayer( ), este método busca en el sistema los componentes adecuados, asi como proporcionar la barra de control, pues al desear hacer una pausa, detener o anular el sonido, esta barra de control lanza eventos y para que el applet pueda recibir los eventos lanzados se debe implementar la interfaz ControllerListener y usar el método addControllerListener para poder llevar el control del estado del objeto player en este applet interactivo.

El primer paso es crear la referencia a un objeto player con la siguiente línea.

Player player = null;

Una vez realizado el paso anterior, cuando el applet VideoLobo inicia, se invoca de manera automática al método init, el cual realizará dos tareas:

Creará un objeto de la clase URL (definida en el paquete java.net), para localizar el archivo media y enseguida se crea el objeto player, haciendo una llamada a Manager.createPlayer, pasándole como argumento el URL. Esto se muestra en las

63

siguientes líneas.

URL mediaURL = new URL (getDocumentBase(), mediaFile);

player = Manager.createPlayer(mediaURL);

A continuación se registra al applet VideoLobo como un escuchador Controller con el nuevo objeto player, llamando a l método addController. Al hacer este registro causa un llamado automático al método controllerUpdate siempre que el objeto player anuncie un evento enviado por el dato media. Esto realiza con la siguiente línea.

player.addControllerListener(this);

Ahora la clase Applet define dos métodos start( ) y stop( ), los cuáles son llamados automáticamente cuando la página que contiene al applet VideoLobo es abierta y cerrada.

El VideoLobo implementa el método start( ), para iniciar el objeto player siempre que este applet ha iniciado.

De manera similar, el applet VideoLobo implementa el método stop( ), para detener y liberar al objeto player, cuando la página que contiene a este applet ha sido cerrada.

public void stop() {

player.stop();

player.deallocate();

}

public void start() {

player.start();

}

64

El método destroy es llamado para disponer de cualquier recurso creado por el applet VideoLobo.

public void destroy() {

player.close();

}

Este applet se registra asimismo como un ControllerListener en su método init( ), así que este recibirá los eventos media del objeto player. Para responder a estos eventos, el applet VideoLobo implementa el método controllerUpdate, es cual es llamado automáticamente cuando el objeto Player envía un evento. El applet VideoLobo responde a un tipo de evento, RealizeCompleteEvent. Cuando el player envía un RealizeCompleteEvent, el VideoLobo despliega los componentes del objeto player y panel de control default. Cuando el método controllerUpdate() de ControllerListener reciba un evento RealizeCompleteEvent se pueden obtener los componentes VisualComponet y ControlPanelComponent y asegurarnos que los componentes existes para añadirlos en la ventana de nuestro applet. Llamando al método validate( ) activa el administrador de diseño para desplegar e incluir los nuevos componentes.

CLASE ZOOMLOBO El objetivo de esta clase, como en su nombre hace referencia, es la de hacer un

pequeño zoom en cierta área de la imagen del lobo mexicano. Esta clase también se encarga de reproducir el aullido del lobo en cuanto el usuario da un clic sobre el hocico del lobo. Esta clase utiliza a la clase VideoLobo si el usuario le da un clic en los ojos del lobo o puede mostrar el esqueleto del lobo utilizando la clase Esqueleto si el usuario da un clic en la panza del lobo. La Figura 51 muestra el applet final de forma visual, en la cual se puede ver un recuadro en el cual se dibuja el zoom del lobo.

65

Figura 35. Applet ZoomLobo

A continuación se dará una breve explicación de los atributos y métodos utilizados en el applet ZoomLobo.

Atributos:

h: Indica la altura en píxeles del área en el cual se hará el zoom.

w: Indica el ancho en píxeles del área en el cual se hará el zoom.

x: Indica en píxeles la coordenada x del centro del área en el cual se hará el zoom.

y: Indica en píxeles la coordenada y del centro del área en el cual se hará el zoom.

escala: Factor que describe cuanto la imágen será escalada.

base: De tipo URL que carga una imagen cuyo nombre es “lobo_anatomia.jpg”

image: Es de tipo bufferedimage, este nos ayuda a manipular los datos de nuestra imagen, creando un buffer fuera de pantalla.

player: De tipo objeto player, para reproducir el aullido del lobo.

Métodos:

ZoomLobo:

Este constructor se encarga de inicializar a las variables x, y, w, h, y escala. Les da un valor default.

66

controllerUpdate:

Al igual que en el applet VideoLobo, este método se encarga de obtener los componentes de control y visuales.

init:

Se carga la imagen, el buffer en el cual se dibujará la imagen fuera de pantalla, se obtiene el archivo mp3, y crea un objeto player para este archivo media.

paint:

Se dibuja el área en el cual se hará el zoom. Fatal:

Lanza mensajes cuando ha ocurrido un error durante la carga de los componentes de control y visuales del objeto player.

67

Bibliografía [1] Schildt H.., Naughton P., “JAVA: Manual de referencia”, McGraw-Hill, 1997. [2] Schildt H.., “JAVA 2”, McGraw-Hill, 1997. [3] http://java.sun.com [4] http://www.programación.com/java [5] http://java.sun.com/products/java-media/jmf/2.1.1/samples/samplecode.html [6] http://atenea.udistrital.edu.co/estudiantes/oleon/page2.htm

68

Conceptos generales

JMF

El JMF acrónimo de Java Media Framework es una interfaz de programación de aplicación (API) creada para el tratamiento de datos multimedia (video y sonido) dentro de aplicaciones Java y applets, así como también para la transmisión de estos. Esta nueva tecnología incluye una arquitectura abierta que les proporciona a los desarrolladores el acceso a los procesos de captura y reproducción. El JMF proporciona una arquitectura unificada y un protocolo de mensajes para el manejo de la adquisición, procesamiento y entrega de datos multimedia basados en tiempo. JMF fue diseñado para soportar la mayoría de los tipos multimedia estándar, tales como, AIFF, AUN, AVI, GSM, MIDI, MP3, MPEG, QuickTime, RMF y WAV. Para explotar las ventajas de la plataforma Java, JMF entrega la promesa de “Escribe una vez y ejecuta en cualquier lugar”, para los desarrolladores que desean utilizar archivos media tales como audio y video en sus programas Java. Las implementaciones del JMF pueden influenciar en la capacidades fundamentales del sistema operativo, mientras que los desarrolladores pueden crear fácilmente programas portables de Java. Con JMF, se puede fácilmente crear applets y aplicaciones para presentar, capturar, manipular y almacenar datos multimedia.

Clase applet

Para la realización de este software se construyeron applets, pues nos ofrece una mayor flexibilidad para el manejo de imágenes, archivos multimedia y dar una mejor presentación para lograr llamar la atención del usuario.

Para crear un applet únicamente necesitamos escribir una clase derivada de la clase Applet del paquete java.applet. La clase Applet tiene que ser la superclase de cualquier applet que se construya. También se hizo uso de la clase Japplet, esta clase también deriva de la clase Applet. La Figura 1 muestra dónde se sitúa esta clase en la jerarquía de clases de la biblioteca Java.

69

Figura. Jerarquía de clases

Características de GIF y JPEG

Dentro de los diferentes tipos de medias que tenemos actualmente se encuentran las imágenes fijas (JPEG, GIF, etc). El objetivo principal que deben de seguir las normas de codificación de imágenes es codificar solo la información que los sentidos humanos perciben, para el caso de las imágenes fijas solo se codifica lo que el ser humano ve. Para la codificación de imágenes se llevaron a cabo estudios del sistema visual humano (se estudiaron sus características fisiológicas y la psicofísica del sistema visual humano). Los estudios hechos mostraron que el color visto por el ojo humano puede ser especificado por solo tres números, además que el ojo humano es altamente sensible a los colores Rojo, Verde y Azul, por lo que para representar una gama (la mayoría) de los colores se utilizan los colores primarios Rojo, Verde y Azul, (RGB).

El formato GIF (Graphic Image Format), propietario de CompuServe, es el formato más utilizado para mostrar gráficos de colores indexados e imágenes en documentos HTML (hypertext markup language) sobre World Wide Web y otros servicios en línea. GIF es un formato de imágenes comprimidas, diseñado para minimizar el tiempo de transferencia de archivos sobre las líneas telefónicas. Es un formato de compresión sin pérdida.

El JPEG (Joint Photographic Experts Group) es el formato que se utiliza comúnmente para almacenar fotografías y otras imágenes de tono continuo, y también se utiliza en documentos HTML para Internet. A diferencia del formato GIF, JPEG guarda toda la información referente al color en RGB. JPEG también utiliza un sistema de compresión, que de forma eficiente reduce el tamaño de los archivos mediante la identificación y el descarte de los datos redundantes que no son esenciales para mostrar la imagen, pues se basa en el hecho de que el ojo humano no es perfecto y no es capaz de

70

captar toda la información que se puede almacenar en una imagen.

Objeto Player

Un Player es un objeto que procesa un flujo de entrada de datos multimedia para entregarlos en un momento preciso, para crear objetos de esta clase se hace uso de un procedimiento llamado createPlayer( ), este método busca en el sistema los componentes adecuados y crea el Player que se necesita en ese momento.

Cuando se necesita crear un objeto Player , se debe hacer la petición a la clase Manager y esta invocará al método createPlayer. El Manager utiliza el URL del dato multimedia (en nuestro caso del video), es decir la ubicación de este archivo media, para crear el objeto Player adecuado a esté, de acuerdo a sus características.

Ahora nos hacemos la pregunta, ¿como presentar la salida de este archivo media?.

En JMF, el proceso de la presentación es modelado por la interfaz Controller. Controller define el mecanismo básico de estado y control para un objeto que controle, presente, o capture datos multimedia. Un Controller fija una variedad de eventos específicos para proporcionar la notificación de cambios en su estatus. Para recibir acontecimientos de un Controller tal como un Player, se implementa la interfaz ControllerListener.

Interfaz ControllerListener

Otra medida a tomar en cuenta es el manejo que tiene el usuario sobre el video, es decir sobre la barra de control, pues al desear hacer una pausa, detener o anular el sonido, esta barra de control lanza eventos y para que el applet pueda recibir los eventos lanzados se debe implementar la interfaz ControllerListener y usar el método addControllerListener para poder llevar el control del estado del objeto player en este applet interactivo. Al utilizar el método addControllerListener se registra un Controller a una lista de Controllers de un player en particular. La importancia de recibir los eventos radica en que es necesario el control de los eventos que se puedan lanzar para tomar las medidas oportunas en el resto de la reproducción del video. En una de las ocasiones en que se hace importante recibir los eventos lanzados es cuando se desea liberar recursos si no se están utilizando.

Control en la presentación del video

71

Uno de los conceptos manejados es el VisualComponet, es aquel componente en el cual se despliega el dato multimedia. Un objeto player a menudo tiene un panel de control que permite al usuario controlar la presentación de la media. Por ejemplo, un objeto player podría estar asociado con un conjunto de botones para iniciar, detener y pausar el dato media y con un control slider para ajustar el volumen, a este panel de control se le denomina ControlPanelComponent. Estos componente se obtienen mediante los métodos getVisualComponent( ) y getControlPanelComponent( ).

72

Anexo B. Código de los programas MODULO: MENU ARCHIVO: cubo.java

/* * CUBO.java */ import java.applet.Applet; import java.applet.AppletContext; import java.awt.*; import java.awt.image.MemoryImageSource; import java.awt.image.PixelGrabber; import java.io.PrintStream; import java.net.MalformedURLException; import java.net.URL; //------------------------------------------------------------------------------ public class CUBO extends Applet implements Runnable { private Graphics Amb_gra;//para obtener el ambiente gráfico, utilizado en update private Graphics Pinta;//Para pintar rectángulos private Thread Hilo;//hilo de ejecucion private Image Im;//auxiliar para pintar y verificar las imagenes private Image Cubo;//imagenes para el cubo private Image Im_matriz; private String target;//target private Dimension Tamaño;//tamaño de la ventana int H;//Height private int J;//mitad del ancho private int K; private int L; private int M; private String Links[];//para guardar los URL private long O; private long P; private int Q[]; private int S[];//manipular imagenes private int T[]; private int U[]; private int V[]; private int W[]; private int X[]; private int Y[] = { 3, 2, 1, 0, -1, 4, 5, 6, 7, -1, 0, 1, 5, 4, -1, 2, 3, 7, 6, -1, 1, 2, 6, 5, -1, 0, 4, 7, 3, -1, -1 };//sirve para pintar las caras private double Z[]; private double a[]; private int sleep;//tiempo para el sleep private int d=512;

73

private int e=900; private int f; private int g=30; private double k; private double l; private double m; private double n; private double o; private double p; private double q; private double r; private double s; private double t; private double u; private double v; private double w; private double x; private double y; private double z; private double vel;//marca un parámetro de respuesta al mouse private double vel_zoom; private double C3; private double C4; private double C9; private double CA; private double CB; private double CD; private double CE; private double CF; private double D0; private double D1; private double D2; private int fondo;//color de fondo private int D5;//color del cubo del fondo private int D6; private int ancho=250;//ancho; private int mitad_ancho; private int DA; private int DB; private int DC; private int DE[]; private int DF[]; private boolean Movimiento; private boolean E1; private boolean E2; private boolean E3; private boolean E4; private boolean E5;//habilita la corrida private boolean E6; private boolean E7; private boolean E8; private boolean E9; //--------------------------------------------------------------- //Constructor de la clase public CUBO(){ Movimiento = false; E1 = false; E2 = false; E3 = false; E4 = false;

74

E5 = false; E6 = false; E7 = false; E8 = false; E9 = false; } //---------------------------------------------------------- public synchronized void paint(Graphics g1) { if(Im != null && E5) g1.drawImage(Im, 0, 0, this); } //---------------------------------------------------------- public synchronized void update(Graphics g1) { paint(g1); } //---------------------------------------------------------- //Transforma los parámetros obtenidos a entero public int Parametros_a_Entero(String s1, int i1) { try { return Integer.parseInt(getParameter(s1), i1); } catch(NumberFormatException _ex) { return 0; } } //---------------------------------------------------------- //Habilita el hilo de ejecución public void start() { if(Hilo == null) { Hilo = new Thread(this); Hilo.start(); } } //---------------------------------------------------------- public void stop() { if(Hilo != null && Hilo.isAlive()) Hilo.stop(); Hilo = null; } //---------------------------------------------------------- //Prepara los valores iniciales de las variables y //obtiene las imagenes del cubo public void init(){ super.init();//para llamar a los miembros que son ocultos de la superclase Obt_Parámetros(); Tamaño = size(); H=Tamaño.height; // ancho=250;//250ancho =150;//Tamaño del cuboI.width >= I.height ? I.height : I.width; mitad_ancho = ancho/2;//ancho / 2; double ad[] = {

75

-mitad_ancho, -mitad_ancho, -mitad_ancho, mitad_ancho, -mitad_ancho, -mitad_ancho, mitad_ancho, mitad_ancho, -mitad_ancho, -mitad_ancho, mitad_ancho, -mitad_ancho, -mitad_ancho, -mitad_ancho, mitad_ancho, mitad_ancho, -mitad_ancho, mitad_ancho, mitad_ancho, mitad_ancho, mitad_ancho, -mitad_ancho, mitad_ancho, mitad_ancho }; a = ad; J = Tamaño.width / 2; K = Tamaño.height / 2; y = 1.0D; z = -1D; S = new int[H]; T = new int[H]; Q = new int[Tamaño.width * H]; W = new int[Tamaño.width * H]; X = new int[Tamaño.width * H]; DF = new int[Tamaño.width]; for(int i1 = 0; i1 < Tamaño.width; i1++) DF[i1] = 0xff000000 + D5; V = new int[H]; for(int j1 = 0; j1 < H; j1++) V[j1] = 0; Amb_gra = getGraphics(); f = a.length / 3; Z = new double[a.length]; Im_matriz = createImage(Tamaño.width, Tamaño.height); Pinta = Im_matriz.getGraphics(); Pinta.setColor(Color.white); Pinta.fillRect(0,0,600,600); Pinta.setColor(new Color(fondo)); PixelGrabber pixelgrabber = new PixelGrabber(Im_matriz, 0, 0, Tamaño.width, Tamaño.height, W, 0, Tamaño.width); try { pixelgrabber.grabPixels(); } catch(InterruptedException _ex) { } pixelgrabber = new PixelGrabber(Im_matriz, 0, 0, Tamaño.width, Tamaño.height, X, 0, Tamaño.width); try { pixelgrabber.grabPixels(); return; } catch(InterruptedException _ex) { return; } } //---------------------------------------------------------- //Obtiene imagenes del cuubo public void run() { Im = createImage(500, 500); Graphics g1 = Im.getGraphics(); DE = new int[Tamaño.width * Tamaño.height * 6];

76

E5 = true; for(int i1 = 0; i1 < 6; i1++){ g1.setColor(Color.white); g1.fillRect(0, 0, 1000, 1000); g1.setColor(Color.blue); String s2 = "Bajando Imagenes " + Integer.toString(i1 + 1); g1.drawString(s2, J/2 , 100); update(Amb_gra); if(getParameter("image" + Integer.toString(i1)) != null){ Cubo = getImage(getDocumentBase(), getParameter("image" + Integer.toString(i1))); Buffer(Cubo); Cubo = I(Cubo, ancho, ancho); System.arraycopy(U, 0, DE, i1 * ancho * ancho, ancho * ancho); } } E5 = false; D2 = 0.0D; D0 = 50D; D1 = 50D; E3 = false; E4 = false; E5 = false; E6 = false; E7 = false; E8 = false; E9 = false; System.arraycopy(a, 0, Z, 0, a.length); n = v= r = 0.0D;//quite r k = p = u = 1.0D; l = m = o = s = q = t = 0.0D; C4 = 0.0D;//quite C5 yC6 E7 = false; do { E2 = E1; n = v = r = 0.0D;//quite r if(E8) { v = 750D; double d1 = Math.asin(Math.sqrt(CA * CA + CB * CB)); double d2 = Math.sqrt(CA * CA + CB * CB); double d3 = (int)(d1 / vel_zoom); for(int j1 = 0; (double)j1 < d3; j1++) { D(-CB / d2, CA / d2, 0.0D, vel_zoom, 1.0D); A(); E5 = true; update(Amb_gra); E5 = false; } A(); E5 = true; update(Amb_gra); E5 = false; double d4 = Math.acos(CD); if(CE > 0.0D) d4 = -d4; int k1 = Math.max((int)(Math.abs(d4) / vel_zoom /

77

3D), 5); double d5 = Math.exp(Math.log(1.45D) / (double)k1); for(int l1 = 1; l1 <= k1; l1++) { D(0.0D, 0.0D, -1D, -d4 / (double)k1, d5); A(); E5 = true; update(Amb_gra); E5 = false; } while(!E4) { E5 = true; try { Thread.sleep(100L); } catch(InterruptedException _ex) { } } for(int i2 = 1; i2 <= k1; i2++) { D(0.0D, 0.0D, -1D, d4 / (double)k1, 1.0D / d5); A(); E5 = true; update(Amb_gra); E5 = false; } v = 750D; d2 = Math.sqrt(CA * CA + CB * CB); for(int j2 = 0; (double)j2 < d3; j2++) { D(-CB / d2, CA / d2, 0.0D, -vel_zoom, 1.0D); A(); E5 = true; update(Amb_gra); E5 = false; } D(-CB / d2, CA / d2, 0.0D, -d1 + d3 * vel_zoom, 1.0D); A(); E5 = true; update(Amb_gra); E5 = false; n = v = r = 0.0D;//quite r C4 = w; //C5 = x; E8 = false; E3 = false; } else if(E6) { C4 = w; //C5 = x; } else { if(E7) { O = System.currentTimeMillis();//devuelve la hora del sistema C4 = w = x = 0.0D;//quite c5 E7 = false; }

78

if(System.currentTimeMillis() - O > 5000L) { //x=C3;//C5 = C3; C4 = (2D* C3) / 3D; } } Giro_Horizontal();//giro horizontal Giro_Vertical();//giro vertical C9 = 750D; v += C9; F(); A(); E5 = true; update(Amb_gra); E5 = false; try { Thread.sleep(sleep); } catch(InterruptedException _ex) { } } while(true); } //---------------------------------------------------------- public void A(){ E9 = false; if(E2) System.arraycopy(W, 0, Q, 0, Tamaño.width * Tamaño.height); else System.arraycopy(X, 0, Q, 0, Tamaño.width * Tamaño.height); int i1 = 0; int ai[] = new int[f]; int ai1[] = new int[f]; int j1 = 0; for(int l1 = 0; l1 < f * 3; l1 += 3) { int i2 = (int)Z[l1]; int k2 = (int)Z[l1 + 1]; int l2 = (int)Z[l1 + 2]; ai[j1] = (i2 * d) / l2 + J; ai1[j1] = (k2 * d) / l2 + K; j1++; } int j2 = 0; Polygon polygon = new Polygon(); int i3 = Y[0]; for(int j3 = 0; j3 < 30; j3++) { int k3 = Y[j3]; if(k3 < 0) { polygon.addPoint(ai[i3], ai1[i3]); i3 = Y[j3 + 1]; byte byte0 = 0; byte byte1 = 0; byte byte3 = 0; byte byte5 = 0; Polygon polygon1 = new Polygon(); double d1 = (double)e - D2;

79

double d2 = ((Z[byte1 * 3] - D0) * d1) / (Z[byte1 * 3 + 2] - D2); double d3 = ((Z[byte1 * 3 + 1] - D1) * d1) / (Z[byte1 * 3 + 2] - D2); double d5 = ((Z[byte0 * 3] - D0) * d1) / (Z[byte0 * 3 + 2] - D2); double d7 = ((Z[byte0 * 3 + 1] - D1) * d1) / (Z[byte0 * 3 + 2] - D2); double d9 = ((Z[byte3 * 3] - D0) * d1) / (Z[byte3 * 3 + 2] - D2); double d11 = ((Z[byte3 * 3 + 1] - D1) * d1) / (Z[byte3 * 3 + 2] - D2); double d13 = ((Z[byte5 * 3] - D0) * d1) / (Z[byte5 * 3 + 2] - D2); double d15 = ((Z[byte5 * 3 + 1] - D1) * d1) / (Z[byte5 * 3 + 2] - D2); polygon1.addPoint((int)((d2 * (double)d) / d1 + (double)J), (int)((d3 * (double)d) / d1 + (double)J)); polygon1.addPoint((int)((d5 * (double)d) / d1 + (double)J), (int)((d7 * (double)d) / d1 + (double)J)); polygon1.addPoint((int)((d9 * (double)d) / d1 + (double)J), (int)((d11 * (double)d) / d1 + (double)J)); polygon1.addPoint((int)((d13 * (double)d) / d1 + (double)J), (int)((d15 * (double)d) / d1 + (double)J)); int ai2[] = polygon1.ypoints; int ai3[] = new int[2]; ai3 = N(polygon1.xpoints, polygon1.ypoints); int j5 = ai3[0]; int k5 = ai3[1]; for(int l5 = Math.max(ai2[k5], 0); l5 < Math.min(ai2[j5], Tamaño.height); l5++) { int i6 = Math.min(S[l5], T[l5]); int j6 = Math.max(S[l5], T[l5]); System.arraycopy(DF, 0, Q, i6 + l5 * Tamaño.width, j6 - i6); } i1++; polygon = new Polygon(); j2 = j3 + 1; } else { polygon.addPoint(ai[k3], ai1[k3]); } } j2 = 0; polygon = new Polygon(); i3 = Y[0]; i1 = 0; for(int l3 = 0; l3 < g; l3++) { int i4 = Y[l3]; if(i4 < 0) { polygon.addPoint(ai[i3], ai1[i3]); i3 = Y[l3 + 1]; byte byte2 = 0; byte byte4 = 0; byte byte6 = 0; boolean flag = false; switch(i1)

80

{ case 0: // '\0' byte2 = 0; byte4 = 1; byte6 = 3; byte byte7 = 2; break; case 1: // '\001' byte2 = 5; byte4 = 4; byte6 = 6; byte byte8 = 7; break; case 2: // '\002' byte2 = 4; byte4 = 5; byte6 = 0; boolean flag1 = true; break; case 3: // '\003' byte2 = 3; byte4 = 2; byte6 = 7; byte byte9 = 6; break; case 4: // '\004' byte2 = 1; byte4 = 5; byte6 = 2; byte byte10 = 6; break; case 5: // '\005' byte2 = 4; byte4 = 0; byte6 = 7; byte byte11 = 3; break; } int j4 = ai[byte6] - ai[byte2]; int k4 = ai1[byte6] - ai1[byte2]; int l4 = ai[byte4] - ai[byte2]; int i5 = ai1[byte4] - ai1[byte2]; if(j4 * i5 - k4 * l4 <= 0) { double d4 = (Z[byte4 * 3] - Z[byte2 * 3]) / (double)ancho; double d6 = (Z[byte4 * 3 + 1] - Z[byte2 * 3 + 1]) / (double)ancho; double d8 = (Z[byte4 * 3 + 2] - Z[byte2 * 3 + 2]) / (double)ancho; double d10 = (Z[byte6 * 3] - Z[byte2 * 3]) / (double)ancho; double d12 = (Z[byte6 * 3 + 1] - Z[byte2 * 3 + 1]) / (double)ancho; double d14 = (Z[byte6 * 3 + 2] - Z[byte2 * 3 + 2]) / (double)ancho; double d16 = Z[byte2 * 3]; double d17 = Z[byte2 * 3 + 1]; double d18 = Z[byte2 * 3 + 2]; double d19 = d12 * d8 - d14 * d6; double d20 = d14 * d4 - d10 * d8;

81

double d21 = d10 * d6 - d12 * d4; double d22 = Math.sqrt(d19 * d19 + d20 * d20 + d21 * d21); d19 /= d22; d20 /= d22; d21 /= d22; double d23 = (double)DA - (d16 + (double)mitad_ancho * d4 + (double)mitad_ancho * d10); double d24 = (double)DB - (d17 + (double)mitad_ancho * d6 + (double)mitad_ancho * d12); double d25 = (double)DC - (d18 + (double)mitad_ancho * d8 + (double)mitad_ancho * d14); int k1 = j2; polygon = new Polygon(); int k6 = Y[k1]; do { polygon.addPoint(ai[k6], ai1[k6]); k6 = Y[++k1]; } while(k6 >= 0); double d26 = (d23 * d19 + d24 * d20 + d25 * d21) / Math.sqrt(d23 * d23 + d24 * d24 + d25 * d25); int l6 = E2 & (!E8) ? 255 : Math.max(Math.min((int)(255D * d26 * 0.90000000000000002D + 25.5D), 255), 20); int ai4[] = new int[2]; ai4 = N(polygon.xpoints, polygon.ypoints); int i7 = Math.min(polygon.ypoints[ai4[0]], Tamaño.height); int j7 = Math.max(polygon.ypoints[ai4[1]], 0); double d27 = (double)d * (d4 * d18 - d8 * d16); double d28 = (double)d * (d8 * d10 - d4 * d14); double d29 = (double)d * (d8 * d17 - d6 * d18); double d30 = (double)d * (d6 * d14 - d8 * d12); double d31 = (double)(d * d) * (d6 * d16 - d4 * d17); double d32 = (double)(d * d) * (d4 * d12 - d6 * d10); double d33 = (double)d * (d10 * d18 - d14 * d16); double d34 = (double)d * (d14 * d4 - d10 * d8); double d35 = (double)d * (d14 * d17 - d12 * d18); double d36 = (double)d * (d12 * d8 - d14 * d6); double d37 = (double)(d * d) * (d12 * d16 - d10 * d17); double d38 = (double)(d * d) * (d10 * d6 - d12 * d4); int k7 = Tamaño.width; int l7 = i1 * ancho * ancho; if(!E2 || E8) { for(int k9 = j7; k9 < i7; k9++) { double d43 = (double)(k9 - K) * d27 + d31; double d45 = (double)(k9 - K) * d28 + d32; double d39 = (double)(k9 - K) * d33 + d37; double d41 = (double)(k9 - K) * d34 + d38; int l9 = Math.min(S[k9], T[k9]); int i10 = Math.max(S[k9], T[k9]); double d51 = (double)(l9 - J) * d35 + d39; double d55 = (double)(l9 - J) * d36 + d41; double d53 = (double)(l9 - J) * d29 +

82

d43; double d57 = (double)(l9 - J) * d30 + d45; int j10 = k9 * k7; for(int k10 = l9; k10 <= i10; k10++) { if(k10 >= 0 && k10 < Tamaño.width) { double d49 = d51 / d55; double d47 = d53 / d57; int i8 = (int)d49; int k8 = (int)d47; i8 = i8 >= 0 ? i8 <= ancho - 1 ? i8 : ancho - 1 : 0; k8 = k8 >= 0 ? k8 <= ancho - 1 ? k8 : ancho - 1 : 0; int i9 = DE[l7 + i8 + ancho * k8]; int l10 = (i9 & 0xff) * l6 & 0xff00; int i11 = ((i9 & 0xff00) >> 8) * l6 & 0xff00; int j11 = ((i9 & 0xff0000) >> 16) * l6 & 0xff00; Q[k10 + j10] = 0xff000000 + (j11 << 8) + i11 + (l10 >> 8); } d51 += d35; d55 += d36; d53 += d29; d57 += d30; } } } else { double d65 = Math.sqrt((0.0D - D0) * (0.0D - D0) + (0.0D - D1) * (0.0D - D1) + (750D - D2) * (750D - D2)); double d66 = -D0 / d65; double d67 = -D1 / d65; double d68 = (750D - D2) / d65; for(int l12 = j7; l12 < i7; l12++) { int i13 = Math.min(S[l12], T[l12]); int j13 = Math.max(S[l12], T[l12]); double d44 = (double)(l12 - K) * d27 + d31; double d46 = (double)(l12 - K) * d28 + d32; double d40 = (double)(l12 - K) * d33 + d37; double d42 = (double)(l12 - K) * d34 + d38; double d52 = (double)(i13 - J) * d35 + d40; double d56 = (double)(i13 - J) * d36 + d42; double d54 = (double)(i13 - J) * d29 + d44; double d58 = (double)(i13 - J) * d30 + d46; int k13 = l12 * k7; for(int l13 = i13; l13 <= j13; l13++) {

83

if(l13 >= 0 && l13 < k7) { double d50 = d52 / d56; double d48 = d54 / d58; double d59 = (d16 + d4 * d50 + d10 * d48) - D0; double d61 = (d17 + d6 * d50 + d12 * d48) - D1; double d62 = (d18 + d8 * d50 + d14 * d48) - D2; double d63 = Math.sqrt(d59 * d59 + d61 * d61 + d62 * d62); d59 /= d63; d61 /= d63; d62 /= d63; double d64 = d66 * d59 + d67 * d61 + d68 * d62; double d69 = -(d19 * d59 + d20 * d61 + d21 * d62); double d70 = Math.max(35D * (d64 - 0.95999999999999996D), 0.0D); int j12 = (int)(((double)l6 * (d69 * (d70 * d70 + 1.0D))) / 2D) - 255; int k12 = (int)(255D * (50D * Math.max(d69 - 0.95999999999999996D, 0.025000000000000001D))); int j8 = (int)d50; int l8 = (int)d48; j8 = j8 >= 0 ? j8 <= ancho - 1 ? j8 : ancho - 1 : 0; l8 = l8 >= 0 ? l8 <= ancho - 1 ? l8 : ancho - 1 : 0; int j9 = DE[l7 + j8 + ancho * l8]; int i12 = j9 & 0xff; int l11 = (j9 & 0xff00) >> 8; int k11 = (j9 & 0xff0000) >> 16; i12 *= k12; l11 *= k12; k11 *= k12; i12 >>= 8; l11 >>= 8; k11 >>= 8; i12 += j12; l11 += j12; k11 += j12; i12 = i12 <= 255 ? i12 : 255; l11 = l11 <= 255 ? l11 : 255; k11 = k11 <= 255 ? k11 : 255; i12 = i12 >= 0 ? i12 : 0; l11 = l11 >= 0 ? l11 : 0; k11 = k11 >= 0 ? k11 : 0; Q[l13 + k13] = 0xff000000 + (k11 << 16) + (l11 << 8) + i12; } d52 += d35; d56 += d36; d54 += d29; d58 += d30; } } } if(polygon.inside(L, M))

84

{ D6 = i1; E9 = true; if(E4 && !E8) { CA = d19; CB = d20; double d60 = Math.sqrt(d4 * d4 + d6 * d6 + d8 * d8); CD = d4 / d60; CE = d6 / d60; CF = d8 / d60; D6 = i1; E8 = true; E4 = false; } else { E4 = false; } } } i1++; polygon = new Polygon(); j2 = l3 + 1; } else { polygon.addPoint(ai[i4], ai1[i4]); } } Im = createImage(new MemoryImageSource(Tamaño.width, Tamaño.height, Q, 0, Tamaño.width)); Buffer(Im); if(!E9) D6 = 7; } //---------------------------------------------------------- public int[] N(int ai[], int ai1[]) { System.arraycopy(V, 0, S, 0, Tamaño.height); System.arraycopy(V, 0, T, 0, Tamaño.height); int i1 = 0xff000001; int j1 = 0xffffff; int k1 = 5; int l1 = 5; for(int i2 = 0; i2 < 4; i2++) { if(ai1[i2] < j1) { j1 = ai1[i2]; l1 = i2; } if(ai1[i2] > i1) { i1 = ai1[i2]; k1 = i2; } } int j2 = (l1 + 1) % 4; int k2 = ((4 + l1) - 1) % 4; byte byte0 = 5; if(ai[j2] < ai[k2])

85

{ K(ai[j2], ai1[j2], ai[l1], ai1[l1], true); K(ai[k2], ai1[k2], ai[l1], ai1[l1], false); if(j2 == k1) { int l2 = ((4 + l1) - 2) % 4; K(ai[k2], ai1[k2], ai[l2], ai1[l2], false); K(ai[l2], ai1[l2], ai[k1], ai1[k1], false); } else if(k2 == k1) { int i3 = (l1 + 2) % 4; K(ai[j2], ai1[j2], ai[i3], ai1[i3], true); K(ai[i3], ai1[i3], ai[k1], ai1[k1], true); } else { K(ai[j2], ai1[j2], ai[k1], ai1[k1], true); K(ai[k2], ai1[k2], ai[k1], ai1[k1], false); } } else { K(ai[j2], ai1[j2], ai[l1], ai1[l1], false); K(ai[k2], ai1[k2], ai[l1], ai1[l1], true); if(j2 == k1) { int j3 = ((4 + l1) - 2) % 4; K(ai[k2], ai1[k2], ai[j3], ai1[j3], true); K(ai[j3], ai1[j3], ai[k1], ai1[k1], true); } else if(k2 == k1) { int k3 = (l1 + 2) % 4; K(ai[j2], ai1[j2], ai[k3], ai1[k3], false); K(ai[k3], ai1[k3], ai[k1], ai1[k1], false); } else { K(ai[j2], ai1[j2], ai[k1], ai1[k1], false); K(ai[k2], ai1[k2], ai[k1], ai1[k1], true); } } int ai2[] = { k1, l1 }; return ai2; } //---------------------------------------------------------- public void K(int i1, int j1, int k1, int l1, boolean flag) { int i2 = k1 - i1; int j2 = l1 - j1; if(Math.abs(i2) > Math.abs(j2)) { if(i2 < 0) { int k2 = i1; i1 = k1; k1 = k2; k2 = j1; j1 = l1; l1 = k2; }

86

byte byte1; if(l1 > j1) byte1 = 1; else byte1 = -1; i2 = k1 - i1; j2 = Math.abs(l1 - j1); int l2 = i1; int k3 = j1; int i4 = -(i2 / 2); if(l2 >= 0 && k3 >= 0 && k3 < Tamaño.height) if(flag) S[k3] = Math.min(l2, Tamaño.width - 1); else T[k3] = Math.min(l2, Tamaño.width - 1); while(l2 < k1) { boolean flag1 = false; i4 += j2; if(i4 >= 0) { k3 += byte1; i4 -= i2; flag1 = true; } if(++l2 >= 0 && k3 >= 0 && k3 < Tamaño.height && flag1) if(flag) S[k3] = Math.min(l2, Tamaño.width - 1); else T[k3] = Math.min(l2, Tamaño.width - 1); } return; } if(j2 < 0) { int i3 = i1; i1 = k1; k1 = i3; i3 = j1; j1 = l1; l1 = i3; } byte byte0; if(k1 > i1) byte0 = 1; else byte0 = -1; i2 = Math.abs(k1 - i1); j2 = l1 - j1; int j3 = i1; int l3 = j1; int j4 = -(j2 / 2); if(j3 >= 0 && l3 >= 0 && l3 < Tamaño.height) if(flag) S[l3] = Math.min(j3, Tamaño.width - 1); else T[l3] = Math.min(j3, Tamaño.width - 1); while(l3 < l1) { j4 += i2;

87

if(j4 >= 0) { j3 += byte0; j4 -= j2; } l3++; if(j3 >= 0 && l3 >= 0 && l3 < Tamaño.height) if(flag) S[l3] = Math.min(j3, Tamaño.width - 1); else T[l3] = Math.min(j3, Tamaño.width - 1); } } //---------------------------------------------------------- public void Obt_Parámetros() { sleep = Parametros_a_Entero("sleeptime", 10); D5 = Parametros_a_Entero("shadowcolor", 16); fondo = Parametros_a_Entero("background", 16); Links = new String[6]; for(int i1 = 0; i1 < 6; i1++) { Links[i1] = getParameter("url" + Integer.toString(i1)); if(Links[i1] == null) Links[i1] = ""; } if(getParameter("showlightbutton") != null) Movimiento = getParameter("showlightbutton").substring(0, 1).equalsIgnoreCase("y"); target = getParameter("target"); vel = ((double)Parametros_a_Entero("mouseresponse", 10) * 3.1415926535897931D) / 180D; vel_zoom = ((double)Parametros_a_Entero("zoomspeed", 10) * 3.1415926535897931D) / 180D; E1 = getParameter("spotlight").substring(0, 1).equalsIgnoreCase("y"); C3= ((double)Parametros_a_Entero("anglestep",10)* 3.1415926535897931D) / 180D; } //---------------------------------------------------------- public void F() { for(int i1 = f * 3; (i1 -= 3) >= 0;) { double d1 = a[i1]; double d2 = a[i1 + 1]; double d3 = a[i1 + 2]; Z[i1] = d1 * k + d2 * l + d3 * m + n; Z[i1 + 1] = d1 * o + d2 * p + d3 * q + r;//+r Z[i1 + 2] = d1 * s + d2 * t + d3 * u + v;//l por s } } //---------------------------------------------------------- public void D(double d1, double d2, double d3, double d4, double d5) { double d12 = Math.cos(d4); double d13 = Math.sin(d4); for(int i1 = f * 3; (i1 -= 3) >= 0;) {

88

double d6 = Z[i1]; double d8 = Z[i1 + 1]; double d10 = Z[i1 + 2] - v; double d14 = d1 * d6 + d2 * d8 + d3 * d10; Z[i1] = d14 * d1 + d12 * (d6 - d14 * d1) + d13 * (d2 * d10 - d3 * d8); Z[i1 + 1] = d14 * d2 + d12 * (d8 - d14 * d2) + d13 * (d3 * d6 - d1 * d10); Z[i1 + 2] = d14 * d3 + d12 * (d10 - d14 * d3) + d13 * (d1 * d8 - d2 * d6); Z[i1] *= d5; Z[i1 + 1] *= d5; Z[i1 + 2] *= d5; Z[i1 + 2] += v; } double d7 = CD; double d9 = CE; double d11 = CF; double d15 = d1 * d7 + d2 * d9 + d3 * d11; CD = d15 * d1 + d12 * (d7 - d15 * d1) + d13 * (d2 * d11 - d3 * d9); CE = d15 * d2 + d12 * (d9 - d15 * d2) + d13 * (d3 * d7 - d1 * d11); CF = d15 * d3 + d12 * (d11 - d15 * d3) + d13 * (d1 * d9 - d2 * d7); } //---------------------------------------------------------- public void Giro_Horizontal() { double d1 = Math.cos(C4); double d2 = Math.sin(C4); double d3 = o * d1 + s * d2; double d4 = p * d1 + t * d2; double d5 = q * d1 + u * d2; double d6 = s * d1 - o * d2; double d7 = t * d1 - p * d2; double d8 = u * d1 - q * d2; o = d3; p = d4; q = d5; s = d6; t = d7; u = d8; } //---------------------------------------------------------- public void Giro_Vertical() { double d1 = Math.cos(x);//quite c5 double d2 = Math.sin(x);//quite C5 double d3 = k * d1 + s * d2; double d4 = l * d1 + t * d2; double d5 = m * d1 + u * d2; double d6 = s * d1 - k * d2; double d7 = t * d1 - l * d2; double d8 = u * d1 - m * d2; k = d3; l = d4; m = d5; s = d6; t = d7; u = d8;

89

} //---------------------------------------------------------- public void H() { double d1 = Math.cos(C4); double d2 = Math.sin(C4); double d3 = o * d1 + k * d2; double d4 = p * d1 + l * d2; double d5 = q * d1 + m * d2; double d6 = k * d1 - o * d2; double d7 = l * d1 - p * d2; double d8 = m * d1 - q * d2; o = d3; p = d4; q = d5; k = d6; l = d7; m = d8; } //---------------------------------------------------------- public Image I(Image image, int i1, int j1) { int k1 = image.getWidth(this); int l1 = image.getHeight(this); int ai[] = new int[k1 * l1]; PixelGrabber pixelgrabber = new PixelGrabber(image, 0, 0, k1, l1, ai, 0, k1); try { pixelgrabber.grabPixels(); } catch(InterruptedException _ex) { } U = new int[i1 * j1]; int i2 = (0x10000 * l1) / j1; int j2 = (0x10000 * k1) / i1; int k2 = 0; int l2 = 0; for(int i3 = 0; i3 < i1; i3++) { for(int j3 = 0; j3 < j1; j3++) { U[i3 + j3 * i1] = ai[(k2 >> 16) + (l2 >> 16) * k1]; l2 += i2; } k2 += j2; l2 = 0; } return createImage(new MemoryImageSource(i1, j1, U, 0, i1)); } //---------------------------------------------------------- //Evento de presioar sobre las caras del cubo public boolean mouseDown(Event event, int i1, int j1) { if(Movimiento && Tamaño.height - j1 < 32 && Tamaño.width - i1 < 18) E1 = !E1; else if(D6 != 7) if(System.currentTimeMillis() - P < 500L) { E3 = true;

90

if(Links[D6] != null) { URL url = null; try { url = new URL(Links[D6]); } catch(MalformedURLException _ex) { System.out.println("Invalid URL"); showStatus("Invalid URL"); } getAppletContext().showDocument(url, target); //url y target } } else { E4 = true; P = System.currentTimeMillis(); } return true; } //---------------------------------------------------------- public boolean mouseEnter(Event event, int i1, int j1) { E6 = true; return true; } //---------------------------------------------------------- public boolean mouseExit(Event event, int i1, int j1) { E7 = true; E6 = false; return true; } //---------------------------------------------------------- public boolean mouseMove(Event event, int i1, int j1) { E6 = true; L = i1; M = j1; if(Movimiento) { if(Tamaño.width - i1 >= 18 || Tamaño.height - j1 >= 32) { w = (((double)(Tamaño.height / 2 - j1) * vel) / (double)Tamaño.width) * 2D; x = (((double)(Tamaño.width / 2 - i1) * vel) / (double)Tamaño.height) * 2D; } } else { w = (((double)(Tamaño.height / 2 - j1) * vel) / (double)Tamaño.width) * 2D; x = (((double)(Tamaño.width / 2 - i1) * vel) / (double)Tamaño.height) * 2D; } return true; } //---------------------------------------------------------- void Buffer(Image image)

91

{ MediaTracker mediatracker = new MediaTracker(this); mediatracker.addImage(image, 0); try { mediatracker.waitForID(0); return; } catch(InterruptedException _ex) { return; } } }

MODULO: INTRODUCCION ARCHIVO: fullscreen.html

<html>

<head>

<script language="JavaScript">

function fullFullScr(){

var vent = null;

vent = window.open('','vVent','fullscreen=yes')

vent.location = "./VideoAudio.html";

}

fullFullScr();

</script>

<body bgcolor="#000000">

</body>

</html>

MODULO: INTRODUCCION ARCHIVO: videoaudio.html

<HTML>

<HEAD>

<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=iso-8859-1">

<META NAME="GENERATOR" CONTENT="Mozilla/4.04 [en] (Win95; I) [Netscape]">

<TITLE>Introducción LOBO</TITLE>

92

<script language="JavaScript" type="text/JavaScript">



</script>

</HEAD>

<BODY BGCOLOR="#000000" onLoad="MM_preloadImages('lobocerrados2.jpg')">

<CENTER>

<p align="center">

<APPLET code=VideoAudio width=670 height=410>

<param name=fileVideo value="planeta1.mpg">

<param name=fileAudio value="intro1.mp3">

</APPLET>

93

</p>

<p align="center"> <font color="#FFFFFF"><a href="LOBO/MENU/Image3dcube.htm"><img src="continuar.gif" name="Continuar" width="89" height="24" border="0" align="top" id="Continuar"></a>

<a href="javascript:window.close()" onMouseOut="MM_swapImgRestore()" onMouseOver="MM_swapImage('CERRAR','','lobocerrados2.jpg',1)"><img src="loboabiertos2.jpg" alt="CERRAR" name="CERRAR" width="100" height="86" border="0" align="right"></a>

</font></p>

</CENTER>

</BODY>

</HTML>

MODULO: PRIMOS DEL LOBO ARCHIVO: EspeciesLoboMundo

/******************************************************* Alumno: Corona Trenado Daniel. e-mail: [email protected] Applet: EspeciesLoboMundo Que hace: 1)Aparece el planeta tierra en el espacio, el planeta se puede rotar arrastrando el mouse en la dirección que se desea rotar. 2)Si se da un click en el planeta tierra en una region continental del norte (norteamerica, europa, asia); se produce un zoom a la región donde se dio el click. Y aparece en pantalla una imagen plana de la región donde se dio click, la cual cuenta con regiones elipticas. 3)Si se da click en una región eliptica se muestra un video del lobo. 4)Se puede regresar al planeta rotando ó a la imagen plana con regiones elipticas, dando click en la imagen que aparece en la esquina inferior izquierda de la pantalla. Fecha de Terminación:25-Julio-2003 *******************************************************/ /* <applet code="EspeciesLoboMundo" width=900 height=600> </applet> */ import java.awt.*; import java.awt.event.*; import java.applet.*; import java.awt.image.*; import java.net.*; import javax.media.*;

94

public class EspeciesLoboMundo extends Applet implements MouseMotionListener,Runnable, MouseListener,ControllerListener { /* Variables miembro para el control del programa */ int m_in_controlprog,bandera_ejec,bandera_click,bandera_region; boolean m_bo_finprog; Thread main; /* Variables ocupadas para implementar el double buffer */ Image dbImage; Graphics dbg; /* Variables miembro para carga y despliegue del planeta en el espacio */ MediaTracker tracker; Image m_im_imtierra[],fondo,m_im_imactual; int m_in_numactim,radio,xcentroplaneta,ycentroplaneta,num_imag; /* Variables para el despliegue del cartel y del zoom */ Image zoom_imag[],imagactual,imagen[]; int pasolargoimag,numimagdesp,xcart,ycart,coordxzoom,coordyzoom; MediaTracker tracker1; /* Variables miembro para busqueda de Regiones Continentales */ boolean buscar_regcont; RegCont ob_regiones[]; /* Variables miembro para las posiciones del mouse cuando se de un click */ int posxmouseclick,posymouseclick; /* Variables miembro para las posiciones del mouse cuando se presione un boton de este */ int m_in_coordxmousepresionado,coordxant; /* Variables miembro para validar regiones elipticas */ Elipses ob_regelipticas[]; /*Variables miembro para mostrar video de los lobos */ Video videos_america[]; Video videos_euroasia1[]; int bandera_ejecplayer,prefech_hecho,realize_hecho; Player player; Dimension d; Component comp1,comp2; /* Variables miembro ocupadas para la imagen de regreso en pantallas */ Image im_loboregresar; /***Metodo Init()***/ public void init() { /* Se obtienen las imagenes para la rotación del planeta tierra */ int vl_in_cont; String al_st_nomIm[]={"seq000000.jpg","seq000013.jpg","seq000025.jpg","seq000038.jpg", "seq000050.jpg","seq000063.jpg","seq000075.jpg","seq000088.jpg","

95

seq000100.jpg", "seq000113.jpg","seq000125.jpg","seq000138.jpg","seq000150.jpg","seq000163.jpg", "seq000175.jpg","seq000188.jpg","seq000200.jpg","seq000213.jpg","seq000225.jpg", "seq000238.jpg","seq000250.jpg","seq000263.jpg","seq000275.jpg","seq000288.jpg", "seq000300.jpg","seq000313.jpg","seq000325.jpg","seq000338.jpg","seq000350.jpg"}; m_im_imtierra=new Image[29]; tracker=new MediaTracker(this); for(vl_in_cont=0;vl_in_cont<29;vl_in_cont++) { m_im_imtierra[vl_in_cont]=getImage(getCodeBase(),al_st_nomIm[vl_in_cont]); tracker.addImage(m_im_imtierra[vl_in_cont],vl_in_cont); } fondo=getImage(getCodeBase(),"universo.jpg"); tracker.addImage(fondo,vl_in_cont); /* Se obtienen imagenes del zoom y loboregreso */ String nombimagzoom[]={"America1.jpg","America2.jpg","America3.jpg","America4.jpg", "America5.jpg","EuroAsia1-1.jpg","EuroAsia1-2.jpg","EuroAsia1-3.jpg","EuroAsia1-4.jpg", "EuroAsia1-5.jpg","EuroAsia2-1.jpg","EuroAsia2-2.jpg","EuroAsia2-3.jpg","EuroAsia2-4.jpg", "EuroAsia2-5.jpg"}; zoom_imag=new Image[15]; tracker1=new MediaTracker(this); for(vl_in_cont=0;vl_in_cont<15;vl_in_cont++) { zoom_imag[vl_in_cont]=getImage(getCodeBase(),nombimagzoom[vl_in_cont]); tracker1.addImage(zoom_imag[vl_in_cont],vl_in_cont); } im_loboregresar=getImage(getCodeBase(),"Lobo1.gif"); tracker1.addImage(im_loboregresar,vl_in_cont); addMouseMotionListener(this); addMouseListener(this); ob_regiones=new RegCont[3]; /* Se inicializan regiones continentales */ for(vl_in_cont=0;vl_in_cont<3;vl_in_cont++) { ob_regiones[vl_in_cont]=new RegCont(); } /* Coordenadas de la Region Continental Norteamerica */ int in_imag[]={0,1,2,3,4,5,6,7,8,9,28,27,26,25,24}; int punt1x[]={299,303,304,333,363,401,437,479,515,575,224,257,228,224,221}; int punt1y[]={74,74,74,74,74,74,74,74,74,85,74,77,83,93,95}; int punt2x[]={573,605,619,635,656,669,673,677,677,671,591,463,420,383,341}; int punt2y[]={242,241,241,241,243,250,254,257,243,233,243,243,246,249,257}; ob_regiones[0].GuardaRect(in_imag,punt1x,punt1y,punt2x,punt2y,15)

96

; /* Coordenadas de la Region Continental EuroAsia1 */ int n_imag_ea1[]={28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11}; int p1xea1[]={631,604,571,533,488,444,401,360,319,288,261,244,220,219,219,217,217,216}; int p1yea1[]={151,131,111,97,98,86,83,81,79,81,81,78,78,81,95,109,149,182}; int p2xea1[]={680,677,680,680,679,671,648,639,608,571,531,484,438,394,344,308,274,247}; int p2yea1[]={278,278,278,278,278,278,278,278,278,278,278,278,278,278,278,278,278,278}; ob_regiones[1].GuardaRect(n_imag_ea1,p1xea1,p1yea1,p2xea1,p2yea1,18); /* Coordenadas de la Region Continental EuroAsia2 */ int n_imag_ea2[]={4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22}; int p1xea2[]={224,223,217,219,220,219,228,248,275,309,345,395,439,485,532,572,609,640,649}; int p1yea2[]={82,79,85,81,81,77,77,77,74,71,74,74,74,78,86,98,133,163,177}; int p2xea2[]={348,387,425,463,497,533,565,588,600,612,623,628,648,648,659,672,676,681,677}; int p2yea2[]={278,278,278,278,278,278,278,278,278,278,278,278,278,278,278,278,278,278,278}; ob_regiones[2].GuardaRect(n_imag_ea2,p1xea2,p1yea2,p2xea2,p2yea2,19); ob_regelipticas=new Elipses[3]; /* Se inicializan regiones elipticas */ for(vl_in_cont=0;vl_in_cont<3;vl_in_cont++) { ob_regelipticas[vl_in_cont]=new Elipses(); } /* Coordenadas de las elipses de America */ int xcentelipsesam[]={460,492}; int ycentelipsesam[]={190,391}; int anchoxelipsesam[]={110,20}; int anchoyelipsesam[]={40,49}; ob_regelipticas[0].GuardaElipses(anchoxelipsesam,anchoyelipsesam,xcentelipsesam,ycentelipsesam,2); /* Coordenadas de las elipses de EuroAsia1 */ int xcentelipsesea1[]={544,510,666,818}; int ycentelipsesea1[]={144,341,425,361}; int anchoxelipsesea1[]={74,45,17,17}; int anchoyelipsesea1[]={13,17,45,46}; ob_regelipticas[1].GuardaElipses(anchoxelipsesea1,anchoyelipsesea1,xcentelipsesea1,ycentelipsesea1,4); /* Coordenadas de las elipses de EuroAsia2 */ int xcentelipsesea2[]={89,479,355}; int ycentelipsesea2[]={211,134,279}; int anchoxelipsesea2[]={16,86,25}; int anchoyelipsesea2[]={63,21,60}; ob_regelipticas[2].GuardaElipses(anchoxelipsesea2,anchoyelipsesea2,xcentelipsesea2,ycentelipsesea2,3); /* Videos del lobo america */ videos_america=new Video[2];

97

String nom_vidamer[]={"clip81.mpg","clip8.mpg"}; String tit_vidamer[]={"Lobo de canada","Lobo Mexicano"}; for(vl_in_cont=0;vl_in_cont<2;vl_in_cont++) { videos_america[vl_in_cont]=new Video(nom_vidamer[vl_in_cont],tit_vidamer[vl_in_cont]); } /* Videos del lobo euroasia1 */ videos_euroasia1=new Video[2]; String nom_videa1[]={"clip24.mpg","clip79.mpg"}; String tit_videa1[]={"Lobo de Europa 1","Lobo de Europa 2"}; for(vl_in_cont=0;vl_in_cont<2;vl_in_cont++) { videos_euroasia1[vl_in_cont]=new Video(nom_videa1[vl_in_cont],tit_videa1[vl_in_cont]); } /* Se establece gestor de organización */ setLayout(new FlowLayout(FlowLayout.CENTER,100,0)); setBackground(Color.black); //Para establecer el color de fondo. setForeground(Color.white);// Color del texto. m_in_controlprog=0; m_in_numactim=0; m_in_coordxmousepresionado=0; coordxant=0; m_bo_finprog=false; radio=235; xcentroplaneta=450; ycentroplaneta=300; buscar_regcont=false; posxmouseclick=0; posymouseclick=0; coordxzoom=0; coordyzoom=0; bandera_ejec=0; bandera_click=0; bandera_region=0; num_imag=0; player=null; bandera_ejecplayer=0; prefech_hecho=0; realize_hecho=0; } /***Metodo start()***/ public void start() { main=new Thread(this); main.start(); } /***Metodo mouseDragged()***/ public void mouseDragged(MouseEvent me) { int vl_in_coordxmouse=0; bandera_click=3; if(m_in_controlprog==2) { vl_in_coordxmouse=me.getX(); if((coordxant+20)<=vl_in_coordxmouse) { RotacionImDer();

98

coordxant=vl_in_coordxmouse; } else if((coordxant-20)>=vl_in_coordxmouse) { RotacionImIzq(); coordxant=vl_in_coordxmouse; } } } /***Metodo No ocupado***/ public void mouseMoved(MouseEvent me) {} /***Metodo No ocupado***/ public void mouseClicked(MouseEvent me) {} /***Metodo No ocupado***/ public void mouseEntered(MouseEvent me) {} /***Metodo No ocupado***/ public void mouseExited(MouseEvent me) {} /***Metodo mousePressed()***/ public void mousePressed(MouseEvent me) { bandera_click=1; m_in_coordxmousepresionado=me.getX(); coordxant=m_in_coordxmousepresionado; } /***Metodo mouseReleased()***/ public void mouseReleased(MouseEvent me) { bandera_click++; if(bandera_click==2) { posxmouseclick=me.getX(); posymouseclick=me.getY(); buscar_regcont=true; } } /***Metodo RotacionImIzq()***/ public void RotacionImIzq() { if(m_in_numactim==0) m_in_numactim=28; else m_in_numactim--; m_im_imactual=m_im_imtierra[m_in_numactim]; repaint(); try { Thread.sleep(1); } catch(InterruptedException ex){} } /***Metodo RotacionImDer()***/ public void RotacionImDer() { if(m_in_numactim==28) m_in_numactim=0; else m_in_numactim++; m_im_imactual=m_im_imtierra[m_in_numactim]; repaint(); try

99

{ Thread.sleep(1); } catch(InterruptedException ex){} } /*** @@@ Metodo DespCart. Este metodo se encarga de desplegar una imagen de arriba hacia abajo por pedazos. La imagen se pasa por parametro en imag, con la variable num_pasos se determina en cuantos pedazos desea que se divida la imagen para que esta aparezca de arriba hacia abajo. Las coordenadas xini, yini son la esquina superior de donde la imagen comenzará a ser desplegada por pedazos. ***/ void DespCart(int num_pasos, int xini, int yini, Image imag) { int anchoimag=0,largoimag=0,vl_in_cont=0; int xsup=0,ysup=0; imagen=new Image[num_pasos]; try { anchoimag=imag.getWidth(null); largoimag=imag.getHeight(null); pasolargoimag=largoimag/num_pasos; tracker1=new MediaTracker(this); CropImageFilter f; FilteredImageSource fis; for(vl_in_cont=0;vl_in_cont<num_pasos;vl_in_cont++) { f=new CropImageFilter(xsup,ysup,anchoimag,pasolargoimag); fis=new FilteredImageSource(imag.getSource(),f); imagen[vl_in_cont]=createImage(fis); tracker1.addImage(imagen[vl_in_cont],vl_in_cont); ysup=ysup+pasolargoimag; } tracker1.waitForAll(); }catch(InterruptedException e){} /* Despligue de cada pedazo de imagen cada 100ms */ numimagdesp=0; xcart=xini; ycart=yini; while(numimagdesp<num_pasos) { xcart=xini; ycart=yini; repaint(); try { Thread.sleep(100); } catch(InterruptedException ex){} numimagdesp++; } } /***/ void ZoomRegion(int puntoinix,int puntoiniy,int indiceimagpartir)

100

{ int pasox=0,pasoy=0,inicio,fin; fin=indiceimagpartir+5; inicio=indiceimagpartir; pasox=puntoinix/4; pasoy=puntoiniy/4; coordxzoom=puntoinix; coordyzoom=puntoiniy; while(inicio<fin) { imagactual=zoom_imag[inicio]; repaint(); if(inicio==indiceimagpartir) { try { Thread.sleep(1000); } catch(InterruptedException ex) {} } else { try { Thread.sleep(100); } catch(InterruptedException ex) {} } inicio++; coordxzoom=coordxzoom-pasox; coordyzoom=coordyzoom-pasoy; } } /***Metodo run()***/ public void run() { int result_america=0,result_ea1=0,result_ea2=0; while(true) { if(m_bo_finprog==true) { if(bandera_ejecplayer==1) { LiberaRecursoVideo(); } break; } if(m_in_controlprog==0) { /* Se muestra infromación y se cargan imagenes */ repaint(); try { Thread.sleep(500); } catch(InterruptedException ex){} } else if(m_in_controlprog==1) {

101

m_im_imactual=m_im_imtierra[num_imag]; repaint(); bandera_ejec=0; m_in_controlprog++; } else if(m_in_controlprog==2) { if(buscar_regcont==true) { if(PosDentroPlaneta(radio,xcentroplaneta,ycentroplaneta,posxmouseclick,posymouseclick)==1) { result_america=ob_regiones[0].ValidaRegCont(m_in_numactim,posxmouseclick, posymouseclick); if(result_america==1) { /* Click dado en la Region de America */ bandera_ejec=1; DespCart(4,585,165,zoom_imag[0]); bandera_ejec=2; ZoomRegion(585,165,0); m_in_controlprog++; bandera_region=1; } else { result_ea1=ob_regiones[1].ValidaRegCont(m_in_numactim,posxmouseclick, posymouseclick); if(result_ea1==1) { /* Click dado en la region de EuroAsia1 */ bandera_ejec=1; DespCart(4,585,165,zoom_imag[5]); bandera_ejec=2; ZoomRegion(585,165,5); m_in_controlprog++; bandera_region=2; } else { result_ea2=ob_regiones[2].ValidaRegCont(m_in_numactim,posxmouseclick, posymouseclick); if(result_ea2==1) { /* Click dado en la region de EuroAsia2 */ bandera_ejec=1; DespCart(4,585,165,zoom_imag[10]); bandera_ejec=2; ZoomRegion(585,165,10); m_in_controlprog++; bandera_region=3; } } } } }

102

buscar_regcont=false; } else if(m_in_controlprog==3) { repaint(); try { Thread.sleep(3000); } catch(InterruptedException ex){} m_in_controlprog=4; num_imag=m_in_numactim; } else if(m_in_controlprog==4) { int indiceAmerica=0,indiceEA1=0,indiceEA2=0; if(buscar_regcont==true) { /* Se valida si se ha dado click en la región regresar */ if((posxmouseclick>=0)&&(posxmouseclick<=100)&&(posymouseclick>=500)&& (posymouseclick<=600)) { m_in_controlprog=1; num_imag=m_in_numactim; } /* Se encuentra en pantalla la region America */ if(bandera_region==1) { indiceAmerica=ob_regelipticas[0].ValidaPuntoElipses(posxmouseclick,posymouseclick); if(indiceAmerica!=-1) { bandera_ejecplayer=1; m_in_controlprog++; repaint(); InicializaPlayer(videos_america[indiceAmerica]); MuestraVideo(); m_in_controlprog++; repaint(); /*System.out.println("America: "+indiceAmerica); EjecutaAmerica(indiceAmerica);*/ } } /* Se encuentra en pantalla la region EuroAsia1 */ if(bandera_region==2) { indiceEA1=ob_regelipticas[1].ValidaPuntoElipses(posxmouseclick,posymouseclick); if(indiceEA1!=-1) { if((indiceEA1==0)||(indiceEA1==1)) { bandera_ejecplayer=1; m_in_controlprog++; repaint(); InicializaPlayer(videos_euroasia1[indiceEA1]); MuestraVideo(); m_in_controlprog++;

103

repaint(); } else { bandera_ejecplayer=1; m_in_controlprog++; repaint(); InicializaPlayer(videos_america[indiceEA1-2]); MuestraVideo(); m_in_controlprog++; repaint(); } /*System.out.println("EuroAsia1: "+indiceEA1); EjecutaEA1(indiceEA1);*/ } } /* Se encuentra en pantalla la region EuroAsia2 */ if(bandera_region==3) { indiceEA2=ob_regelipticas[2].ValidaPuntoElipses(posxmouseclick,posymouseclick); if(indiceEA2!=-1) { /*EjecutaEA2(indiceEA2);*/ System.out.println("EuroAsia2: "+indiceEA2); } } buscar_regcont=false; } } else if(m_in_controlprog==6) { if(buscar_regcont==true) { /* Se valida si se ha dado click en la región regresar */ if((posxmouseclick>=0)&&(posxmouseclick<=100)&&(posymouseclick>=500)&& (posymouseclick<=600)) { LiberaRecursoVideo(); if(bandera_region==1) imagactual=zoom_imag[4]; else if(bandera_region==2) imagactual=zoom_imag[9]; else imagactual=zoom_imag[14]; m_in_controlprog=3; bandera_ejecplayer=0; } buscar_regcont=false; } } } } /***Metodo stop()***/ public void stop() { m_bo_finprog=true; } /***Metodo paint()***/ public void paint(Graphics g)

104

{ if(m_in_controlprog==0) { int vl_in_imagcarg=0,imagzoom=0; for(int i=0;i<30;i++) { if(tracker.checkID(i,true)) vl_in_imagcarg++; } /* Se verifica si ya se cargarón imagenes del zoom */ for(int i=0;i<16;i++) { if(tracker1.checkID(i,true)) imagzoom++; } if((vl_in_imagcarg==30)&&(imagzoom==16)) m_in_controlprog++; } else if(m_in_controlprog==1) { if(m_im_imactual!=null) { g.drawImage(fondo,0,0,this); g.drawImage(m_im_imactual,215,65,this); } } else if(m_in_controlprog==2) { if(bandera_ejec==0) { if(m_im_imactual!=null) { g.drawImage(fondo,0,0,this); g.drawImage(m_im_imactual,215,65,this); } } else if(bandera_ejec==1) { int cont=0; if(m_im_imactual!=null) { g.drawImage(fondo,0,0,this); g.drawImage(m_im_imactual,215,65,this); } while(cont<(numimagdesp+1)) { imagactual=imagen[cont]; if(imagactual!=null) { g.drawImage(imagactual,xcart,ycart,this); } cont++; ycart=ycart+pasolargoimag; } } else { if(m_im_imactual!=null) { g.drawImage(fondo,0,0,this); g.drawImage(m_im_imactual,215,65,this); } if(imagactual!=null)

105

{ g.drawImage(imagactual,coordxzoom,coordyzoom,this); } } } else if((m_in_controlprog==3)||(m_in_controlprog==4)) { g.drawImage(imagactual,0,0,this); g.drawImage(im_loboregresar,0,500,this); } else if((m_in_controlprog==5)) { /* Pantalla en blanco */ } else if((m_in_controlprog==6)) { g.drawImage(im_loboregresar,0,500,this); } } /*** Metodo para Validar si se esta dentro del planeta Regresa -1 Fuera del planeta Regresa 1 Dentro del planeta ***/ int PosDentroPlaneta(int radiocir,int centrox,int centroy, int pospuntox,int pospuntoy) { int circulo=0; circulo=(pospuntox-centrox)*(pospuntox-centrox); circulo=circulo+(pospuntoy-centroy)*(pospuntoy-centroy); if(circulo<=(radiocir*radiocir)) return(1); else return(-1); } /* Metodo: void InicializaPlayer(Video vid) Se encarga de incializar el player para mostrar video. */ void InicializaPlayer(Video vid) { try { URL mediaURL = new URL(getDocumentBase(),vid.getVideoName()); player= Manager.createPlayer(mediaURL); player.addControllerListener(this); } catch (Exception e) { System.err.println("Got exception "+e); } } /* Metodo: void MuestraVideo() Este metodo se encarga de mostrar el video. */ void MuestraVideo() { prefech_hecho=0; realize_hecho=0; player.realize(); while(true)

106

{ if(realize_hecho==1) { break; } try { Thread.sleep(1000); } catch(InterruptedException ex) {} } player.prefetch(); while(true) { if(prefech_hecho==1) { break; } try { Thread.sleep(1000); } catch(InterruptedException ex) {} } d=comp1.getSize(); comp1.setLocation(100,50); comp1.setSize(d.width+150,d.height+150); comp2.setLocation(100,50+d.height+150); player.start(); } /* Metodo: void LiberaRecursoVideo() Se encarga de liberar recursos y remover componentes ocupados por el player actual. */ void LiberaRecursoVideo() { player.stop(); player.deallocate(); player.close(); remove(comp1); remove(comp2); player=null; } /* Metodo: public synchronized void controllerUpdate(ControllerEvent event) Este metodo se encarga de desplegar los componenetes visuales necesarios para la manipulación del video cuando se muestra video. */ public synchronized void controllerUpdate(ControllerEvent event) { if (event instanceof RealizeCompleteEvent) { if ((comp1 = player.getVisualComponent()) != null) add (comp1); if ((comp2 = player.getControlPanelComponent()) != null) add (comp2); validate();

107

realize_hecho=1; } if (event instanceof PrefetchCompleteEvent) { prefech_hecho=1; } } /*** Metodo update()***/ public void update(Graphics g) { if(dbImage==null) { dbImage=createImage(this.getSize().width,this.getSize().height); dbg=dbImage.getGraphics(); } dbg.setColor(getBackground()); dbg.fillRect(0,0,this.getSize().width,this.getSize().height); dbg.setColor(getForeground()); paint(dbg); g.drawImage(dbImage,0,0,this); } } /* Fin de la Clase */

MODULO: PRIMOS DEL LOBO ARCHIVO: Elipse.java

/* Clase Elipse Esta clase se encarga de alamacenar una elipse y validar cuando un punto se encuentra dentro de la elipse. */ class Elipse { private int anchox; private int anchoy; private int xcentro; private int ycentro; /* Metodo Constructor */ public Elipse() { anchox=0; anchoy=0; xcentro=0; ycentro=0; } /* Metodo GuardaElipse() Se encarga de almacenar una elipse */ void GuardaElipse(int ax,int ay,int xcent,int ycent) { anchox=ax; anchoy=ay;

108

xcentro=xcent; ycentro=ycent; } /* Metodo ValidaPuntoElipse() Se encarga de validar si un punto(x,y) esta dentro de la elipse. Regresa -1 Si el punto esta fuera. Regresa 1 Si esta el punto dentro. */ int ValidaPuntoElipse(int x,int y) { float sumando1=0,sumando2=0; sumando1=((x-xcentro)*(x-xcentro))/(anchox*anchox); sumando2=((y-ycentro)*(y-ycentro))/(anchoy*anchoy); if((sumando1+sumando2)<=1) return(1); else return(-1); } } /* Fin de la Clase Elipse */

MODULO: PRIMOS DEL LOBO ARCHIVO: Elipses.java

/* Clase Elipses Esta clase guarda muchas elipses. */ class Elipses { Elipse ob_elipses[]; int num_elipses; /* Metodo Constructor() */ public Elipses() { num_elipses=0; } /* Metodo GuardaElipses() Este metodo se encarga de alamacenar n_eli elipses. */ void GuardaElipses(int anx[],int any[],int xcent[],int ycent[],int n_eli) { int cont=0; ob_elipses=new Elipse[n_eli]; for(cont=0;cont<n_eli;cont++) { ob_elipses[cont]=new Elipse(); } for(cont=0;cont<n_eli;cont++) {

109

ob_elipses[cont].GuardaElipse(anx[cont],any[cont],xcent[cont],ycent[cont]); } num_elipses=n_eli; } /* Metodo ValidaPuntoElipses() Este metodo se encarga de determinar si un punto (x,y) se encuentra dentro de alguna de las elipses almacenadas. Regresa -1 Si el punto no esta dentro de ninguna elipse. En otro caso Regresa el indice de la elipse donde el punto esta dentro. */ int ValidaPuntoElipses(int cx,int cy) { int result=0,cont=0; for(cont=0;cont<num_elipses;cont++) { result=ob_elipses[cont].ValidaPuntoElipse(cx,cy); if(result==1) return(cont); } return(-1); } } /* Fin de la Clase Elipses */

MODULO: PRIMOS DEL LOBO ARCHIVO: RegCont.java

/* Clase: RegCont El objetivo de esta clase será almacenar y validar las diferentes regiones continentales. */ class RegCont { private int imagenes[]; private int p1x[]; private int p1y[]; private int p2x[]; private int p2y[]; private int num_rect; /* Cosntructor */ public RegCont() { num_rect=0; } /* Guarda Rectangulos de la RegCont */ void GuardaRect(int imag[], int P1X[],int P1Y[],int P2X[],int P2Y[],int numrect) {

110

int i=0; imagenes=new int[numrect]; p1x=new int[numrect]; p1y=new int[numrect]; p2x=new int[numrect]; p2y=new int[numrect]; while(i<numrect) { imagenes[i]=imag[i]; p1x[i]=P1X[i]; p1y[i]=P1Y[i]; p2x[i]=P2X[i]; p2y[i]=P2Y[i]; i++; } num_rect=numrect; } /* Valida un punto en la RegCont Regresa 1 si esta en la RegCont Regresa -1 si no esta. */ int ValidaRegCont(int imagact, int x,int y) { int i=0,res=0; while(i<num_rect) { if(imagact==imagenes[i]) { res=ValidaPunto(i,x,y); return(res); } i++; } return(-1); } /* Valida un punto en un rectangulo */ int ValidaPunto(int ind_imag,int x,int y) { if((x>=p1x[ind_imag])&&(x<=p2x[ind_imag])&&(y>=p1y[ind_imag])&&(y<=p2y[ind_imag])) return(1); else return(-1); } }

111

MODULO: PRIMOS DEL LOBO ARCHIVO: Video.java

/* Clase Video Esat clase se encargará de almacenar el nombre de un archivo de video mpeg y el titulo del video mpeg. */ class Video { private String nom_video; private String titulo_video; /* Constructor */ public Video(String n_video,String tit_video) { nom_video=n_video; titulo_video=tit_video; } /* Metodo para obtener el nombre del archivo de video */ String getVideoName() { return(nom_video); } /* Metodo para obtener el titulo del video */ String getVideoTitle() { return(titulo_video); } } MODULO: VIDEOJUEGO ARCHIVO: cCazador.java

import java.applet.*; import java.awt.*; import java.lang.*; import java.util.*; import java.awt.image.*; public class cCazador extends java.applet.Applet { /* Estas cuatro variables Area_x1,Area_y1, Area_x2, Area_y2 delimitan una region en la que el lobo estara dentro del alcance de la escopeta de el cazador*/ private float Area_x1; private float Area_y1; private float Area_x2; private float Area_y2; /* ImgCazador: Contendra todas las imagenes que se necesitan para que el cazador tenga

112

la secuencia de disparo*/ private Image ImgCazador[]= new Image[20]; /*Img_CA: Esta contendra la imagen en turno que devuelve el metodo Get_ImgCA() y que es la siguiente a ser mostrada para continuar la animacion*/ private Image Img_CA; private ImageProc Img_PCA; //objeto necesario para realiza manipulaciones de giro en las imagenes del cazador private float angulo; //angulo de rotacion para la imagen a mostrar del el cazador /*(X,Y) : Son las coorfdfenadas de impresion de el cazador*/ private float X; private float Y; /*(x_centCA,y_centCA) denotan elcentro de la imagen del cazador que se esta imprimiendo*/ private float x_centCA; private float y_centCA; private int Num_ImgCA; //Numero de imagenes que posee la animacion de el cazador cazador private int Cont_ImgCA; //Indica que imagen continua en la secuencia de animacion en la que el lobo dispara private boolean CA_habilitado; //bandera que determina el estado de el cazador, si esta habilitada quiere decir que //la animacion de el cazador para disparar ha comenzado private MediaTracker CAtracker; //para reducir parpadeo private cFunciones cF_CA; //objeto para obtener el angulo de rotacion para las imagenes de el cazador // a la hora de realizar la animacion /*sonido del disparo*/ private AudioClip sonidoCA; //audio para el efecto de el disparo /*Constructor : inicializa las variables del objeto cazador*/ public cCazador(float p_x,float p_y, float ax1,float ay1, float ax2, float ay2,Image[] imgca,int n_imgca) { int z=0; /*se copian las imagenes al objeto cazador*/ for(z=0;z<n_imgca;z++) { ImgCazador[z]=imgca[z]; }

113

Num_ImgCA=n_imgca; X=p_x; Y=p_y; Area_x1=ax1; Area_y1=ay1; Area_x2=ax2; Area_y2=ay2; angulo=0; CA_habilitado=false; Cont_ImgCA=0; cF_CA=new cFunciones(); sonidoCA=null; } public boolean Estado_CA() { return(CA_habilitado); } /*Carga las imagenes del cazador en el objeto media tracker*/ public void Carga_ImgCA() { int z; float tempA; float tempL; CAtracker=new MediaTracker(this); for(z=0;z<Num_ImgCA;z++) { CAtracker.addImage(ImgCazador[z],1); } try { CAtracker.waitForID(1); } catch (InterruptedException e){} Img_PCA = new ImageProc(ImgCazador[0]); Img_PCA.rotate((double)270); Img_CA=Img_PCA.createImage(); tempA=(float)Img_CA.getWidth(this); tempL=(float)Img_CA.getHeight(this); x_centCA=X + (float)(tempA/2); y_centCA=Y + (float)(tempL/2); } /*Get_XCA: Regresa la coordenada x donde se deve imprimir el cazador */ public float Get_XCA() { return(X); }

114

/*Get_YCA: Regresa la coordenada y donde se debe imprimir el cazador*/ public float Get_YCA() { return(Y); } /*Mueve_CA: Esta funcion gira laimagen del cazador n angulos para simular el efecto de que el cazador va enfocando al lobo antes de disparar*/ public boolean Mueve_CA(float xlobo, float ylobo) { int indCA=0; CA_habilitado=true; //para seguir movien al cazador hasta que dispare angulo=cF_CA.Get_angulo(x_centCA,y_centCA,xlobo,ylobo); indCA=Cont_ImgCA % Num_ImgCA; Img_PCA.InsertImage(ImgCazador[indCA]); Img_PCA.rotate((double)angulo); Img_CA=Img_PCA.createImage(); Cont_ImgCA++; if(Cont_ImgCA==5) sonidoCA.play(); //se escucha el disparo if(Cont_ImgCA==Num_ImgCA) //lo que indica que se ha mostrado la ultima imagen del cazador { Cont_ImgCA=0; CA_habilitado=false; return(true); //indica que el cazador le disparo al lobo,se activara la funcion muere lobo. } return(false); // el cazador no a atrapado al lobo } /*Dentro_RCA: Regresa el valor verdadero si el lobo esta dentro del area de tiro del cazador, habilita la funcion mueve cazador poniendo la bandera Ca_habilitado a true*/ public boolean Dentro_RCA(float xlobo,float ylobo) { if((xlobo>Area_x1)&&(xlobo<Area_x2)) { if((ylobo>Area_y1)&&(ylobo<Area_y2)) { CA_habilitado=true; return(true); } } return(false);

115

} /* Get_ImgCA: Regresa la imagen del cazador que se debe imprimir*/ public Image Get_ImgCA() { return(Img_CA); } /*Set_sonidoCA: Esta funcion inserta en el objeto cazador el sonido del disparo*/ public void Set_sonidoCA(AudioClip son) { sonidoCA=son; } } MODULO: VIDEOJUEGO ARCHIVO: cConejo.java

import java.applet.*; import java.awt.*; import java.lang.*; import java.util.*; import java.awt.image.*; public class cConejo extends java.applet.Applet{ private float[] puntos_x=new float[10]; private float[] puntos_y=new float[10]; private float Madriguera_x; private float Madriguera_y; private int Num_coord; private boolean conejo_habilitado; private float[] b_conejo=new float[10]; private float[] m_conejo=new float[10]; private int Num_img; private int contador; private int indice; private float x_act; private float y_act; private int cont_img; private float[] angulo_conejo=new float[10]; private Image Img_actual; private ImageProc Img_PC; private float Avance; private Image ImgConejo[]= new Image[7]; private cFunciones objeto_f; private MediaTracker Ctracker; private float ancho; private float largo;

116

/*metodo para habilitar el conejo, esto permitira una mejor manipulacion del objeto para la hora de imprimirlo*/ public void Habilitar() { conejo_habilitado=true; } public void Deshabilitar() { conejo_habilitado=false; cont_img=0; y_act=Madriguera_y; x_act=Madriguera_x; } public boolean Estado() //conejo_Habilitado() { return(conejo_habilitado); } public cConejo( float[] xo,float[] yo, float madriguera_x,float madriguera_y, Image[] imagenes, int n,int m,float avance) { int i; // n representa el numero de puntos, es decir la longitud del arrego puntos_x Madriguera_x=madriguera_x; Madriguera_y=madriguera_y; objeto_f=new cFunciones(); for(i=0;i<n;i++) { puntos_x[i]=xo[i]; puntos_y[i]=yo[i]; m_conejo[i]=objeto_f.Get_pendiente(xo[i], yo[i], Madriguera_x, Madriguera_y); b_conejo[i]=objeto_f.Get_b(xo[i],yo[i],m_conejo[i]); angulo_conejo[i]=objeto_f.Get_angulo(xo[i],yo[i],Madriguera_x,Madriguera_y); } for(i=0;i<m;i++) { ImgConejo[i]=imagenes[i]; } /* solo se inicializa el objeto Img_p, esto se puede hacer con cualquier imagen, no tiene importancia*/

117

Num_img=m; // m es el numero de imagenes que se han introducido Num_coord=n; y_act=Madriguera_y; x_act=Madriguera_x; conejo_habilitado=false; Avance=avance; cont_img=0; contador=0; indice=0; } public void Mueve_conejo() { if(x_act==Madriguera_x && y_act==Madriguera_y) { /*cont_img=0;para que se cominecen a mostrar las imagenes a partir de la imagen cero*/ cont_img=0; contador++; /*se determina que valores de los arreglos se utilizaran*/ indice=contador % Num_coord; conejo_habilitado=false; x_act=puntos_x[indice]; y_act=puntos_y[indice]; return; } /*se cambia de imagen para la proxima impresion*/ cont_img++; if(Avance > 0) { if(y_act>Madriguera_y) { y_act=Madriguera_y; x_act=Madriguera_x; return; } } if(Avance < 0) // se mueve el conejo de abajo hacia arriba { if(y_act<Madriguera_y) { y_act=Madriguera_y; x_act=Madriguera_x; return;

118

} } y_act +=Avance; x_act=(float)((y_act- b_conejo[indice])/m_conejo[indice]); } public void CargaImg() { int z; Ctracker=new MediaTracker(this); for(z=0;z<Num_img;z++) { Ctracker.addImage(ImgConejo[z],1); } try { Ctracker.waitForID(1); } catch (InterruptedException e){} Img_PC = new ImageProc(ImgConejo[0]); ancho=(float)ImgConejo[0].getWidth(this); largo=(float)ImgConejo[0].getHeight(this); } public float Get_xC() { return(x_act); } public float Get_yC() { return(y_act); } /*Get_xactC:esta funcion regresa la coordenada x de el centro de la imagen a partir del punto donde se esta imprimiendo la imagen*/ public float Get_xactC() { float temp=x_act + (float)(ancho/2); return(temp); } public float Get_yactC() { float temp=y_act + (float)(largo/2); return(temp); }

119

public Image Get_img() { int ind=0; ind= cont_img%Num_img; Img_PC.InsertImage(ImgConejo[ind]); Img_PC.rotate((double)angulo_conejo[indice]); Img_actual=Img_PC.createImage(); return(Img_actual); } } MODULO: VIDEOJUEGO ARCHIVO: cFunciones.java

import java.awt.*; import java.lang.*; /*Esta clase fue diseñada para realizar diversas funciones como son: encontrara el angulo de inclinacion entre dos puntos, su pendiente y ordenada al origen y obtener una region de desplazamineto deacuerdo a la posicion de dos puntos*/ public class cFunciones { private float m; //contendra la pendiente entre dos puntos private float b; //contendra la ordenada al origen entre dos puntos public cFunciones() { m=0; b=0; } /* Get_pendiente: Devuelve la pendiente que tiene una recta formada por dos puntos (xo,yo),(xd,yd)*/ public float Get_pendiente(float xo,float yo,float xd,float yd) { m=(float)((yd-yo)/(xd-xo)); return(m);

120

} /* Get_b: Devuelve la ordenada al origen que tiene una recta formada por dos puntos (xo,yo),(xd,yd)*/ public float Get_b(float x,float y,float m) { b=(float)(((-1*m)*x)+y); return(b); } /* Get_angulo: Devuelve el angulo que tiene una recta formada por dos puntos (xo,yo),(xd,yd)*/ public float Get_angulo(float xo, float yo, float xd, float yd) { float Cx,Cy,h, result, grad; Cx= xd-xo; Cy= yd-yo; Cx=(float)Math.abs(Cx); Cy=(float)Math.abs(Cy); h=(float)Math.pow((double)Cx,2); h+=(float)Math.pow((double)Cy,2); h=(float)Math.sqrt((double)h); if((xd>=xo-20)&&(xd<=(xo+ 20))&&(yd<yo)) { //region 2 return(270); } if((xd<xo)&&(yd>=(yo-20))&&(yd<=(yo+20))) { //regon 4 return(180); } if((xd>xo)&&(yd>=(yo-20))&&(yd<=(yo+20))) { //region 5 return(0); } if((xd>=(xo-20))&&(xd<=(xo+ 20))&&(yd>yo)) {//region7 return(90); } if(xd<xo && yd< yo) { // region 1 result=Cy/h; grad=(float)Math.asin((double)result); grad=(float)Math.toDegrees((double)grad); grad+=180; return(grad); } if(xd>xo && yd< yo) { // region 3 result=Cy/h;

121

grad=(float)Math.asin((double)result); grad=(float) Math.toDegrees((double)grad); grad=360-grad; return(grad); } if(xd<xo && yd> yo) { // region 6 result=Cx/h; grad=(float)Math.asin((double)result); grad=(float) Math.toDegrees((double)grad); grad+=90; return(grad); } if(xd>xo && yd> yo) { // region 8 result=Cx/h; grad=(float)Math.asin((double)result); grad=(float) Math.toDegrees((double)grad); grad=90-grad; return(grad); } else return(-1); } /*Obtenregion: Esta funcion determina la region a la que se dirije el movimiento de el lobo donde (posact_x,posact_y) es el punto de origen y (px,py) es el punto de destino. */ public int Obtenregion(float posact_x,float posact_y,float px,float py) { if((px>=posact_x-50)&&(px<=(posact_x+ 50))&&(py<posact_y)) { return(2); } if((px<posact_x)&&(py>=(posact_y-50))&&(py<=(posact_y+50))) { return(4); } if((px>posact_x)&&(py>=(posact_y-50))&&(py<=(posact_y+50))) { return(5); } if((px>=(posact_x-50))&&(px<=(posact_x+ 50))&&(py>posact_y)) { return(7); }

122

if((px<posact_x)&&(py<posact_y)) { return(1); } if((px<posact_x)&&(py>posact_y)) { return(6); } if((px>posact_x)&&(py<posact_y)) { return(3); } if((px>posact_x)&&(py>posact_y)) { return(8); } else { return(0); } } } MODULO: VIDEOJUEGO ARCHIVO: cListalineal.java

/********************************************************** CLASE DE LA LISTA LIGADA:Esta clase tiene los mismos metodos que una lista ligada, pero en realidad funciona como una cola el dato que entra primero es el primero en salir ***********************************************************/ class cCoordenada{ //atributos private int c_x; private int c_y; //Metodos public cCoordenada() { } public cCoordenada(int x,int y) { c_x=x; c_y=y; } public void Set_xy(int x,int y) { c_x=x; c_y=y;

123

} public int Get_x() { return(c_x); } public int Get_y() { return(c_y); } } public class cListalineal{ //p: referencia al primer elemento de la lista private cElemento p=null; //Elemento de una lista lineal simplemente enlazada private class cElemento { private cCoordenada datos; private cElemento siguiente; //Metodos private cElemento() { } } public cListalineal() { } public void addprincipio(cCoordenada objeto) { cElemento q; if(p==null) { p=new cElemento(); p.datos=objeto; p.siguiente=null; return; } q=p; while(q.siguiente!=null) { q=q.siguiente;

124

} q.siguiente= new cElemento(); q=q.siguiente; q.datos=objeto; q.siguiente=null; q=null; } //vacia la cola a la que se aplica este metodo public void Vaciar() { p=null; } public cCoordenada Obtener() { cElemento q; if(p==null) { System.out.println("\nError, cola vacia"); return(null); } q=p; p=p.siguiente; q.siguiente=null; return(q.datos); } public int Num_elem() { int i=1; cElemento q=new cElemento(); q=p; if(p==null) { return(0); } while(q.siguiente!=null) { i++; q=q.siguiente; } return i; } }

125

MODULO: VIDEOJUEGO ARCHIVO: cLobo.java

import java.applet.*; import java.awt.*; import java.lang.*; import java.util.*; import java.awt.image.*; public class cLobo extends java.applet.Applet { /* definen el largo y ancho de la imagen que se va a mostrar*/ private float largo; private float ancho; private float x_act; private float y_act; private float m; //pendiemte de la linea recta que determina la trayectoria que debe seguir el lobo private float b; //ordenada de la linea recta que determina la trayectoria que debe seguir el lobo private float angulo; //angulo de inclinacion que tiene la trayectoria a seguir private Image ImgLobo[]= new Image[10]; //contendra las imagenes de el lobo para caminar private cListalineal ListaLobo; //Es una colo que contendra todos los puntos de la trayectoria de el lobo private boolean lobo_habilitado; //bandera que indica si el lobo esta habilitado para caminar o no private cCoordenada coordenada1; //coordenada auxiliar para guardar los puntos que debe recorrer el lobo private int Region; //contendra la region a la que se dirige el lobo private cFunciones objetof1; //objeto necesario para realizar manipulaciones entre dos //puntos que determinan una trayectoria de el lobo private Image Img_L; //para realizar la animacion en la que el lobo camina, esta contendra la imagen siguiente para //dar el efecto de la animacion private float x_cent; // puntos en los que se debera imprimir la imagen de el lobo despues de haberla movido private float y_cent; // private boolean sale_lobo; //bandera que indica que el lobo esta en el estado de salir de la cueva

126

private boolean entra_lobo; //bandera que indica que el lobo esta entrando de la cueva private float x_dest; // (x_dest,y_dest)es el punto al que se dirige el lobo en el primer avance private float y_dest; private int Cont_Img; //Este contador indica el numero de imagen que sogue para la animacion para dar el efecto de que el lobo camina private int Num_Img; //numero de iamgenes que componen la animacion de el lobo private ImageProc Img_PL; //objeto necesario para rotar las imagenes de el lobo private float x_temp; private float y_temp; private float Avance; //avance de el lobo en cada paso que da,es decir los pixeles de el desplazamineto private float Y_CUEVA; //(X_CUEVA,Y_CUEVA):determinan el punto al que el lobo debe dirigirse cuando se activa la secuencia de entrar a la cueva private float X_CUEVA; private MediaTracker Ltracker; // objeto para disminuir el parpadeo en las animaciones de el lobo private float X_CENTRO; //(X_CENTRO,Y_CENTRO)punto centrico de el ambiente de el lobo al que debe dirigirse cuando sale de su cueva private float Y_CENTRO; private boolean region_5; //bandera que indica que el lobo esta caminando hacia una region 5 private float x_act_ant; //Estas cuatro variables guardan el punto anterior de destino y de posicion de el lobo para recuperarlos private float y_act_ant; //en caso de que el nuevo punto de posicion o destino no sean validos, es decir, se encuentren en una region prohibida private float x_dest_ant; private float y_dest_ant; private float cuadro_x1; //Determinan el cuadro en el que hay que hacer clic para que el lobo entre a su private float cuadro_y1; //cueva private float cuadro_x2; private float cuadro_y2; private AudioClip sonidoL; //guarda el aullido de el lobo /*<<<<<<<<cambio de imagenes>>>>>>>>>>*/ /*variables necesarias para hacer el cambio de imagenes cuando el lobo ha atrapado a su presa*/ private boolean ImgCambiadas; private int NI_aux; private Image ImgLaux[]=new Image[10];

127

public cLobo(Image[] Imagenes, float x_cueva,float y_cueva,float x_cent,float y_cent,int num_img,float avance) { int z=0; for(z=0;z<num_img;z++) { ImgLobo[z]=Imagenes[z]; } /* estas dos coordenadas indican el punto de salida de la cueva*/ Y_CUEVA=y_cueva; X_CUEVA=x_cueva; /*estas dos coordenadas indican el punto central donde para la animacion cuando el lobo sale de su cueva*/ X_CENTRO=x_cent; Y_CENTRO=y_cent; Num_Img=num_img; x_act=0; y_act=0; m=0; b=0; angulo=0; ListaLobo=new cListalineal(); lobo_habilitado=false; sale_lobo=false; entra_lobo=false; x_dest=0; y_dest=0; Cont_Img=0; x_temp=X_CUEVA; y_temp=Y_CUEVA; Avance=avance; Region=0; objetof1=new cFunciones(); region_5=false; x_act_ant=0; y_act_ant=0; x_dest_ant=0; y_dest_ant=0; ImgCambiadas=false; sonidoL=null;//por seguridad cuadro_x1=0; cuadro_y1=0; cuadro_x2=0; cuadro_y2=0; }

128

public void CaminaLobo() { int ind=0; if((x_act==x_dest) || (y_act==y_dest)) { if(ListaLobo.Num_elem()==0) //la lista esta vacia { /* solo aqui se puede deshabilitar la funcion Camina_lobo porque aqui ya se han terminado los puntos de la trayectoria que debe seguir el lobo */ lobo_habilitado=false; return; } /* se obtiene el nuevo punto de destino*/ coordenada1=ListaLobo.Obtener(); x_dest=(float)coordenada1.Get_x(); y_dest=(float)coordenada1.Get_y(); Region=objetof1.Obtenregion(x_act,y_act,x_dest,y_dest); /***esta parte valida si la posicion destino esta dentro del recuadro que se encuentra en el techo de la cueva, lo que hace que el lobo entre en la cueva*/ if((x_dest>cuadro_x1)&&(x_dest < cuadro_x2)) { if((y_dest>cuadro_y1)&&(y_dest<cuadro_y2)) { entra_lobo=true; lobo_habilitado=false; /*se vacia la cola*/ ListaLobo.Vaciar(); Cont_Img=1; //para no empesar desde la imagen parado return; } } m=objetof1.Get_pendiente(x_act,y_act,x_dest,y_dest); b=objetof1.Get_b(x_act,y_act,m); angulo=objetof1.Get_angulo(x_act,y_act,x_dest,y_dest); } /*se guardan las coordenadas anteriores*/ x_act_ant=x_act; y_act_ant=y_act; if(Region==1)

129

{ x_act=x_act-Avance; y_act=(m*x_act)+b; if(x_act<=x_dest) // se a pasado el punto destino { x_act=x_dest; y_act=y_dest; x_cent=x_act-(float)(ancho/2); y_cent=y_act-(float)(largo/2); Img_PL.InsertImage(ImgLobo[0]); Img_PL.rotate((double)angulo); Img_L=Img_PL.createImage(); Cont_Img=0; return; } } if(Region==2) { y_act-=Avance; if(y_act<=y_dest) // se a pasado el punto destino { y_act=y_dest; //x_cent=x_act-(float)(ancho/2); y_cent=y_act-(float)(largo/2); Img_PL.InsertImage(ImgLobo[0]); Img_PL.rotate((double)angulo); Img_L=Img_PL.createImage(); Cont_Img=0; return; } } if(Region==3) { x_act=x_act+Avance; y_act=(m*x_act)+b; if(x_act>=x_dest) // se a pasado el punto destino { x_act=x_dest; y_act=y_dest; /* se determina elpunto de impresion de la imagen*/ x_cent=x_act-(float)(ancho/2); y_cent=y_act-(float)(largo/2); Img_PL.InsertImage(ImgLobo[0]); Img_PL.rotate((double)angulo);

130

Img_L=Img_PL.createImage(); Cont_Img=0; return; } } if(Region==4) { x_act=x_act-Avance; if(x_act<=x_dest) // se a pasado el punto destino { x_act=x_dest; /* se determina elpunto de impresion de la imagen*/ x_cent=x_act-(float)(ancho/2); y_cent=y_act-(float)(largo/2); Img_PL.InsertImage(ImgLobo[0]); Img_PL.rotate((double)angulo); Img_L=Img_PL.createImage(); Cont_Img=0; return; } } if(Region==5) { x_act=x_act+Avance; if(x_act>=x_dest) // se a pasado el punto destino { x_act=x_dest; /* se determina elpunto de impresion de la imagen*/ x_cent=x_act-(float)(ancho/2); y_cent=y_act-(float)(largo/2); Img_PL.InsertImage(ImgLobo[0]); Img_PL.rotate((double)angulo); Img_L=Img_PL.createImage(); Cont_Img=0; return; } } if(Region==6) { x_act=x_act-Avance; y_act=(m*x_act)+b; if(x_act<=x_dest) // se a pasado el punto destino { x_act=x_dest; y_act=y_dest;

131

/* se determina elpunto de impresion de la imagen*/ x_cent=x_act-(float)(ancho/2); y_cent=y_act-(float)(largo/2); Img_PL.InsertImage(ImgLobo[0]); Img_PL.rotate((double)angulo); Img_L=Img_PL.createImage(); Cont_Img=0; return; } } if(Region==7) { y_act=y_act+Avance; if(y_act>=y_dest) // se a pasado el punto destino { y_act=y_dest; /* se determina elpunto de impresion de la imagen*/ x_cent=x_act-(float)(ancho/2); y_cent=y_act-(float)(largo/2); Img_PL.InsertImage(ImgLobo[0]); Img_PL.rotate((double)angulo); Img_L=Img_PL.createImage(); Cont_Img=0; return; } } if(Region==8) { x_act=x_act+Avance; y_act=(m*x_act)+b; if(y_act>=y_dest) // se a pasado el punto destino { y_act=y_dest; /* se determina elpunto de impresion de la imagen*/ x_cent=x_act-(float)(ancho/2); y_cent=y_act-(float)(largo/2); Img_PL.InsertImage(ImgLobo[0]); Img_PL.rotate((double)angulo); Img_L=Img_PL.createImage(); Cont_Img=0; return; } }

132

x_cent=x_act-(float)(ancho/2); y_cent=y_act-(float)(largo/2); ind=(Cont_Img %(Num_Img-1)) + 1; // para no imrpimir la imagen del lobo parado Img_PL.InsertImage(ImgLobo[ind]); Img_PL.rotate((double)angulo); Img_L=Img_PL.createImage(); Cont_Img++; } /*Sale_cueva:Esta funcion hace las manipulaciones necesarias para que el lobo salga de su cueva*/ public void Sale_cueva() { int ind=0; sale_lobo=true; region_5=true; // permite dar el efecto de que el lobo sale de la cueva x_temp-=Avance; x_cent=x_temp; y_cent=Y_CENTRO; if(ImgCambiadas==true) { for(ind=0;ind<NI_aux;ind++) { ImgLobo[ind]=ImgLaux[ind]; } Num_Img=NI_aux; ind=0; ImgCambiadas=false; ancho=(float)ImgLobo[0].getWidth(this); largo=(float)ImgLobo[0].getHeight(this); } if(x_temp <= X_CENTRO) { /*se posicionan las coordenadas en ultimo punto de la animacion de salida de la cueva*/ x_temp=X_CUEVA; y_temp=Y_CUEVA; x_cent=X_CENTRO; y_cent=Y_CENTRO; /* coordenadas para que el centro de la imagen mostrada quede en el punto (x_act,y_act) */

133

y_act=y_cent + (float)(largo/2); x_act=x_cent + (float)(ancho/2); /* para la conducion de la funcion "camina".*/ y_dest=y_act; x_dest=y_act; /* se imprime la imagen del lobo parado*/ Img_PL.InsertImage(ImgLobo[0]); Img_PL.rotate((double)180); Img_L=Img_PL.createImage(); Cont_Img=0; sale_lobo=false; region_5=false; return; } ind=(Cont_Img %(Num_Img-1)) + 1; // para no imrpimir la imagen del lobo parado Img_PL.InsertImage(ImgLobo[ind]); Img_PL.rotate((double)180); Img_L=Img_PL.createImage(); Cont_Img++; return; } /******Entra_cueva: Hace las manipulaciones necesarias para que laanimacion del lobo de la apariencia que sale de la cueva*/ public void Entra_Cueva() { int ind=0; //impide que las otras funcione que modifican las posiciones el lobo se actine entra_lobo=true; if(Region==5) //el lobo camina en la region 5 { /* La variable Y no se modifica*/ x_act+=Avance; region_5=true; if(x_act>=X_CUEVA) { x_act=X_CUEVA; Cont_Img=0; // para que se ejecute la secuencia que hace salir al lobo de la cueva entra_lobo=false; sale_lobo=true;

134

region_5=false; return; } x_cent=x_act-(float)(ancho/2); ind=(Cont_Img %(Num_Img-1)) + 1; // para no imrpimir la imagen del lobo parado Img_PL.InsertImage(ImgLobo[ind]); Img_PL.rotate((double)0); Img_L=Img_PL.createImage(); Cont_Img++; return; } if(Region==8) { if(y_act!=Y_CUEVA) { y_act+=Avance; if(y_act>=Y_CUEVA) { y_act=Y_CUEVA; Cont_Img=0; } y_cent=y_act-(float)(largo/2); ind=(Cont_Img %(Num_Img-1)) + 1; // para no imrpimir la imagen del lobo parado Img_PL.InsertImage(ImgLobo[ind]); Img_PL.rotate(90); Img_L=Img_PL.createImage(); Cont_Img++; return; } if(x_act!=X_CUEVA) { region_5=true; x_act+=Avance; if(x_act >= X_CUEVA) { x_act=X_CUEVA; /* para que se ajecute la secuencia en la que el lobo sale de su cueva*/ sale_lobo=true; region_5=false; entra_lobo=false; Cont_Img=0; return; } x_cent=x_act-(float)(ancho/2);

135

ind=(Cont_Img %(Num_Img-1)) + 1; // para no imrpimir la imagen del lobo parado Img_PL.InsertImage(ImgLobo[ind]); Img_PL.rotate((double)0); Img_L=Img_PL.createImage(); Cont_Img++; return; } } if(Region==3) { if(y_act!=Y_CUEVA) { y_act-=Avance; if(y_act<=Y_CUEVA) { y_act=Y_CUEVA; Cont_Img=0; } y_cent=y_act-(float)(largo/2); ind=(Cont_Img %(Num_Img-1)) + 1; // para no imrpimir la imagen del lobo parado Img_PL.InsertImage(ImgLobo[ind]); Img_PL.rotate(270); Img_L=Img_PL.createImage(); Cont_Img++; return; } if(x_act!=X_CUEVA) { region_5=true; x_act+=Avance; if(x_act >= X_CUEVA) { x_act=X_CUEVA; /* para que se ajecute la secuencia en la que el lobo sale de su cueva*/ sale_lobo=true; entra_lobo=false; region_5=false; Cont_Img=0; return; } x_cent=x_act-(float)(ancho/2); ind=(Cont_Img %(Num_Img-1)) + 1; // para no imrpimir la imagen del lobo parado Img_PL.InsertImage(ImgLobo[ind]); Img_PL.rotate((double)0); Img_L=Img_PL.createImage(); Cont_Img++; return; }

136

} } /*************************************************** Get_XL: Regresa la coordenada x donde el lobo se debera imprimir ***************************************************/ public float Get_xL() { return(x_cent); } /*************************************************** Get_YL: Regresa la coordenada y donde el lobo se debera imprimir ***************************************************/ public float Get_yL() { return(y_cent); } /*************************************************** EstadoLca: Regresa truesi la funcion camina lobo deve habilitarse ***************************************************/ public boolean EstadoLCa() { return(lobo_habilitado); } /*************************************************** EstadoLSa: Regresa true si la funcion Sale_lobo lobo debe ajacutarse ***************************************************/ public boolean EstadoLSaC() { return(sale_lobo); } /*************************************************** EstadoLEnC: Regresa true si la funcion Sale_lobo lobo debe ajacutarse ***************************************************/ public boolean EstadoLEnC() { return(entra_lobo); } /************************************************** get_ImgLobo: Regresa una referencia a la imagen del lobo que se debe mostrar **************************************************/ public Image Get_ImagLobo() { return(Img_L); }

137

/*Inserta_recuadro: Esta funcion inserta los valores que delimitan el recuadro sobre el techo de la cueva sobre el cual hay que hacer un clikc para entrar en la cueva */ public void Inserta_recuadro(float r_x1,float r_y1, float r_x2,float r_y2) { cuadro_x1=r_x1; cuadro_y1=r_y1; cuadro_x2=r_x2; cuadro_y2=r_y2; } /*CargaImgLobo: esta funcion se encarga de cargar las imagenes en un objeto mediatraker para tenerlas disponibles y disminuir el parpadeo*/ public void CargaImgLobo() { int z; Ltracker=new MediaTracker(this); for(z=0;z<Num_Img;z++) { Ltracker.addImage(ImgLobo[z],1); } try { Ltracker.waitForID(1); } catch (InterruptedException e){} Img_PL = new ImageProc(ImgLobo[0]); Img_L=ImgLobo[0]; ancho=(float)ImgLobo[0].getWidth(this); largo=(float)ImgLobo[0].getHeight(this); } /*Este método se utiliza para integrar a la trayectoria que debe de seguir nuestro lobo los puntos de destino que se generan con el mouse*/ public void Set_Lobo(int x, int y) { if((sale_lobo==false)&&(entra_lobo==false)) //si no estoy entrando ni saliendo de la cueva { if(Distancia((int)x_dest_ant,(int)y_dest_ant,(int)x,(int)y) > 50) { ListaLobo.addprincipio(new cCoordenada(x,y)); lobo_habilitado=true;

138

x_dest_ant=(float)x; y_dest_ant=(float)y; } } } /*<<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>> Region5: Esta funcion regresa verdadero si el lobo va a entrar a la cueva caminando en region 5, es decir de frente a la cueva <<<<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>*/ public boolean Region5() { return(region_5); } /*<<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>> Reset: Esta funcion se encarga de resetear los valores de las variables que se usan para determinar movimientos de el lobo. Se usa cuando el punto de impresion esta dentro de una region no valida. <<<<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>>*/ public void ResetL() { sonidoL.play(); region_5=false; // se deshabilita la opcion de caminar en regiones no validas lobo_habilitado=false; sale_lobo=false; entra_lobo=false; ListaLobo.Vaciar(); x_act=x_act_ant; y_act=y_act_ant; x_dest=x_act; y_dest=y_act; Img_PL.InsertImage(ImgLobo[0]); Img_PL.rotate((double)angulo); Img_L=Img_PL.createImage(); Cont_Img=0; } /*regresan el punto el centro de la imagen de el lobo que se este imprimiendo*/ public float Get_xact() { return(x_act); } public float Get_yact() {

139

return(y_act); } /*InsertImgLoboPresa: Esta funcion hace un cambio en las imagenes para que las imagenes mostradas sean las del lobo con la presa*/ public void InsertImgLoboPresa(Image[] lobo_presa,int num_ILP) { int iz=0; if(ImgCambiadas==true) return; // si las imagenes ya estan cambiadas no hagas nada ImgCambiadas=true; for(iz=0;iz<Num_Img;iz++) { ImgLaux[iz]=ImgLobo[iz]; } NI_aux=Num_Img; for(iz=0;iz<num_ILP;iz++) { ImgLobo[iz]=lobo_presa[iz]; } Num_Img=num_ILP; x_dest=x_act; y_dest=y_act; Img_PL.InsertImage(ImgLobo[0]); Img_PL.rotate((double)angulo); Img_L=Img_PL.createImage(); Cont_Img=0; ancho=(float)ImgLobo[0].getWidth(this); largo=(float)ImgLobo[0].getHeight(this); x_cent=x_act-(float)(ancho/2); y_cent=y_act-(float)(largo/2); sale_lobo=false; entra_lobo=false; lobo_habilitado=false; } /*Set_sonidoL: Esta cancion se encarga de cargar el sonido para el lobo cuando choca con alguna region prohibida. Este sonido se activa desde la funcion reset del lobo*/ public void Set_sonidoL(AudioClip son) { sonidoL=son;

140

} /*Habilita_SaleCueva:Esta funcion pone en valor verdadero la bandera lobo_sale, se usa para hacer que al inicio del juego el lobo salga de la cueva*/ public void Habilita_SaleCueva() { sale_lobo=true; } private int Distancia(int x1,int y1, int x2,int y2) { double x; double y; double distancia; x=x2 - x1; y=y2 - y1; distancia= Math.sqrt((x*x) + (y*y)); return((int)distancia); } }

MODULO: VIDEOJUEGO ARCHIVO: cPlayer.java

/*Esta clase sirve para llevar la puntuacion de el jugador en el juego de el lobo*/ public class cPlayer { private int score; private int capturas; private int tiempo_vida; private boolean estado_player; /*player:esta funcion inicializa al objeto player, el valor de tiempo de vida es de diez por defaul*/ public cPlayer() { score=0; capturas=0; tiempo_vida=10;

141

estado_player=true;// el jugador esta activo } /*<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>> Get_score: Esta funcion regresa el record acumulado por el jugador <<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>*/ public int Get_score() { return(score); } /*<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>> Get_capturas: Esta funcion regresa las capturas acumuladas por el jugador <<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>*/ public int Get_capturas() { return(capturas); } /*<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>> Get_TV: Esta funcion regresa el tiempo de vida de el jugador <<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>*/ public int Get_TV() { return(tiempo_vida); } /*<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>> Inc_capturas(): Esta funcion incrementa el valor de el atributo capturas en uno. <<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>*/ public void Inc_capturas() { capturas++; } /*<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>> Inc_score(): Esta funcion incrementa el valor de el atributo score en cinco. <<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>*/ public void Inc_score() { score+=5; } /*<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>> Inc_TV(): Esta funcion incrementa el valor de el atributo tiempo de vida en diez. <<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>*/

142

public void Inc_TV() { tiempo_vida+=10; } /*<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>> Dec_TV(): Esta funcion decrementa el valor de el atributo tiempo de vida en diez. <<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>*/ public boolean Dec_TV() { tiempo_vida-=1; if(tiempo_vida==0) return(false); //se termino el tiempo de vida del jugador return(true); //el jugador aun tiene tiempo de vida } /*<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>> Elimina_player: Pone la bandera estado_player a false, que indica que esl jugado ha perdido y pone el atributo tiempo de vida a cero <<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>*/ public void Elimina_player() { estado_player=false; tiempo_vida=0; } /*<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>> Estado_P:Esta funcion regresa el esta del jugador(vivo o en deceso) si el resultado es verdadero, el jugador sigue activo, si es falso, el jugador esta inactivo <<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>*/ public boolean Estado_P() { return(estado_player) ; } } MODULO: VIDEOJUEGO ARCHIVO: cValidación.java

import java.awt.*; import java.lang.*; /*Esta clase contiene una serie de puntos que determinn cuadros en los que el lobo no podra tener acceso, es decir delimitan regiones prohibidas*/

143

public class cValidacion { private float[] Xo; //contiene el valor x de el primer punto que forma la region private float[] Yo;//contiene el valor y de el primer punto que forma la region private float[] X1;//contiene el valor x de el segundo punto que forma la region private float[] Y1; //contiene el valor y de el segundo punto que forma la region /******************************************NOTA************************ Es importante la relacion que debe haber entre los arreglos, cada posicion debe referenciar datos que estan asociados es decir el par de puntos (xo[0],y[0]),(x1[0],y1[0]) delimitan la primer region*/ private int Num_elem; //numero de regiones prohibidas private float Xizq; //determinan la region de el lobo a partir de la cual se determina si se esta en una region prohibida o no private float Yizq; private float Xder; private float Yder; private float X1_act; //variables temporales private float Y1_act; private float X2_act; private float Y2_act; //Constructor cValidacion(float[] x0,float[] y0,float[] x1,float[] y1, int num, float xi,float yi, float xd, float yd) { int z=0; Xo=new float[num]; Yo=new float[num]; X1=new float[num]; Y1=new float[num]; for(z=0;z<num;z++) { Xo[z]=x0[z]; Yo[z]=y0[z]; X1[z]=x1[z]; Y1[z]=y1[z]; } Num_elem=num; Xizq=xi; Yizq=yi;

144

Xder=xd; Yder=yd; X1_act=0; Y1_act=0; X2_act=0; Y2_act=0; } /*Esta funcion valida de acuerdo a los datos de el objeto lobo, si este quiere accesar a una region prohibida, deser asi devuel el valor 0, en caso contrario devuelve 1 */ public int Valida(cLobo lobo) { int z=0; float pos_x=lobo.Get_xL(); float pos_y=lobo.Get_yL(); X1_act=pos_x + Xizq; Y1_act=pos_y + Yizq; X2_act=pos_x + Xder; Y2_act=pos_y + Yder; if(lobo.Region5()==true) return(1); if(lobo.EstadoLCa()==false) return(1); //para que no se quede ciclado el sonido cuando se llega a un obsataculo for(z=0;z<Num_elem;z++) { if((X1_act > Xo[z]) && (X1_act < X1[z])) { if((Y1_act > Yo[z]) && (Y1_act < Y1[z])) { return(0); } if((Y2_act > Yo[z]) && (Y2_act < Y1[z])) { return(0); } } if((X2_act > Xo[z]) && (X2_act < X1[z])) { if((Y1_act > Yo[z]) && (Y1_act < Y1[z])) { return(0); } if((Y2_act > Yo[z]) && (Y2_act < Y1[z])) { return(0); } } } return(1); // area valida } }

145

MODULO: VIDEOJUEGO ARCHIVO: cValidación.java

/*********************************************************** Alumnos: Corona Trenado Daniel Figueroa Gonzalez Rogelio Programa: Lobo que sigue al mouse dentro de una ventana. Fecha: 14-Febrero-2003 ************************************************************/ /*<applet code="Followmouse" width=720 height=500> </applet>*/ import java.applet.*; import java.awt.*; import java.awt.event.*; import java.lang.*; public class Followmouse extends Applet implements Runnable,MouseListener { /*Variables para el lobo*/ cLobo lobo1; Image ImgLobo1[]=new Image[7]; int num_imgL1=7; /* Determinan el punto centrico en la cueva*/ float p_xcueva=601; float p_ycueva=235; /* destermina el punto de destino para la funcion sale_cueva*/ float p_xcentro=410; float p_ycentro=235; float avanceL=8; String NombImgLob[]={"pararseR5.gif","camina1R5.gif", "camina2R5.gif","camina3R5.gif","camina4R5.gif","camina5R5.gif","camina6R5.gif"}; /* ESTAS CUATRO VARIABLES DELIMITAN UN RECTANGULO UBICADO EN LA IMAGEN DE LA CUEVA, SI SE HACE CLICK EN ESTE RECUADRO, SE ACTIVA LA FUNCION ENTRA_CUEVA */ final int r_x1c=601; final int r_y1c=231; final int r_x2c=720; final int r_y2c=307; /*sonido de el lobo cuando choca con un obstaculo */

146

AudioClip sonido1; /*************** Variables para el conejo*************/ cConejo conejo1; /* definen los puntos de los cuales salen losconejos*/ float xConejo[]={111,413,662}; float yConejo[]={89,75,342}; float madrigueraC_x=290; float madrigueraC_y=412; /* numero de puntos de los arreglos*/ int puntos=3; int num_imgC=6; /* ubicacion de la madriguera del conejo*/ float Y_MADRIGUERA=290; float X_MADRIGUERA=412; Image ImgConejo[]=new Image[6]; float avanceC1=5; String Nomb_img_conejo[]={"conejo1.gif","conejo2.gif", "conejo3.gif","conejo4.gif","conejo5.gif","conejo1.gif"}; /**************variables para el cazador*********************/ cCazador cazador1; String Nom_cazador[]={"cazador1.gif","cazador2.gif","cazador3.gif","cazador4.gif","cazador5.gif", "cazador6.gif","cazador7.gif","cazador8.gif","cazador9.gif","cazador10.gif","cazador11.gif", "cazador12.gif","cazador13.gif" }; int n_img_cazador=13; //numero de imagenes float x_cazador=0; float y_cazador=301; /*area del cazador*/ float x1_ca=0,y1_ca=190,x2_ca=189,y2_ca=500; Image Img_cazador[]= new Image[13]; /***********************************************************/ /*****variables para el objeto validacion***********/

147

cValidacion ob_valida1; float posiciones_x1[]={93,398,280,669,622,600,561}; float posiciones_y1[]={76,68,402,68,82,97,135}; float posiciones_x2[]={125,423,308,720,669,622,600}; float posiciones_y2[]={114,92,431,406,416,416,308}; /* delimitan un recuadro virtualen la imagen del lobo*/ float rL_x1=31; float rL_y1=16; float rL_x2=78; float rL_y2=72; int num_r=7; /*<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<clase del judador>>>>>>>>>>>>>>>>>>>>>>>*/ cPlayer jugador1; /*******************************IMAGENES DEL HAMBIENTE*****************************/ String Nomb_img_fondo[]={"pinoG.gif","pino1.gif","piedras.gif","arbustocfloresd3.gif", "suelo_cueva.gif","techo_cueva.gif"}; //ESTOS ARREGLOS GUARDAN LAS POSICIONES DE LAS IMAGENES DE FONDO int pos_Imgx[]={0,4,223,489,665,641}; int pos_Imgy[]={0,166,316,31,210,0}; Image Img_Fondo[]=new Image[6]; //objeto media tracker para cargar las imagenes del hambiente MediaTracker tracker; final int FONDO=1; Image Img_actualLobo=null; //referencia la imagen actualmente visualizada Image img_conejoActual=null; Image arbusto=null; Image Img_actualCazador=null; Image lobo_negro=null; /*<<<<<<<<<<<<<<<variables auxiliares>>>>>>>>>>>>>>>>>>>*/ float x_temp1=0,y_temp1=0; float x_actL=0,y_actL=0; /*variable para el color de fondo*/

148

Color colorfondo1; //se presenta una vez inicializado el juego Color colorfondo2; //se presenta cuando esta el mensaje de inicio /*Variables para el doble buffer*/ Image offscreenImg=null; Graphics offscreenG; Thread Neko=null; // hilo que ejecutara la animacion Image LoboPresa[]=new Image[7]; String NombImgLP[]={"pararseLP.gif","camina1LP.gif", "camina2LP.gif","camina3LP.gif","camina4LP.gif","camina5LP.gif","camina6LP.gif"}; final int IMGLP=2; /* String Nomb_img_comida[]={"comida1.gif","comida2.gif", "comida3.gif","comida4.gif","comida5.gif","comida6.gif","comida7.gif"};*/ /*<<<<<<arreglos con las posiciones de los arbustos que rodean al cazador>>>>>>>>>>>>*/ int x_arbusto[]={0,43,92,120,131,158,104,45,0,0}; int y_arbusto[]={343,316,322,352,407,439,439,439,438,396}; /* esta bandera indica si el programa esta en ejecucion o si debe estar detenido */ boolean bandera_runing=false; int vg_i_CONTER=0; boolean conejo_atrapado; boolean temp; int vg_i_cont_TVJ; //esta variable es un contador para decrementar el tiempo de vida deljugador; /*sonido para el inicio del juego*/ AudioClip aullido; /*letras de fondo*/ Font f =new Font("serif",Font.BOLD,20); public void init() { int i;

149

tracker=new MediaTracker(this); conejo_atrapado=false; vg_i_cont_TVJ=0; temp=true; setFont(f); // se cargan las imagenes en un arreglo for(i=0;i<ImgLobo1.length;i++) { ImgLobo1[i]=getImage(getCodeBase(),NombImgLob[i]); } /*se obtienen las imagenes del cazador*/ for(i=0;i<13;i++) { Img_cazador[i]=getImage(getCodeBase(),Nom_cazador[i]); } for(i=0;i<6;i++) { Img_Fondo[i]=getImage(getCodeBase(),Nomb_img_fondo[i]); tracker.addImage(Img_Fondo[i],FONDO); } /*<<<<<<<<se cargan las imagenes de el lobo con la presa>>>>>>>>*/ for(i=0;i<7;i++) { LoboPresa[i]=getImage(getCodeBase(),NombImgLP[i]); tracker.addImage(LoboPresa[i],IMGLP); } for(i=0;i<6;i++) { ImgConejo[i]=getImage(getCodeBase(),Nomb_img_conejo[i]); } /*se espera a que se xcarguen las imagenes de fondo*/ arbusto=getImage(getCodeBase(),"arbustocf.gif"); tracker.addImage(arbusto,FONDO); lobo_negro=getImage(getCodeBase(),"Lobo_negro.gif"); tracker.addImage(lobo_negro,FONDO); try { tracker.waitForID(FONDO); } catch (InterruptedException e){} try { tracker.waitForID(IMGLP); } catch (InterruptedException e){}

150

sonido1=getAudioClip(getCodeBase(),"error.au"); aullido=getAudioClip(getCodeBase(),"aullido.wav"); colorfondo1 =new Color(153,102,51); colorfondo2 =new Color(73,207,103); setBackground(colorfondo2); addMouseListener(this); lobo1=new cLobo(ImgLobo1,p_xcueva,p_ycueva,p_xcentro,p_ycentro,num_imgL1,avanceL); lobo1.CargaImgLobo(); lobo1.Inserta_recuadro((float)r_x1c,(float)r_y1c,(float)r_x2c,(float)r_y2c); lobo1.Set_sonidoL(sonido1); lobo1.Habilita_SaleCueva(); //para que el lobob salga de la cueva conejo1= new cConejo(xConejo,yConejo,(float)280,(float)395,ImgConejo,puntos,num_imgC,avanceC1); conejo1.CargaImg(); ob_valida1=new cValidacion(posiciones_x1,posiciones_y1,posiciones_x2,posiciones_y2,num_r,rL_x1,rL_y1,rL_x2,rL_y2); cazador1= new cCazador(x_cazador,y_cazador,x1_ca,y1_ca,x2_ca,y2_ca,Img_cazador,n_img_cazador); cazador1.Carga_ImgCA(); cazador1.Set_sonidoCA(getAudioClip(getCodeBase(),"gun.au")); jugador1= new cPlayer(); } /*********************************************************** ***********************************************************/ public void start() { if (Neko==null) { Neko=new Thread(this); //crea el hilo Neko.start(); //lanzar el hilo } } /*********************************************************** ***********************************************************/ public void stop() { Neko=null; } /********************************************************** **********************************************************/

151

public void run() { int vl_i_c=0; Thread hiloActual= Thread.currentThread(); while(Neko==hiloActual) { /*<<<<<<<<manipulacion de la posicion del lobo>>>>>>>>>>>*/ if(bandera_runing==true) { setBackground(colorfondo1); vg_i_cont_TVJ++; if(vg_i_cont_TVJ==50) { vg_i_cont_TVJ=0; if(jugador1.Dec_TV()==false) //el tiempo de vida del jugador se termino { jugador1.Elimina_player(); /*se activa la funcion muere lobo*/ setBackground(colorfondo2); //se restablece el color de fondo repaint(); //se muestran los resultados obtenidos como tiempo de vida, etc; pausa(5000); bandera_runing=false; } } if(lobo1.EstadoLCa()==true) { /* esta habilitada la funcion para que el lobo camine*/ lobo1.CaminaLobo(); x_temp1=lobo1.Get_xL(); y_temp1=lobo1.Get_yL(); } if(lobo1.EstadoLEnC()==true) { lobo1.Entra_Cueva(); x_temp1=lobo1.Get_xL(); y_temp1=lobo1.Get_yL(); /* En este if se incrementan los valores del jugador, ya que si se activo la funcion de entrar a la cueva y la bandera conejo_atrapado es igual a true, se indica que el lobo ha guardado un conejo capturado en su cueva*/

152

if(conejo_atrapado==true) { conejo_atrapado=false; jugador1.Inc_capturas(); jugador1.Inc_score(); jugador1.Inc_TV(); } } if(lobo1.EstadoLSaC()==true) { lobo1.Sale_cueva(); x_temp1=lobo1.Get_xL(); y_temp1=lobo1.Get_yL(); } if(ob_valida1.Valida(lobo1)==0) // area no valida { lobo1.ResetL(); x_temp1=x_actL; //esto se hace para que la funcion de reseteo no se ejecute todo el tiempo y_temp1=y_actL; // ya que los valores de x y temp se quedan en region no valida } if(ob_valida1.Valida(lobo1)==1) // area valida { /* si los puntos estan en area valida se actualizan los puntos de impresion del lobo*/ x_actL=x_temp1; y_actL=y_temp1; /* se obtiene la nueva imagen a imprimir**/ } cazador1.Dentro_RCA(lobo1.Get_xact(),lobo1.Get_yact()); // pregunto si el lobo esta en el area de tiro //del cazador, si es asi, se habilita al cazador /* se ejecuta la secuencia del cazador*/ if(cazador1.Estado_CA()==true) { if(cazador1.Mueve_CA(lobo1.Get_xact(),lobo1.Get_yact())==true)//indica que se ha disparado al lobo { jugador1.Elimina_player(); /*se activa la funcion muere lobo*/ setBackground(colorfondo2); //se restablece el color de fondo repaint(); //se muestran los resultados obtenidos como tiempo de vida, etc; pausa(5000);

153

bandera_runing=false; } } Img_actualCazador=cazador1.Get_ImgCA(); Img_actualLobo=lobo1.Get_ImagLobo(); /*<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/ vl_i_c++; if(vl_i_c==50) { conejo1.Habilitar(); vl_i_c=0; } if(conejo1.Estado()==true) { conejo1.Mueve_conejo(); img_conejoActual=conejo1.Get_img(); if(Conejo_atrapado(lobo1,conejo1)==true) { conejo1.Deshabilitar(); lobo1.InsertImgLoboPresa(LoboPresa,7); Img_actualLobo=lobo1.Get_ImagLobo(); conejo_atrapado=true; x_actL=lobo1.Get_xL(); y_actL=lobo1.Get_yL(); } } } repaint(); pausa(100); } } /*funcion que valida si el lobo ha atrapadoal conejo*/ boolean Conejo_atrapado(cLobo lobo,cConejo conejo) { float xl,yl,xc,yc; double x,y,distancia; xc=conejo.Get_xactC(); //se obtienen las coordenadas del centro de la imagen que se imprime del conejo yc=conejo.Get_yactC(); xl=lobo.Get_xact(); //se obtienen las coordenadas del

154

centro de la imagen del yl=lobo.Get_yact(); //lobo que se esta imprimiendo x=xc-xl; y=yc-yl; distancia=Math.sqrt((x*x)+(y*y)); if(distancia<20) { return(true); // el lobo atrapa al conejo; } return(false); //el lobo no atrapa al conejo; } /****************************************************************** ******************************************************************/ void pausa(int tiempo) { try { Thread.sleep(tiempo); // duerme al hilo momentaneamente } catch(InterruptedException ignorada) { } } /*************************************************************** ***************************************************************/ public void mouseEntered(MouseEvent me) { } public void mouseExited(MouseEvent me) { } public void mousePressed(MouseEvent me) { if(bandera_runing==true) { lobo1.Set_Lobo(me.getX(),me.getY()); } } public void mouseReleased(MouseEvent me)

155

{ } public void mouseClicked(MouseEvent me) { if(bandera_runing==false) vg_i_CONTER++; if(vg_i_CONTER==2 && bandera_runing==false) { init(); aullido.play(); pausa(2000) ; bandera_runing=true; vg_i_CONTER=0; } } /***************************************************************** *****************************************************************/ public void paint(Graphics g) { int i; if((jugador1.Estado_P()==false)&& (bandera_runing==true)) //entra si el jugador fue eliminado { g.drawString(" La cantidad de conejos que atrapaste fue de: " + jugador1.Get_capturas() ,100,100); g.drawString(" Tu puntuacion fue de : " + jugador1.Get_score() ,100,120); return; } if(bandera_runing==true) { /* se pinta el escondite de el cazador*/ for(i=0;i<10;i++) { g.drawImage(arbusto,x_arbusto[i],y_arbusto[i],this);//se pintan las piedras } if(Img_actualCazador!=null) g.drawImage(Img_actualCazador,0,301,this);//se pintan las piedras if(conejo1.Estado()==true) g.drawImage(img_conejoActual,(int)conejo1.Get_xC(),(int)conejo1.Get_yC(),this);//se pinta el conejo g.drawImage(Img_Fondo[4],535,210,this); //se pinta el suelo de la cueba /*<<<<<<<<<<<<<<se pinta el lobo>>>>>>>>>>>>>>>>>*/

156

if(Img_actualLobo!=null) g.drawImage(Img_actualLobo,(int)x_actL,(int)y_actL,this); g.drawImage(Img_Fondo[5],520,0,this); //se pinta el techo de la cueba //se pinta el pinoG. g.drawImage(Img_Fondo[0],2,2,this); //se pinta el pino1 g.drawImage(Img_Fondo[1],332,9,this); g.drawImage(Img_Fondo[1],213,343,this); //se pinta el pino1 repetido g.drawRect(643,244,53,42); /*se pintan los datos del jugador*/ g.drawString("¡¡¡Conejos capturados: "+ jugador1.Get_capturas() + " Tiempo de vida: " + jugador1.Get_TV() + " Score: " + jugador1.Get_score(),150,20); } if(bandera_runing==false) { g.drawImage(lobo_negro,0,22,this); //se pinta la imagen de fondo de inicio del juego g.drawString("PARA INICIAR EL JUEGO DE DOBLE CLICK EN LA PANTALLA",100,20); } } public void update(Graphics g) { if(offscreenImg==null) { offscreenImg= createImage(this.getSize().width,this.getSize().height); offscreenG= offscreenImg.getGraphics(); } offscreenG.setColor(getBackground()); offscreenG.fillRect(0,0,this.getSize().width,this.getSize().height); offscreenG.setColor(getForeground()); paint(offscreenG); g.drawImage(offscreenImg,0,0,this); } } MODULO: VIDEOJUEGO ARCHIVO: Followmouse.java

/*********************************************************** Alumnos: Corona Trenado Daniel

157

Figueroa Gonzalez Rogelio Programa: Lobo que sigue al mouse dentro de una ventana. Fecha: 14-Febrero-2003 ************************************************************/ /*<applet code="Followmouse" width=720 height=500> </applet>*/ import java.applet.*; import java.awt.*; import java.awt.event.*; import java.lang.*; public class Followmouse extends Applet implements Runnable,MouseListener { /*Variables para el lobo*/ cLobo lobo1; Image ImgLobo1[]=new Image[7]; int num_imgL1=7; /* Determinan el punto centrico en la cueva*/ float p_xcueva=601; float p_ycueva=235; /* destermina el punto de destino para la funcion sale_cueva*/ float p_xcentro=410; float p_ycentro=235; float avanceL=8; String NombImgLob[]={"pararseR5.gif","camina1R5.gif", "camina2R5.gif","camina3R5.gif","camina4R5.gif","camina5R5.gif","camina6R5.gif"}; /* ESTAS CUATRO VARIABLES DELIMITAN UN RECTANGULO UBICADO EN LA IMAGEN DE LA CUEVA, SI SE HACE CLICK EN ESTE RECUADRO, SE ACTIVA LA FUNCION ENTRA_CUEVA */ final int r_x1c=601; final int r_y1c=231; final int r_x2c=720; final int r_y2c=307; /*sonido de el lobo cuando choca con un obstaculo */ AudioClip sonido1; /*************** Variables para el conejo*************/ cConejo conejo1; /* definen los puntos de los cuales salen losconejos*/ float xConejo[]={111,413,662};

158

float yConejo[]={89,75,342}; float madrigueraC_x=290; float madrigueraC_y=412; /* numero de puntos de los arreglos*/ int puntos=3; int num_imgC=6; /* ubicacion de la madriguera del conejo*/ float Y_MADRIGUERA=290; float X_MADRIGUERA=412; Image ImgConejo[]=new Image[6]; float avanceC1=5; String Nomb_img_conejo[]={"conejo1.gif","conejo2.gif", "conejo3.gif","conejo4.gif","conejo5.gif","conejo1.gif"}; /**************variables para el cazador*********************/ cCazador cazador1; String Nom_cazador[]={"cazador1.gif","cazador2.gif","cazador3.gif","cazador4.gif","cazador5.gif", "cazador6.gif","cazador7.gif","cazador8.gif","cazador9.gif","cazador10.gif","cazador11.gif", "cazador12.gif","cazador13.gif" }; int n_img_cazador=13; //numero de imagenes float x_cazador=0; float y_cazador=301; /*area del cazador*/ float x1_ca=0,y1_ca=190,x2_ca=189,y2_ca=500; Image Img_cazador[]= new Image[13]; /***********************************************************/ /*****variables para el objeto validacion***********/ cValidacion ob_valida1; float posiciones_x1[]={93,398,280,669,622,600,561}; float posiciones_y1[]={76,68,402,68,82,97,135}; float posiciones_x2[]={125,423,308,720,669,622,600}; float posiciones_y2[]={114,92,431,406,416,416,308};

159

/* delimitan un recuadro virtualen la imagen del lobo*/ float rL_x1=31; float rL_y1=16; float rL_x2=78; float rL_y2=72; int num_r=7; /*<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<clase del judador>>>>>>>>>>>>>>>>>>>>>>>*/ cPlayer jugador1; /*******************************IMAGENES DEL HAMBIENTE*****************************/ String Nomb_img_fondo[]={"pinoG.gif","pino1.gif","piedras.gif","arbustocfloresd3.gif", "suelo_cueva.gif","techo_cueva.gif"}; //ESTOS ARREGLOS GUARDAN LAS POSICIONES DE LAS IMAGENES DE FONDO int pos_Imgx[]={0,4,223,489,665,641}; int pos_Imgy[]={0,166,316,31,210,0}; Image Img_Fondo[]=new Image[6]; //objeto media tracker para cargar las imagenes del hambiente MediaTracker tracker; final int FONDO=1; Image Img_actualLobo=null; //referencia la imagen actualmente visualizada Image img_conejoActual=null; Image arbusto=null; Image Img_actualCazador=null; Image lobo_negro=null; /*<<<<<<<<<<<<<<<variables auxiliares>>>>>>>>>>>>>>>>>>>*/ float x_temp1=0,y_temp1=0; float x_actL=0,y_actL=0; /*variable para el color de fondo*/ Color colorfondo1; //se presenta una vez inicializado el juego Color colorfondo2; //se presenta cuando esta el mensaje de inicio /*Variables para el doble buffer*/ Image offscreenImg=null; Graphics offscreenG;

160

Thread Neko=null; // hilo que ejecutara la animacion Image LoboPresa[]=new Image[7]; String NombImgLP[]={"pararseLP.gif","camina1LP.gif", "camina2LP.gif","camina3LP.gif","camina4LP.gif","camina5LP.gif","camina6LP.gif"}; final int IMGLP=2; /* String Nomb_img_comida[]={"comida1.gif","comida2.gif", "comida3.gif","comida4.gif","comida5.gif","comida6.gif","comida7.gif"};*/ /*<<<<<<arreglos con las posiciones de los arbustos que rodean al cazador>>>>>>>>>>>>*/ int x_arbusto[]={0,43,92,120,131,158,104,45,0,0}; int y_arbusto[]={343,316,322,352,407,439,439,439,438,396}; /* esta bandera indica si el programa esta en ejecucion o si debe estar detenido */ boolean bandera_runing=false; int vg_i_CONTER=0; boolean conejo_atrapado; boolean temp; int vg_i_cont_TVJ; //esta variable es un contador para decrementar el tiempo de vida deljugador; /*sonido para el inicio del juego*/ AudioClip aullido; /*letras de fondo*/ Font f =new Font("serif",Font.BOLD,20); public void init() { int i; tracker=new MediaTracker(this); conejo_atrapado=false; vg_i_cont_TVJ=0; temp=true; setFont(f); // se cargan las imagenes en un arreglo

161

for(i=0;i<ImgLobo1.length;i++) { ImgLobo1[i]=getImage(getCodeBase(),NombImgLob[i]); } /*se obtienen las imagenes del cazador*/ for(i=0;i<13;i++) { Img_cazador[i]=getImage(getCodeBase(),Nom_cazador[i]); } for(i=0;i<6;i++) { Img_Fondo[i]=getImage(getCodeBase(),Nomb_img_fondo[i]); tracker.addImage(Img_Fondo[i],FONDO); } /*<<<<<<<<se cargan las imagenes de el lobo con la presa>>>>>>>>*/ for(i=0;i<7;i++) { LoboPresa[i]=getImage(getCodeBase(),NombImgLP[i]); tracker.addImage(LoboPresa[i],IMGLP); } for(i=0;i<6;i++) { ImgConejo[i]=getImage(getCodeBase(),Nomb_img_conejo[i]); } /*se espera a que se xcarguen las imagenes de fondo*/ arbusto=getImage(getCodeBase(),"arbustocf.gif"); tracker.addImage(arbusto,FONDO); lobo_negro=getImage(getCodeBase(),"Lobo_negro.gif"); tracker.addImage(lobo_negro,FONDO); try { tracker.waitForID(FONDO); } catch (InterruptedException e){} try { tracker.waitForID(IMGLP); } catch (InterruptedException e){} sonido1=getAudioClip(getCodeBase(),"error.au"); aullido=getAudioClip(getCodeBase(),"aullido.wav"); colorfondo1 =new Color(153,102,51); colorfondo2 =new Color(73,207,103); setBackground(colorfondo2); addMouseListener(this); lobo1=new

162

cLobo(ImgLobo1,p_xcueva,p_ycueva,p_xcentro,p_ycentro,num_imgL1,avanceL); lobo1.CargaImgLobo(); lobo1.Inserta_recuadro((float)r_x1c,(float)r_y1c,(float)r_x2c,(float)r_y2c); lobo1.Set_sonidoL(sonido1); lobo1.Habilita_SaleCueva(); //para que el lobob salga de la cueva conejo1= new cConejo(xConejo,yConejo,(float)280,(float)395,ImgConejo,puntos,num_imgC,avanceC1); conejo1.CargaImg(); ob_valida1=new cValidacion(posiciones_x1,posiciones_y1,posiciones_x2,posiciones_y2,num_r,rL_x1,rL_y1,rL_x2,rL_y2); cazador1= new cCazador(x_cazador,y_cazador,x1_ca,y1_ca,x2_ca,y2_ca,Img_cazador,n_img_cazador); cazador1.Carga_ImgCA(); cazador1.Set_sonidoCA(getAudioClip(getCodeBase(),"gun.au")); jugador1= new cPlayer(); } /*********************************************************** ***********************************************************/ public void start() { if (Neko==null) { Neko=new Thread(this); //crea el hilo Neko.start(); //lanzar el hilo } } /*********************************************************** ***********************************************************/ public void stop() { Neko=null; } /********************************************************** **********************************************************/ public void run() { int vl_i_c=0; Thread hiloActual= Thread.currentThread(); while(Neko==hiloActual) {

163

/*<<<<<<<<manipulacion de la posicion del lobo>>>>>>>>>>>*/ if(bandera_runing==true) { setBackground(colorfondo1); vg_i_cont_TVJ++; if(vg_i_cont_TVJ==50) { vg_i_cont_TVJ=0; if(jugador1.Dec_TV()==false) //el tiempo de vida del jugador se termino { jugador1.Elimina_player(); /*se activa la funcion muere lobo*/ setBackground(colorfondo2); //se restablece el color de fondo repaint(); //se muestran los resultados obtenidos como tiempo de vida, etc; pausa(5000); bandera_runing=false; } } if(lobo1.EstadoLCa()==true) { /* esta habilitada la funcion para que el lobo camine*/ lobo1.CaminaLobo(); x_temp1=lobo1.Get_xL(); y_temp1=lobo1.Get_yL(); } if(lobo1.EstadoLEnC()==true) { lobo1.Entra_Cueva(); x_temp1=lobo1.Get_xL(); y_temp1=lobo1.Get_yL(); /* En este if se incrementan los valores del jugador, ya que si se activo la funcion de entrar a la cueva y la bandera conejo_atrapado es igual a true, se indica que el lobo ha guardado un conejo capturado en su cueva*/ if(conejo_atrapado==true) { conejo_atrapado=false; jugador1.Inc_capturas(); jugador1.Inc_score(); jugador1.Inc_TV(); } }

164

if(lobo1.EstadoLSaC()==true) { lobo1.Sale_cueva(); x_temp1=lobo1.Get_xL(); y_temp1=lobo1.Get_yL(); } if(ob_valida1.Valida(lobo1)==0) // area no valida { lobo1.ResetL(); x_temp1=x_actL; //esto se hace para que la funcion de reseteo no se ejecute todo el tiempo y_temp1=y_actL; // ya que los valores de x y temp se quedan en region no valida } if(ob_valida1.Valida(lobo1)==1) // area valida { /* si los puntos estan en area valida se actualizan los puntos de impresion del lobo*/ x_actL=x_temp1; y_actL=y_temp1; /* se obtiene la nueva imagen a imprimir**/ } cazador1.Dentro_RCA(lobo1.Get_xact(),lobo1.Get_yact()); // pregunto si el lobo esta en el area de tiro //del cazador, si es asi, se habilita al cazador /* se ejecuta la secuencia del cazador*/ if(cazador1.Estado_CA()==true) { if(cazador1.Mueve_CA(lobo1.Get_xact(),lobo1.Get_yact())==true)//indica que se ha disparado al lobo { jugador1.Elimina_player(); /*se activa la funcion muere lobo*/ setBackground(colorfondo2); //se restablece el color de fondo repaint(); //se muestran los resultados obtenidos como tiempo de vida, etc; pausa(5000); bandera_runing=false; } } Img_actualCazador=cazador1.Get_ImgCA(); Img_actualLobo=lobo1.Get_ImagLobo();

165

/*<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/ vl_i_c++; if(vl_i_c==50) { conejo1.Habilitar(); vl_i_c=0; } if(conejo1.Estado()==true) { conejo1.Mueve_conejo(); img_conejoActual=conejo1.Get_img(); if(Conejo_atrapado(lobo1,conejo1)==true) { conejo1.Deshabilitar(); lobo1.InsertImgLoboPresa(LoboPresa,7); Img_actualLobo=lobo1.Get_ImagLobo(); conejo_atrapado=true; x_actL=lobo1.Get_xL(); y_actL=lobo1.Get_yL(); } } } repaint(); pausa(100); } } /*funcion que valida si el lobo ha atrapadoal conejo*/ boolean Conejo_atrapado(cLobo lobo,cConejo conejo) { float xl,yl,xc,yc; double x,y,distancia; xc=conejo.Get_xactC(); //se obtienen las coordenadas del centro de la imagen que se imprime del conejo yc=conejo.Get_yactC(); xl=lobo.Get_xact(); //se obtienen las coordenadas del centro de la imagen del yl=lobo.Get_yact(); //lobo que se esta imprimiendo x=xc-xl; y=yc-yl; distancia=Math.sqrt((x*x)+(y*y)); if(distancia<20) {

166

return(true); // el lobo atrapa al conejo; } return(false); //el lobo no atrapa al conejo; } /****************************************************************** ******************************************************************/ void pausa(int tiempo) { try { Thread.sleep(tiempo); // duerme al hilo momentaneamente } catch(InterruptedException ignorada) { } } /*************************************************************** ***************************************************************/ public void mouseEntered(MouseEvent me) { } public void mouseExited(MouseEvent me) { } public void mousePressed(MouseEvent me) { if(bandera_runing==true) { lobo1.Set_Lobo(me.getX(),me.getY()); } } public void mouseReleased(MouseEvent me) { } public void mouseClicked(MouseEvent me) { if(bandera_runing==false) vg_i_CONTER++; if(vg_i_CONTER==2 && bandera_runing==false)

167

{ init(); aullido.play(); pausa(2000) ; bandera_runing=true; vg_i_CONTER=0; } } /***************************************************************** *****************************************************************/ public void paint(Graphics g) { int i; if((jugador1.Estado_P()==false)&& (bandera_runing==true)) //entra si el jugador fue eliminado { g.drawString(" La cantidad de conejos que atrapaste fue de: " + jugador1.Get_capturas() ,100,100); g.drawString(" Tu puntuacion fue de : " + jugador1.Get_score() ,100,120); return; } if(bandera_runing==true) { /* se pinta el escondite de el cazador*/ for(i=0;i<10;i++) { g.drawImage(arbusto,x_arbusto[i],y_arbusto[i],this);//se pintan las piedras } if(Img_actualCazador!=null) g.drawImage(Img_actualCazador,0,301,this);//se pintan las piedras if(conejo1.Estado()==true) g.drawImage(img_conejoActual,(int)conejo1.Get_xC(),(int)conejo1.Get_yC(),this);//se pinta el conejo g.drawImage(Img_Fondo[4],535,210,this); //se pinta el suelo de la cueba /*<<<<<<<<<<<<<<se pinta el lobo>>>>>>>>>>>>>>>>>*/ if(Img_actualLobo!=null) g.drawImage(Img_actualLobo,(int)x_actL,(int)y_actL,this); g.drawImage(Img_Fondo[5],520,0,this); //se pinta el techo de la cueba //se pinta el pinoG. g.drawImage(Img_Fondo[0],2,2,this); //se pinta el pino1

168

g.drawImage(Img_Fondo[1],332,9,this); g.drawImage(Img_Fondo[1],213,343,this); //se pinta el pino1 repetido g.drawRect(643,244,53,42); /*se pintan los datos del jugador*/ g.drawString("¡¡¡Conejos capturados: "+ jugador1.Get_capturas() + " Tiempo de vida: " + jugador1.Get_TV() + " Score: " + jugador1.Get_score(),150,20); } if(bandera_runing==false) { g.drawImage(lobo_negro,0,22,this); //se pinta la imagen de fondo de inicio del juego g.drawString("PARA INICIAR EL JUEGO DE DOBLE CLICK EN LA PANTALLA",100,20); } } public void update(Graphics g) { if(offscreenImg==null) { offscreenImg= createImage(this.getSize().width,this.getSize().height); offscreenG= offscreenImg.getGraphics(); } offscreenG.setColor(getBackground()); offscreenG.fillRect(0,0,this.getSize().width,this.getSize().height); offscreenG.setColor(getForeground()); paint(offscreenG); g.drawImage(offscreenImg,0,0,this); } } MODULO: VIDEOJUEGO ARCHIVO: Imageproc.java

import java.util.*; import java.awt.*; import java.awt.image.*; class ImageProc extends java.applet.Applet {

169

int width,snapshotWidth; int height,snapshotHeight; int centerX; int centerY; int[] pixels,snapshotPixels; int bgColor=0; ImageProc(Image picture) { //obtiene el largo y ancho de las imagenes width=picture.getWidth(this); height=picture.getHeight(this); centerX=Math.round(width/2); centerY=Math.round(height/2); //Allocate buffer to hold the image's pixels pixels = new int[width * height]; //Grab pixels PixelGrabber pg = new PixelGrabber(picture, 0, 0, width, height, pixels, 0, width); try { pg.grabPixels(); } catch (InterruptedException e){} } void InsertImage(Image picture) { //Get the width and height of the image width=picture.getWidth(this); height=picture.getHeight(this); centerX=Math.round(width/2); centerY=Math.round(height/2); //Allocate buffer to hold the image's pixels pixels = new int[width * height]; //Grab pixels PixelGrabber pg = new PixelGrabber(picture, 0, 0, width, height, pixels, 0, width); try { pg.grabPixels(); } catch (InterruptedException e){} } void rotate(double angle) { if (angle%360!=0) { //se duplica la imagen para no alterar la original int[] sourcePixels=pixels; pixels = new int[width * height];

170

//Convert from degrees to radians and calculate cos and sin of angle //Negate the angle to make sure the rotation is clockwise double angleRadians=-angle/(180.0/Math.PI); double ca=Math.cos(angleRadians); double sa=Math.sin(angleRadians); int index=0; for (int y=-centerY;y<centerY;y++) { for (int x=-centerX;x<centerX;x++) { int xs=(int)(x*ca-y*sa)+centerX; int ys=(int)(y*ca+x*sa)+centerY; if ((xs>=0)&&(xs<width)&&(ys>=0)&&(ys<height)) pixels[index++]=sourcePixels[width*ys+xs]; else pixels[index++]=bgColor; } } } } Image createImage() { Image img= createImage(new MemoryImageSource(width, height, pixels, 0, width)); //Make sure the pixels pointer changes after createImage, silly but neccesary int[] sourcePixels=pixels; pixels = new int[width * height]; System.arraycopy(sourcePixels,0,pixels,0,width*height); return img; } } MODULO: ANATOMIA DEL LOBO ARCHIVO: VIdeoLobo.java

//<APPLET CODE=PlayerApplet WIDTH=600 HEIGHT=400> //</APPLET> import java.applet.*; import java.awt.*; import java.net.*; import javax.media.*; public class VideoLobo extends Applet implements ControllerListener { Player player = null; public void init() { setLayout(new BorderLayout()); //String mediaFile = getParameter("Parameter_FILE"); try { URL mediaURL = new URL(getDocumentBase(), "Clip81.mpg"); player = Manager.createPlayer(mediaURL);

171

player.addControllerListener(this); } catch (Exception e) { System.err.println("Got exception "+e); } } public void start() { player.start(); } public void stop() { player.stop(); player.deallocate(); } public void destroy() { player.close(); } public synchronized void controllerUpdate(ControllerEvent event) { if (event instanceof RealizeCompleteEvent) { Component comp; if ((comp = player.getVisualComponent()) != null) add ("Center", comp); if ((comp = player.getControlPanelComponent()) != null) add ("South", comp); validate(); } } } MODULO: ANATOMIA DEL LOBO ARCHIVO: Esqueleto.java

import java.applet.Applet; import java.applet.*; import java.awt.*; import java.awt.image.*; public class Esqueleto extends Applet{ int width; int height; int[] pixels; int [] pixeles; Image myImage1, myImage2; int red, green, blue; int alpha=0; Image offscreenImg=null; Graphics offscreenG; private Panel p1; private Scrollbar sbalpha; private MyCanvas theCanvas; public void init(){ myImage1 = getImage(getCodeBase(), "imagenes/lobo.jpg"); myImage2 = getImage(getCodeBase(), "imagenes/esqueleto.jpg" ); getThePixels(myImage2, myImage1);

172

theCanvas= new MyCanvas(); theCanvas.resize(width, height); myImage2=showImage(); sbalpha = new Scrollbar(Scrollbar.HORIZONTAL, 0, 1, 0, 255+1); p1 =new Panel(); setLayout(new BorderLayout()); p1.setLayout(new BorderLayout()); p1.add("South", sbalpha ); p1.add("Center", theCanvas); add("Center", p1); } public void getThePixels(Image picture, Image picture2){ waitToOpenImage(picture, picture2); width=picture.getWidth(this); height=picture.getHeight(this); pixels= new int [width*height]; pixeles = new int [width*height]; try{ PixelGrabber pg=new PixelGrabber(picture, 0, 0, width, height, pixels, 0, width); if( pg.grabPixels() && ( (pg.getStatus() & ImageObserver.ALLBITS ) != 0 ) ) { for( int i=0; i < (width*height); i++ ) { red=getRed(pixels[i]); green=getGreen(pixels[i]); blue=getBlue(pixels[i]); pixeles[i] = (alpha<<24)+(red<<16)+(green<<8)+blue; } } } catch( InterruptedException e ) { System.out.println( e ); } } void waitToOpenImage(Image picture, Image picture2){

173

MediaTracker tracker= new MediaTracker(this); tracker.addImage(picture,0); tracker.addImage(picture2,1); try{ tracker.waitForID(0); tracker.waitForID(1); }catch (InterruptedException e){ System.out.println("Error al cargar la imagen"); } } public static int getRed(int pixel){ return (pixel>>16)&0xff; } public static int getGreen(int pixel){ return (pixel>>8)&0xff; } public static int getBlue(int pixel){ return pixel&0xff; } public Image showImage(){ myImage2= createImage(new MemoryImageSource (width, height, pixeles, 0, width)); return myImage2; } public boolean handleEvent(Event e){ if(e.target instanceof Scrollbar){ theCanvas.setAlpha(sbalpha.getValue()); theCanvas.repaint(); return true; } return super.handleEvent(e); } class MyCanvas extends Canvas{ public MyCanvas(){ setAlpha(0); } public void setAlpha(int a){ alpha=a; }

174

public void update(Graphics g) { if(offscreenImg==null) { offscreenImg= createImage(this.getSize().width,this.getSize().height); offscreenG= offscreenImg.getGraphics(); } offscreenG.setColor(getBackground()); offscreenG.fillRect(0,0,this.getSize().width,this.getSize().height); offscreenG.setColor(getForeground()); paint(offscreenG); g.drawImage(offscreenImg,0,0,this); } public void paint(Graphics g){ getThePixels(myImage2, myImage1); g.drawImage(myImage1, 0, 0, this); myImage2=showImage(); waitToOpenImage(myImage2, myImage1); g.drawImage(myImage2, 0, 0, this); } } }

MODULO: ANATOMIA DEL LOBO ARCHIVO: ZoomLobo.java

import java.applet.Applet; import java.applet.AppletContext; import java.awt.event.MouseEvent; import java.awt.event.MouseAdapter; import java.awt.*; import java.awt.image.BufferedImage; import java.io.IOException; import java.net.MalformedURLException; import java.net.URL; import javax.media.*; import javax.swing.JApplet;

175

public class ZoomLobo extends JApplet implements ControllerListener { class MouseHandler extends MouseAdapter{ public void mousePressed(MouseEvent mouseevent){ x = mouseevent.getX(); y = mouseevent.getY(); if( x >= 65 && x <= 115 && y >= 95 && y <= 120){ if(player != null) player.start(); } if( x < 65 && x > 115 && y < 95 && y > 120){ player.stop(); player.close(); player.deallocate(); player = null; } if(x >= 65 && x <= 115 && y >= 75 && y <= 90){ try{ URL url = new URL(getDocumentBase(), "VideoLobo.html"); getAppletContext().showDocument(url, "_top"); } catch(MalformedURLException malformeurlexception){} } if(x >= 200 && x<= 250 && y >= 140 && y <= 190){ try{ URL url1 = new URL(getDocumentBase(), "Esqueleto.html"); getAppletContext().showDocument(url1, "_top"); } catch(MalformedURLException malformedurlexception){} } repaint(); } MouseHandler(){} } // The image private BufferedImage image; // Position and size of the magnifying area int x; int y; int h; int w; // Factor describing how much the image should be scaled int escala; // The applet base URL private URL base;

176

Player player; public ZoomLobo(){ x = 400; y = 100; h = 120; w = 120; escala = 3; } // Applet initialisation public void init() { try { base = getDocumentBase(); } catch (Exception e) { showStatus("Error: " + e); } // Set up background and load image setBackground(Color.white); Image image1 = getImage(base, "lobo_anatomia.jpg"); // Wait for image to be loaded try { MediaTracker tracker = new MediaTracker(this); tracker.addImage(image1, 0); tracker.waitForID(0); } catch (Exception exception1) {} int ancho = image1.getWidth(this); int alto = image1.getHeight(this); image = new BufferedImage(ancho, alto, BufferedImage.TYPE_INT_RGB); Graphics2D grafico2d = image.createGraphics(); grafico2d.drawImage(image1, 0, 0, this); // Prepare to listen for mouse events addMouseListener(new MouseHandler()); /****************************************/ // input file name from html param String cadena = null; // URL for our media file URL url = null; // URL for doc containing applet URL url1 = getDocumentBase(); // Get the media filename info. // The applet tag should contain the path to the // source media file, relative to the html page. if ((cadena = getParameter("FILE")) == null) Fatal("Parametro de archivo mp3 invalido"); try{ // Create an url from the file name and the url to the // document containing this applet. if ((url = new URL(url1, cadena)) == null) Fatal("Error al cargar " + cadena);

177

// Create an instance of a player for this media try { player = Manager.createPlayer(url); } catch (NoPlayerException e) { System.out.println(e); Fatal("Error al cargar: " + url); } // Add ourselves as a listener for player's events player.addControllerListener(this); } catch (MalformedURLException u){ Fatal("Error con el archivo de sonido mp3!"); } catch(IOException i){ Fatal("Error al crear: "+url); } /***************************************/ } // Applet paint method public void paint(Graphics g) { // Get Graphics2D object and clear the painting area Graphics2D grafico2d = (Graphics2D) g; Dimension dimension = getSize(); g.clearRect(0, 0, dimension.width, dimension.height); // Draw original image grafico2d.drawImage(image, 0, 0, this); // Draw magnified area // The position of the mouse indicates the center of the // magnifying area: // (x-w/2, y-h/2) w // +-----------------------+ // h | (x,y) | // +-----------------------+ // (x+w/2, y+h/2) // and the same for the area in the original image, // only smaller (determined by the scale factor). grafico2d.drawImage(image, Math.max(x - (w/2), 0), // destination x Math.max(y - (h/2), 0), // destination y x + (w/2), // destination width y + (h/2), // destination height Math.max(x - (w/escala/2), 0), // source x Math.max(y - (h/escala/2),0), // source y x + (w/escala/2), // source width y + (h/escala/2), // source height this); // Make a nice border grafico2d.draw(new Rectangle(x - (w/2), y - (h/2), w, h)); } public synchronized void controllerUpdate(ControllerEvent controllerevent){ // If we're getting messages from a dead player, // just leave

178

if (player == null) return; // When the player is Realized, get the visual // and control components and add them to the Applet if (controllerevent instanceof CachingControlEvent) if (controllerevent instanceof EndOfMediaEvent){ // We've reached the end of the media; rewind and // start over player.setMediaTime(new Time(0L)); player.start(); } else if (controllerevent instanceof ControllerErrorEvent) { // Tell TypicalPlayerApplet.start() to call it a day player = null; Fatal (((ControllerErrorEvent)controllerevent).getMessage()); } } void Fatal (String s) { // Applications will make various choices about what // to do here. We print a message and then exit System.err.println("Error fatal: " + s); throw new Error(s); // Invoke the uncaught exception // handler System.exit() is another // choice. } }

179

Anexo C. Videojuego.

Clase conejo

Creación de un objeto de esta clase

A continuación describiremos los pasos y métodos que debe seguir para usar esta clase.

El constructor de esta clase es: cConejo( float[] xo, float[] yo, float madriguera_x,float madriguera_y, Image[] imágenes, int

n, int m, float avance)

Los parámetros xo y yo son dos arreglo de tipo flotante que describen una serie de

puntos en la ventana de nuestro applet. Estos arreglos indican los puntos desde los cuales saldrá nuestro conejo corriendo y ambos deben de ser del mismo tamaño y deben contener el mismo número de elementos.

Los atributos madriguera_x y madriguera_y describen el punto al cual se dirigirá nuestro conejo, es decir, ubican la madriguera de nuestro conejo. Por ejemplo podemos ver el contenido de nuestros parámetros si tenemos los siguientes datos:

Figura B1 Conejo de Norte a sur (arriba hacia abajo)

180

Algo importante respecto a los puntos de partida en la clase cConejo, es que cuando inicia la animación en la que un conejo sale de un punto de partida y se dirige hacia la madriguera y es ahí donde termina la animación. El cambio de los puntos de salida se hace automáticamente, por ejemplo, si en la animación el conejo sale del punto P1 la animación no terminará hasta que el conejo llegue a su madriguera. Después de esto, el punto de salida será P2, después el punto de salida será P3 y después se repetirá la secuencia comenzando por P1 y así sucesivamente.

El parámetro ‘imágenes’ es un arreglo que contiene las imágenes necesarias para la animación en la que el animal camina.

Nota : Cabe recalcar que las imágenes que se introducen al objeto deben de ser todas del mismo tamaño. Además, la orientación debe ser como las que se muestran en la Figura 1 (las imágenes de la secuencia en la que el conejo camina), esto debido a que las imágenes son retadas automáticamente, dentro de los métodos de la clase, para que se obtenga el efecto en el que el conejo sigue la trayectoria a su madriguera. Las rotaciones se hacen considerando que las imágenes se encuentran en la posición antes dicha.

Los enteros n y m describen el número de elementos de nuestros arreglos xo y yo y el número de elementos (imágenes) de nuestro arreglo ‘imágenes’ respectivamente.

El parámetro flotante llamado avance indica el número de píxeles que se desea avanzar cada que se muestre una imagen.

Por ejemplo si el avance es de 10 y nuestra trayectoria a seguir es paralela al eje x, tendremos lo siguiente:

10 píxeles de avance X (píxeles) 10 20 30 40 50 60 10 * * * * * * Y (píxeles)

Figura B2. Imágenes y desplazamientos.

Para todos los parámetros numéricos, el signo debe ser positivo a excepción del

parámetro Avance, ya que dependiendo de su signo será la dirección del desplazamiento. Si quisiéramos que nuestro desplazamiento fuera de sur a norte (de abajo hacia arriba), nuestros datos deberían ser :

Avance =+10

181

Figura B3. Conejo de sur a norte (de abajo hacia arriba).

Métodos que complementan la clase conejo public void CargaImg().

Parámetro: Ninguno. Valor de retorno: Ninguno.

Objetivo: Una vez que se ha inicializado nuestro objeto conejo1, es necesario aplicarle el método CargaImg()que añade a un objeto de la clase MediaTracker y verifica que se cargue totalmente las imágenes que el objeto del conejo1 recibe en su constructor, esto se hace para disminuir parpadeo. Estos tres pasos se deben de seguir para utilizar un objeto de la clase cConejo.

public void Habilitar()

Parámetros: Ninguno. Valor de retorno: Ninguno.

Objetivo: Este método pone el valor de verdadero a un atributo booleano conejo_habilitado. El que conejo1 esté habilitado sirve para controlar dentro del juego el momento justo en el que se deben mostrar las imágenes del conejo, sirve para llevar el control del objeto dentro de la animación. Si el valor de este atributo es verdadero, indica que la animación en la que el conejo sale caminando está activa, en caso de ser falso el objeto esta deshabilitado para ser mostrado en la animación.

public void Deshabilitar().

Parámetros: Ninguno.

Valor de retorno: ninguno

Madriguera_x 6 Madriguera_y 1 Avance +

xo yo 1 5 6 7 11 7

182

Objetivo: Esta función da el valor de falso al atributo conejo_habilitado, que sirve para tener un control sobre la animación del objeto.

public boolean Estado().


Valor de retorno: boolean.

Objetivo: Regresa el estado del objeto de la clase conejo, es decir, el valor del atributo conejo_habilitado.

public void Mueve_conejo().


Objetivo: El objeto conejo tiene una coordenada (x,y) que indica, dentro de la pantalla de nuestro applet, el lugar donde se imprimió por ultima vez la imagen del objeto conejo. Si aplicamos este método al objeto, se modifica el valor de esta coordenada y lo acerca más a la madriguera, esto siguiendo una trayectoria.

Ejemplo:

Figura B4. Conejo en movimiento.

183

public float Get_xC().

Parámetros :Ninguno. Valor de retorno: float.

Objetivo: Regresa la coordenada x del punto donde se imprimió por última vez la imagen del objeto conejo1. En el caso de la imagen anterior, si antes de aplicar la función Mueve_conejo() aplicamos esta función a nuestro objeto conejo tendríamos el siguiente resultado:

X = Conejo1.Get_xactC() X = 30.0;

public float Get_yC().

Parámetros: Ninguno. Valor de retorno: float. Objetivo: Regresa la coordenada y del punto donde se imprimió por última vez la imagen de nuestro objeto conejo1. En el caso de la imagen anterior si antes de aplicar la función Mueve_conejo() aplicamos ésta al objeto conejo tendríamos el siguiente resultado: y = Conejo1.Get_yactC() Y = 95.0;

public Image Get_img().

Parámetros: Ninguno. Valor de retorno: Un objeto de la clase Image.

Objetivo: Cuando el objeto conejo1 esta habilitado para la animación, esta función regresa la próxima imagen a mostrar dentro de la animación.

public float Get_xactC().

Parámetros: Ninguno. Valor de Retorno: flota.

Objetivo: Dentro del objeto conejo1 a parte de los atributos que nos indican la coordenada (x , y) donde se imprimió por ultima vez la imagen , cuenta con otros atributos que indican la coordenada del centro de la imagen a partir de la coordenada donde se imprimió por última vez. Esta función devuelve el valor de la coordenada x de este punto central, el cual es calculado a partir de la posición de impresión de la imagen y tomando en cuenta el ancho y largo de la misma.

184

Ejemplo:

Figura B5Coordenadas del conejo.

public float Get_yactC().

Parámetros: Ninguno. Valor de Retorno: float.

Objetivo: Esta función devuelve el valor de la coordenada ‘y’ del punto central de la imagen, que es calculado a partir de la posición de impresión de la msima tomando en cuenta su ancho y largo.

boolean Conejo_atrapado(cLobo lobo, cConejo conejo).

Parámetros: Un objeto de la clase cLobo y uno de la clase cConejo Valor de Retorno: true si se ha atrapado al conejo y false en caso contrario.

Objetivo: Este método se usa para determinar si el conejo ha sido atrapado por el lobo en el juego. En base a parámetros que indican la posición del lobo y del conejo este método determina si lo ha atrapado, esto depende de la distancia a la que este uno del otro y esta se especifica dentro del método. Cabe mencionar que éste método no pertenece a esta clase, es un método general construido en el programa principal del juego.

Clase cCazador

La secuencia de imágenes que utilizamos para crear el efecto en el que el cazador dispara es la siguiente:

185

Figura B6. Imágenes del cazador.

Ahora describiremos cada uno de los métodos que posee nuestra clase cCazador, y

los pasos necesarios para utilizarla.

Constructor public cCazador(float p_x, float p_y, float ax1,float ay1, float ax2, float ay2,Image[]

imgca, int n_imgca).

Los parámetros p_x y p_y forman una coordenada dentro de la pantalla de nuestro applet (p_x , p_y) , esta coordenada indica el punto donde se imprimirán todas las imágenes del cazador. Este punto se mantiene estático durante todo el juego, nunca cambia.

Los parámetros ax1, ay1, ax2, ay2 forman dos coordenadas (ax1,ay1) y (ax2,ay2) que describen un rectángulo dentro del applet siendo esta arbitraria definiendo el área de tiro del cazador.

El arreglo imgca[] contiene las imágenes necesarias para la animación en la que el cazador dispara. Estas imágenes deben de ser del mismo tamaño y deben tener la misma orientación que las mostradas en la Figura 13. Esta orientación es necesaria ya que dentro de la clase, las imágenes son rotadas automáticamente dentro de los métodos y esta rotación se hace considerando que todas las imágenes tienen la orientación antes mencionada.

El parámetro n_img indica el número de imágenes que contiene el arreglo imgca[];

186

public void Carga_ImgCA().

Una vez que se ha inicializado el objeto cazador1, se debe aplicar el método public void Carga_ImgCA() que carga las imágenes que recibió el objeto cazador1 por parámetro y las añade a un objeto de la clase MediaTracker que esta dentro del mismo objeto.

Una vez que se han cargado las imágenes del objeto cazador1 se carga el sonido del

disparo del cazador. Esto se hace usando el método:

public void Set_sonidoCA(AudioClip son) Cuyo parámetro “son” contiene el sonido del disparo del cazador. public boolean Estado_CA().

Parámetros: Ninguno. Valor de retorno: boolean.

Objetivo: El objetivo de este método es indicar el estado del cazador que son dos:

Cazador habilitado: Se está en este estado si el valor que devuelve la función

es trae, significa que el lobo ha entrado al área de tiro del cazador y éste está listo para disparar.

Cazador no habilitado: Indica que el lobo no ha entrado al área de tiro del cazador.

El estado de nuestro cazador se determina automáticamente utilizando el método Dentro_RCA( ) que veremos más adelante.

public float Get_XCA().

Parámetros: Ninguno. Valor de retorno: float.

Objetivo: Esta función regresa el valor x de la coordenada donde se debe imprimir la imagen del cazador.

public float Get_YCA()

Parámetros: Ninguno. Valor de retorno: float.

Objetivo: Esta función regresa el valor y de la coordenada donde se debe imprimir la imagen del cazador.

public boolean Mueve_CA(float xlobo, float ylobo)

Parámetros: Dos números flotantes. Valor de retorno: boolean.

187

Objetivo: Esta función gira la imagen del cazador n ángulos para simular el efecto de que va enfocando al lobo antes de disparar. Los parámetros que recibe forman una coordenada que indica la posición del lobo, en base a esta coordenada y a la posición del lobo se calcula automáticamente un ángulo y se rota la siguiente imagen del cazador a mostrar. Después de aplicar este método se debe obtener la imagen del objeto cazador1 y mostrarla en la animación.

public boolean Dentro_RCA(float xlobo, float ylobo)

Parámetros: Dos números flotantes. Valor de retorno: boolean.

Objetivo: Esta función recibe como parámetro una coordenada que indica la posición del lobo y determina si está dentro del área de tiro del cazador. Si es así, el valor devuelto será true, en caso contrario, será false.

public Image Get_ImgCA().

Parámetros: Ninguno. Valor de retorno: Un objeto de la clase Image.

Objetivo: Esta función regresa la siguiente imagen que se debe mostrar en la animación en la que el lobo dispara. Para dar este efecto, una vez que el lobo ha entrado al área de tiro del cazador, se debe aplicar al objeto cazador la función Mueve_CA, después la función Get_ImgCA() y mostrar la imagen obtenida dentro del applet. Dentro de esta función se activara automáticamente el sonido del disparo sin necesidad de hacer nada.

Clase cCoordenada

A continuación se describen lo métodos de ésta clase:

Procedimiento “cCoordenada()”. public cCoordenada(int x, int y).

Parámetros: Dos enteros que forman una coordenada ( x ,y ) en la pantalla del applet. La unidad de estos números es el píxel. Valor de retorno: Ninguno.

Objetivo: Este método es el constructor de la clase.

public cCoordenada().


Objetivo: Este es otro constructor de nuestra clase. Si se utiliza este constructor será necesario utilizar el método Set_xy( ) de la clase para darle valor al objeto.

188

public void Set_xy(int x,int y).

Parámetros: Dos enteros. Valor de retorno: Ninguno.

Objetivo: Este método se utiliza para introducir valores al objeto.

public int Get_x().

Parámetros: Ninguno. Valor de retorno: Regresa un entero.

Objetivo: Este método devuelve el atributo x del objeto, es decir, el elemento x de la coordenada;

public int Get_y().

Parámetros: Ninguno. Valor de retorno: Regresa un entero.

Objetivo: Este método devuelve el atributo “y “del objeto, es decir, el elemento “y” de la coordenada.

Clase clistalineal

A continuación se describen los métodos de ésta clase:

public cListalineal().

Parámetros: Ninguno. Valor de retorno: Ninguno

Objetivo: Esta función es el constructor de nuestra clase.

public void addprincipio(cCoordenada objeto).

Parámetros: Un objeto de la clase cCoordenada. Valor de retorno: ninguno.

Objetivo: Esta función añade un elemento a la cola.

public void Vaciar().

Parámetros: Ninguno. Valor de retorno: Ninguno. Objetivo: Esta función se encarga de vaciar totalmente la cola. public cCoordenada Obtener().


189

Valor de retorno: Un objeto de la clase coordenada que contiene el próximo destino de la trayectoria.

public int Num_elem().

Parámetros: Ninguno. Valor de retorno: El numero de elementos que contiene la cola.

Objetivo: Indicar el numero de elementos del objeto de la clase cCola.

Clase cValidacion

Para reconocer la región no valida primero se debe saber donde se colocarán las imágenes del ambiente. Cada región no valida es representada por dos coordenadas que denotan un rectángulo dentro del applet. Sobre esta región, delimitada por el rectángulo, no podrá caminar el lobo y la región que queda dentro de este rectángulo será región no valida.

Los rectángulos encierran las imágenes que se mostrarán en el ambiente del juego, imágenes como: piedras, árboles, arbustos, etc.

El rectángulo denota una región más pequeña que la que abarca la imagen, esto se debe a que el lobo también tendrá un rectángulo dentro de su propia imagen y la validación de áreas consistirá en que los dos rectángulos no se sobrepongan uno sobre el otro.

Figura B7. Regiones no validas.

Los métodos de la clase son:

190

void cValidacion(float[] x0,float[] y0,float[] x1,float[] y1, int num, float xi,float yi, float xd, float yd).

Valor de retorno: Ninguno. Parámetros: x0, x1 , y0, y1 arreglo de flotantes.

num numero entero. xi, yi, xd, yd flotantes.

Para cada rectángulo que denote una región no valida se tendrán dos puntos dentro del applet (x0[1],y0[1]) y (x1[1],y1[1]), así que debe haber una correspondencia entre los datos guardados en cada posición del arreglo.

El valor num es el número de elementos del arreglo(en los cuatro arreglos debe haber el mismo numero de elementos). La imagen del lobo tendrá también un rectángulo que denota una área, los dos puntos que denotan ese rectángulo dentro de la imagen del lobo deben ser pasado por parámetro en este procedimiento. El rectángulo de la imagen del lobo no dependerá de la posición del lobo sino del tamaño de su. Por ejemplo si se tuviera la siguiente imagen, tendríamos los puntos:

Figura B8. Área de validación del lobo.

Estos valores de (xi,yi), (xd,yd) se deberán pasar a nuestro objeto de la clase cValidacion.

Objetivo: Inicializar nuestro objeto cValidacion.

public int Valida(cLobo lobo)

Valor de retorno: 1 si el siguiente paso del lobo no caerá dentro de una región no

valida. 0 si caerá dentro de una región no valida.

Parámetros: Un objeto de la clase cLobo.

Objetivo: Este método determinara (a partir de las propiedades del objeto cLobo que recibe) si el siguiente paso que el lobo dará estará dentro de una región no valida. El objeto cLobo que recibe debe de estar inicializado, en cazo

191

contrario se producirá un error.

Clase ImageProc

A continuación se describen los métodos de ésta clase.

ImageProc(Image picture).

Valor de retorno: Ninguno. Parámetros: Un objeto de la clase Image.

Objetivo: Este método inicializa nuestro objeto insertando dentro de él la imagen que recibe por parámetro y la cual será modificada.

void InsertImage(Image picture).

Valor de retorno: Ninguno.

Parámetros: Un objeto de la clase Imagen, es decir, una imagen.

Objetivo: Una vez creado un objeto de la clase ImageProc, podemos cambiar la imagen que contiene aplicándole a nuestro objeto su método InsertImage. Este método substituye la imagen original que tenia el objeto por una nueva.

Image createImage().

Parámetros: Ninguno. Valor de retorno: Un objeto de la clase imagen. Objetivo: Este método obtiene la imagen que contiene nuestro objeto de la clase ImageProc.

void rotate(double angle).

Parámetros: Un numero double. El parámetro angle indica el número de grados que se va a rotar la imagen. La imagen debe tener cierta orientación para que la rotación sea adecuada.

A continuación damos un ejemplo de la orientación que debe tener la imagen al ser introducida dentro de nuestro objeto ImageProc.

192

Figura B8. Orientación de la imagen.

La cantidad de ángulos que se puede rotar nuestra imagen es arbitraria, pueden se 10, 208, 35, 40, etc. A continuación se da un ejemplo de la rotación de una imagen a distintos grados:

Figura B9. Rotación de la Figura.

La secuencia de pasos a realizar en caso de que se desee utilizar un elemento de esta clase son los siguientes:

1.- Declarar un objeto de la clase ImageProc. ImageProc procesador1; 2.- Inicializar el objeto con los parámetros correspondientes. procesador1 = New ImageProc(imagen1);

193

3.- Hasta aquí el objeto procesador1 posee una imagen que se manipula. Ahora si queremos rotarla debemos hacer lo siguiente: procesador1. rotate(90); 4.- Hasta aquí la imagen está rotada. Para poder obtener la imagen rotada y poder mostrarla debemos usar la función createImage como sigue: imagen2 = procesador1. CreateImage(); De este modo en la variable imagen2 tendremos la imagen1 pero rotada.

Figura B10. Rotando la imagen

Ahora, si al objeto procesador1 se le aplica el método Insertar, se tendrá lo

siguiente:

Figura B11. Cambio de imagen.

Clase cPlayer


194

public cPlayer();


Objetivo: Este es el constructor de nuestra clase cPlayer;

public int Get_score();

Parámetros: Ninguno; Valor de retorno: Un entero que representa el marcador del jugador; Objetivo: Regresar el marcador (record) que ha acumulado el jugador.

public int Get_capturas().

Parámetros: Ninguno; Valor de retorno: Un entero que representa el número de animales (conejos) capturados por el jugador; Objetivo: Regresar el número de conejos capturados por el jugador.

public int Get_TV().

Parámetros: Ninguno; Valor de retorno: Un entero que representa el tiempo de vida que le resta al jugador; Objetivo: Regresar el tiempo que le queda de vida al jugador.

public void Inc_capturas();

Parámetros: Ninguno; Valor de retorno: Ninguno; Objetivo: Incrementar en uno el número de conejos capturados del jugador.

public void Inc_score().

Parámetros: Ninguno; Valor de retorno: Ninguno; Objetivo: Incrementar cinco puntos en el record del jugador.

public void Inc_TV().

Parámetros: Ninguno; Valor de retorno: Ninguno; Objetivo: Incrementar en diez unidades el tiempo de vida del jugador.

public boolean Dec_TV().

Parámetros: Ninguno; Valor de retorno: Ninguno; Objetivo: Decrementa en diez unidades el tiempo de vida del jugador.

public void Elimina_player().

Parámetros: Ninguno;

195

Valor de retorno: Ninguno; Objetivo: Este método pone el tiempo de vida del jugador en cero, lo que indica que el jugador a perdido.

public boolean Estado_P().

Parámetros: Ninguno; Valor de retorno: Un boolean que representa el estado del jugador. Objetivo: Este método sirve para saber si el jugador ha perdido o sigue activo. Si el

valor de retorno es “true”, entonces el jugador sigue con vida. En caso de ser “false”, el jugador ha perdido.

Clase cFunciones

A continuación describimos los métodos que contiene esta clase.

public cFunciones().

Parámetros: Ninguno. Valor de retorno: Ninguno. Objetivo: Esta función es el constructor de esta clase.

public float Get_pendiente(float xo,float yo,float xd,float yd).

Parámetros: Cuatro variables de tipo entero las cuales representan dos puntos uno de origen (xo,yo) y uno destino (xd,yd). Con estos dos puntos en el espacio se genera una recta. Valor de retorno: Un flotante que representa la pendiente de una recta. Objetivo: Calcular la pendiente de la recta representada por los dos puntos que recibe por parámetro.

public float Get_b(float x,float y,float m).

Parámetros: Tres variables de tipo flotante. Los valores (x,y) forman un punto de una recta y la variable m es la pendiente de esa recta. Valor de retorno: Un flotante que representa la ordenada al origen de la recta. Objetivo: Calcula la ordenada al origen de una recta.

public float Get_angulo(float xo, float yo, float xd, float yd).

Parámetros: Cuatro variables de tipo float que representan una trayectoria (forman una recta). (xo,yo) representan el punto de origen y (xd, yd) que representa el punto de destino. Valor de retorno: Un flotante que representa un ángulo de rotación.

196

Objetivo: Anteriormente se mencionó que en las animaciones sería necesario rotar las imágenes. Este método determina, a partir del punto de destino y del punto origen, el ángulo de rotación para la siguiente imagen de la animación.

public int Obtenregion(float posact_x,float posact_y,float px,float py).

Parámetros: Cuatro variables flotantes que representan el punto actual de nuestra ultima imagen mostrada (punto de origen de la trayectoria) y el punto destino de nuestra trayectoria (px, py). Valor de retorno: Un entero que representa la región hacia la que esta orientado el movimiento (más adelante se explicara esto de las regiones, en la sección del lobo). Objetivo: Calcular la región a la que esta orientada el movimiento de la animación.

Clase cLobo

Esta clase se utiliza para controlar la animación del lobo. Para generar la animación en la que el lobo camina usamos una serie de imágenes.


Figura 36. Secuencia del lobo

Todas ellas forman el movimiento de un paso que da el lobo. La imagen camina6 representara al lobo cuando este estático.

Para controlar el movimiento del lobo usamos una recta, la cual estará formada por

un punto de origen y un punto de destino. Para llegar al punto de destino solo se tiene que ir incrementando una de las variables, ya sea x o y, de nuestro punto origen hasta alcanzar nuestro punto destino. Utilizando esta técnica tenemos ocho casos distintos de

197

movimiento, sólo se analizan algunos.

Primero, dividiremos el plano cartesiano en ocho regiones, cada una corresponderá a una posible dirección en la que podrá caminar el lobo. Es necesario identificar la región del movimiento del lobo porque en algunas regiones, para llegar al punto destino, se deberá incrementar la variable x y en otros casos se deberá decrementar, todo depende de la región a la que pertenezca el movimiento. El centro de la división del applet siempre será la ultima imagen del lobo, es decir, no importa en que espacio del applet este el lobo siempre estará en el centro del plano cartesiano que haremos.

A continuación se muestra una imagen que explica la división del plano artesiano del applet.

Figura B12. Regiones del applet.

Si el lobo debe caminar a la región 3, del el punto origen (100,80) al punto destino

(200,150), entonces tenemos los siguientes datos:

Datos Operaciones xo = 100. yo = 80. xd = 200. yd =40.

La pendiente de la recta que se genera con estos dos puntos es la siguiente:

xoxdyoydm

−−

= = 1002008040

−−

= -0.4 y = mx + b b = y – mx

b = 80 – (-0.4)*100= 120 m = -0.4 b = 120.

198

Una vez que tenemos la pendiente y la ordenada al origen de la recta, sólo

comenzamos a variar uno de los valores ( ya sea xo ó yo ) hasta alcanzar el punto de destino. En este caso particular, el valor de xo se deberá ir incrementando hasta alcanzar al punto destino, más adelante veremos que no es así en todos los casos.

Los resultados de la variación de xo se muestran en la siguiente tabla.

En este caso usamos un incremento de 10 en x.

X Y

120 72 130 64 140 56 150 48 160 40 Si el movimieto en la región 1 y se tienen los siguientes puntos, tendremos:

xo = 100. yo = 100. tendremos la siguiente tabla. xd = 50. yd =50.

En este caso nos damos cuenta de que si incrementamos nuestra variable xo pretendiendo llegar al punto de destino, nunca lo lograremos, en este caso debemos decrementar nuestro punto origen hasta alcanzar el punto destino de nuestra trayectoria.

Ahora mostraremos el caso en el que el movimiento sea en la región 2. Supongamos que tenemos los siguientes puntos:

xo = 120. yo = 150. xd = 120. yd = 50.

En este caso, lo único que se debe de variar es el valor de “y” hasta llegar al valor de la yd, esto debido a que el valor de “x” no sufre ninguna variación, es decir, “x” vale lo mismo en el punto origen que en el punto de destino. A continuación se muestra la tabla que describe los puntos hasta llegar al punto de destino.

y X 100 100 90 90 80 80 70 70 60 60 50 50

m = 1 b = 0

m=0 y b=y

199

Si el movimiento fuera hacia la región cuatro, tendríamos una tabla parecida a la anterior, solo que en esta la variable que se modificaría seria x permaneciendo y constante. Además se decrementaria la variable x hasta alcanzar su punto de destino.

Ejemplo: xo = 100. yo = 130. xd = 50. yd = 130

Así es como dependiendo de la región donde se encuentre el punto de destino, será la decisión si la variable xo se debe incrementar o decrementar. A continuación se muestra una tabla que muestra la relación entre el avance (positivo o negativo) que se le debe dar a nuestra variable xo para llegar al punto destino.

Tipo de región Tipo de avance (sobre x)

Región 1 negativo Región 3 positivo Región 6 negativo Región 8 positivo

Cave mencionar que un avance positivo indica que la variable en cuestión debe ser incrementada para llegar al punto de destino y un avance negativo indica que debe ser decrementada para llegar al punto de destino.

Una vez que hemos explicado como se controla el movimiento del lobo pasaremos a explicar los métodos de esta clase.

public cLobo(Image[] Imagenes, float x_cueva,float y_cueva,float x_cent,float

y_cent,int num_img,float avance).

Y x 150 120 130 120 110 120 90 120 70 120 50 120

y X 130 100 130 90 130 80 130 70 130 60 130 50

Tipo de región Tipo de avance Variable sobre la que aplica.

Región 2 negativo y Región 4 negativo x Región 5 positivo x Región 7 positivo y

200

Parámetros: Image[] Imágenes : Arreglo que contiene las imágenes que forman la animación del lobo cuando camina. El orden en que deben introducirse las imágenes en el arreglo es el mismo en el que deben aparecer en la animación (ver Figura 20). float x_cueva y float y_cueva: Estas dos variables forman una coordenada del tipo (x, y), se encuentra dentro de la cueva. A partir de este punto comenzará ha caminar el lobo dando la apariencia de que sale de la cueva. El lobo caminara automáticamente al iniciar el juego hasta el punto indicado por la coordenada (x_cent, y_cent). float x_cent y float y_cent : Estas variables forman un punto hasta el que caminará el lobo automáticamente cada que salga de su cueva. int num_img : Esta variable indica el número de imágenes que integran la animación en la que el lobo camina. float avance: Esta variable indica el número de píxeles que se debe avanzar cada que se muestra una imagen de nuestra animación. Valor de retorno: Ninguno. Objetivo: Este método es el constructor de nuestra clase.

public void CaminaLobo().

Parámetros: Ninguno. Valor de retono: Ninguno. Objetivo: Dentro del objeto lobo1 tenemos variables que indican su posición actual y variables que indican la posición de la próxima imagen a imprimir para dar efecto a la animación del lobo. Con este método modificamos automáticamente las variables que indican la posición de nuestra próxima imagen a imprimirse (x, y) para dar el efecto del lobo caminando. También dentro de este método se rota automáticamente la próxima imagen a mostrar. La rotación de la imagen se hace en base al punto de destino y origen de nuestra animación, estos dos puntos se obtienen automáticamente al dar clic en la pantalla de nuestro applet utilizando los métodos de la clase MouseListener.

public void Sale_cueva().

Parámetros: Ninguno. Valor de retorno: Ninguno: Objetivo: Esta función se usa cuando se quiere dar el efecto en el que el lobo camina saliendo de su cueva, se ejecuta cuando inicia el juego, lo que en realidad hace esta función es modificar el punto (x, y) donde se imprimirá la siguiente imagen del lobo en nuestra animación. La variación de este punto (x, y) se hace en base a dos puntos (uno de origen y uno de destino) que están dentro del objeto cLobo, el punto de origen se encuentra dentro de la área de la cueva y el punto destino se encuentra más o menos a la mitad del ambiente de nuestro juego.

201

Para usar este método se sugiere un ciclo, siguiendo los siguientes pasos:

1.- Aplicar al objeto de la clase cLobo su método Sale_cueva(). 2.- Obtener el siguiente punto donde se imprimirá la siguiente imagen de nuestra animación. 3.-Obtener la siguiente imagen a imprimir, esto aplicando el método Get_ImagLobo a nuestro objeto de la clase cLobo(más adelante explicaremos este método). 4.- Mandar a llamar al método repaint para imprimir nuestra imagen obtenida. Este ciclo se repite mientras el método EstadoLSac() dé cómo resultado verdadero. Ejemplo: lobo1.Habilita_SaleCueva(); While(lobo1.EstadoLSac() == true) { lobo1.Sale_Cueva(); imglobo=lobo1.Get_ImagLobo(); x = lobo1.Get_XL(); y = lobo1.Get_XL(); repaint(); } paint(Graphic g) { g.drawImage(imglobo,x, y, this); }

Este ciclo se repite hasta que el lobo llega a su punto destino, cuanto esto sucede el valor de retorno del método EstadoLSac() es false. La función Sale_Cueva hace automáticamente todos los cambios necesarios para indicar que el lobo ha llegado a su punto de destino, es decir, ha salido completamente de la cueva.

Figura B13. Lobo saliendo de la cueva.

202

public void Entra_Cueva().

Parámetros: Ninguno. Valor de retorno: Ninguno. Objetivo: Este método se usa para dar el efecto en el que el lobo entra a su cueva, no importa desde que lugar esté, esta función calcula una trayectoria sencilla que seguirá para entrar a su cueva. La forma de usar este método es la misma que la explicada para usar el método en el que el lobo entra a su cueva. En el juego indicamos un área sobre la cueva en donde si se hace clic, el lobo entrara a la cueva automáticamente.

A continuación se muestra una trayectoria que el lobo seguiría si se aplica este método.

Figura B14. Lobo entrando a la cueva.

public float Get_xL().

Parámetros: Ninguno. Valor de retorno: Un flotante. Objetivo: Este método se utiliza para obtener la coordenada x del próximo punto donde se imprimirá la siguiente imagen de la animación, este método se utiliza en cualquier animación, ya sea en la que el lobo sale de la cueva, o entra o simplemente esta caminando en el medio ambiente.

public float Get_yL().

Parámetro: Ninguno. Valor de Retorno: Un flotante.

203

Objetivo: Este método se utiliza para obtener la coordenada “y” del próximo punto donde se imprimirá la siguiente imagen de la animación, este método se utiliza en cualquier animación, ya sea en la que el lobo sale de la cueva, o entra o simplemente esta caminando en el medio ambiente.

public boolean EstadoLCa().

Parámetro: Ninguno. Valor de Retorno: True si el lobo esta caminando, es decir si esta activa una animación en la que el lobo camina. False si la animación del lobo cuando camina ha terminado, es decir el lobo esta estático. Objetivo: Este método se utiliza para ver el estado del lobo, mas que nada para llevar un control dentro de la animación. El estado del lobo se pone a true automáticamente cuando tiene un punto de destino a donde llegar y se pone a false automáticamente cuando allegado a su destino. Dentro de la clase cLobo tenemos una cola donde se depositan los puntos de destino del lobo, este método devolverá false hasta que esta cola este vacía.

public boolean EstadoLSaC().

Parámetros: Ninguno. Valor de retorno: True si se debe ejecutar la animación en la que el lobo sale de su cueva, es decir mientras el lobo sale de su cueva esta función retornara true.. Objetivo: Este método se utiliza para llevar el control de la animación en la que el lobo sale de su cueva.

public boolean EstadoLEnC()

Parámetros: Ninguno. Valor de retorno: True si se debe ejecutar la animación en la que el lobo entra en su cueva.

False si el lobo no esta entrando en su cueva. Objetivo: Este método se utiliza para llevar el control de la animación en la que el lobo entra en su cueva.

public Image Get_ImagLobo().

Parámetros: Ninguno. Valor de Retorno: Un objeto de la clase Image, que es la siguiente imagen a mostrar dentro de nuestra animación. Objetivo: Este método sirve para obtener la próxima imagen a mostrar dentro de la animación. No debemos preocuparnos por llevar el control del orden de las imágenes que debemos mostrar, los métodos llevan automáticamente el control, siempre y cuando las imágenes se hayan introducido en el orden especificado en el método constructor de esta clase.

204

public void Inserta_recuadro(float r_x1,float r_y1, float r_x2,float r_y2).

Parámetros: Cuatro variables de tipo entero que denotan dos punto que describen un rectángulo. Valor de retorno: Ninguno. Objetivo: Introducir al objeto de la clase cLobo un recuadro, en el cual al hacer clic con el ratón, el lobo entrará automáticamente a su cueva.

public void CargaImgLobo().

Parámetros: Ninguno. Valor de Retorno: Ninguno. Objetivo: Dentro del objeto de la clase “cLobo” tenemos un objeto de la clase “MediaTracker” en el cual se cargarán todas las imágenes de la animación, es decir , las imágenes que recibe el objeto cuan se inicializa con el constructor de esta clase. Este método carga las imágenes en ese objeto de la clase “MediaTracker” para tenerlas disponibles rápidamente.

public void Set_Lobo(int x, int y).

Parámetros: Dos enteros que forman una coordenada dentro de la pantalla de nuestro applet. Valor de Retorno: Ninguno. Objetivo: Este método se utiliza para integrar a la trayectoria que debe de seguir el lobo, los puntos de destino que se generan con el ratón. Dentro del objeto de la clase cLobo tenemos una cola donde se integran los puntos de destino que forman la trayectoria del lobo, con este método integramos a esa cola los puntos de destino.

public boolean Region5().

Parámetros: Ninguno. Valor de retorno: True si el lobo esta caminando en región 5 y false en caso contrario. Objetivo: Esta función regresa verdadero si el lobo va a entrar a la cueva caminando en región 5, es decir de frente a la cueva.

public void ResetL().

Parámetros: Ninguno. Valor de Retorno: Ninguno. Objetivo: Cuando el lobo se encuentra con una región no valida dentro de su trayectoria, esta se debe desechar y el lobo deberá quedar parado frente al objeto. Mediante esta función se elimina la trayectoria que estaba siguiendo el lobo y se dejan las propiedades del lobo de modo que indiquen que esta quieto sin caminar.

public float Get_xact().

Parámetros: Ninguno. Valor de Retorno: Un flotante que forma parte de un punto (x, y) dentro de

205

nuestro applet. Objetivo: Obtener el valor x de la coordenada que indica la posición del centro de nuestra ultima imagen del lobo con respecto al applet.

public float Get_yact().

Parámetros: Ninguno. Valor de Retorno: Un flotante que forma parte de un punto (x, y) dentro de nuestro applet. Objetivo: Obtener el valor y de la coordenada que indica la posición del centro de nuestra ultima imagen del lobo con respecto al applet.

public void InsertImgLoboPresa(Image[] lobo_presa,int num_ILP).

Parámetros: Un arreglo de imágenes llamado lobo_presa. que contiene las imágenes que se deben utilizar en la animación después de que el lobo ha capturado al conejo. En este caso sólo se utilizan imágenes con el conejo pero si se tienen más animales se utilizarían las imágenes correspondientes al animal que se ha capturado. El entero num_ILP indica el número de imágenes introducidas. Valor de Retorno: Ninguno. Objetivo: Realizar un cambio de imágenes dentro del objeto de la clase cLobo, para que las imágenes que se utilicen en la animación cuando el lobo camina sean cuando carga a su presa. En el juego se utilizan imágenes que representan al lobo caminando con su presa, el conejo.

Figura B14. Imágenes del lobo con su presa.

public void Set_sonidoL(AudioClip son).

Parámetros: Un objeto de clase AudioClip . Valor de Retorno: Ninguno. Objetivo: Cuando el lobo choca con un árbol o con una piedra, este se debe de detener pero tambien se debe de escuchar un sonido que indica un pequeño golpe. Este método introduce en el objeto de la clase cLobo, el sonido que se escuchara cada vez que el lobo choca contra algún obstáculo.

public void Habilita_SaleCueva().


206

Valor de Retorno: Ninguno. Objetivo: Esta función hablita al lobo para salir de la cueva. Si se aplica este método al objeto y después se aplica el método EstadoLSaC() , este regresara verdadero.

prívate int Distancia(int x1,int y1, int x2,int y2).

Parámetros: Cuatro variables de tipo entero que denotan dos puntos del applet. Valor de Retorno: Un entero que indica la distancia entre los dos puntos introducidos. Objetivo: Este método es de uso interno en la clase y calcula la distancia entre los dos puntos que recibe como parámetro.

207

Anexo D. Acrónimos CDROM: Compact Disk Read Only Memory. JPEG: Joint Picture Expert Group 2D: Dos dimensiones URL: Uniform Resource Locator

TESIS LICENCIATURA EN COMPUTACION …148.206.53.84/tesiuami/UAMI11025.pdf2 Agradecimientos Martínez...

Documents

Transcript of TESIS LICENCIATURA EN COMPUTACION …148.206.53.84/tesiuami/UAMI11025.pdf2 Agradecimientos Martínez...