Bienvenidos!

------------------------------------------------JAVA II  EN PROCESO---- ------------------------------------

Carun - Game

Hola gente a continuación les traigo el código de un juego, junto con su diagrama de clases y una presentación del juego que yo lo nombre Carun - Game y es para 2 jugadores, es parecido a 100 mexicanos dijeron pero con algunas reglas diferentes, este juego esta creado en Java.

simplemente utilizando: 

- Sockets: Para crear un cliente y un servidor

- Thread: Que actúa como el interprete  

- Interfaces: que son las encargadas de pasar la información de un usuario al otro

Primero comenzare publicando mi prototipo del juego que realice en WireFrame que me ayudo mucho para poder terminar mi juego, bueno aqui lo tienen.

La primer pantalla que aparece al correr el juego es la siguiente que te pregunta cual es tu nombre de usuario  y lo ingresas.

Despues de ver ingresado tu nombre de usuario te aparecera la ventana que contiene la informacion del modo de juego y ya que comprendas el juego pulsas el boton de iniciar.

Ya que estas listo y pulsas el boton iniciar te aparece el siguiente mensaje

Cuando ambos jugadores estan listos y los dos dieron clic en iniciar comienza el juego y aparece el boton "ok" y "responde" si ganas el clic en el boton "ok" para responder.

Si tu ganas ah presionar "ok" tu tablero se mirara como la imagen de arriba y al otro jugador lo mirara así como la imagen de abajo y no podrá responder asta que el otro jugador se falle en su respuesta.

Ya que alguno de los jugadores consiga los 500 puntos les aparecerá los siguientes mensajes:

Derrota: al jugador que no cumpla con los 500 puntos

 Victoria: si conseguiste los 500 puntos o si el otro jugador abandona la partida durante el proceso del juego también te aparecerá victoria ya que ganaras automáticamente.

Ya que das clic en "ok" en el mensaje de victoria o derrota, les aparecerá   este mensaje a cada jugador si le das clic en que si quieres jugar otra partida, se actualizara el mensaje y ahora dira "esperando al otro jugador".

En el caso de que el jugador no acepte jugar otra partida va aparecer el siguiente mensaje:

A qui les dejo un video mostrando como se juega y pues mostrando cual es el juego del que les hablo en este post del blog!
si les gusta abajo esta el codigo del juego




A qui les dejo el diagrama de arquitectura explicando un poco como esta conformado el juego y con que clases cuenta para poder hacer la comunicación entre los usuarios a través de un interprete y maquina de estados.

Clase	Capa	Referencia
Usuario	Chat	Envía el nombre de usuario al otro jugador para diferenciarse en el chat.
Interfas	Engine	En esta clase depende de lo que le mande el intérprete cambiara el estado del juego o el del chat
Pregun	Juego	Es una interfaz que se encarga de cambiar la pregunta que están resolviendo los jugadores
Responde	Juego	Es una interfaz que diferencia que jugador es el que puede responder la pregunta y si este se equivoca pasara el turno al otro jugador
Cliente	Cliente	Cliente  es la salida de la arquitectura ya que esta se encarga de mandar los mensajes
Server	Servidor	Representa el escuchador de mensajes en nuestra arquitectura, esta es la entrada.
Interprete	Interprete	Interprete es el intérprete que recibe el mensaje del cliente y él se encarga de diferenciar si es un mensaje para el chat o para cambiar el estado del juego
Carun	Engine	Es la primer pantalla que aparece donde registra tu usuario que se usara en la partida
Client	Juego	Es parte de la ejecución del juego, donde se realizan todas las actividades. Es el que se comunica con el intérprete para cambiar el estado del chat o del juego
PreInicio	Engine	Te muestra el modo de juego y si estás listo para comenzar, inicias el juego
Victoria	Engine	Cuando un jugador cumple con los puntos que se piden para ganar aparecerá un mensaje dándole la victoria o la derrota
Maquina	Juego	Maquina de estados es la que se encarga de realizar todas las ejecuciones del juego y mantiene comunicación con el interprete

Para comprender mas claro como esta estructurado el juego a continuacion les dejo el diagrama de clases para ver si les sirve un poco para entender el juego

A continuación les proporciono el código del juego.

Esta clase es la que contiene el primer objeto y es con la que se ejecuta el juego como su nombre lo indica.

--------------------- Clase Ejecutable ---------------------



Carun: es una clase que imprime el inicio del juego donde ingresas tu nombre de usuario para el juego
--------------------- Clase Carun --------------------------



PreInicio: es la clase que te mostrara como jugar y cuando estés listo pulsas "iniciar" y podrás iniciar a jugar cuando ambos jugadores estén listos

