Desarrollo de Juegos de Tablero (6): Control de Partida Eventos Y Observadores

Desarrollo de Juegos de Tablero (6):
Control de Partida:  Eventos Y Observadores

En este artículo describiré la forma de como programar cuando una ficha/personaje llegue a una casilla y que el programa haga algo (mostrar un mensaje, dar una penalización o premio, etc.). Para ello vamos a usar la programación orientada a eventos, mediante el mecanismo de definir eventos y observadores.

 Creo que esta es la forma más genérica de programarlo y que luego admitirá añadirle más cosas o interacciones en el juego, aunque también se podría haber programado usando el Patrón Chain Of Responsibility: Cadena de Responsabilidad

Vamos a la explicación: 

1. Tenemos una clase llamada "Control de partida", que estará observando lo que ocurre en la partida, en este ejemplo va a observar a los jugadores que haya.
Esta clase tiene definido un observador:

Private ObservadorControl As Observer

También tiene un método llamado "addobservador", al que le pasamos un array de jugadores que debe de observar.

Public Sub addObservador(p As Object[])

'En nuestro caso las piezas a vigilar son las piezas de los jugadores
Dim objetoTmp As Object
For Each objetoTmp In p

ObservadorControl = New Observer(objetoTmp) As "Observador"

          Next

End

Ahora queremos que cuando se produzca un evento "_Llegue" de un jugador, aparezca un mensaje en el programa, con el nombre del jugador y la casilla a la que ha llegado. Se programaría asi:

Public Sub Observador_LLegue(jug As Object, NumeroCasilla As Integer)
Dim mensaje As String
'muestro datos del objeto 

mensaje = ("El jugador") & " " & jug.nombre & ", " & ("ha llegado a la casilla nº:") & " " & NumeroCasilla
Message.Info(mensaje)
End

2. Vamos a añadir el código necesario para la clase Jugador.
La clase jugador debe de producir el evento _Llegue, cuando sepa que ha llegado a la casilla.
Para ello tenemos que hacer 3 cosas:
2.1. Definir el evento _llegue

Event LLegue(pieza As Object, NumeroCasilla As Integer)

2.2. Hacer saltar el evento, cuando llegue a la casilla:

Raise Llegue(Me, NumeroCasilla) 'informo de que jugador a llegado a la casilla NumeroCasilla

2.3. ¿Cuando sabe el jugador que ha llegado a la casilla? Bien, eso lo sabe a traves su objeto miPiezaAnimada (de la clase PiezaAnimada). Esta clase en su  método  actualizaPosicion(), sabe cuando ha llegado a la casilla destino y cambia la animación a "miEstado.Parado". Lo que vamos a hacer, es en la parte del jugador:

2.3.1 Observar ese objeto "miPiezaAnimada", añadiendole un observador en el jugador

Public ObservadorCambioAnimacionAParada As Observer

2.3.2 que observe a la animación:

Me.ObservadorCambioAnimacionAParada = New Observer(Me.miPiezaAnimada) As "ObservadorAnimacion"

2.3.3 Y que cuando reciba un evento de miPiezaAnimada (que lo vamos a llamar _LlegadaCasilla), dispare el evento que _Llegue(), para que sea escuchado por el control de juego:

Public Sub ObservadorAnimacion_LLegadaCasilla(NumeroCasilla As Integer)
Raise Llegue(Me, NumeroCasilla)

'informo de que jugador a llegado a la casilla NumeroCasilla

End

2.3.4. Ahora en la clase PiezaAnimada, hay que añadirle:
2.3.4.1 Un evento "_llegadaCasilla"

Event LLegadaCasilla(NumeroCasilla As Integer)

2.3.4.2. Que se dispare cuando llegue a una casilla destino. Eso lo hacemos añadiendo al método actualizaPosicion(), el lanzamiento del evento _LlegadaCasilla:

Public Sub actualizaPosicion()
If casillaFinal = casillaInicial Then Return 'a llegado a la casilla de destino
contadorA += 1

          pto.x = casillaInicialX + difx * contadorA

pto.y = casillaInicialY + dify * contadorA
If casillafinalX = pto.x And casillafinaly = pto.y Then

          casillaInicial = casillaFinalmiEstadoAnimacion.CambioEstado(miEstado.Parado) 

AnimacionTmp = miEstadoAnimacion.animacionActual()

'--------------------------------------------------------------------------

          'lanzar evento de llegada a la casilla destino por parte de la pieza.
          '--------------------------------------------------------------------------

Raise LLegadaCasilla(Me.CasillaActual() + 1)
Endif
End

Resumiendo:
El mecanismo programado funciona así:

• Cuando la clase piezaAnimada llegue a la casilla destino, produce un evento _LlegadaCasilla. 
• Este es escuchado por el jugador, y produce otro evento _Llegue.
• Este evento _Llegue es escuchado por el Control de Juego, que nos muestra un mensaje por pantalla dando el nombre del jugador y de la casilla a la que ha llegado.

Aqui teneis un video mostrando el programa:




Enlace de descarga del código fuente: alojado en drive google


En los  próximos artículos  veremos como implementar las reglas del juego, por ejemplo:
- Cuando llegue a una casilla roja, retroceda 2 casillas
- Cuando llegue a una casilla azul, se haga una pregunta, y si acierta gane 2 puntos.
- el objetivo del juego, será llegar a la casilla 43 ( el tesoro) y mostrar cuantos puntos ha tenido el jugador.

Saludos

Julio