Manual del Desarrollador de Juegos Parte Compartida y Servidor Requisitos



Descargar 143,08 Kb.
Fecha de conversión21.07.2017
Tamaño143,08 Kb.


Manual del Desarrollador de Juegos
Parte Compartida

y

Servidor



Requisitos


  • Tener instalado un entorno de desarrollo (IDE) para JAVA (NetBeans, Eclipse, JBuilder, y otros) con el último Java Development Kit (JDK) instalado.
    Nosotros pondremos como ejemplo el IDE desarrollado por Sun bajo licencia GPL, NetBeans 6.0.

  • Conocimientos de programación orientada objetos en un nivel medio.

  • Conocimiento del lenguaje de programación Java y su modelo de eventos en un nivel medio.


Descargas
El software requerido se puede descargar gratuitamente de los sitios de Internet que a continuación se detallan.
NetBeans:

http://download.netbeans.org/netbeans/6.0/final/
Eclipse:

http://www.eclipse.org/downloads/


JDK:

http://java.sun.com/javase/downloads/


Parte Compartida

Parte de clases que estarán disponibles a la hora de crear un juego, la funcionalidad principal radica clases envoltorio para el envío de mensajes y configuración de la partida.


Este paquete se supone deberá cargarse en el ambos puntos de la aplicación, servidor y cliente.
Clases a implementar
La única clase que es obligatorio implementar para este proyecto es:

  1. Una clase que extienda DatosPartida.


Clase DatosPartida
Esta clase abstracta sirve para que el applet que crea la partida envíe al servidor los datos básicos de la partida, que son los que van a quedar reflejados en la Base de Datos.

Para cada juego, se extenderá esta clase, agregando los datos que se precisen (ej: tiempo máximo de turno) y definiendo el método abstracto getNombreJuego.




public abstract java.lang.String getNombreJuego()

Método que devuelve el nombre del juego (que debe ser ÚNICO) para que el ModuloJuegos haga la carga dinámica correspondiente del juego.

El resto de la clase tiene los campos de datos públicos que representan lo que indican sus nombres:



boolean _entrarAMitad
int _maxJugadores
int _minJugadores
int _nivelMax
int _nivelMin
boolean _observable //si permite observadores
boolean _privada
Clase MensajePartida
Clase para englobar los mensajes que envía una partida.

public MensajePartida(java.lang.String evento, java.lang.Object datos)

Constructora de MensajePartida. Que tendrá un String que será la descripción del tipo de mensaje y un Object que será el mensaje concreto.


Clases propias del juego
En este proyecto también se deberán incluir el resto de clases que sean necesarias en ambas partes del juego (servidor y cliente).

Por ejemplo si decidimos hacer una clase envoltorio que agrupe todos los datos que incluirá un mensaje, para usarla para el pasaje de datos, debe estar aquí.


Parte Servidor


Instrucciones a la hora de crear un juego
El framework del servidor permite controlar el curso de la partida, obteniendo información de los clientes y notificándoles de los hechos que ocurren en dicha partida. Las acciones de la partida están dirigidas por eventos, ya sean éstos la llegada de un mensaje por parte de un cliente, o el transcurso de determinado período de tiempo.
Clases a implementar
Para implementar el controlador (servidor) de una partida, es necesario crear (como mínimo) las siguientes clases:

  1. Una clase que implemente IInicioPartida.

  2. Una clase que extienda (herede) la clase abstracta Partida.

Estas clases se encuentran el la librería JuegosServidor.jar, que se debe importar en el proyecto (como se explicó en la introducción del tutorial).

También es necesario implementar la librería: JuegosComun.jar.
Manifest
El módulo de juegos necesita ciertos datos de los proyectos para poder hacer la carga dinámica y actualizar la información en la base de datos.

Los atributos que se deben agregar al archivo MANIFEST.MF que está en el directorio del proyecto son:



  1. ClaseInicio: Nombre completo de la clase iniciadora para la partida (incluyendo el paquete). Recordamos que esta clase es la que implementa la interfaz IInicioPartida.

  2. NombreJuego: Nombre del juego que se mostrará tal cual en el portal web. Debe coincidir con el valor devuelto por el método de DatosPartida.

  3. RutaJar: Ruta del archivo JAR (binario) del applet cliente en el servidor web.

  4. ClaseJuego: Nombre y ruta de la clase que extiende JuegoAbstracto en el cliente.

  5. Tipo: Por ahora los tipos contemplados son "cartas", "tablero", "otros".

  6. RutaFoto: Ruta de la imagen en el servidor que se mostrará en el portal web.

