"Trouver et gagner"

Version imprimable

16/06/2010, 11h43
ptitdje

"Trouver et gagner"

Bonjours à tous,

je suis actuellement dans l'élaboration d'un petit jeux en python mais beaucoup de problème apparaissent , tout d'abord je suis un débutant. Mon 1er jeu créer est le ping pong ( j'ai utilisé un fichier client.py un server.py et un proto.py ) mais désormais je voudrai créer un second jeu plus compliqué mais je ne sais pas comment commencé : ce jeux consisterai à avoir une grille 2D avec un nombre de cases ( exemple : grille de 8x8 donc 64 cases ) définit. Donc le but serait simple, on a 2 joueurs qui sont lancé via les 2 clients, et chacun leur tour ils choisiraient une case de la grille, jusqu'à trouver l'unique case gagnante (définit aléatoirement) . J'ai surtout des problèmes pour la grille . Et je ne sais pas si il faudrait que je mette tout mon code uniquement dans le server.py ou dans le server et le client.

Voilà le principe est relativement simple je veux faire ce jeu pour comprendre les tableaux sous python et ensuite faire du versionnage via lauchpad !! ^^

Merci d'avance pour le coup de main =)

1ère erreur

Traceback (most recent call last):
File "momo.py", line 129, in <module>
tour_joueur += 1
TypeError: unsupported operand type(s) for +=: 'NoneType' and 'int'

Je vous laisse le code entier afin d'évaluer l'erreur :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
 
import string
 
def placer(tour, nom_j1, nom_j2):
    global tableau, case_remplie
 
 
    if tour%2 == 0:
        symbole = "X"
        nom = nom_j1
    else :
        symbole = "Y"
        nom = nom_j2
 
    texte = nom + ", ou voulez vous placer(A1) : "
    case = raw_input(texte)
    case = string.upper(case)
 
    # on place le symbole à la case demandée
    if case == "A1" and tableau[0][0] == " ":
        tableau[0][0] = symbole
        case_remplie += 1
    elif case == "A2" and tableau[1][0] == " ":
        tableau[1][0] = symbole
        case_remplie += 1
    elif case == "A3" and tableau[2][0] == " ":
        tableau[2][0] = symbole
        case_remplie += 1
    elif case == "A4" and tableau[3][0] == " ":
        tableau[3][0] = symbole
        case_remplie += 1
    elif case == "B1" and tableau[0][1] == " ":
        tableau[0][1] = symbole
        case_remplie += 1
    elif case == "B2" and tableau[1][1] == " ":
        tableau[1][1] = symbole
        case_remplie += 1
    elif case == "B3" and tableau[2][1] == " ":
        tableau[2][1] = symbole
        case_remplie += 1
    elif case == "B4" and tableau[3][1] == " ":
        tableau[3][1] = symbole
        case_remplie += 1
    elif case == "C1" and tableau[0][2] == " ":
        tableau[0][2] = symbole
        case_remplie += 1
    elif case == "C2" and tableau[1][2] == " ":
        tableau[1][2] = symbole
        case_remplie += 1
    elif case == "C3" and tableau[2][2] == " ":
        tableau[2][2] = symbole
        case_remplie += 1
    elif case == "C4" and tableau[3][2] == " ":
        tableau[3][2] = symbole
        case_remplie += 1
    elif case == "D1" and tableau[0][3] == " ":
        tableau[0][3] = symbole
        case_remplie += 1 
    elif case == "D2" and tableau[1][3] == " ":
        tableau[1][3] = symbole
        case_remplie += 1
    elif case == "D3" and tableau[2][3] == " ":
        tableau[2][3] = symbole
        case_remplie += 1
    elif case == "D4" and tableau[3][3] == " ":
        tableau[3][3] = symbole
        case_remplie += 1
 
    else :
        print "la case est déjà remplie, ou vous n'avez pas tapez une case valide."
        tour -= 1
        return tour
 
 
 
# affiche le tableau
def affichage(tableau):
    print "\n  A   B   C   D"
    print "#################"
    for i in range(0,4):
        print "#",tableau[i][0],"|",tableau[i][1],"|",tableau[i][2],"|",tableau[i][3],"#", i+1
        if i != 3 :
            print "#---+---+---+---#"
        if i != 0 and i != 1 and i != 2 :
            print "#################"
 
 
