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 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()
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 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 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 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
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 __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()
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(
"--------------------------------------------------------------------------------"
)
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)
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):
#!/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 grille_base():
return Grille()
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:
# 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/lv2")
_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:
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 __init__(self, player_1, player_2):
self.palyer_1 = player_1
self.player_2 = player_2
self.grille = Grille()
self.winner = 0
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 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)
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)