Si en el directorio del proyecto no existe ningún archivo llamado MANIFEST.MF, debe crearse un archivo de texto con este nombre y el contenido descrito. También hay que asegurarse que el archivo llamado project.properties dentro de la carpeta nbproject tiene una línea con el siguiente texto:

manifest.file=MANIFEST.MF
Ejemplo con el Servidor de la PatataCaliente

ClaseInicio: IStation.Modulos.Juegos.Servidor.PatataCaliente.InicioPatataCaliente

NombreJuego: Patata Caliente

RutaJar: juegos/patata/JuegosClientePatataCaliente.jar

ClaseJuego: IStation.Cliente.Juegos.PatataCaliente.JuegoPatataCaliente

Tipo: otros

RutaFoto: img/Patata.jpg


Incluir una descripción del juego
La idea es que en el portal se muestre una breve descripción del juego para tener una idea general de qué va.

El portal va a acceder a dicha descripción a través de la base de datos. El encargado de poner dicha información en la BBDD es el ModuloJuegos que va a leer del archivo JAR que se encuentra en el servidor un fichero que se encuentra en la ruta "/IStation/Descripcion.txt".



Aquí se muestra una imagen del proyecto JuegosServidorPatataCaliente en donde se puede apreciar donde va ubicado el archivo de descripción.


Se puede ver el archivo dentro del paquete IStation.

Clase Jugador
Esta clase proporciona la funcionalidad para tratar un jugador. Permite realizar acciones sobre los jugadores tales como enviar mensajes o alterar el número de puntos.

Los métodos útiles de la clase para un desarrollador son los siguientes:




public java.lang.String getNombre()

Accesora que devuelve el nombre del jugador.




public int obtenerPuntos()

Consulta los puntos actuales del jugador.




public void sumarPuntos(int puntos)

Suma a los puntos del usuario (jugador) una cantidad de puntos.



public void enviarMensaje(String evento, Object msg)

Envía un mensaje (se envuelve con un MensajePartida).



Clase que implementará IInicioPartida
Esta interfaz tiene sólo un método tipo factoría que lo que hace es proporcionarnos una nueva instancia de una partida concreta.
El prototipo de la función es el siguiente:

public Partida iniciarPartida(DatosPartida datos,

IModuloJuegos modJuegos, int idPartida)


Evidentemente lo que vamos a devolver será una instancia de una partida concreta (una clase que extiende a Partida) y el parámetro datos será de clase que extienda a DatosPartida, como se explicó en la sección anterior.


Clase que extenderá a Partida
La clase ABSTRACTA Partida, es la que proporciona la funcionalidad común para todas las partidas (en el lado del servidor).

Esta clase deberá extenderse para crear las partidas de los juegos concretos.

La clase partida se comunica con el Módulo de Juegos a través de la interfaz IModuloJuegos. Sin embargo, toda la interacción con el Módulo de Juegos es transparente al desarrollador de juegos.



Hay métodos que se pueden redefinir y otros que no, éstos son los que llevan el modificador final en su cabecera.
Métodos que se tienen que implementar obligatoriamente


protected void accionesInicioPartida()

En este método deben llevarse a cabo las acciones derivadas del inicio de la partida. Estas acciones serán llevadas a cabo justo después de que la partida haya iniciado.




protected void accionesFinPartida()

En este método deben llevarse a cabo las acciones derivadas de la finalización de la partida. Estas acciones serán llevadas a cabo justo antes de que la partida termine.




protected void jugadorAnadido(Jugador jugador)

Este método realiza acciones derivadas de la incorporación de un

jugador a la partida.

Aquí se deben implementar para añadir las acciones oportunas.




protected void jugadorAbandona(Jugador jugador)

Este método realiza acciones dependientes de la partida concreta cuando un jugador abandona la misma. El motivo del abandono ha podido ser voluntario (por ejemplo, el usuario ha cerrado la ventana del juego) o involuntario (por ejemplo, por desconexión de la red).

Se recibe por parámetro el jugador que ha abandonado.




protected void accionesNuevoTurno(Jugador jAnterior, Jugador jNuevo)

Este método realiza las acciones que provoca un cambio de turno. Cuando este método se llama, todos los clientes ya han sido informados del cambio de turno, luego los mensajes que se envíen en este método llegarán después de dicha información.

Parámetros: jugador anterior y jugador nuevo (el que tiene el turno)




protected void procesarDatos(Jugador jugador, String evento, Object datos)