def verification(tableau, nom_j1, nom_j2):
    global fini   
    if tableau[2][2] == "X" or tableau[2][2] == "Y":
        print "Bravo", nom_j1, "vous avez gagné"
        fini = True
    else :
        print "Bravo", nom_j2, "vous avez gagné"
        fini = True
 
 
 
 
 
 
tour_joueur = 0
fini = False
tableau = [[" ", " ", " "," "],[" ", " ", " "," "],[" ", " ", " "," "],[" ", " ", " "," "]]
case_remplie = 0
nom_joueur1 = raw_input("entrez le nom du 1er joueur, vous aurez les X: ")
nom_joueur2 = raw_input("entrez le nom du 2eme joueur, vous aurez les X: ")
 
affichage(tableau)
 
while not fini :
    tour_joueur = placer(tour_joueur, nom_joueur1, nom_joueur2)
    affichage(tableau)
    tour_joueur += 1
    affichage(tableau)
    verification(tableau, nom_joueur1, nom_joueur2)

bonjour,

ça m'a l'air sympa comme petit challenge. par contre je suis vraiment lamentable en appli client/serveur. tu pourrais poster ce que tu as fais pour le premier jeu dont tu parles s'il te plait ?

pour représenter la grille, tu as la solution native Python qui consiste à faire une liste de liste. Tu peux même te créer toi même une classe spécifique, par exemple:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
import random
 
class Grid(object):
 
    def __init__(self, rows, columns):
 
        self._rows = []
        for i in xrange(rows):
            column = [0]*columns
            self._rows.append(column)
        self._shape = (rows, columns)
        self._initialise()
 
    def __getitem__(self, key):
 
        return self._rows[key[0]][key[1]]
 
    def __setitem__(self, key, value):
 
        self._rows[key[0]][key[1]] = value
 
    def shape(self):
 
        return self._shape
 
    def _initialise(self):
 
        i = random.randint(0,self._shape[0]-1)
        j = random.randint(0,self._shape[1]-1)
        self[i,j] = 1
 
    def __str__(self):
 
        return str(self._rows)
 
    def play(self, i, j):
 
        try:
            if self[i,j]:
                print "Gagne !!"
            else:
                print "Perdu, essaie encore."
        except IndexError:
            print "Le point n'est pas dans la grille..."
 
 
g = Grid(2,2)
g.play(1,3)
g.play(0,0)
g.play(0,1)
g.play(1,0)
g.play(1,1)
print g

edit: pas vu ton code avant de poster. je pense que c'est interessant de passer par une classe comme je l'ai fait, ça sera vachement plus facile pour implémenter la mécanique de jeu ;)

mon 1er jeu :

Voilà ce que donne mon 1er jeu :

client.py

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
from proto import proto
from pynetez.Session import Session
from pynetez.Client  import Client
 
class SessionOnClient(Session):
 
    def do_pong(self):
        print "PONG"
        self.finish()
 
    def on_start(self):
        self.send.ping()
 
client = Client(proto, SessionOnClient)
client.run("localhost", 9999)

server.py

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
from proto import proto
from pynetez.Session import Session
from pynetez.Server  import Server
 
class SessionOnServer(Session):
 
    def do_ping(self):
        print "PING"
        self.send.pong()
 
server = Server(proto, SessionOnServer)
server.run(9999)

proto.py

Code:

1
2
3
4
5
6
 
from pynetez.Protocol import Protocol
 
proto = Protocol()
proto.defmsgtype("ping")
proto.defmsgtype("pong")

Il n' y a rien de spécial mais sa fonctionne bien . Pour l'idée de passer par une classe , je vais faire comme sà mais du coup je ne sais plus trop comment faire l'affichage de la grille par rapport a ce que j'avais fait comme sà

Code:

1
2
3
4
5
6
7
8
9
10
11
 
 
def affichage(tableau):
    print "\n  A   B   C   D"
    print "#################"
    for i in range(0,4):
        print "#",tableau[i][0],"|",tableau[i][1],"|",tableau[i][2],"|",tableau[i][3],"#", i+1
        if i != 3 :
            print "#---+---+---+---#"
        if i != 0 and i != 1 and i != 2 :
            print "#################"

