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)
Exemplo n.º 3
0
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
Exemplo n.º 4
0
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()
Exemplo n.º 5
0
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)
Exemplo n.º 6
0
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)
Exemplo n.º 7
0
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()
Exemplo n.º 8
0
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()
Exemplo n.º 9
0
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
Exemplo n.º 10
0
    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()
Exemplo n.º 11
0
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
Exemplo n.º 12
0
def main():
    jeu = Jeu()
    jeu.jouer()
Exemplo n.º 13
0
# -*- coding: utf-8 -*-

from settings import *
from jeu import Jeu

j = Jeu()
j.start()

# !!!! TESTING !!!!

# !!!! TESTING !!!!



Exemplo n.º 14
0
    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()
Exemplo n.º 15
0
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:
Exemplo n.º 16
0
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()
Exemplo n.º 17
0
 def setUp(self):
     self.jeu = Jeu()
     self.joueurs = [Joueur('David'), Joueur('Guillaume'), Joueur('Damien'), Joueur('Mathieu')]
     self.jeu.ajoute_des_joueurs(self.joueurs)
Exemplo n.º 18
0
    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)
Exemplo n.º 19
0
# (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()
Exemplo n.º 20
0
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()
Exemplo n.º 21
0
    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()
Exemplo n.º 22
0
def test_parse_message(test_input, expected):
    """Test de la fonction parse_message."""
    jeu = Jeu()
    assert jeu.parse_message(test_input) == expected
Exemplo n.º 23
0
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))
Exemplo n.º 24
0
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
Exemplo n.º 25
0
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
Exemplo n.º 26
0
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)).
Exemplo n.º 27
0
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()
Exemplo n.º 28
0
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
Exemplo n.º 29
0
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()
Exemplo n.º 30
0
    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
Exemplo n.º 31
0
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