def setUp(self):
"""Crée un jeu vide avec deux joueurs."""
carte = Carte("test", GRILLE)
self.jeu = Jeu(carte)
self.grille = dict(self.jeu.labyrinthe.grille)
self.joueur_1 = self.jeu.ajouter_joueur(None)
self.joueur_2 = self.jeu.ajouter_joueur(None)
class TestJeu(TestCase):
"""Test vérifiant le bon fonctionnement du jeu.
Ceci inclut l'application des règles.
"""
def setUp(self):
"""Crée un jeu vide avec deux joueurs."""
carte = Carte("test", GRILLE)
self.jeu = Jeu(carte)
self.grille = dict(self.jeu.labyrinthe.grille)
self.joueur_1 = self.jeu.ajouter_joueur(None)
self.joueur_2 = self.jeu.ajouter_joueur(None)
def test_tour(self):
"""Vérifie le bon fonctionnement du changement de tour."""
self.assertEqual(self.jeu.tour, self.joueur_1)
self.jeu.changer_tour()
self.assertEqual(self.jeu.tour, self.joueur_2)
self.jeu.changer_tour()
self.assertEqual(self.jeu.tour, self.joueur_1)
def test_placement(self):
"""Vérifie que le robot est placé sur une case autrefois vide."""
x, y = self.joueur_1.robot.x, self.joueur_1.robot.y
# Vérifie que le robot s'est bien ajouté sur un emplacement vide
self.assertNotIn((x, y), self.grille)
def test_deplacement(self):
"""Essaye de déplacer le robot."""
robot = self.jeu.labyrinthe.grille.get((1, 1))
retour = self.jeu.labyrinthe.deplacer_robot(robot, "est")
self.assertTrue(retour)
self.assertEqual(robot.x, 2)
self.assertEqual(robot.y, 1)
def test_collision(self):
"""Vérifie que le robot ne bouge pas en cas de collision."""
robot = self.jeu.labyrinthe.grille.get((1, 1))
# Si le robot va au nord, il doit se prendre le mur
retour = self.jeu.labyrinthe.deplacer_robot(robot, "nord")
self.assertFalse(retour)
self.assertEqual(robot.x, 1)
self.assertEqual(robot.y, 1)
# Si il va deux fois vers l'est, il doit se heurter à l'autre robot
self.jeu.labyrinthe.deplacer_robot(robot, "est")
retour = self.jeu.labyrinthe.deplacer_robot(robot, "est")
self.assertFalse(retour)
def test_position_navire_disponible():
jeu = Jeu()
jeu.placer_navire(0, 1, 1, "Horizontal", "Sous-marin de combat")
assert jeu.position_navire_disponible(0, 0, 3, 1, 0) is True
assert jeu.position_navire_disponible(0, 0, 5, 2, 0) is True
assert jeu.position_navire_disponible(0, 0, 5, 1, 0) is True
assert jeu.position_navire_disponible(0, 0, 4, 1, 0) is True
assert jeu.position_navire_disponible(13, 0, 3, 2, 0) is False
assert jeu.position_navire_disponible(15 * 10, 0, 6, 1, 90) is False
assert jeu.position_navire_disponible(2 * 15, 2, 3, 4, 0) is False
assert jeu.position_navire_disponible(1, 1, 2, 1, 90) is False
def demarrer():
""" Crée une instance de Jeu lance une première boucle de jeu. Si une
erreur se produit, affiche un rapport d'erreur et arrête le jeu
proprement. """
jeu = Jeu()
jeu.charger()
jeu.initialiser_menu_principal()
try:
jeu.lancer_boucle()
except Exception as e:
utile.debogguer(
"Une erreur non gérée est survenue pendant l'exécution", 2)
traceback.print_exc()
finally:
jeu.arreter()
def main():
'''Fonction principale du jeu de Nim.'''
args = parserArguments()
jeu = Jeu(args.n, args.kmin, args.kmax)
# créer les deux joueurs
joueurs = []
# créer les joueurs humains
for num in range(args.humains):
defaut = "HUMAIN-{}".format(num+1)
nom = input("Entrez le nom du joueur {} (défaut={}) >>> ".format(num+1, defaut))
if nom == '': nom = defaut
joueurs.append(JoueurHumain(nom))
# créer les joueurs ordinateurs
for num in range(2 - args.humains):
joueurs.append(JoueurOrdinateur("ORDI-{}".format(num+1)))
# jouer la partie avec les deux joueurs
jeu.jouerPartie(*joueurs)
def test_recevoir_tir():
"""Test de la fonction recevoir un tir."""
jeu = Jeu()
navire = Navire(0, 3, 1, "AlainBernard")
jeu.carte_perso.navires.append(navire)
jeu.carte_perso.navires[0].cases.append(Case(11, 5, 1))
jeu.carte_perso.navires[0].cases.append(Case(10, 5, 1))
jeu.carte_perso.navires[0].cases.append(Case(9, 5, 1))
navire1 = Navire(1, 4, 1, "HollandaisVolant")
jeu.carte_perso.navires.append(navire1)
jeu.carte_perso.navires[1].cases.append(Case(1, 7, 2))
jeu.carte_perso.navires[1].cases.append(Case(2, 7, 2))
jeu.carte_perso.navires[1].cases.append(Case(3, 7, 2))
jeu.carte_perso.navires[1].cases.append(Case(4, 7, 2))
assert jeu.recevoir_tir(0, 0)[0] is False
assert jeu.recevoir_tir(4, 5)[0] is False
assert jeu.recevoir_tir(11, 5) == (True, 2, False)
assert jeu.recevoir_tir(4, 7) == (True, 3, False)
def lancement(nom_fichier = 'carte.json'): initialiser() jeu = Jeu(DOSSIER + nom_fichier) fenetre = Fenetre(jeu.carte.cases) def deplacer_perso(fenetre, jeu): if jeu.peut_deplacer(): dessiner_mouvement(fenetre, jeu) jeu.deplacer_perso() jeu_continue = True while jeu_continue: dessiner_carte(fenetre, jeu) dessiner_perso(fenetre, jeu) action = obtenir_action() if action.type == ACTION_QUITTER: jeu_continue = False elif action.type == ACTION_CLAVIER: if action.key == TOUCHE_HAUT: jeu.tourner_perso(Direction.HAUT) deplacer_perso(fenetre, jeu) elif action.key == TOUCHE_BAS: jeu.tourner_perso(Direction.BAS) deplacer_perso(fenetre, jeu) elif action.key == TOUCHE_GAUCHE: jeu.tourner_perso(Direction.GAUCHE) deplacer_perso(fenetre, jeu) elif action.key == TOUCHE_DROITE: jeu.tourner_perso(Direction.DROITE) deplacer_perso(fenetre, jeu) elif action.key == TOUCHE_ECHAP: jeu_continue = False if jeu.est_arrive(): animation_fin(fenetre, jeu) pause(.5) jeu_continue = False quitter()
def lancement(nom_fichier='carte.json'):
initialiser()
jeu = Jeu(DOSSIER + nom_fichier)
fenetre = Fenetre(jeu.cases)
def deplacer_perso(fenetre, jeu):
if jeu.peut_deplacer():
dessiner_mouvement(fenetre, jeu)
jeu.deplacer()
jeu_continue = True
while jeu_continue:
dessiner_carte(fenetre, jeu)
dessiner_perso(fenetre, jeu)
action = obtenir_action()
if action.type == ACTION_QUITTER:
jeu_continue = False
elif action.type == ACTION_CLAVIER:
if action.key == TOUCHE_HAUT:
jeu.perso.dir = Direction.HAUT
deplacer_perso(fenetre, jeu)
elif action.key == TOUCHE_BAS:
jeu.perso.dir = Direction.BAS
deplacer_perso(fenetre, jeu)
elif action.key == TOUCHE_GAUCHE:
jeu.perso.dir = Direction.GAUCHE
deplacer_perso(fenetre, jeu)
elif action.key == TOUCHE_DROITE:
jeu.perso.dir = Direction.DROITE
deplacer_perso(fenetre, jeu)
elif action.key == TOUCHE_ECHAP:
jeu_continue = False
if jeu.est_arrive():
animation_fin(fenetre, jeu)
pause(.5)
jeu_continue = False
quitter()
def test_get_navire_at():
jeu = Jeu()
jeu.placer_navire(2, 2, 2, "Horizontal", "Sous-marin de combat")
assert jeu.get_navire_at(32, 2) is True
assert jeu.get_navire_at(33, 2) is True
assert jeu.get_navire_at(32, 1) is False
assert jeu.get_navire_at(33, 0) is False
assert jeu.get_navire_at(31, 2) is False
assert jeu.get_navire_at(34, 2) is True
def personnaliser(self):
"""met en place les joueurs et le jeu"""
logger.info("Démarrage du contrôleur")
# détermine les joueurs interactifs
# pour commencer un seul
moi = m.JoueurInteractif("moi", visible = True)
# installe les joueurs à la table
# pour commencer par programme
self.table.accueuillir(moi, m.Joueur("gauche"), m.Joueur("partenaire"), m.Joueur("droite"))
# prepare la table pour un jeu de cartes
# pour commencer un jeu générique
self.table.dedier(Jeu())
self.vue.personnaliser(self.table)
self.vue.afficher()
def test_placer_navire():
jeu = Jeu()
jeu.placer_navire(5, 5, 1, "Vertical", "Destroyer")
assert jeu.carte_perso.navires[0].cases[0].x == 5
assert jeu.carte_perso.navires[0].cases[0].y == 5
assert jeu.carte_perso.navires[0].cases[0].z == 1
assert jeu.carte_perso.navires[0].cases[1].x == 5
assert jeu.carte_perso.navires[0].cases[1].y == 6
assert jeu.carte_perso.navires[0].cases[1].z == 1
assert jeu.carte_perso.navires[0].cases[2].x == 5
assert jeu.carte_perso.navires[0].cases[2].y == 7
assert jeu.carte_perso.navires[0].cases[2].z == 1
assert not jeu.carte_perso.navires[0].cases[2].x == 6
assert not jeu.carte_perso.navires[0].cases[2].y == 8
assert not jeu.carte_perso.navires[0].cases[1].z == 2
jeu.placer_navire(0, 0, 1, "Horizontal", "Sous-marin nucléaire")
assert jeu.carte_perso.navires[1].cases[1].x == 1
assert jeu.carte_perso.navires[1].cases[1].y == 0
assert jeu.carte_perso.navires[1].cases[1].z == 1
def main():
jeu = Jeu()
jeu.jouer()
# -*- coding: utf-8 -*- from settings import * from jeu import Jeu j = Jeu() j.start() # !!!! TESTING !!!! # !!!! TESTING !!!!
def jouer(self):
""" enchaine les parties tant qu'un joueur interactif le souhaite"""
self.partie.derouler()
def veut_arreter(self):
"""retourne vrai si la décision est prise d'arrêter de jouer"""
# pour l'instant, joue une seule partie du jeu
# passer de la partie finie à une nouvelle partie sinon
return True
if __name__=='__main__':
from jeu import Jeu
print "début des tests du modèle"
un_jeu = Jeu()
print un_jeu.nom
une_table = Table()
une_table.dedier(un_jeu)
print une_table.partie
un_joueur = Joueur("Testeur")
print un_joueur.main
une = 3
un_joueur.recevoir(une)
print un_joueur.main
plusieurs = range(4)
un_joueur.recevoir(plusieurs)
print un_joueur.main
print un_joueur.donner_une_carte()
Il faut exécuter ce fichier avant de lancer un ou plusieurs clients.
Les clients sont contenus dans le fichier 'client.py'.
"""
import os
import socket
import select
from carte import Carte
from commande import commandes
from jeu import Jeu
# Create the game
jeu = Jeu(carte)
for i, commande in enumerate(commandes):
# Commande Instanciation
commandes[i] = commande(jeu)
#Connect
clients = []
connexion = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
connexion.bind(('localhost', 29408))
connexion.listen(5)
print("On attend les clients.")
# Card choice
labyrinthe = None
while labyrinthe is None:
import traceback
from jeu import Jeu
pygame.init()
jeu_en_cours = True
#génération fenetre
pygame.display.set_caption("morpion")
ecran = pygame.display.set_mode((630, 630))
#import arrière plan
ArrierePlan = pygame.image.load('bg.png')
#importé le jeu
jeu = Jeu(ecran)
jeu.choisir_qui_commence()
def jeu_boucle():
global jeu_en_cours
#try:
# appliquer arrière plan
ecran.blit(ArrierePlan, (0, -200))
jeu.boucle_du_jeu()
# mettre a jour l'écrant
pygame.display.flip()
def setUp(self):
self.jeu = Jeu()
self.joueurs = [Joueur('David'), Joueur('Guillaume'), Joueur('Damien'), Joueur('Mathieu')]
self.jeu.ajoute_des_joueurs(self.joueurs)
choix = input("Entrez un numéro de labyrinthe pour commencer à jouer : ")
# Si le joueur n'a pas entré R, on s'attend à un nombre
try:
choix = int(choix)
except ValueError:
print("Choix invalide : {}".format(choix))
else:
if choix < 1 or choix > len(cartes):
print("Numéro invalide : ".format(choix))
continue
carte = cartes[choix - 1]
labyrinthe = carte.labyrinthe
# On crée le jeu
jeu = Jeu(carte)
for i, commande in enumerate(commandes):
# Instanciation de la commande
commandes[i] = commande(jeu)
# On connete le serveur
clients = []
connexion = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
connexion.bind(('localhost', 29408))
connexion.listen(5)
print("On attend les clients.")
# On boucle pendant toute la durée du jeu
while not jeu.labyrinthe.gagnee:
# On accepte les nouvelles connexions
nouvelles, w, x = select.select([connexion], [], [], 0.1)
# (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. # # main.py # Corps principal du programme # # Crée un objet de type jeu (contenant les règles et le moteur du jeu) # Crée un objet de type fenetre (contenant l'interface graphique) # Traite en boucle les évènements de l'interface graphique qui activent les fonctions du jeu # Le jeu renvoie les valeurs d'affichage vers l'interface graphique from tkinter import Tk # Création du jeu from jeu import Jeu job = Jeu() # Création de l'interface graphique root = Tk() from fenetre import Fenetre wnd = Fenetre(root, job) root.mainloop()
import pygame
from jeu import Jeu
pygame.init()
pygame.display.set_caption("Pokemon")
ecran = pygame.display.set_mode((1080, 700))
background = pygame.image.load('C:/Users/Mathys/Desktop/assets/bg.png')
jeu = Jeu()
execution = True
while execution:
ecran.blit(background, (0, -500))
ecran.blit(jeu.joueur.image, jeu.joueur.rect)
for projectile in jeu.joueur.all_projectiles:
projectile.move()
jeu.joueur.all_projectiles.draw(ecran)
if jeu.pressed.get(
pygame.K_RIGHT
) and jeu.joueur.rect.x + jeu.joueur.rect.width < ecran.get_width():
jeu.joueur.move_right()
elif jeu.pressed.get(pygame.K_LEFT) and jeu.joueur.rect.x > 0:
jeu.joueur.move_left()
pygame.display.flip()
jeu.dialoguer(dialogue)
def testSerializedDialogue():
with open('resources/temporaire/dialogue.pickle', 'rb') as file:
dialogue = pickle.load(file)
jeu.dialoguer(dialogue)
pygame.init()
pygame.mixer.init()
fenetre = Fenetre("test ISN Dialogue", constantes.largeur, constantes.hauteur)
fenetre.fond = pygame.image.load("resources/galaxie.jpg").convert_alpha()
with open('resources/niveau/1/firstDialog.pickle', 'rb') as file:
firstDialog = pickle.load(file)
with open('resources/niveau/1/middleDialog.pickle', 'rb') as file:
middleDialog = pickle.load(file)
with open('resources/niveau/1/lastDialog.pickle', 'rb') as file:
lastDialog = pickle.load(file)
jeu = Jeu(fenetre, Niveau(1), 0, 0)
for explode in constantes.explodeList:
explode = explode.convert_alpha()
#testDialog()
#testSerializedDialogue()
testplay()
pygame.quit()
def test_parse_message(test_input, expected):
"""Test de la fonction parse_message."""
jeu = Jeu()
assert jeu.parse_message(test_input) == expected
class TestJeu(unittest.TestCase):
def setUp(self):
self.jeu = Jeu()
self.joueurs = [Joueur('David'), Joueur('Guillaume'), Joueur('Damien'), Joueur('Mathieu')]
self.jeu.ajoute_des_joueurs(self.joueurs)
def test_peut_créer_un_jeu(self):
self.assertTrue(self.jeu)
def test_peut_ajouter_des_joueurs_en_plusieurs_fois(self):
self.assertEqual(len(self.jeu.joueurs), 4)
self.assertEqual(self.jeu.joueurs, self.joueurs)
self.jeu.ajoute_des_joueurs(['Edouard'])
self.assertEqual(len(self.jeu.joueurs), 5)
def test_le_premier_joueur_est_le_dealer(self):
self.assertEqual('David', self.jeu.donne_dealer().nom)
def test_chaque_joueur_joue_tour_a_tour(self):
self.assertEqual('David', self.jeu.donne_joueur().nom)
self.jeu.tour_suivant()
self.assertEqual('Guillaume', self.jeu.donne_joueur().nom)
self.jeu.tour_suivant()
self.jeu.tour_suivant()
self.jeu.tour_suivant()
self.assertEqual('David', self.jeu.donne_joueur().nom)
def test_le_joueur_peut_passer_son_tour(self):
self.jeu.action('passe')
self.assertEqual(len(self.jeu.joueurs_restant), 3)
self.assertTrue(self.joueurs[0] not in self.jeu.joueurs_restant)
def test_le_joueur_peut_checker(self):
self.jeu.action('check')
self.assertEqual(len(self.jeu.joueurs_restant), 4)
self.assertTrue(self.joueurs[0] in self.jeu.joueurs_restant)
def test_a_un_gagnant(self):
self.jeu.action('passe')
self.assertIsNone(self.jeu.gagnant())
self.jeu.action('passe')
self.jeu.action('passe')
self.assertEqual('Mathieu', self.jeu.gagnant().nom)
def test_chaque_joueur_se_voit_attribuer_2_cartes(self):
self.jeu.deal()
for joueur in self.joueurs:
self.assertEqual(len(joueur.cartes), 2)
def test_deux_joueurs_ne_peuvent_pas_avoir_la_meme_main(self):
self.jeu.deal()
self.assertTrue(self.joueurs[0].cartes[0] not in self.joueurs[1].cartes)
self.assertTrue(self.joueurs[0].cartes[1] not in self.joueurs[1].cartes)
def test_un_jeu_a_52_cartes(self):
self.assertEqual(52, len(self.jeu.cartes))
def test_fin_de_partie():
jeu = Jeu()
jeu.placer_navire(1, 2, 0, "Horizontal", "Sous-marin de reconnaissance")
jeu.fin_partie()
assert jeu.partie_gagnee is False
assert jeu.partie_perdue is False
jeu.recevoir_tir(1, 2)
jeu.recevoir_tir(2, 2)
jeu.recevoir_tir(3, 2)
jeu.fin_partie()
assert jeu.partie_perdue is True
assert jeu.partie_gagnee is False
jeu.compteur_bateau_coule = 18
jeu.fin_partie()
assert jeu.partie_gagnee is True
assert jeu.partie_perdue is True
jeu = Jeu()
jeu.placer_navire(1, 2, 0, "Horizontal", "Sous-marin de reconnaissance")
jeu.fin_partie()
assert jeu.partie_gagnee is False
assert jeu.partie_perdue is False
jeu.compteur_bateau_coule = 18
jeu.fin_partie()
assert jeu.partie_perdue is False
assert jeu.partie_gagnee is True
def test_ajouter_navire():
jeu = Jeu()
jeu.ajouter_navire(0, 0, 5, 2, 0)
jeu.ajouter_navire(60, 0, 5, 1, 0)
jeu.ajouter_navire(66, 0, 4, 1, 90)
jeu.ajouter_navire(10, 0, 3, 2, 0)
jeu.ajouter_navire(0, 1, 6, 1, 0)
jeu.ajouter_navire(30, 1, 3, 1, 90)
jeu.ajouter_navire(105, 2, 2, 1, 90)
jeu.ajouter_navire(105, 1, 5, 3, 90)
assert jeu.get_navire_at(0, 0) is True
assert jeu.get_navire_at(3, 0) is True
assert jeu.get_navire_at(5, 0) is False
assert jeu.get_navire_at(60, 0) is True
assert jeu.get_navire_at(0, 2) is False
assert jeu.get_navire_at(75, 0) is False
assert jeu.get_navire_at(66, 2) is False
assert jeu.get_navire_at(66, 0) is True
assert jeu.get_navire_at(67, 0) is False
assert jeu.get_navire_at(225, 0) is False
assert jeu.get_navire_at(125, 1) is False
assert jeu.get_navire_at(13, 0) is False
assert jeu.get_navire_at(0, 1) is True
assert jeu.get_navire_at(33, 0) is False
assert jeu.get_navire_at(6, 1) is False
assert jeu.get_navire_at(30, 2) is False
assert jeu.get_navire_at(45, 1) is True
assert jeu.get_navire_at(31, 1) is False
assert jeu.get_navire_at(105, 2) is True
assert jeu.get_navire_at(115, 0) is False
assert jeu.get_navire_at(106, 2) is False
assert jeu.get_navire_at(105, 1) is False
WIDTH_SCREEN = 600 # Paramétrage de la hauteur de la fenêtre.
HEIGHT_SCREEN = 600 # Paramétrage de la Longeur de la fenêtre.
def close_window():
'''
Fonction pour fermer la fenêtre du jeu.
'''
jeu.stopGame(
) # Ferme les processus en cours (sortie de la boucle infinie(While).
print("Game closed")
fen.destroy() # Ferme la fenêtre affichée sur l'écran.
fen = tk.Tk() # Ouvre une instance de Tkinter sur fen.
fen.protocol("WM_DELETE_WINDOW", close_window
) # Fonction appelée lors d'un clic sur la croix de la fenêtre.
fen.config(width=WIDTH_SCREEN,
height=HEIGHT_SCREEN) # Initialise la taille de la fenêtre.
fen.resizable(
width=False, height=False
) # Interdit le redimensionnement de la fenêtre en hauteur et en largeur.
fen.title('Casse Brique') # Définit un titre à la fenêtre.
fen.update() # Demande à l'os de rafraîchir le fenêtre.
jeu = Jeu(fen) # Crée une instance de Jeu dans la fenêtre.
jeu.startGame(
) # Démarre la boucle infinie (While) qui permet de rafraîchir tout les eléments du jeu, elle s'éxécute tant que la variable running est à l'état : True.
fen.mainloop(
) # Maintient la fenêtre ouverte (gestion des évênements clavier même lorsque le jeu est mis en pause(sortie de la boucle infinie)).
def main():
#for arg in sys.argv:
iterations = 500 # default
if len(sys.argv) == 2:
iterations = int(sys.argv[1])
print("Iterations: ")
print(iterations)
init()
#-------------------------------
# Initialisation
#-------------------------------
players = [o for o in game.layers['joueur']]
nbPlayers = len(players)
score = [0] * nbPlayers
# on localise tous les états initiaux (loc du joueur)
initStates = [o.get_rowcol() for o in game.layers['joueur']]
print("Init states:", initStates)
# on localise tous les objets ramassables
goalStates = [o.get_rowcol() for o in game.layers['ramassable']]
print("Goal states:", goalStates)
# on localise tous les murs
wallStates = [w.get_rowcol() for w in game.layers['obstacle']]
#print ("Wall states:", wallStates)
#-------------------------------
# Placement aleatoire des fioles
#-------------------------------
# on donne a chaque joueur une fiole a ramasser
# en essayant de faire correspondre les couleurs pour que ce soit plus simple à suivre
posPlayers = initStates
temoin = False
jeux = []
z = 0
for i in range(len(goalStates)):
#jeux.append(Jeu(game, players[z], "j"+str(z), posPlayers[z], goalStates[-i-1], wallStates, goalStates))
jeux.append(
Jeu(game, players[z], "j" + str(z), posPlayers[z], goalStates[i],
wallStates, goalStates))
jeux[i].play()
if (z >= nbPlayers):
z = 0
else:
z += 1
#-------------------------------
# Boucle principale de déplacements
#-------------------------------
for i in range(iterations):
if (temoin):
break
for jeu in jeux:
jeu.move()
# si on a trouvé un objet on le ramasse
if (jeu.position == jeu.goal):
o = jeu.player.ramasse(game.layers)
game.mainiteration()
# print ("Objet trouvé par le joueur ", jeu.nom)
goalStates.remove(
jeu.position) # on enlève ce goalState de la liste
score[jeu.ID] += 1
# et on remet un même objet à un autre endroit
x = random.randint(1, 19)
y = random.randint(1, 19)
while (x, y) in wallStates:
x = random.randint(1, 19)
y = random.randint(1, 19)
#o.set_rowcol(x,y)
#goalStates.append((x,y)) # on ajoute ce nouveau goalState
game.layers['ramassable'].add(o)
jeu.goal = (-1, -1)
jeu.reset()
jeu.play()
temoin = jeu.done()
game.mainiteration()
break
print("scores:", score)
pygame.quit()
FPS = 30
# Démarrer la bibliothèque
pygame.init()
# Définir la taille de la fenêtre en pixels
WIDTH, HEIGHT = 500, 500
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Gestion des menus")
# Horloge pour contrôler le fps
clock = pygame.time.Clock()
# Initialisation des pages
pages = [Page0(WIDTH, HEIGHT), Page1(WIDTH, HEIGHT), Jeu()]
page_idx = 0
prev_page_idx = 0
# Boucle principale
continuer = True
while continuer:
# Lancer uniquement la bonne page
if prev_page_idx != page_idx: # Chargement si nouvelle page
prev_page_idx = page_idx
pages[page_idx].start()
pages[page_idx].update(screen)
# Identifier la page suivante
page_idx = pages[page_idx].next_page_idx
def main():
# Ligne de commande
args = cli_setup()
if args.client:
if args.input!=None:
sys.stderr.write("\nErreur: le client n'a pas le droit de charger "+
"une partie sauvegardée\n\n")
quit()
# Mode réseau
if args.serveur or args.client:
args.nombre_joueurs = 2 # pour le moment
reseau = Reseau(args)
else:
reseau = None
# Initialisation de la fenêtre et de pygame
if reseau != None:
titre = 'Scrabble réseau - ' + args.pseudo
if args.serveur:
titre += ' (serveur)'
elif args.client:
titre += ' (client)'
else:
titre = 'Scrabble (local)'
pygame.init()
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption(titre)
# Création du plateau
plateau = Plateau(screen, Jeu.grille_bonus)
# Création du jeu
jeu = Jeu(args, reseau)
# mémoriser les éventuelles lettres posées sur le plateau
plateau.memoriser(jeu.joueurs[0])
# Contenu des chevalets
jeu.debuter_partie(reseau, plateau)
#####################
# Boucle principale #
#####################
continuer = True
clock = pygame.time.Clock()
while continuer:
# Gestion des évènements
for event in pygame.event.get():
if event.type == pygame.QUIT: # Fermeture de la fenêtre
continuer = False
if reseau!=None: reseau.reception.stop()
elif event.type == pygame.KEYUP:
if plateau.edition_joker==None:
if event.key == pygame.K_v: # Capture console
print(jeu)
elif event.key == pygame.K_s: # Sauvegarde fichier
if not(args.client):
filename = jeu.sauvegarder()
plateau.set_message('Sauvegarde dans '+filename, 'info')
elif jeu.partie_finie:
continuer = False
else: # Édition joker
res = plateau.editer_joker(event.key)
if res[0] and reseau != None:
reseau.envoyer('joker', str(jeu.joueur_local)+res[1])
elif not(jeu.partie_finie) and event.type == pygame.MOUSEBUTTONDOWN \
or event.type == pygame.MOUSEMOTION \
or event.type == pygame.MOUSEBUTTONUP:
res = plateau.handle_mouse_click(event, jeu)
if res != None:
############################
# Déplacement d'une lettre #
############################
src = res[0].pos # cellule initiale
dst = res[1] # cellule finale
result = jeu.deplacer_piece(jeu.joueur_local, dst, res[0])
if result and reseau!=None:
reseau.envoyer('move', src + ',' + dst)
# Afficher le plateau (arrière-plan, chevalet, lettre en mouvement,
# statistiques)
plateau.draw(jeu)
# Message d'information termporaire
plateau.afficher_message()
if not(jeu.partie_finie): #### Partie en cours ####
# Comptabiliser le score actuel du coup en cours
total_points, mots, points = jeu.verifier_positionnement()
# Bouton de validation (affichant les points)
plateau.afficher_bouton(total_points, jeu, jeu.local_is_playing())
###################
# Valider un coup #
###################
if plateau.button.is_clicked():
# Vérifier si le coup est valide
result = jeu.valider(jeu.joueur_local)
if not(result[0]): # Coup non valide
plateau.set_message(result[1])
else: # Coup valide
plateau.set_message(result[1], 'info')
plateau.memoriser(jeu.joueurs[jeu.joueur_actuel-1])
tirage = jeu.completer_chevalet(jeu.joueur_actuel)
if reseau!=None:
if tirage=="##FIN##": # fin de la partie
reseau.envoyer_multiple(['detail_coup', 'validation', 'tirage', 'fin'],
[result[1], '', ''.join(tirage), ''])
reseau.reception.stop()
else: # coup classique
reseau.envoyer_multiple(['detail_coup', 'validation', 'tirage'],
[result[1], '', ''.join(tirage)])
else:
jeu.joueur_local = jeu.joueur_actuel
else: #### Partie finie ####
plateau.afficher_fin(screen, jeu)
# Mettre à jour l'écran
pygame.display.flip()
# Contrôle du rafraichissement des images
clock.tick(fps)
pygame.quit()
quit()
def __init__(self, parent, controller, n, name):
super().__init__(parent)
# On expose le controlleur au reste de la classe pour pouvoir naviguer
self.controller = controller
self.first_tower = None
self.last_tower = None
# Utilisé à la fin du jeu pour les scores
self.name = name
self.start_time = None
self.columnconfigure(0)
self.rowconfigure(0, weight=1)
self.rowconfigure(1, weight=1, minsize=40)
# Placement de la Frame de turtle et de celle qui contient les boutons
frame1 = tk.Frame(self)
frame2 = tk.Frame(self)
frame1.grid(row=0, column=0)
frame2.grid(row=1, column=0)
canvas = tk.Canvas(frame1, width=600, height=300)
turtle = RawTurtle(canvas, visible=False)
turtle.up()
turtle._tracer(0) # Désactiver l'animation de déplacement
set_turtle(turtle) # Définir l'instance de turtle dans turtle_utils
canvas.grid()
# On initialise le jeu
game = Jeu(n)
dessine_plateau(game.n)
game.dessine_config()
self.game = game
# Placement de la Frame qui contient les boutons
buttons_frame = tk.Frame(frame2, bg='red')
buttons_frame.grid(sticky='nesw')
# Placement des boutons pour les tours
tk.Button(buttons_frame,
text=" 1 ",
command=lambda: self.button_press(0)).grid(row=0,
column=0,
sticky='nesw')
tk.Button(buttons_frame,
text=" 2 ",
command=lambda: self.button_press(1)).grid(row=0,
column=1,
sticky='nesw')
tk.Button(buttons_frame,
text=" 3 ",
command=lambda: self.button_press(2)).grid(row=0,
column=2,
sticky='nesw')
tk.Button(buttons_frame,
text='Ecran principal',
command=lambda: self.navigate_to_main(),
bg='red').grid(row=1, column=0, sticky='nesw')
action_button = tk.Button(buttons_frame,
text='Résoudre',
command=lambda: self.action_button_press())
action_button.grid(row=1, column=1, columnspan=2, sticky='nesw')
self.action_button = action_button
def test_defense_touche():
jeu = Jeu()
jeu.placer_navire(1, 2, 1, "Horizontal", "Sous-marin de reconnaissance")
jeu.recevoir_tir(0, 0)
jeu.recevoir_tir(1, 2)
jeu.recevoir_tir(3, 3)
assert jeu.get_defense_touche(0, 2) is True
assert jeu.get_defense_touche(0, 1) is True
assert jeu.get_defense_touche(0, 0) is True
assert jeu.get_defense_touche(31, 2) is False
assert jeu.get_defense_touche(31, 1) is True
assert jeu.get_defense_touche(31, 0) is True
assert jeu.get_defense_touche(32, 2) is False
assert jeu.get_defense_touche(32, 1) is False
assert jeu.get_defense_touche(32, 0) is False