Concernant l’affichage de ton tableau:

if i != 0 and i != 1 and i != 2 :
plus simple et sans doute plus rapide d’écrire
if i not in (0,1,2):

mais ce n’est pas ce qu’il faut faire, car étant donné que
for i in range(0,4):
c’est équivalent à if i==3

à mon avis, pour éviter ces tests continuels, il faut mettre les valeurs à afficher en dictionnaire
Code:

1 2 3 4 lignes = dict( ((0,"#---+---+---+---#") , (1,"#---+---+---+---#") , (2,"#---+---+---+---#") , (3,"#################") ))
et on affiche lignes[i]

au lieu de
"#",tableau[i][0],"|",tableau[i][1],"|",tableau[i][2],"|",tableau[i][3],"#", i+1
il faut écrire
"# "+tableau[i][0]+" | "+tableau[i][1]+" | "+tableau[i][2]+" | "+tableau[i][3]+" # "+str( i+1)
C’est plus rapide à afficher.

- L’objet d’identifiant tableau étant un objet composite, et ses valeurs étant accessibles à partir de l’intérieur d’une fonction, il n’a pas à être déclaré comme objet global pour être modifié à partir de l’intérieur d’une fonction.

- Les objets d’identifiants nom_j1 et nom_j2 n’étant pas modifiés tout au long d’une session de jeu, et leurs valeurs étant accessibles de l’intérieur d’une fonction, on peut se passer de les donner comme arguments à la fonction placer()

- Ça ne me semble pas une bonne manière de faire d’avoir un objet d’identifiant fini qui soit un objet global.
Je pense préférable de faire renvoyer une valeur booléenne par la fonction verification().
Celle-ci demande à être réécrite, d’ailleurs, car je ne vois pas à quoi correspond la condition if tableau[2][2] == "X" or tableau[2][2] == "Y":

- Pourquoi faire de l’objet case_remplie un objet global et pas l’objet tour ?

J’ai apporté des modifications pour condenser le code:

On peut remplacer les lignes
Code:

1 2 3 4 5 6 if tour%2 == 0: symbole = "X" nom = nom_j1 else : symbole = "Y" nom = nom_j2
par
Code:

1 2 3 (nom_j1,nom_j2)[tour%2] et ("X","Y")[tour%2]
Transformation de ’A1’ en (0,0) , de ’A2’ en (1,0) , de ’A3’ en (2,0) , de ’A4’ en (3,0) , de ’B1’ en (0,1) , de ’B2’ en (1,) , ......
pour simplifier les conditions
Code:

1 2 3 4 5 6 7 8 9 10 if case == "A1" and tableau[0][0] == " ": tableau[0][0] = symbole case_remplie += 1 elif case == "A2" and tableau[1][0] == " ": tableau[1][0] = symbole case_remplie += 1 elif case == "A3" and tableau[2][0] == " ": tableau[2][0] = symbole case_remplie += 1 etc
Simplification de l’entrée des donnees A1, b4, c3, A2, etc....

Code:

col,lin = input((nom_j1,nom_j2)[tour%2] + ", ou voulez vous placer(A1) : ").upper()

L’importation de string est dès lors inutile.
Code:

1 2 print "\n A B C D" print "#################"
remplacées par

Code:

print ("\n A B C D\n#################")

