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