def jugar(self):
Interfaz.setear_titulo('Trabajo de Entrega Grupal')
Interfaz.alertar('Bienvenido!', 'Bienvenido al Trabajo de Entrega Grupal')
# Se selecciona el numero de jugadores y se crean los mismos:
self.configurar_el_juego()
# Se reparten los paises iniciales:
self.repartir_paises()
self.tablero.actualizar_interfaz()
# Se sortea que jugador iniciara el juego:
inicia_ronda = random.randrange(len(self.jugadores))
Interfaz.setear_texto("Ronda: %s" % self.texto_ronda(inicia_ronda))
# Primer refuerzo de ejercitos:
self.agregar_ejercitos_inicial(inicia_ronda)
# Bucle principal del juego:
while Interfaz.esta_corriendo():
# Para cada jugador en la ronda:
for i in range(len(self.jugadores)):
jugador = self.jugadores[(inicia_ronda + i) % len(self.jugadores)]
# El jugador puede haber muerto durante esta ronda:
if not self.jugador_esta_vivo(jugador):
continue
# El jugador juega su fase de ataques:
paises_ganados = self.realizar_fase_ataque(jugador)
# Se verifica si gano el juego:
if self.jugador_es_ganador(jugador):
Interfaz.alertar('Hay ganador!', 'El jugador %s ha ganado el juego' % jugador)
return
# El jugador realiza sus reagrupamientos:
self.realizar_fase_reagrupamiento(jugador)
# Se entrega la tarjeta y se verifica si ocupa
# algun pais del cual posee tarjeta.
self.manejar_tarjetas(jugador, paises_ganados)
# Si algun jugador hubiera perdido durante la ronda
# anterior se lo saca del juego:
for i in range(len(self.jugadores) - 1, -1, -1):
if not self.jugador_esta_vivo(self.jugadores[i]):
Interfaz.alertar('Uno menos!', 'El jugador %s ha quedado eliminado' % jugador)
self.jugadores.pop(i)
if inicia_ronda >= i:
inicia_ronda -= 1
# La siguiente ronda es iniciada por el siguiente jugador:
inicia_ronda = (inicia_ronda + 1) % len(self.jugadores)
Interfaz.setear_texto("Ronda: %s" % self.texto_ronda(inicia_ronda))
# Los jugadores refuerzan sus ejercitos:
self.agregar_ejercitos(inicia_ronda)
def agregar_ejercitos_inicial(self, inicia_ronda):
"""Realiza la primer fase de colocacion de ejercitos."""
Interfaz.setear_titulo('Incorporando ejercitos')
ejercitos_primera = int(math.ceil(self.tablero.cantidad_paises() / 10.0))
ejercitos_segunda = int(math.ceil(self.tablero.cantidad_paises() / 20.0))
for cantidad in (ejercitos_primera, ejercitos_segunda):
for i in range(len(self.jugadores)):
jugador = self.jugadores[(inicia_ronda + i) % len(self.jugadores)]
Interfaz.alertar(jugador, '%s pone ejercitos' % jugador.nombre)
# cantidad de ejercitos
#en cualquier continente
ejercitos = jugador.agregar_ejercitos(self.tablero, {"": cantidad})
#print(sum(ejercitos.values()))
#print(cantidad)
assert (sum(ejercitos.values()) == cantidad)
for pais in ejercitos:
assert (self.tablero.color_pais(pais) == jugador.color)
self.tablero.asignar_ejercitos(pais, ejercitos[pais])
self.tablero.actualizar_interfaz(self.tablero.paises)
def realizar_fase_ataque(self, jugador):
"""Implementa la fase de ataque de un jugador.
Sucesivamente hace combatir a los paises seleccionados.
Devuelve el numero de paises conquistados."""
Interfaz.setear_titulo('%s ataca' % jugador)
Interfaz.alertar(jugador, '%s ataca' % jugador)
paises_ganados = 0
while True:
ataque = jugador.atacar(self.tablero)
if not ataque:
break
atacante, atacado = ataque
assert (self.tablero.es_limitrofe(atacante, atacado))
assert (self.tablero.ejercitos_pais(atacante) > 1)
self.dados.lanzar_dados(self.tablero.ejercitos_pais(atacante), self.tablero.ejercitos_pais(atacado))
self.tablero.asignar_ejercitos(atacante, -self.dados.ejercitos_perdidos_atacante())
self.tablero.asignar_ejercitos(atacado, -self.dados.ejercitos_perdidos_atacado())
Interfaz.setear_titulo('%s: -%d, %s: -%d %s' % (
atacante, self.dados.ejercitos_perdidos_atacante(), atacado, self.dados.ejercitos_perdidos_atacado(),
self.dados))
if self.tablero.ejercitos_pais(atacado) == 0:
paises_ganados += 1
mover = Interfaz.elegir(jugador, 'Cuantos ejercitos se desplazan a %s?' % atacado,
range(1, min(self.tablero.ejercitos_pais(atacante) - 1, 3) + 1))
self.tablero.asignar_ejercitos(atacante, -mover)
self.tablero.ocupar_pais(atacado, jugador.color, mover)
self.tablero.actualizar_interfaz(self.tablero.paises)
else:
self.tablero.actualizar_interfaz(self.tablero.paises)
time.sleep(5)
return paises_ganados
def realizar_fase_reagrupamiento(self, jugador):
"""
Realiza el reagrupamiento de ejercitos.
"""
Interfaz.setear_titulo('%s reagrupa' % jugador)
Interfaz.alertar(jugador, '%s reagrupa' % jugador)
lista = jugador.reagrupar(self.tablero)
# Se fija que el reagrupamiento sea consistente:
salientes = {}
for origen, destino, cantidad in lista:
assert(self.tablero.es_limitrofe(origen, destino))
assert(self.tablero.color_pais(origen) == jugador.color)
assert(self.tablero.color_pais(destino) == jugador.color)
salientes[origen] = salientes.get(origen, 0) + cantidad
for pais in salientes:
assert(self.tablero.ejercitos_pais(pais) > salientes[pais])
# Aplica la lista de cambios:
for origen, destino, cantidad in lista:
self.tablero.asignar_ejercitos(origen, -cantidad)
self.tablero.asignar_ejercitos(destino, cantidad)