On peut encore faire des modifications, mais j’arrête là pour le moment.
Voici ce que ça donne comme code. La fonction verification() est laissée telle quelle, c’est à dire fausse.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 def placer(tour, nom_j1, nom_j2): global case_remplie col,lin = input((nom_j1,nom_j2)[tour%2] + ", ou voulez vous placer(A1) : ").upper() print ('col =',col,' lin =',lin) col,lin = int(tr[col]),int(lin)-1 # on place le symbole à la case demandée if tableau[lin][col] == " ": tableau[lin][col] = ("X","Y")[tour%2] case_remplie += 1 else : print ("la case est déjà remplie, ou vous n'avez pas tapez une case valide.") tour -= 1 return tour lignes = dict( ((0,"#---+---+---+---#") , (1,"#---+---+---+---#") , (2,"#---+---+---+---#") , (3,"#################") )) # affiche le tableau def affichage(tableau): print ("\n A B C D\n#################") for i in range(0,4): print ("# "+tableau[i][0]+" | "+tableau[i][1]+" | "+\ tableau[i][2]+" | "+tableau[i][3]+" # "+str( i+1)+\ '\n'+lignes[i]) def verification(tableau, nom_j1, nom_j2): global fini print ('tableau[2][2] = ',tableau[2][2],tableau[2][2] == "X",tableau[2][2] == "Y") if tableau[2][2] == "X" or tableau[2][2] == "Y": print ("Bravo", nom_j1, "vous avez gagné") fini = True else : print ("Bravo", nom_j2, "vous avez gagné") fini = True tr = dict(zip( ('A','B','C','D'), (0,1,2,3) )) tour_joueur,case_remplie = 0,0 fini = False tableau = [[" ", " ", " "," "],[" ", " ", " "," "],[" ", " ", " "," "],[" ", " ", " "," "]] nom_joueur1 = 'alain'#input("entrez le nom du 1er joueur, vous aurez les X: ") nom_joueur2 = 'robert'#input("entrez le nom du 2eme joueur, vous aurez les X: ") affichage(tableau) print('fini =',fini) while not fini : tour_joueur = placer(tour_joueur, nom_joueur1, nom_joueur2) affichage(tableau) tour_joueur += 1 affichage(tableau) print('fini =',fini) verification(tableau, nom_joueur1, nom_joueur2)
---------------------

Pour l’erreur que tu as:

TypeError: unsupported operand type(s) for +=: 'NoneType' and 'int'

c’est parce que la fonction placer() ne renvoie rien, c’est à dire qu’en fait elle renvoie None, quand le remplissage d’une case s’est bien déroulé.

L’instruction tour_joueur += 1 consiste alors à vouloir ajouter 1 à None.

Merci pour tout ces conseils , je viens d'effectuer les modifications , il ne me reste plus qu'a mettre se gros paquet de code en un server.py , un client.py et un proto.py

Voilà ce que j'ai pour le moment :
proto.py

Code:

1
2
3
4
5
6
7
8
9
10
11
12
rom pynetez.Protocol import Protocol, int8
proto = Protocol()
proto.defmsgtype("pending")  
proto.defmsgtype("connected") 
proto.defmsgtype("go")
proto.defmsgtype("wait")
proto.defmsgtype("take", n=int8)
proto.defmsgtype("err")
proto.defmsgtype("abort")
proto.defmsgtype("left", n=int8)
proto.defmsgtype("won")
proto.defmsgtype("lost")

client.py

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
from proto import proto
from pynetez.Session import Session
from pynetez.Client  import Client
 
 
 
class SessionOnClient(Session):
 
 
    def do_go(self):
        n = int(raw_input("A vous de jouer: "))	
        self.send.take(n=n)
 
 
    def do_err(self):
        print "Mouvement impossible"
 
 
 
    def do_left(self, n=None):
        i=0
        while self.grille[i][n] == 0 and i < 7:	
            i+=1
        if self.grille[i][n] != 0:
			i-=1
        self.compteur += 1
        if self.compteur %2 == 1:
            self.grille[i][n] = 1
        else:
            self.grille[i][n]=2
        #On affiche l'etat de la grille
        i=0
        print " _ _ _ _ _ _ _ _"
        while i<len(self.grille):
            j=0
            chaine = ""
            while j<len(self.grille):
                chaine += "|"
                chaine += str(self.grille[i][j])
                j+=1
            print chaine
            i+=1
        print " _ _ _ _ _ _ _ _"
 
 
 
 
 
    def do_won(self):
        print "Vous gagnez la partie!"
        self.finish()
 
 
 
 
 
    def do_lost(self):
        print "Vous perdez la partie!"
        self.finish()
 
 
 
 
    def do_abort(self):
        print "Partie abandonnee!"
        self.finish()
 
 
 
 
 
    def do_pending(self):
        self.compteur = 0
        self.grille  = [[0,0,0,0,0,0,0,0],
                        [0,0,0,0,0,0,0,0],
                        [0,0,0,0,0,0,0,0],
                        [0,0,0,0,0,0,0,0],
                        [0,0,0,0,0,0,0,0],
                        [0,0,0,0,0,0,0,0],
                        [0,0,0,0,0,0,0,0],
                        [0,0,0,0,0,0,0,0]]
        print "En attente d'un adversaire..."
 
 
 
 
 
    def do_connected(self):	
        print "Vous avez un adversair!"
        i=0
        print " _ _ _ _ _ _ _ _"
        while i<len(self.grille):
            j=0
            chaine = ""	
            while j<len(self.grille):
                chaine += "|"
                chaine += str(self.grille[i][j])
                j+=1
            print chaine
            i+=1
        print " _ _ _ _ _ _ _ _"
 
 
 
 
 
    def do_wait(self):
        print "C'est au tour de l'adversair de jouer..."
 
 
