Exemplo n.º 1
0
	def quiero_atacar(self, tablero, origen, destino):
		""" Informa si el pais de destino es una buena opcion para atacar.
		Esto dependera de muchos factores:
			Si tenemos suficientes paises para agarrar tarjeta
			Las probabilidades de conquistar el pais enemigo
			Las probabilidades de hacerlo con ayuda aliada
			El riesgo en que quedara nuestro pais a ataques enemigos
			
		"""
		# Ejercitos de paises
		atacante = tablero.ejercitos_pais(origen)
		atacado = tablero.ejercitos_pais(destino)
		if atacante == 1: return False

		# En casos extremos no hace falta usar el modulo de probas
		# Victoria muy probable, con el doble de ejercitos + 1
		if atacante >= 2*atacado + 1:
			return True

		if (atacante >= atacado and (proba.ataque(self.rival_pais(tablero, origen), atacante-3) < 0.3)):
			return True

		# Para los casos restantes se necesita ayuda externa
		paises_a_componer = [pais for pais in tablero.paises_limitrofes(destino) if self.es_mi_pais(tablero, pais) and pais != origen]
		if not paises_a_componer: return False
		
		# Calculamos una probabilidad que no es exacta pero seguro es menor a la exacta.
		atacante += sum([max(tablero.ejercitos_pais(pais)-3,0) for pais in paises_a_componer])
		if (atacante >= 2*atacado + 1):
			return True
		return (proba.ataque(atacante, atacado) >= self.proba_aceptada)
Exemplo n.º 2
0
	def quiero_atacar(self, tablero, origen, destino, proba_aceptada):
		""" Informa si el pais de destino es una buena opcion para atacar. Recibe
		la probabilidad de exito aceptable y devuelve True si la probabilidad real
		la iguala o supera.
		"""
		return (proba.ataque(tablero.ejercitos_pais(origen), 
				tablero.ejercitos_pais(destino)) >= proba_aceptada)
Exemplo n.º 3
0
	def _agregar_ejercitos_libres(self, tablero, cantidad, jugada):
		''' Agregara los ejercitos libres. Modifica el diccionario de jugada.'''
		if self.caracter == PER_DEFENSOR:
			esta_solo = lambda pais: all((not self.es_mi_pais(tablero, limitrofe) for limitrofe in tablero.paises_limitrofes(pais)))
			paises_frontera = [pais for pais in tablero.paises_color(self.color) if self.es_frontera(tablero, pais) and not esta_solo(pais)]
			if not paises_frontera:
				paises_frontera = [pais for pais in tablero.paises_color(self.color) if self.es_frontera(tablero, pais)]
			self._agregar_en_fronteras(tablero, jugada, paises_frontera, cantidad)
		else: 
			limitrofe_mas_debil = lambda pais: min([limitrofe for limitrofe in tablero.paises_limitrofes(pais) if not self.es_mi_pais(tablero, limitrofe)],key=tablero.ejercitos_pais)

			# paises_agregables devuelve todos los paises en los que la probabilidad de atacar al mas debil no sea aceptada.
			paises_agregables = [pais for pais in tablero.paises_color(self.color) if self.es_frontera(tablero, pais) and
						proba.ataque(tablero.ejercitos_pais(pais), tablero.ejercitos_pais(limitrofe_mas_debil(pais))) < self.proba_aceptada]
			if paises_agregables == []:
				paises_agregables = [pais for pais in tablero.paises_color(self.color) if self.es_frontera(tablero, pais)]

			while cantidad:
				# El pais elegido sera el que quede con mejor probabilidad luego de agregar.
				pais_elegido = max(paises_agregables, key=lambda pais:
							proba.ataque(tablero.ejercitos_pais(pais) + jugada.get(pais, 0),
							1 + tablero.ejercitos_pais(limitrofe_mas_debil(pais))))
				jugada[pais_elegido] = jugada.get(pais_elegido, 0) + 1
				cantidad -= 1
Exemplo n.º 4
0
	def _agregar_en_fronteras(self, tablero, agregados, paises_frontera, ejercitos):
		""" Recibe una lista de paises frontera propios y un 
		diccionario de adiciones previas. Modifica este
		diccionario con los ejercitos agregados en algun
		pais segun el criterio.
		"""
		
		# Este diccionario asigna a cada pais la fuerza (ejercitos compuestos) del enemigo mas poderoso.
		amenaza_mas_poderosa = {pais: self.rival_pais(tablero, pais) for pais in paises_frontera}

		# Devuelve las chances de que el mas poderoso rival conquiste 
		# el pais (considerando los nuevos ejercitos agregados).
		probabilidad_de_morir = lambda pais: proba.ataque(amenaza_mas_poderosa[pais], tablero.ejercitos_pais(pais) + agregados.get(pais, 0))
		pais_elegido = lambda: max(paises_frontera, key=probabilidad_de_morir)
		agregar_a_pais_elegido = lambda: agregados.update([(pais_elegido(), agregados.get(pais_elegido(), 0) + 1)])
		
		# Bucle donde se agregan ejercitos de a uno, revisando en cada iteracion
		# el pais en mayor peligro.
		[agregar_a_pais_elegido() for x in xrange(ejercitos)]
		return