def main(nbLignes, nbColonnes, nb_coups_avance_blanc=0):
if nbLignes <= 1 or nbColonnes <= 1:
raise ValueError(
"Le nombre de lignes et de colonnes doit être supérieur ou égale à 2"
)
if nb_coups_avance_blanc < 0:
raise ValueError("On peut pas retourner en arrière")
grille = Grille(nbLignes, nbColonnes)
for i in range(nb_coups_avance_blanc):
mouv = choice(grille.possibilitesJoueur(grille.joueurActuel))
nouvelle_grille = grille.effectuerAction(mouv)
grille.grille = nouvelle_grille.grille
del nouvelle_grille
print(
f"Grille initiale (avec {nb_coups_avance_blanc} coups d'avance pour le joueur blanc):"
)
print(grille)
while not grille.estTermine():
joueur = grille.joueurActuel
mouvements = grille.possibilitesJoueur(joueur)
print(mouvements)
mouv = choice(mouvements)
grille = grille.effectuerAction(mouv)
print(grille.possibilitesJoueur(grille.joueurActuel))
return grille
def creer_grille_connue(self) -> Grille:
"""
À partir de l'ensemble des cases coulées, on peut calculer une grille partielle.
"""
g = Grille(self.tailles)
for type_, dir_, positions in self.bateaux_coules:
c_pos = self._grille.registre_des_positions[next(iter(positions))]
g.place(type_, c_pos, dir_)
return g
def __init__(self, nom_fichier=None):
'''
Méthode d'initialisation d'une partie.
'''
self.grille = Grille()
self.gagnant_partie = None
self.partie_nulle = False
if nom_fichier is not None:
self.charger(nom_fichier)
else:
self.initialiser_joueurs()
def generer_grille_objet_perdu(n: int = 10, m: int = 10):
perdu = tirer_point_uniformement((n, m))
inner = np.zeros((n, m), np.uint8)
inner[perdu[0], perdu[1]] = TypeBateau.ObjetPerdu.value
return Grille.depuis_tableau(inner)
def __init__(self):
self.continuer = True
self.gagne = False
self.grille = Grille()
self.joueur_actif = "rond"
print "Nouvelle partie"
self.creer_fenetre()
self.load_assets()
self.fenetre.blit(self.fond, (0, 0))
pygame.display.flip()
while self.continuer:
self.run()
def __init__(self, parent, large, haut):
self.parent = parent
self.large = large
self.haut = haut
self.niveau = 0
self.docteur = None
self.daleks = None
self.grid = Grille(large, haut)
def aiMonteCarlo(self, grille):
'''Déterminer la meilleure action en fonction des résultats des simulations Monte-Carlo'''
mes_coups_possibles = grille.lookForAllowedSteps()
meilleure_action = None
meilleure_evaluation = None
for action in mes_coups_possibles:
grille_simulee = Grille(grille)
# Le joueur (A) joue un coup.
grille_simulee.drop(self.player, action)
# C'est au tour de l'autre joueur (B).
symbole_dont_c_est_le_tour = getOtherSymbol(self.player)
# Nous prenons l'opposé de la valeur simulée, car nous nous intéressons au joueur A.
evaluation = - self.simulerMonteCarlo(grille_simulee, symbole_dont_c_est_le_tour)
if(evaluation > meilleure_evaluation):
meilleure_evaluation = evaluation
meilleure_action = action
return meilleure_action
def tests_chaine():
chaine_attendue = "0,0,jaune\n0,1,jaune\n0,2,jaune\n0,3,jaune\n0,4,jaune\n0,5,jaune\n"
assert chaine_attendue == grille_colonne0_pleine().convertir_en_chaine(), \
"Grille.convertir_en_chaine() devrait retourner une chaine contenant " + \
"toutes les cases au format spécifié."
grille_attendue = grille_colonne0_pleine().cases
grille = Grille()
grille.charger_dune_chaine(chaine_attendue)
grille_retournee = grille.cases
assert grilles_egales(grille_attendue, grille_retournee), \
"Grille.charger_dune_chaine() devrait retourner une grille contenant " + \
"toutes les cases contenues dans la chaîne."
def create_grid(self) : self.frame.destroy() cfg = self.getConfig() if cfg != "None" : self.grille = Grille(self.window, self, cfg) # charge une config else : # self.grille = Grille(self.window) #grille aléatoire pass
def changerEtatApresTransition(etat, action, joueur): '''Déterminer l'état obtenu lorsque le joueur effectue l'action dans l'état donné''' grille_copiee = Grille() grille_copiee.set(etat) grille_copiee.drop(joueur, action) nouvel_etat = grille_copiee.getName() return nouvel_etat
def aiUCT(self, grille):
'''Déterminer la meilleure action en fonction des résultats de l'exploration UCT'''
# recevoir une position p
etat_initial = grille.getName()
symbole_dont_c_est_le_tour = self.player
# soit A l'arbre UCT vide à la racine près
self.tree = Node(etat_initial)
self.compteur_visite_etat = {}
self.score_choix_action_dans_etat = {}
self.compteur_choix_action_dans_etat = {}
# boucle : plusieurs descentes dans l'arbre
for i in range(self.num_descentes_dans_arbre):
# soit p' une copie de p
grille_copiee = Grille()
grille_copiee.set(etat_initial)
# soit N le noeud résultat d'une descente dans l'arbre (A, p')
(N, symbole_dont_c_est_le_tour_pour_N) = self.TreeDown(grille_copiee, symbole_dont_c_est_le_tour)
# soit R l'évaluation de p'
grille_pour_N = N.name
grille_simulee = Grille()
grille_simulee.set(grille_pour_N)
R = self.simulerMonteCarlo(grille_simulee, symbole_dont_c_est_le_tour_pour_N)
# nous effectuons une remontée de l'arbre (A, N, R)
self.TreeUp(N, R, symbole_dont_c_est_le_tour, symbole_dont_c_est_le_tour_pour_N)
# renvoyer le coup fils (de la racine de A) qui a la meilleure valeur UCT
meilleure_action = self.choisirActionUCT(grille)
return meilleure_action
def TreeDown(self, position_courante, symbole_dont_c_est_le_tour): '''Descendre dans l'arbre UCT''' # soit N la racine de l'arbre N = self.tree joueur = symbole_dont_c_est_le_tour # boucle : fils non explorés de N grille = Grille() grille.set(N.name) mes_coups_possibles = grille.lookForAllowedSteps() while all([self.compteur_choix_action_dans_etat.has_key((N.name, i)) for i in mes_coups_possibles]): # soit F le fils de N ayant la plus grande valeur UCT if(len(mes_coups_possibles)>0): action = self.choisirActionUCT(grille) nouvel_etat = changerEtatApresTransition(N.name, action, joueur) F = Node(nouvel_etat, N) F.code = action N = F joueur = getOtherSymbol(joueur) grille.set(N.name) mes_coups_possibles = grille.lookForAllowedSteps() else: break # soir F un fils de N tiré au hasard parmi les fils non explorés grille.set(N.name) mes_coups_possibles = grille.lookForAllowedSteps() if(len(mes_coups_possibles)>0): actions_inexplorees = [i for i in mes_coups_possibles if not self.compteur_choix_action_dans_etat.has_key((N.name, i))] tirage = randint(0, len(actions_inexplorees)-1) action = actions_inexplorees[tirage] etat_inexplore = changerEtatApresTransition(N.name, action, joueur) F = Node(etat_inexplore, N) F.code = action joueur = getOtherSymbol(joueur) else: F = N return (F, joueur)
def est_admissible(
grille: Grille,
bataille: Bataille,
placement: Placement) -> bool:
if grille[placement[1]] != TypeBateau.Vide:
# print('la grille ne le permet pas', placement)
return False
if not grille.peut_placer(*placement):
return False
for q in engendre_position_pour_un_bateau(*placement):
if bataille.etat_de_case(q) == RetourDeTir.Vide:
# print('le cdb montre qu\'une des cases est vide: {}'.format(q))
return False
return True
def pvp():
'''Une partie entre joueurs humains'''
grid = Grille()
input = []
player = 'X'
while(input != 'q' and grid.checkVictory() is False):
grid.showGrid()
input = raw_input("1 2 3 4 5 6 7 = drop disc, q = quit. \nPlayer " +player+" to move:")
if (input in ['1','2','3','4','5','6','7']):
if grid.drop(player, int(input)):
if(player == 'X'):
player = 'O'
else:
player = 'X'
print "The game ended in the following state:"
grid.showGrid()
def main(nbLignes,
nbColonnes,
nb_coups_avance_blanc=0,
profondeur_raisonnement_noir=1,
profondeur_raisonnement_blanc=1,
alphabeta_utilisation=True):
if nbLignes <= 1 or nbColonnes <= 1:
raise ValueError(
"Le nombre de lignes et de colonnes doit être supérieur ou égale à 2"
)
if nb_coups_avance_blanc < 0:
raise ValueError("On peut pas retourner en arrière")
if profondeur_raisonnement_blanc < 1:
raise ValueError(
"Il faut que l'IA puisse réfléchir. Mettez un nombre >= 1")
if profondeur_raisonnement_noir < 1:
raise ValueError(
"Il faut que l'IA puisse réfléchir. Mettez un nombre >= 1")
historique_grille = []
grille = Grille(nbLignes, nbColonnes)
ia_blanc = IA('blanc', profondeur_raisonnement_blanc,
alphabeta_utilisation)
ia_noir = IA('noir', profondeur_raisonnement_noir, alphabeta_utilisation)
for i in range(nb_coups_avance_blanc):
mouv = ia_blanc.play(grille)
nouvelle_grille = grille.effectuerAction(mouv)
grille.grille = nouvelle_grille.grille
del nouvelle_grille
print(
f"Grille initiale (avec {nb_coups_avance_blanc} coups d'avance pour le joueur blanc):"
)
print(grille)
while not grille.estTermine() and not any(
[grille == h for h in historique_grille]):
historique_grille.append(grille)
joueur = grille.joueurActuel
if joueur == 'blanc':
mouvement = ia_blanc.play(grille)
else:
mouvement = ia_noir.play(grille)
grille = grille.effectuerAction(mouvement)
return grille, ia_blanc, ia_noir
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
from flotte import Flotte
from grille import Grille
flotte = Flotte("version_5_nav", 1)
grille = Grille(flotte, flotte.taille_grille)
while (flotte.liste_navires):
grille.jouer_coup()
print('Bravo, vous avez coulé tous les navires')
def build(self):
self.title = "Nomadhys"
Logger.info('Application: Repertoire user_data_dir = %s' %
self.user_data_dir)
# Deplacement de fichiers si besoin
for fichier in os.listdir(self.user_data_dir):
for prefixe in ("nomadhysactions", "nomadhysconfig",
"nomadhysdata"):
if fichier.startswith(prefixe):
nouveaufichier = os.path.join(
UTILS_Divers.GetRepData(),
fichier.replace("nomadhys", ""))
Logger.info("Deplacement du fichier %s -> %s" %
(fichier, nouveaufichier))
shutil.move(os.path.join(self.user_data_dir, fichier),
nouveaufichier)
# Config
config = UTILS_Config.Config()
# Verifie si fichier de config bien genere
config.Verification()
# Importe le code utilisateur si besoin
memoriser_code = config.Lire(section="utilisateur",
option="memoriser_code",
defaut="")
code_utilisateur = config.Lire(section="utilisateur",
option="code",
defaut="")
if memoriser_code == "1" and code_utilisateur != "":
self.VerifieMdp(mdp=code_utilisateur, silencieux=True)
config.Close()
# Init pages
self.ctrl_multipages = self.root.ids.ctrl_multipages
self.dict_pages = {
"menu_principal": {
"label": "Menu principal",
"page": PageAccueil(app=self)
},
"liste_individus": {
"label": "Individus",
"page": ListeIndividus(app=self)
},
"consommations": {
"label": "Consommations",
"page": Grille(app=self)
},
"synchronisation": {
"label": "Synchronisation",
"page": Synchronisation(app=self)
},
"aide": {
"label": "Aide",
"page": Aide()
},
}
# Init spinner de l'actionBar
self.pages_spinner = [
"menu_principal", "liste_individus", "consommations",
"synchronisation", "aide"
]
# Affichage du menu principal
self.code_page = ""
self.Afficher_page("menu_principal")
# Binds
Window.bind(on_keyboard=self.OnKey)
TEMPS_CHARGEMENT = time.time() - HEURE_CHARGEMENT
Logger.info('Application: Temps de chargement = %s' % TEMPS_CHARGEMENT)
def createGrid(self, param):
self.grille = Grille(param)
self.large = large
self.haut = haut
self.niveau = 0
self.docteur = None
self.daleks = None
self.grid = Grille(large, haut)
class Jeu:
def __init__(self, parent):
self.parent = parent
self.partie_active = None
class Controleur:
def __init__(self):
self.modele = Jeu(self)
self.vue = Vue(self)
if __name__ == '__main__':
grille = Grille(10, 10)
rep = ""
vue.cls()
while rep != "Q":
grille._print()
rep = input("entrez qqch (Q pour quitter)")
grille.move(rep)
vue.cls()
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from node import Node
from grille import Grille
from astar import AStar
from cell import Cell
from robot import Robot
from coordination import Coordination
from InterfaceV3 import *
lab = Grille(8, 8)
lab.setRect(0, 0, 4, 8, ".")
lab.setRect(2, 5, 1, 2, "?")
lab.setRect(2, 1, 1, 1, "?")
# Liste des robots
robots = []
#Liste des chemins
paths = []
astar = AStar(lab)
dic = {"?": "grey", ".": "white", "S": "green", "G": "blue"}
coord = Coordination(robots)
disp = Display(lab, astar, dic, paths, robots)
#disp.showPath(aPath, "red")
#disp.showPath(bPath, "yellow")
def sp(choix_ai_adversaire, num_tirages_MC = 3, num_descentes_dans_arbre = 7, facteur_uct = 0.0):
'''Une partie opposant un joueur humain à une intelligence artificielle'''
grid = Grille()
ai = AI('O')
if choix_ai_adversaire == 2:
ai = MC('O', num_tirages_MC)
elif choix_ai_adversaire == 3:
ai = UCT('O', num_tirages_MC, num_descentes_dans_arbre, facteur_uct)
le_joueur1_gagne = False
mes_coups_possibles = grid.lookForAllowedSteps()
input = []
player = 'X'
while(input != 'q' and grid.checkVictory() is False and len(mes_coups_possibles)>0):
grid.showGrid()
input = raw_input("Number 1 through 7 = drop disc, q = quit. \nYour move:")
if (input in ['1','2','3','4','5','6','7']):
MonCoup = int(input)
if grid.drop(player, MonCoup):
le_joueur1_gagne = True
mes_coups_possibles = grid.lookForAllowedSteps()
if(grid.checkVictory() is False and len(mes_coups_possibles)>0):
VotreCoup = ai.ai(grid)
grid.drop(ai.player, VotreCoup)
le_joueur1_gagne = False
mes_coups_possibles = grid.lookForAllowedSteps()
il_y_a_un_vainqueur = grid.checkVictory()
print "The game ended in the following state:"
grid.showGrid()
print("Y a-t-il un gagnant ?"),
print(il_y_a_un_vainqueur)
print("Si oui, est-ce le joueur n 1 (X) ?"),
print(le_joueur1_gagne)
from grille import Grille
import tkinter as tk
import time
root = tk.Tk()
root.geometry("650x705")
app = Grille(master=root)
while True:
app.action_generate()
app.update_idletasks()
app.update()
time.sleep(1)
# contraintes de bloc
for bloc in blocs:
for i in range(9):
for j in [k for k in range(9) if k > i]:
problem.addConstraint(lambda x, y: x != y, (bloc[i], bloc[j]))
# Contraintes de colonnes
for i in cols:
for j in rows:
problem.addConstraint(lambda x, y: x != y, (i, i + 9 * j))
# Contraintes de lignes
for i in rows:
for j in cols:
problem.addConstraint(lambda x, y: x != y, (i * 9, i * 9 + j))
# chargement de la grille
with open('problemes.txt', 'r') as fd:
grilles = fd.readlines()
sudoku = Grille(grilles[1])._to_list()
print(sudoku)
for case in cases:
valeur = sudoku[case]
if valeur != 0:
problem.addConstraint(lambda x: x == valeur, (case, ))
solutions = problem.getSolution()
print solutions
import sys
from pygame.locals import *
from grille import Grille
from player import Player
from config import *
pygame.init()
screen = pygame.display.set_mode((LARGEUR, HAUTEUR))
pygame.display.set_caption(TITRE)
background = pygame.image.load("img/back.png")
screen.blit(background, (0, 0))
_grille = Grille("lvl/lv1")
_grille.drawMap(screen)
_player = Player(_grille)
_player.drawPlayer(screen)
pygame.display.flip()
continuer = True
while not _grille.is_fini():
for event in pygame.event.get():
if event.type == QUIT:
sys.exit()
if event.type == KEYDOWN:
_player.move(event.key)
if event.key == K_r:
def main():
parser = argparse.ArgumentParser()
parser.add_argument(
"strategie",
help="Sélectionne une stratégie nommée qui se trouve dans strategie/__init__.py (exemple: monte_carlo)",
)
parser.add_argument(
"-t",
"--tailles",
help="Taille du champ de bataille au format NxM (par défaut: 10x10)",
default="10x10",
)
parser.add_argument(
"-fv",
"--facteur-vide",
type=float,
help="Détermine le facteur vide de la grille générée aléatoirement (defaut: environ 30 %% des cases sont vides)",
default=0.3,
)
parser.add_argument(
"-ag",
"--animation-grille",
help="Affiche à la fin du jeu la grille en temps réel",
action="store_true",
)
parser.add_argument(
"-ab",
"--animation-bataille",
help="Affiche à la fin du jeu la bataille en temps réel",
action="store_true",
)
args = parser.parse_args()
tailles = tuple(map(int, args.tailles.split("x")))
grille = Grille.generer_grille(
tailles=tailles, facteur_vide=args.facteur_vide
)
if args.animation_bataille and args.animation_grille:
raise NotImplementedError("Race condition is occurring when those two options are enabled, try only one")
print(repr(grille))
bataille = Bataille(grille)
strategie = charge_strategie(args.strategie)
trames_bataille = []
trames_grille = []
fig = plt.figure()
ax = fig.add_subplot(111)
while not bataille.victoire:
if args.animation_bataille:
trames_bataille.append(bataille.fog_of_war().copy())
if args.animation_grille:
trames_grille.append(grille.inner.copy())
cible = strategie.agir(bataille)
retour = bataille.tirer(cible)
print('Tir à {}, retour: {}'.format(cible, retour))
strategie.analyser(bataille, cible, retour)
print(bataille._nb_cases_occupees, sum(bataille._nb_cases_touchees.values()))
if args.animation_bataille:
trames_bataille.extend([bataille.fog_of_war().copy()] * 10)
if args.animation_bataille:
ani_bataille = cree_animation(ax, fig, trames_bataille, BATAILLE_CMAP, BATAILLE_NORM, BATAILLE_BOUNDS)
ani_bataille.save('bataille.mp4')
if args.animation_grille:
ani_grille = cree_animation(ax, fig, trames_grille, None, None, None)
ani_grille.save('grille.mp4')
print(bataille.score)
from grille import Grille
param = dict() #paramètres de la grille
param['long'] = -4.83
param['lat'] = 48.42
param['rows'] = 2
param['lines'] = 2
param['pasH'] = 0.04
param['pasV'] = -0.04
g = Grille(param)
g.printGrid('testGridOut.log')
def np(choix_ai_joueur, choix_ai_adversaire, num_tirages_MC = 3, num_descentes_dans_arbre = 7, facteur_uct = 0.0, show_grid = False):
'''Une partie entre intelligences artificielles'''
grid = Grille()
ai1 = AI('X')
if choix_ai_joueur == 2:
ai1 = MC('X', num_tirages_MC)
elif choix_ai_joueur == 3:
ai1 = UCT('X', num_tirages_MC, num_descentes_dans_arbre, facteur_uct)
ai2 = AI('O')
if choix_ai_adversaire == 2:
ai2 = MC('O') # paramètres par défaut
elif choix_ai_adversaire == 3:
ai2 = UCT('O') # paramètres par défaut
le_joueur1_gagne = False
mes_coups_possibles = grid.lookForAllowedSteps()
while(grid.checkVictory() is False and len(mes_coups_possibles)>0):
MonCoup = ai1.ai(grid)
grid.drop(ai1.player, MonCoup)
le_joueur1_gagne = True
mes_coups_possibles = grid.lookForAllowedSteps()
if show_grid:
grid.showGrid()
sleep(1)
if(grid.checkVictory() is False and len(mes_coups_possibles)>0):
VotreCoup = ai2.ai(grid)
grid.drop(ai2.player, VotreCoup)
le_joueur1_gagne = False
mes_coups_possibles = grid.lookForAllowedSteps()
if show_grid:
grid.showGrid()
il_y_a_un_vainqueur = grid.checkVictory()
print "The game ended in the following state:"
grid.showGrid()
print("Y a-t-il un gagnant ?"),
print(il_y_a_un_vainqueur)
print("Si oui, est-ce le joueur 1 (X) ?"),
print(le_joueur1_gagne)
return (il_y_a_un_vainqueur, le_joueur1_gagne)
import pygame
import random
from grille import Grille
pygame.init()
morpion = Grille()
morpion.quadrillage()
croix = morpion.image("croix.png")
rond = morpion.image("rond.png")
run = True
game = 0
i = 0
r = 0
while run :
for event in pygame.event.get():
if event.type == pygame.QUIT:
run = False
if r == 0:
morpion.text("Joueur vs Joueur : Touche J", -60, 50)
morpion.text("Joueur vs Ordinateur : Touche O", 60, 50)
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_j:
game = 0
r = 1
morpion.quadrillage()
if event.key == pygame.K_o:
game = 1
from grille import Grille
import sys
#Initialisaton de la grille
ficheInit = open("config.txt").readlines()
dimensionGrille = ficheInit[0][:-1].split(",")
grilleJeu = Grille(int(dimensionGrille[1]), int(dimensionGrille[0]))
#place les organismes initiales selon config.txt
grilleJeu.init(ficheInit)
try:
parametre = sys.argv[1]
except IndexError:
parametre = input("add a parameter")
#selectionne le bon mode d'execution
if parametre == 'animation':
grilleJeu.afficherGrille()
while True:
input()
for i in range(30):
print('\n')
grilleJeu = grilleJeu.actualisation()
grilleJeu.afficherGrille()
elif parametre == 'couleur':
grilleJeu.afficherGrilleCouleur()
while True:
input()
for i in range(30):
dessin += "#"
elif case in case_a_etudier:
dessin += "?"
elif case.cout > 1:
dessin += "x"
else:
dessin += " "
if compte % grille.largeur == grille.largeur - 1:
dessin += "\n"
compte += 1
print dessin
if __name__ == '__main__':
g = Grille(10, 10, "von_neumann")
source = None
arrivee = None
for case in g.cases:
if case.cout == 1:
source = case
break
nb_case = len(g.cases)
case = source
while 1 == 1:
if case.cout == 1 and case != source:
arrivee = case
break
case = g.cases[random.randint(0, nb_case - 1)]
print AEtoile(g, source, arrivee)
serror) + ") m\r\n"
output = output + "Root mean square error: " + str(rmse) + " (+/- " + str(
srmse) + ") m\r\n"
output = output + "X bias: " + str(be) + " (+/- " + str(sbe) + ") m\r\n"
output = output + "Y bias: " + str(bn) + " (+/- " + str(sbn) + ") m"
print(output)
return (completion, scompletion, missing, error, serror, rmse, srmse, be,
sbe, bn, sbn)
acquisition_file_path = 'D:\\DATA\\PoussePousse\\Points.csv'
validation_file_path = 'D:\\DATA\\PoussePousse\\ctrl_20190526_233430.dat'
xmin = 650851.648136
ymin = 6859531.09908
nx = 8
ny = 7
Nc = 16
rx = 250
ry = 250
C = [[5, 4], [4, 6], [6, 6], [4, 5], [7, 6], [7, 4], [7, 5], [3, 6], [6, 5],
[5, 5]]
g = Grille(nx, ny, xmin, ymin, rx, ry)
# B=1000
print(validation(acquisition_file_path, validation_file_path, g, C, Nc))
print(
"--------------------------------------------------------------------------------"
)
class PartieConnectFour:
def __init__(self, nom_fichier=None):
'''
Méthode d'initialisation d'une partie.
'''
self.grille = Grille()
self.gagnant_partie = None
self.partie_nulle = False
if nom_fichier is not None:
self.charger(nom_fichier)
else:
self.initialiser_joueurs()
def initialiser_joueurs(self):
'''
On initialise ici quatre attributs : joueur_jaune,
joueur_rouge, joueur_courant et couleur_joueur_courant.
joueur_courant est initialisé par défaut au joueur_jaune
et couleur_joueur_courant est initialisée à "jaune".
Pour créer les objets joueur, faites appel à
creer_joueur().
Pycharm vous sortira probablement des messages d'erreur à
cette fonction car vous initialisez des attributs en
dehors de la fonction __init__(), mais vous pouvez les
ignorer.
'''
self.joueur_jaune = self.creer_joueur("jaune")
self.joueur_rouge = self.creer_joueur("rouge")
self.joueur_courant = self.joueur_jaune
self.couleur_joueur_courant = "jaune"
def creer_joueur(self, couleur):
'''
Demande à l'usager quel type de joueur ('Humain' ou
'Ordinateur') il désire pour le joueur de la couleur en
entrée.
Tant que l'entrée n'est pas valide, on continue de
demander à l'utilisateur.
Faites appel à self.creer_joueur_selon_type() pour créer
le joueur lorsque vous aurez le type.
Args :
couleur, la couleur pour laquelle on veut le type
de joueur.
Returns :
Un objet Joueur, de type JoueurHumain
si l'usager a entré 'Humain', JoueurOrdinateur s'il a
entré 'Ordinateur'.
'''
choix_correct = False
while choix_correct == False:
demander_jouer = input("Quel type de joueur désirez-vous pour la couleur {}? Entrez Humain ou Ordinateur? ".format(couleur))
if demander_jouer == "Humain" or demander_jouer == "Ordinateur":
choix_correct = True
return self.creer_joueur_selon_type(demander_jouer,couleur)
def creer_joueur_selon_type(self, type_joueur, couleur):
'''
Crée l'objet Joueur approprié, selon le type passé en
paramètre.
Pour créer les objets, vous n'avez qu'à faire appel à
leurs constructeurs, c'est-à-dire à
JoueurHumain(couleur), par exemple.
Args :
type, le type de joueur, "Ordinateur" ou "Humain"
couleur, la couleur du pion joué par le jouer,
"jaune" ou "rouge"
Returns :
Un objet JoueurHumain si le
type est "Humain", JoueurOrdinateur sinon
'''
if type_joueur == "Humain":
return JoueurHumain(couleur)
if type_joueur == "Ordinateur":
return JoueurOrdinateur(couleur)
def jouer(self):
'''
Méthode représentant la boucle principale de jeu.
Celle-ci fonctionne comme une boucle infinie. Pour chaque
itération, on affiche la grille avec print(self.grille)
et on joue un tour. Si la partie est terminée, on quitte
la boucle. Sinon, on change de joueur.
Quand on sort de la boucle principale, on fait le
traitement de la fin de partie.
Utilisez les fonctions partie_terminee(), jouer_tour(),
changer_joueur() et traitement_fin_partie() pour vous
faciliter la tâche.
'''
while not self.partie_terminee():
print(self.grille)
self.jouer_tour()
self.changer_joueur()
self.changer_joueur()
self.traitement_fin_partie()
def jouer_tour(self):
'''
Cette méthode commence par afficher à quel joueur c'est
tour de jouer. Ensuite, on fait jouer le joueur courant
sur la grille.
'''
print("C'est au tour du joueur {} de jouer".format(self.couleur_joueur_courant))
self.joueur_courant.jouer_sur_grille(self.grille)
def partie_terminee(self):
'''
Méthode vérifiant si la partie est terminée.
Si la grille est pleine, on ajuste l'attribut
partie_nulle à True.
Si la grille possède un gagnant, on assigne la couleur du
joueur courant à l'attribut gagnant_partie.
Returns :
True si la partie est terminée, False sinon
'''
if self.grille.possede_un_gagnant():
self.gagnant_partie = self.couleur_joueur_courant
return True
elif self.grille.est_pleine():
self.partie_nulle = True
return True
else:
return False
def changer_joueur(self):
'''
En fonction de la couleur du joueur courant actuel, met à
jour les attributs joueur_courant et couleur_joueur_courant.
'''
if self.joueur_courant is self.joueur_jaune:
self.joueur_courant = self.joueur_rouge
self.couleur_joueur_courant = self.joueur_rouge.couleur
else:
self.joueur_courant = self.joueur_jaune
self.couleur_joueur_courant = self.joueur_jaune.couleur
def traitement_fin_partie(self):
'''
Méthode qui gère le comportement de fin de partie.
Si l'attribut gagnant_partie n'est pas None, on surligne
la séquence gagnante de la grille et on affiche un
message approprié pour féliciter le gagnant en plus
d'afficher la grille avec la séquence gagnante surlignée.
Sinon, on affiche le message d'un match nul.
'''
if self.grille.sequence_gagnante is not None:
self.grille.surligner_sequence_gagnante()
print("Le gagnant de la partie est le joueur {}! ".format(self.couleur_joueur_courant))
print("Voici la ligne lui ayant permis de gagner! ")
print(self.grille)
else:
print("match nul!")
def sauvegarder(self, nom_fichier):
'''
Sauvegarde une partie dans un fichier. Le fichier
contiendra:
- Une ligne indiquant la couleur du joueur courant.
- Une ligne contenant le type du joueur jaune.
- Une ligne contenant le type du joueur rouge.
- Le reste des lignes correspondant à la grille. Voir la
méthode convertir_en_chaine de la grille pour le
format.
Args :
nom_fichier, le string du nom du fichier où sauvegarder.
'''
nom_string = self.couleur_joueur_courant + "\n"
nom_string += self.joueur_jaune.obtenir_type_joueur() + "\n"
nom_string += self.joueur_rouge.obtenir_type_joueur() + "\n"
nom_string += self.grille.convertir_en_chaine()
with open(nom_fichier, "w") as mon_fichier:
mon_fichier.write(nom_string)
def charger(self, nom_fichier):
'''
Charge une partie dans à partir d'un fichier. Le fichier
a le même format que la méthode de sauvegarde.
Pycharm vous sortira probablement des messages d'erreur à
cette fonction car vous initialisez des attributs en
dehors de la fonction __init__(), mais vous pouvez les
ignorer.
Args:
nom_fichier: Le string du nom du fichier à charger.
'''
myline = []
with open(nom_fichier, "r") as mon_fichier:
myline = mon_fichier.read().splitlines()
self.joueur_jaune = self.creer_joueur_selon_type(myline[1],"jaune")
self.joueur_rouge = self.creer_joueur_selon_type(myline[2], "rouge")
self.couleur_joueur_courant = myline[0]
if self.couleur_joueur_courant == "jaune":
self.joueur_courant = self.joueur_jaune
else:
self.joueur_courant = self.joueur_rouge
self.grille.charger_dune_chaine("\n".join(myline[3:]))
class Game:
def __init__(self):
self.continuer = True
self.gagne = False
self.grille = Grille()
self.joueur_actif = "rond"
print "Nouvelle partie"
self.creer_fenetre()
self.load_assets()
self.fenetre.blit(self.fond, (0, 0))
pygame.display.flip()
while self.continuer:
self.run()
def creer_fenetre(self):
pygame.init()
self.fenetre = pygame.display.set_mode((600, 600))
def load_assets(self):
self.fond = pygame.image.load(REP_ASSETS + ASSET_BACKGROUND).convert()
self.croix = pygame.image.load(REP_ASSETS + ASSET_CROIX).convert_alpha()
self.rond = pygame.image.load(REP_ASSETS + ASSET_ROND).convert_alpha()
def modifie_joueur_actif(self):
if self.grille.verifier_gagner() == "non":
if self.joueur_actif == "croix":
self.joueur_actif = "rond"
elif self.joueur_actif == "rond":
self.joueur_actif = "croix"
else:
self.gagne = True
def gestion_evenements(self):
for event in pygame.event.get():
if event.type == QUIT:
self.continuer = False
if event.type == KEYDOWN and self.gagne == False:
if event.key == K_a:
print "touche a"
self.grille.jouer(self.joueur_actif, 0, 0)
self.modifie_joueur_actif()
self.grille.afficher()
if event.key == K_z:
print "touche z"
self.grille.jouer(self.joueur_actif, 0, 1)
self.modifie_joueur_actif()
self.grille.afficher()
if event.key == K_e:
print "touche e"
self.grille.jouer(self.joueur_actif, 0, 2)
self.modifie_joueur_actif()
self.grille.afficher()
if event.key == K_q:
print "touche q"
self.grille.jouer(self.joueur_actif, 1, 0)
self.modifie_joueur_actif()
self.grille.afficher()
if event.key == K_s:
print "touche s"
self.grille.jouer(self.joueur_actif, 1, 1)
self.modifie_joueur_actif()
self.grille.afficher()
if event.key == K_d:
print "touche d"
self.grille.jouer(self.joueur_actif, 1, 2)
self.modifie_joueur_actif()
self.grille.afficher()
if event.key == K_w:
print "touche w"
self.grille.jouer(self.joueur_actif, 2, 0)
self.modifie_joueur_actif()
self.grille.afficher()
if event.key == K_x:
print "touche x"
self.grille.jouer(self.joueur_actif, 2, 1)
self.modifie_joueur_actif()
self.grille.afficher()
if event.key == K_c:
print "touche c"
self.grille.jouer(self.joueur_actif, 2, 2)
self.modifie_joueur_actif()
self.grille.afficher()
if event.type == MOUSEBUTTONDOWN and event.button == 1 and event.pos[0] > 0 and event.pos[0] < 200 and event.pos[1] > 0 and event.pos[1] < 200 and self.gagne == False:
print "touche a"
self.grille.jouer(self.joueur_actif, 0, 0)
self.modifie_joueur_actif()
self.grille.afficher()
if event.type == MOUSEBUTTONDOWN and event.button == 1 and event.pos[0] > 200 and event.pos[0] < 400 and event.pos[1] > 0 and event.pos[1] < 200 and self.gagne == False:
print "touche z"
self.grille.jouer(self.joueur_actif, 0, 1)
self.modifie_joueur_actif()
self.grille.afficher()
if event.type == MOUSEBUTTONDOWN and event.button == 1 and event.pos[0] > 400 and event.pos[0] < 600 and event.pos[1] > 0 and event.pos[1] < 200 and self.gagne == False:
print "touche e"
self.grille.jouer(self.joueur_actif, 0, 2)
self.modifie_joueur_actif()
self.grille.afficher()
if event.type == MOUSEBUTTONDOWN and event.button == 1 and event.pos[0] > 0 and event.pos[0] < 200 and event.pos[1] > 200 and event.pos[1] < 400 and self.gagne == False:
print "touche q"
self.grille.jouer(self.joueur_actif, 1, 0)
self.modifie_joueur_actif()
self.grille.afficher()
if event.type == MOUSEBUTTONDOWN and event.button == 1 and event.pos[0] > 200 and event.pos[0] < 400 and event.pos[1] > 200 and event.pos[1] < 400 and self.gagne == False:
print "touche s"
self.grille.jouer(self.joueur_actif, 1, 1)
self.modifie_joueur_actif()
self.grille.afficher()
if event.type == MOUSEBUTTONDOWN and event.button == 1 and event.pos[0] > 400 and event.pos[0] < 600 and event.pos[1] > 200 and event.pos[1] < 400 and self.gagne == False:
print "touche d"
self.grille.jouer(self.joueur_actif, 1, 2)
self.modifie_joueur_actif()
self.grille.afficher()
if event.type == MOUSEBUTTONDOWN and event.button == 1 and event.pos[0] > 0 and event.pos[0] < 200 and event.pos[1] > 400 and event.pos[1] < 600 and self.gagne == False:
print "touche w"
self.grille.jouer(self.joueur_actif, 2, 0)
self.modifie_joueur_actif()
self.grille.afficher()
if event.type == MOUSEBUTTONDOWN and event.button == 1 and event.pos[0] > 200 and event.pos[0] < 400 and event.pos[1] > 400 and event.pos[1] < 600 and self.gagne == False:
print "touche x"
self.grille.jouer(self.joueur_actif, 2, 1)
self.modifie_joueur_actif()
self.grille.afficher()
if event.type == MOUSEBUTTONDOWN and event.button == 1 and event.pos[0] > 400 and event.pos[0] < 600 and event.pos[1] > 400 and event.pos[1] < 600 and self.gagne == False:
print "touche c"
self.grille.jouer(self.joueur_actif, 2, 2)
self.modifie_joueur_actif()
self.grille.afficher()
def run(self):
self.fenetre.blit(self.fond, (0, 0))
self.gestion_evenements()
for ligne in xrange(3):
for colonne in xrange(3):
if self.grille.grille[ligne][colonne] == "X":
self.fenetre.blit(self.croix, [colonne*200, ligne*200])
if self.grille.grille[ligne][colonne] == "O":
self.fenetre.blit(self.rond, [colonne*200, ligne*200])
if self.gagne == True:
print self.grille.verifier_gagner()
pygame.display.flip()
import sys
from pygame.locals import *
from grille import Grille
from player import Player
from config import *
pygame.init()
screen = pygame.display.set_mode((LARGEUR, HAUTEUR))
pygame.display.set_caption(TITRE)
background = pygame.image.load("img/back.png")
screen.blit(background, (0,0))
_grille = Grille("lvl/lv1")
_grille.drawMap(screen)
_player = Player(_grille)
_player.drawPlayer(screen)
pygame.display.flip()
continuer = True
while not _grille.is_fini():
for event in pygame.event.get():
if event.type == QUIT:
sys.exit()
if event.type == KEYDOWN:
_player.move(event.key)
if event.key == K_r:
def __init__(self, player_1, player_2):
self.palyer_1 = player_1
self.player_2 = player_2
self.grille = Grille()
self.winner = 0
def main_loop(level):
_grille = Grille(level)
_grille.drawMap(screen)
_player = Player(_grille)
_player.drawPlayer(screen)
pygame.display.update()
background = pygame.image.load("img/back.png")
while not _grille.is_fini():
for event in pygame.event.get():
if event.type == QUIT:
sys.exit()
if event.type == KEYDOWN:
_player.move(event.key)
if event.key == K_r:
_grille.genMap(level)
_grille.drawMap(screen)
_player = Player(_grille)
_player.drawPlayer(screen)
if event.key == K_q:
sys.exit()
l = 0
if event.key == K_p:
for level in lvl:
main_loop(lvl[l])
l += 1
screen.blit(background, (150, 100))
_grille.drawMap(screen)
_player.drawPlayer(screen)
pygame.display.update()
from node import Node
from grille import Grille
from astar import AStar
from cell import Cell
from robot import Robot
from coordination import Coordination
from InterfaceV3 import *
lab = Grille(10,6)
lab.setRect(1,1,4,8,".")
lab.setRect(3,6,1,2,"?");
lab.setRect(3,2,1,1,"?");
# Liste des robots
robots = []
#Liste des chemins
paths=[]
# Robot A
#aStart = Node(Cell(8, 12,"S"),"L")
#aGoal = Node(Cell(13, 12,"G"),"L")
#a = Robot("A", aStart, aGoal)
#print(a)
#robots.append(a)
# Robot B
#bStart = Node(Cell(11, 12,"S"),"L")
#bGoal = Node(Cell(9, 13,"G"),"L")
#b = Robot("B", bStart, bGoal)
#print(b)
def agir(self, bataille: Bataille) -> Point2D:
while True:
g = Grille.generer_grille(tailles=bataille.tailles)
for p in g.registre_des_positions.keys():
if p not in self.positions_deja_jouees:
return p