--------------------- Clase PreInicio ------------------------



La clase que esta aquí abajo es la vista donde se encuentra todo el proceso del juego y la que mantiene comunicación con el interprete y la maquina de estados, una de las clases mas importantes

----------------------- Clase Client ------------------------



La clase Victoria: es la que contiene se llama cuando algún jugador gana o pierde la partida

--------------------  Clase Victoria ------------------------




Estas son las interfaces que se utilizan para el intercambio de datos entre un usuario y el otro

--------------------- Interface Interfaz ---------------------



-------------------- Interface Pregun -----------------------



-------------------- Interface Responde ---------------------



--------------------- Interface Usuario ------------------------



Esta es la clase cliente que es la que se encarga de mandar el mensaje que emitirá el usuario

--------------------- Clase Cliente ----------------------------



A continuación este es el código del cliente que es donde los usuarios se conectan a través de el se comunican

---------------------- Clase Server --------------------------



EL interprete es el encargado de distinguir entre todos los mensajes que envía el cliente hacia donde debe dirigirte su mensaje entre todas las opciones del juego

------------------------ Clase Interprete -----------------------



La maquina de estados es donde se llevan acabo todos los procesos del juego como operaciones y entre otras cosas, se podría decir que es una de las clases mas importantes en el juego para su ejecucion

----------------------- Clase Maquina --------------------------

Chat Utilizando Sockets

Este código es para un chat trabajando con socket, utilizando una clase clientes y un servidor solo funciona para dos personas, corres el mismo programa 2 veces solo le cambias la ruta en vez de 9000 la cambias a 9001 del cliente y del servidor solo invierte las y listo..

Clase vistaChat



Clase client 



Clase Interfaz

Se encarga de mandar el mensaje al otro cliente por medio de la interfaz



Clase Cliente

Se encarga de enviar el mensaje por medio del socket al servidor por medio de un puerto y una ruta



Clase Servidor



Clase Thread

Relación entre clases

Asociación

_________________

Una asociación es una relación estructural que describe una conexión entre objetos.

Agregación y composición

Agregación: Las partes pueden formar partes de distintos agregados.
Composición: Las partes solo existen asociadas al compuesto (solo se accede a ellas a travez del compuesto).

ej:


Dependencia

------------->
Relación (mas débil que una asociación) que muestra la relación entre un cliente y un proveedor de un servicio usado por un cliente.

     Cliente: Es el objeto que solicita un servicio.
     Servidor: Es el objeto que provee el servicio solicitado.

ej:


Generalización y especificación 

La generalización y especificación permiten reflejar el hecho de que hay una entidad general, que denominamos entidad superclase, que se puede especializar en subclases:
a) la entidad subclase nos permiten  modelizar las caracteristicas propias de sus especializaciones.
b) Las entidades subclase nos permiten modelizar las características propias de sus especializaciones.
Es necesario que se cumpla que toda ocurrencia de una entidad subclase sea también una ocurrencia de su entidad superclase.

Filósofos Comensales

Este programa representa la vieja historia de los filósofos comensales que son 5 filósofos y cada uno cuenta con un tenedor, los 5 están hambrientos pero solo pueden comer el que tenga 2 tenedores en sus manos, si no los tiene tendrá que esperar a que liberen el tenedor que este a su lado.

Enseguida les mostrare el diagrama de clases espero puedan entender un poco mejor el codigo con lo siguiente:

A continuación les presento las clases con algunos comentarios para que puedan entenderlo mejor gracias:

---------------------------------- Clase Tenedor ----------------------------------







---------------------------------- Clase Filosofo ----------------------------------






---------------------------------- Clase Comensales ----------------------------------

Productor // Consumidor

Este es un ejemplo donde se muestra el funcionamiento de  thread, utilisando 1 consumidor y un productor  como ejemplo, notify(), wait(), sleep(), y metodo synchronized con get() y put().

espero este claro el ejemplo y lo puedan entender con los comentarios que le puse!

--------------------------------- Clase  CubbyHole ---------------------------------

--------------------------------- Clase Consumidor ---------------------------------

--------------------------------- Clase  Procuctor ---------------------------------

--------------------------------- Clase ProducerConsumerTest ---------------------------------

Cronometro Fail

                                                     Clase Vista

Esta es la clase vista que tiene errores uno de los errores que mire aqui cuando
lo corro me sale un " Exception in thread "main" java.lang.StackOverflowError "
y si quito mi objeto de tipo logica ya me abre la ventana de la vista!!

-------------------------------------------------------------------------------------------------------------------------

-------------------------------------------------------------------------------------------------------------------------

                                                   

                                                     Clase Logica