Este método recibe un mensaje enviado por un jugador. Si la variable

jugador es null y el evento es “temporizador", entonces el mensaje a procesar es un eco.



Métodos que se pueden sobrescribir
Si las acciones que proporcionan no son las deseadas para el juego que se esté desarrollando, esta es la lista de métodos que se pueden sobrescribir para cambiar su funcionalidad:


protected boolean permitirJugador(Jugador jugador)

Este método debe devolver un valor booleano que indique si un jugador (solicitante) puede entrar en la partida. Redefinir esta función permitirá añadir condiciones particulares para entrar en la partida concreta.




protected Jugador jugadorInicial()

Decide el jugador que comienza la partida. Por defecto, elegirá el jugador que creó la partida. Si se desea cambiar el jugador inicial, puede redefinirse este método.




protected boolean permitirIniciarPartida(Jugador jug)

Decide si el jugador puede iniciar la partida. Por defecto, solamente el creador de la partida puede iniciarla.




protected Jugador siguienteJugador(Jugador jAnterior)

Decide el jugador que jugará el siguiente turno. Esta implementación hace que el orden de juego sea secuencial y circular según el orden de entrada a la partida.

Si se quiere definir otro orden, puede redefinirse este método.



Métodos que NO se podrán sobrescribir
Hay métodos que están declarados como final en la clase Partida. Se adjunta la descripción de sus funcionalidades.


public final void terminarPartida()

Hace que la partida termine, dejando de proporcionar todos los servicios a los clientes.




protected final void difundirMensaje(java.lang.String evento, java.lang.Object datos)

Envía un mensaje a todos los observadores y jugadores.

Ésta es la única manera de enviar mensajes a los observadores, de manera que no es posible enviar información a los observadores sin que sea enviada también a todos los jugadores.






protected final Jugador jugadorActual()

Devuelve el jugador al que le corresponde el turno actual.




protected final java.util.List getListaJugadores()

Devuelve una lista con todos los jugadores de la partida.




protected final void generarEco(int milisegundos, Object datos)

Genera un mensaje con los datos pasados por parámetro que será enviado de vuelta a la partida transcurrido el tiempo establecido.




protected final void cambioDeTurno(Jugador jugador)

Este método se llama cada vez que un jugador solicita el fin de su turno. Se comprueba que el jugador que lo solicita estuviese en posesión del turno, y utiliza el método siguienteJugador para averiguar el siguiente jugador que comenzará su turno.

Este método también puede ser llamado desde otro método de esta misma clase para forzar el fin de turno de un jugador. Para implementar acciones que deban llevarse a cabo en los cambios de turno, debe implementarse el método accionesNuevoTurno.




Desarrollando un juego



Concepto del juego
Vamos a poner como ejemplo de desarrollo un juego sencillo, La Patata Caliente. Este juego consiste en pasar el turno (la patata) al siguiente jugador sin que se acabe el tiempo de la partida con la patata en tu poder.

Cuando el tiempo de la ronda (que se decide de forma aleatoria en el servidor) se acaba el jugador que está en posesión del turno pierde.



Parte Común
Para realizar la parte común hay que seguir los pasos que se indicaron en la parte correspondiente de este manual.

En resumen, estos eran:



  1. Crear un proyecto que se llamara JuegosComunPatataCaliente.

  2. Importar como biblioteca JAR el archivo JuegosComun.jar.

  3. Crear una clase que extienda a DatosPartida e implemente su método abstracto getNombreJuego.

Entonces, creamos la clase DatosPatataCaliente con el siguiente método:


/**

* Permite acceder al nombre del juego

* @return Cadena de caracteres que representa el nombre del juego

*/

public String getNombreJuego() {



return “Patata Caliente”;

}
Y un constructor por defecto que nos facilitará el ingreso de los datos de la partida.


/**

* Crea una instancia de DatosPatataCaliente con un número de jugadores dado

* @param numJug : Numero maximo de jugadores permitidos

*/

public DatosPatataCaliente(int numJug) {

_maxJugadores= numJug;

_entrarAMitad= false;

_minJugadores= 1;

_nivelMax= Integer.MAX_VALUE;

_nivelMin= 0;

_observable= false;

_privada= false;

}
Con esta clase la parte común ya está lista, dado que no vamos a pasar mensajes de otro tipo. Ya podemos empezar con la parte servidor.



Parte Servidor
Para realizar la parte común hay que seguir los pasos que se indicaron en la parte correspondiente de este manual.

