Diseño de Juegos Servidor
Partida.png

Paquete que va estar sólo en el lado del servidor. La idea es proporcionar una base para que los desarrolladores de juegos puedan implementar la lógica del juego en particular que estén desarrollando.

Partida

Clase ABSTRACTA 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.

  • public Partida(IModuloJuegos mJuegos, int idPartida, DatosPartida datos)

Constructora de una partida. Comprueba que los datos de creación sean correctos, lanzando una excepción del tipo IllegalArgumentException en caso contrario.
Las implementaciones de juegos concretos deben proporcionar una constructora con estos mismos parámetros. Dichas constructoras pueden añadir comprobaciones a los datos de la partida adicionales, lanzando excepciones del tipo mencionado en caso de error.

  • 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.

  • public final boolean anadirCliente(int idCliente, java.lang.Object mensaje)

Este método añade un cliente (jugador u observador) a la partida, siempre que éste pueda entrar. Este método no debe redefinirse. Para cambiar las condiciones que permiten a un jugador entrar a una partida, hay que redefinir el método permitirJugador. Si lo que se quiere es realizar alguna acción especial cuando se incorpora un jugador, entonces hay que redefinir el método jugadorAnadido.

  • protected abstract void jugadorAnadido(Jugador jugador)

Este método realiza acciones derivadas de la incorporación de un jugador a la partida. Este método se tiene que implementar para añadir acciones.

  • protected final void clienteAbandona(int idCliente)

Procesa los mensajes que le llegan a la partida indicando que un jugador ha abandonado.
El motivo del abandono ha podido ser voluntario o involuntario.
Este método no debe redefinirse. En su lugar, debe implementarse el método jugadorAbandona para realizar las acciones que provoca el abandono de un jugador.

  • protected abstract 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).
Después de realizarse la llamada a jugadorAbandona, se elimina el jugador de la lista y, si el jugador que ha abandonado sigue siendo el jugador que tiene el turno, entonces se llama a cambioDeTurno para saber de quién es el nuevo turno.

  • public final void aceptarDatos(int idCliente, java.lang.Object datos)

La partida debe almacenar para procesar los datos que reciba.
El objeto que recibe es exactamente el mismo objeto que envió el cliente. Por tanto, el cliente y el servidor de una partida deben conocer el tipo del objeto.
Este método no debe redefinirse.

  • protected abstract void accionesNuevoTurno(Jugador jugadorAnterior, Jugador jugadorNuevo)

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.

  • protected abstract 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 abstract 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 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 jugador)

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

  • protected Jugador siguienteJugador(Jugador jugadorAnterior)

Decide el jugador que jugará el siguiente turno. Esta implementación hace que el orden de juego sea secuencial. Si se quiere definir otro orden, puede redefinirse este método.

  • 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.
Este método no debe redefinirse. Para implementar acciones que deban llevarse a cabo en los cambios de turno, debe implementarse el método accionesNuevoTurno.

  • public void run()

Hilo de un juego. Se limita a leer mensajes en la cola. Si no hay mensajes, el hilo permanece bloqueado.

  • protected final void generarEco(int milisegundos, java.lang.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 abstract void procesarDatos(Jugador jugador, java.lang.Object datos)

Este método recibe un mensaje enviado por un jugador.
Si la variable jugador es null y el evento es "temporizador", el mensaje a procesar es un eco.

  • public final void terminarPartida()

Hace que la partida termine, dejando de proporcionar todos los servicios a los clientes. Este método no debe redefinirse.

  • 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.

  • public final IStation.Modulos.Juegos.Compartido.DatosPartida getDatosPartida()

Devuelve los datos asociados a la partida.

  • protected final Jugador obtenerJugador(int idCliente)

Si existe en la partida un jugador con el idCliente indicado, devuelve el jugador. En caso contrario, devuelve null.

  • protected final boolean estaEnPartida(int idCliente)

Busca entre los jugadores y observadores si existe alguien con el idCliente indicado, e informa del éxito o fallo en la búsqueda.

  • protected final Jugador jugadorActual()

Devuelve el jugador al que le corresponde el turno actual.

  • protected final java.util.Iterator<Jugador> iteradorJugadores()

Devuelve un Iterator que permite recorrer toda la lista de jugadores. El método getListaJugadores permite obtener directamente la lista de jugadores.

  • protected final java.util.List<Jugador> getListaJugadores()

Devuelve una lista con todos los jugadores de la partida.

  • public final int getNumJugadores()

Devuelve el número de jugadores en la partida.

  • public final ILogger getLogger()

Devuelve un objeto que permite guardar un registro de información o de errores.

  • public final boolean partidaIniciada()

Indica si la partida ya ha sido iniciada.

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.

  • public Jugador(int idCliente, IModuloJuegos mJuegos)

Constructora que recibe el entero que identifica al cliente y la instancia del módulo de juegos para tener acceso a los datos del jugador.

  • void enviarMensaje(java.lang.String evento, java.lang.Object msg)

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

  • int getID()

Accesora para saber el ID del jugador.

  • java.lang.String getNombre()

Accesora que devuelve el nombre del jugador.

  • int obtenerPuntos()

Consulta los puntos actuales del jugador.

  • void sumarPuntos(int puntos)

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

  • public void notificarInicio(Jugador jugadorPrimerTurno)

Notifica a un jugador de que la partida ha empezado. Este método debe utilizarse en caso de que un jugador se ha incorporado cuando la partida ya ha sido iniciada.

  • public boolean esCreador()

Indica si el jugador es quien ha creado la partida.

  • public void ponValor(java.lang.String clave, java.lang.Object valor)

Guarda un valor para el jugador, accesible a través de una clave.

  • public java.lang.Object dameValor(java.lang.String clave)

Devuelve un valor del jugador previamente guardado.

IInicioPartida

Esta interfaz sirve para crear clases cuyo objetivo sea crear instancias de una partida concreta.

  • Partida iniciarPartida(IStation.Modulos.Juegos.Compartido.DatosPartida datosPartida,

IModuloJuegos moduloJuegos,
int idPartida)
Crea una nueva partida para un juego concreto.
Recibe los datos de la partida, que envía el applet desde el cliente y la instancia del módulo de juegos que debe tomar cuenta de la partida que se va a crear.

ILogger

Interfaz que permite registrar información de depuración y de errores en un archivo de texto.

  • void escribirInformacion(java.lang.String mensaje)

Escribe una linea de informacion en el Log diario.

  • void escribirError(java.lang.String mensaje)

Escribe una linea de error en el Log diario

  • void escribirExcepcion(java.lang.Exception ex, java.lang.String mensaje)

Escribe una excepcion en el Log diario

IModuloJuegos

Interface del módulo de juegos de cara al exterior. Está implementada en la clase ModuloJuegos que se detalla aqui.