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 mostrar_canje(self,tarjetas,jugador):
"""Muestra por pantalla la tarjetas canejada"""
paises = []
for tipo in tarjetas:
for tarjeta in tarjetas[tipo]:
paises.append(tarjeta.su_pais())
Interfaz.setear_titulo( jugador.su_nombre()+" realizo canje de tarjetas: "+paises[0]+" "+paises[1]+" "+paises[2])
time.sleep(5)
self.tablero.actualizar_interfaz()
def pedir_pais_propio(self, tablero, mensaje): """Recibe una cadena de texto y lo escribe en el titulo. Pide al jugador que seleccione un pais que sea suyo. Si clickea un pais suyo con click izquierdo, devuelve el pais. Si hace click derecho, devuelve None.""" Interfaz.setear_titulo(mensaje) origen, boton = Interfaz.seleccionar_pais() while boton == Interfaz.BOTON_IZQUIERDO and tablero.color_pais(origen) != self.color: origen, boton = Interfaz.seleccionar_pais() if boton != Interfaz.BOTON_IZQUIERDO: return None return origen
def configurar_el_juego(self):
"""Pone a los jugadores en el juego."""
Interfaz.setear_titulo('Configurando el juego')
n = Interfaz.elegir('Jugadores', 'Seleccione el numero de jugadores', range(2,7))
nombre_colores = NOMBRE_COLORES.values()
for i in range(n):
nombre = Interfaz.elegir('Jugador %d' % (i + 1), 'Ingrese el nombre del jugador %d' % (i + 1))
color = Interfaz.elegir('Jugador %d' % (i + 1), 'Ingrese el color del jugador %d' % (i + 1), nombre_colores)
nombre_colores.remove(color)
c = NOMBRE_COLORES.keys()[NOMBRE_COLORES.values().index(color)]
self.jugadores.append(Jugador(c, nombre))
def repartir_paises(self):
"""Reparte en ronda las tarjetas de paises y pone un ejercito
en cada uno de los paises."""
Interfaz.setear_titulo('Repartiendo paises iniciales')
ntarjetas = self.mazo.cantidad_tarjetas()
njugadores = len(self.jugadores)
for jugador in \
self.jugadores * (ntarjetas / njugadores) + \
random.sample(self.jugadores, ntarjetas % njugadores):
t = self.mazo.sacar_tarjeta()
self.tablero.ocupar_pais(t.pais, jugador.color, 1)
self.mazo.devolver_tarjeta(t)
def atacar(self, tablero):
"""Le pide al usuario que ingrese un par de paises para
realizar un ataque. Devuelve None si el jugador no quiere
atacar y un par (atacante, atacado) en caso contrario."""
while True:
Interfaz.setear_titulo('%s ataca. Seleccionar atacante' % self)
atacante, boton = Interfaz.seleccionar_pais()
while boton == Interfaz.BOTON_IZQUIERDO and (tablero.color_pais(atacante) != self.color or tablero.ejercitos_pais(atacante) == 1):
atacante, boton = Interfaz.seleccionar_pais()
if boton != Interfaz.BOTON_IZQUIERDO:
return None
Interfaz.setear_titulo('%s ataca. Seleccionar pais atacado por %s' % (self, atacante))
atacado, boton = Interfaz.seleccionar_pais()
while boton == Interfaz.BOTON_IZQUIERDO and (tablero.color_pais(atacado) == self.color or not tablero.es_limitrofe(atacante, atacado)):
atacado, boton = Interfaz.seleccionar_pais()
if boton != Interfaz.BOTON_IZQUIERDO:
continue
return (atacante, atacado)
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)
def mostrar_canje_pais(self,pais,jugador):
"""Muestra por pantalla el pais canejado"""
Interfaz.setear_titulo("%s realizo canje: %s" % (jugador.su_nombre(),pais))
time.sleep(5)
self.tablero.actualizar_interfaz()
