示例#1
0
def calcul_score ():
	""" Calcul le score actuel a partir du nombre de coups et de la difficulté
		
		@return : int = le score calculé 
	"""
	
	if moteur.est_en_partie () != True:
		raise moteur.PasEnCoursDePartie
	
	coups = moteur.get_restant () # Le nombre de coup qu'il reste à jouer ... donc plus il y en a mieux c'est !
	mode = get_mode()
	if mode == "facile":
		score = 10 * (coups - 1) / 2
	elif mode == "moyen":
		score = 10 * (coups - 1) / 1.5
	else:
		score = 10 * (coups - 1)
	
	return int (score) # On retourne un entier
示例#2
0
def ia_matrice ():
	""" Une ia qui fait une matrice probabiliste
		qui permet d'étudier quelle doit être 
		la combinaison couleurs/cases qui
		correspond au code
	"""
	# Il est pratique d'avoir l'univers sous la main 
	# (l'ensemble des couleurs disponibles dans l'ordre)
	univers = couleurs.liste_couleurs (moteur.get_nombre_couleurs ())
	
	# On crée la matrice pondérée des coefs case/couleur (affichée en sortie !)
	m = matrice.make (4, len (univers), lambda x,y: 0) # une matrice couleur/case

	def coup_alea ():
		""" Crée un coup totalement aléatoire, tout en 
			vérifiant qu'il n'est pas dans l'historique
			et vérifiant qu'il n'utilise pas des combinaisons
			cases/couleurs qui sont impossibles 
		"""
		coup = []
		while coup == []:
			# On génère un coup aléatoire (totalement) à partir de l'univers
			coup = generer_couleurs_aleatoires (univers)
			valide = True # On présuppose que le coup est valide
			for i,j in enumerate (coup):
				if matrice.get (m,i, univers.index (j)) == "F":
					valide = False # Mais s'il utilise une valeur interdite ... il ne l'est pas
			
			hi = moteur.get_historique () # On récupère les coups déjà joués 
			for h in hi:
				if h[0] == coup: # h[0] représente le coup et h[1] la réponse
					valide = False # S'il y est ... on ne le rejoue pas !

			if valide == False: # Si c'est invalide (historique ou valeur interdite)
				coup = [] # On met à [] (donc on continue à boucler)
		return coup # On retourne le coup une fois généré !

	def coup_tentative ():
		""" Fait une tentative d'interprétation des 
			résultats !
		"""
		coup = [] # Un coup
		
		# Pour chaque numéro de ligne est une case
		# et les colonnes sont les couleurs, donc 
		# Pour chaque ligne, on trouve la colonne avec 
		# le meilleur coef, et on prend la couleur qui
		# correspond à cette colonne :-)
		for i in matrice.parcourir_lignes (m):
			maximum = 0
			maximum_pos = 0
			for j,k in enumerate (i):
				if k != "F" and k >= maximum:
					maximum = k
					maximum_pos = j
			coup.append (univers[maximum_pos])
		
		# On vérifie que le coup n'est pas déjà joué
		for h in moteur.get_historique ():
			if h[0] == coup:
				return coup_alea () # Auquel cas on retourne un coup aléatoire
	
		return coup # Sinon on retourne le coup géneré
	

	while True:
		coup = []
		
		# En fonction du nombre de coups restant
		# On a une approche différente ...

		if moteur.get_restant () < 5:
			coup = coup_tentative ()
		else:
			coup = coup_alea ()
		
		# On récupère la réponse 
		reponse = moteur.verification_solution (coup)

		if reponse == "gagne" or reponse == "perdu":
			raise StopIteration
		else:
			yield
			a,b = reponse # là c'est le couple (a,b) !
			# ce code tente de remplir la matrice d'informations 
			# les plus pertinentes possibles à partir de ce couple
			# et des couleurs jouées ... Mais c'est dur !
			
			if a + b == 4:
				def une_petite_lambda (i,j,v):
					if univers[j] not in coup:
						return "F"
					else:
						return v
				matrice.apply (m, une_petite_lambda)
			elif a == 0:
				for i,j in enumerate (coup):
					matrice.set (m,i,univers.index (j), "F") # Met faux dans les cases 
					if b > 0:
						k = 0
						for element in matrice.parcourir_colonne (m, univers.index (j)):
							if element != "F":
								matrice.set (m, k, univers.index (j), element + b)
							k += 1
					elif b == 0:
						k = 0
						for element in matrice.parcourir_colonne (m, univers.index (j)):
							matrice.set (m, k, univers.index (j), "F")
							k += 1
			else: # A ≠ 0
				sc = 20 * a + b
				
				def my_little_lambda (i,j,v):
					if v == "F":
						return "F"
					else:
						return v - 5 * a

				matrice.apply (m, my_little_lambda)

				for i,j in enumerate (coup):
					old = matrice.get (m,i,univers.index (j))
					if old != "F":
						matrice.set (m,i,univers.index (j), old + sc)
			
			matrice.display (m,univers) # Affiche la matrice résultante !