En resumen, estos eran:



  1. Crear un proyecto que se llamara JuegosServidorPatataCaliente.

  2. Importar como biblioteca JAR el archivo JuegosComun.jar.

  3. Importar como biblioteca JAR el archivo JuegosComunPatataCaliente.jar.

  4. Importar como biblioteca JAR el archivo JuegosServidor.jar.

  5. Incluir un TXT con la descripción del juego.

  6. Crear un fichero MANIFEST.MF

  7. Crear una clase que extienda a Partida e implemente sus métodos abstractos.

  8. Crear una clase iniciadora que implemente la interfaz IInicioPartida



Interfaz iniciadora
Creamos una clase dentro del paquete IStation.Juegos.PatataCaliente.Servidor:

public class InicioPatataCaliente implements IInicioPartida {
public Partida iniciarPartida(DatosPartida datos,

IModuloJuegos mJuegos,



int idPartida) {

return new PartidaPatataCaliente(mJuegos,

idPartida,

(DatosPatataCaliente)datos);

}

}




Clase que implementa el servidor
La constructora de la clase, simplemente se limita a pasar los parámetros a su súper clase (Partida).
public PartidaPatataCaliente(IModuloJuegos mJuegos,

int idPartida,

DatosPatataCaliente datos) {

super(mJuegos,idPartida,datos);

}

Vamos a analizar los métodos que hay que implementar obligatoriamente:
Cuando un jugador se una a la partida no hay que hacer nada para este juego, el framework ya se encarga de mantenerlo en una lista, para saber que está unido a la misma.

La misma situación se produce cuando un jugador abandona una partida, no tenemos que hacer nada. Es cierto que podríamos haber optado por penalizar al jugador y restarle puntos por abandonar el juego antes de finalizar (para esto bastaría con agregar una línea de código.


protected void jugadorAnadido(Jugador jugador) { }
protected void jugadorAbandona(Jugador jugador) {

//posible acción

// jugador.sumarPuntos(-1);

}

Dado que el tiempo que va a estar circulando la patata es aleatorio, cuando se da comienzo a la partida, calculamos el tiempo en segundos que queremos que dure la partida, o lo que es lo mismo que la patata esté circulando.



Y cuando la partida acabe no tendremos que realizar ninguna acción particular.
protected void accionesInicioPartida() {

int tiempoPartida = (int)(java.lang.Math.random()*50+10)*1000;

//Ejemplo de uso del módulo de LOG

getLogger().escribirInformacion( "Tiempo: " +

(tiempoPartida/1000) +" segundos");

//Genero un Eco para recibir un mensaje cuando

//haya transcurrido el tiempo de la partida



this.generarEco(tiempoPartida, null);

}
protected void accionesFinPartida() { }


Los mensajes de paso de turno los administra el framework de modo que no tenemos que preocuparnos por los mismos. Desde los clientes no nos llegarán mensajes, por tanto el único tipo de mensaje que nos queda por procesar en el del ECO, que generamos cuando se inicia la partida.


protected void procesarDatos(Jugador jugador, String evento,

Object datos) {


if(evento != null && evento.equals(TEMPORIZADOR)) {

//Uso del LOG

getLogger().escribirInformacion("Se acabó el tiempo");

//Envío mensaje a todos los jugadores,

//indica que se acabó el tiempo

difundirMensaje("tiempo", null);


Iterator it = getListaJugadores().iterator();

while(it.hasNext()) {

Jugador jugAux = it.next();

//Ganan todos los jugadores que no tengan la patata

if(!jugAux.equals(jugadorActual())) {

jugAux.sumarPuntos(1);

}

}

//Llamo al framework para dar la partida por finalizada



terminarPartida();

}

}



Por último nos queda ver que hacer cuando un jugador toma posesión del turno. Como el framework se encarga de registrar este evento, y registrar qué jugador tiene el turno, no haremos nada cuando pase el turno.
protected void accionesNuevoTurno(Jugador jugadorAnterior,

Jugador jugadorNuevo) { }


Este era el último método que teníamos que implementar obligatoriamente. Con lo cual ya hemos terminado.
Si quisiéramos cambiar el comportamiento por defecto del framework tendríamos que sobre escribir los métodos permitirJugador, jugadorInicial, siguienteJugador o permitirIniciarPartida.
El equipo de IStation espera que manual te haya sido útil, si tienes cualquier tipo de duda, entra a la sección del portal web dedicada a los desarrolladores, o al foro.



IStation Página /


La base de datos está protegida por derechos de autor ©absta.info 2016
enviar mensaje

    Página principal