from optparse import OptionParser
parser = OptionParser("usage: %prog [options]")
parser.add_option("--host","-H",dest="host",default="localhost")
parser.add_option("--port","-p",dest="port",type=int,default=9999)
options, args = parser.parse_args()
client = Client(proto, SessionOnClient)
client.run(options.host, options.port)

et le server.py reste a faire mais je ne sais pas comment m'y prendre pour que tout cela fonctionne ...

J’ai bourré le code d’astuces de calculs et d’affichage et j’arrive à ça:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
def jouer_un_coup():
 
    # pour entrer correctement les valeurs
    while 1:
        entree = input((nom_joueur1,nom_joueur2)[tour%2] + ", quelle case voulez vous cocher ? : ")
        if len(entree)==2:
            col,lin = 'ABCD'.find(entree[0].upper()),'1234'.find(entree[1])
            if -1 not in (col,lin):
                if NUM[lin][col]==0:
                    break
                else:
                    afficher ("\nil faut désigner une case vide. recommencez")
            else:
                afficher ("\nil faut désigner une case valide. recommencez")
        else:
            afficher ('\nil faut taper 2 caractères. recommencez')
 
    # on remplit la liste et le tableau dans la case désignée
    LI[5*lin+col] = ("| X ","| Y ")[tour%2]
    NUM[lin][col]      = (1,-1)[tour%2]
 
    # on affiche le resultat du coup
    afficher ("\n  A   B   C   D\n#################\n" + ''.join(LI))
 
    # tester s'il y a un gagnant ou si cases toutes remplies
    sommes = (sum(NUM[lin]), sum(NUM[x][col] for x in (0,1,2,3)),
              sum(NUM[i][i] for i in (0,1,2,3)), sum(NUM[i][3-i] for i in (0,1,2,3)) )
    if 4 in sommes or -4 in sommes:
        afficher ("Bravo", (nom_joueur1,nom_joueur2)[-4 in sommes], "vous avez gagné.")
        return 16
 
    return 1
 
#-------------------------------------------------------------------------------------
 
afficher = print
 
nom_joueur1 = 'alain'#input("entrez le nom du 1er joueur, vous aurez les X: ")
nom_joueur2 = 'robert'#input("entrez le nom du 2eme joueur, vous aurez les X: ")
 
NUM = [[0,0,0,0],
       [0,0,0,0],
       [0,0,0,0],
       [0,0,0,0]]
# affichage du tableau vide
LI = ["|   ", "|   ", "|   ","|   ","| 1\n#---+---+---+---#\n",
      "|   ", "|   ", "|   ","|   ","| 2\n#---+---+---+---#\n",
      "|   ", "|   ", "|   ","|   ","| 3\n#---+---+---+---#\n",
      "|   ", "|   ", "|   ","|   ","| 4\n#################\n"]
afficher ("\n  A   B   C   D\n#################\n" + ''.join(LI))
 
# une partie
tour = 0 
while tour<16:
    tour += jouer_un_coup()

La ligne afficher = print rend ce code exécutable aussi bien en Python 3 qu’en version précédente sans se casser la tête à changer les instructions de print.

Le tableau de X et Y est en fait représenté par une liste LI.
Remarquer l’affichage instantané d'un tableau grâce à la façon dont son affichage est écrit.

Un autre tableau numérique (NUM) enregistre des 1 ou - 1 selon le joueur.
Ceci pour simplifier la recherche de ligne ou colonne ou diagonale remplie de X (-> de 1) ou de Y(-> -1).