Projet jeu de plateau EscaT Game

**antoine43211234** · 20/05/2022, 23h11

bonsoir,
je suis en première année d’école d’ingénieur et j'ai donc un projet en langage python mais je ne sais vraiment pas comment le réaliser.
Si quelqu'un a des conseille ou peut m'aider pour ce projet je serai très reconnaissant et je peux rémunérer a hauteur des moyen d'un étudient.
ps: pas besoin d’interface il faut juste le jeux et les déplacement.
merci d'avance.
PythonProjetSujet.pdf

Invité · 21/05/2022, 00h19

Salut !

Pas mal comme petit projet !

Si tu connais un peu python ça ne me paraît pas si difficile, il te faudra par contre un peu de temps pour coder ça, tu dois rendre ça pour quand ?

Le travail est en binôme, mais la note est individuelle : lors de la soutenance, vous devrez être capable de proposer à la volée des modifications cohérentes pour votre code sur demande du jury.

Faut être vive d'esprit dites donc ! J'imagine qu'ils ne sont pas trop méchants et demandent juste de changer l'endroit du bassin ou ce genre de détails ?

PySimpleGUI je ne connais pas, mais ça à l'air assez simple d'utilisation, ça te permettrait d'avoir 2 points en + là dessus...

Bref, à ta place je prendrais les choses dans l'ordre :
- Créer un tableau 2D
- Faire de la POO pour les chats, le chaf, les robots et les gardiens (ex : chat1.pos = (x, y), chat1.mov = -1, ...)
- Le remplir avec les objets ayant une position fixe au démarrage : chaf, chats, sorties, gardiens et bassin
- Le remplir aléatoirement avec les robots autonomes en excluant les positions déjà occupées
- Etablir un tuple des positions correspondant aux zones d'exclusions (bassin, lieu de "spawn" des chats) pour les robots et les gardiens
- Etablir un tuple des positions correspondant à la zones d'exclusion (bassin) pour les chats et le chaf

Côté déplacement :
• Faut gérer le nombre de coups que chaque joueur à le droit de faire par tour,
• Gérer le nombre de mouvement par chat/gardien, d'où l'utilité du chatx.mov par exemple, si le joueur qui contrôle les chats bouge le chat1 et si chat1.mov != numero_du_tour alors chat1.mov = numero_du_tour ...
• Gérer les évènements : Si gardien.pos == chat.pos alors ... Si gardien.pos == robot.pos alors ... etc, etc.
• Gérer les collisions avec les parois et les zones d'exclusions précédemment renseignées (dans les tuples)
• Gérer les mouvements des robots automatiques

Bref je ne suis pas sûr d'apporter grand chose à l'énoncé...

A bientôt et bon courage !

**antoine43211234** · 21/05/2022, 00h30

salut,
le projet sur papier est plus complique que ce que je veux faire je vais simplement faire un tableau avec des lettre qui ce déplace mais je suis vraiment mauvais en python et j'ai un délais un peux réduit. j'ai également des examen et un binôme qui ne travaille plus c'est pour cela que je suis un peux bloque.
j'ai un début mais pas trop le temps de le finir.
mais merci des quelque conseils.

**MPython Alaplancha** · 21/05/2022, 06h44

Bonjour,
@antoine: L'énoncé ne nous dit pas quelles sont les difficultés que tu rencontres...
Aussi montre nous le code que tu as écrit et formule où tu bloques pour que nous puissions t'aider d'avantage.

**antoine43211234** · 21/05/2022, 08h12

bonjour,
voici ce que j'ai déjà fais. Ce qui me pose le plus de problème est le déplacement des robots qui doit être aléatoire sans quitter le tableau.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
118
119
120
121
122
123
124
125
126
127
128
from random import *
 
 
# creation du tableau 11*11
Taille_grille = 11
 
def tab(Taille_grille):
    tableau = [["0"]* Taille_grille for i in range(Taille_grille)]
 
 
    #positionnement éléments
    tableau[0][5]="S"
    tableau[4][0]="S"
    tableau[4][10]="S"    #positionnement sorties
 
    tableau[1][2]="W"     #positionnement gardiens
    tableau[1][8]="W"
 
    tableau[2][4]="B"
    tableau[2][5]="B"
    tableau[2][6]="B"     #positionnement bassin
    tableau[3][4]="B"
    tableau[3][5]="B"
    tableau[3][6]="B"
 
    tableau[8][4]="C"
    tableau[8][5]="C"
    tableau[8][6]="C"
    tableau[9][3]="C"
    tableau[9][4]="C"      #positionnement chats
    tableau[9][5]="C"
    tableau[9][6]="C"
    tableau[9][7]="C"
    tableau[10][3]="C"
    tableau[10][4]="C"
    tableau[10][5]="C"
    tableau[10][6]="C"
    tableau[10][7]="C"
 
    tableau[7][5]="ç"      # positionnement chaf 
 
    # positionnement des robots
    a= randint(0,len(tableau)-1)
    b= randint(0,len(tableau)-1)
 
    for i in range (9):
        a=randint(0,len(tableau)-1)
        b=randint(0,len(tableau)-1)
 
        while tableau[a][b]!="0":
             a=randint(0,len(tableau)-1)
             b=randint(0,len(tableau)-1)
        tableau[a][b]='R'
 
 
    #affichage de tableau ligne par ligne
    for i in range (len(tableau)):
        print (tableau[i])
    return tableau
 
#choix du chat    
def depchats(tab):
 
    for i in range (0,1):
        print ("quel chat déplacez vous ?")
        x=int(input("la coordonéée verticale = "))
        y=int(input("la coordonée horizontale ="))
        z=int(input("bas gauche (1), bas (2), bas droite (3), gauche (4), droite (6), haut gauche (7), haut (8), haut droite (9)"))
 
       # print(tab[x][y])
 
        if tab[x][y]=='C':
            if z == 1 and tab[x+1][y-1] == "0":
                tab[x+1][y-1]="C"
                tab[x][y]="0"
 
            else:
                print ("pas possible")
 
            if z==2 and tab[x+1][y] =="0":
                tab[x+1][y]="C"
                tab[x][y]="0"
 
            else:
                print ("pas possible")
 
            if z==3 and tab[x+1][y+1] =="0":
                tab[x+1][y+1]="C"
                tab[x][y]="0"
            else:
                    print ("pas possible")
 
            if z==4 and tab[x][y-1] =="0":
                tab[x][y-1]="C"
                tab[x][y]="0"
            else:
                    print ("pas possible")
 
            if z==6 and  tab[x][y+1]=="0":
                tab[x][y+1]="C"
                tab[x][y]="0"
            else:
                    print ("pas possible")
 
            if z==7 and  tab[x-1][y-1]=="0":
                 tab[x-1][y-1]="C"
                 tab[x][y]="0"
            else:
                     print ("pas possible")
 
            if z==8 and  tab[x-1][y]=="0":
                tab[x-1][y]="C"
                tab[x][y]="0"
            else:
                    print ("pas possible")
 
            if z==9 and  tab[x-1][y+1]=="0":
                tab[x-1][y+1]="C"
                tab[x][y]="0"
            else:
                    print ("pas possible")
 
    return tab            
 
tableau = tab(Taille_grille)
depchats(tableau)
 
print(tableau)

**Sve@r** · 21/05/2022, 09h25

Bonjour

Envoyé par antoine43211234

voici ce que j'ai déjà fait.

Déjà on met son code entre balises "code". Tu te serais promené dans le forum histoire de montrer qu'il t'intéresse et que tu ne le considères pas comme un pool de codeurs prêts à te faire ton boulot tu l'aurai vu. Accessoirement c'est érit dans les règles. Tu le sais qu'en Python on structure son algo sur les tabulations. Tu trouves ton code lisible? T'es-tu seulement relu après avoir posté???
Et c'est donc aussi écrit dans ces mêmes règles qu'on n'est pas là pour te faire ton boulot, même en étant payés pour ça. Franchement si tu penses que le boulot d'ingénieur en informatique c'est de déléguer ce qu'on te donne à faire vaut mieux que tu changes de voie tout de suite.

Envoyé par antoine43211234

Ce qui me pose le plus de problème est le déplacement des robots qui doit être aléatoire sans quitter le tableau.

Si ce n'est que ça... Tu connais la position du robot. Donc te suffit de boucler sur un déplacement hypothétique et tant que ce déplacement te fait sortir le robot du plateau tu recommences. Et quand tu quittes la boucle le déplacement hypothétique devient le déplacement réel du robot.

Sauf que malheureusement tu ne connais pas la position du robot. Parce que tu as codé à l'envers. Tu es parti du plateau de jeu et tu lui as placé les robots, les chats, les gardiens etc. Et arrivé à la fin, tu ne peux pas gérer tes pions parce que tu n'as pas de pions, tu as juste un plateau contenant des lettres. Tu as pris l'affichage comme support du jeu alors qu'en réalité il n'en est que la visualisation.

En effet, en programmation la phase "affichage" n'est qu'un détail. Il se fait à l'écran mais il pourrait se faire sur une imprimante, sur un réseau, sur une tablette tactile. L'écran n'est qu'un support.
Ce qu'il te faut faire c'est

un objet "chat"
un objet "robot"
un objet "gardien"
un objet "obstacle"

Chaque objet aura comme attributs une position X et Y. Tu pourrais même faire un objet "pion" contenant le minimum commun à tous ces éléments et faire hériter tous les autres objets de cet objet "pion". Ensuite lors des tours de jeu tu déplaces ces différents objets en modifiant leur X et/ou Y en gérant les intéractions. Et enfin seulement à la fin tu les affiches sur ton plateau.

Envoyé par LeNarvalo

PySimpleGUI je ne connais pas, mais ça à l'air assez simple d'utilisation,

C'est une IHM très minimaliste. Un peu style Qt mais en plus simple (et donc moins riche) Ou style tk mais en plus joli.

Envoyé par LeNarvalo

Faire de la POO pour les chats, le chaf, les robots et les gardiens (ex : chat1.pos = (x, y), chat1.mov = -1, ...)

Le chaf n'est qu'un chat un peu particulier. Suffit d'inclure la particularité comme booléen "est/n'est pas" dans l'objet "chat". Et franchement chat1 chat2... ça sert à quoi les listes???

Envoyé par LeNarvalo

Bref je ne suis pas sûr d'apporter grand chose à l'énoncé...

Sisi, c'est exactement ça qu'il faut faire. Partir des objets du jeu, les faire bouger et les afficher à la fin.

**antoine43211234** · 21/05/2022, 09h46

effectivement j’étais pressé et un peut perdu mais je suis au tout début de la programmation pour moi ce projet seul est presque insurmontable. sachant que je ne doit pas faire d'interface car le professeur pense que personne n'y arrivera dans ma classe. c'est pour cela que j'ai code de cette manière je cherche vraiment a faire un tableau ou il est possible de bouger les chats ce qui est fait. il me reste le déplacement de gardien qui va surement s'apparenter a celui des chats et celui des robots qui est pour moi le plus dure.
merci quand même pour les quelques conseils.

**antoine43211234** · 21/05/2022, 09h48

désole pour le code je n'est effectivement pas tout lu.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
118
119
120
121
122
123
124
125
126
127
128
from random import *
 
 
# creation du tableau 11*11
Taille_grille = 11
 
def tab(Taille_grille):
    tableau = [["0"]* Taille_grille for i in range(Taille_grille)]
 
 
    #positionnement éléments
    tableau[0][5]="S"
    tableau[4][0]="S"
    tableau[4][10]="S"    #positionnement sorties
 
    tableau[1][2]="W"     #positionnement gardiens
    tableau[1][8]="W"
 
    tableau[2][4]="B"
    tableau[2][5]="B"
    tableau[2][6]="B"     #positionnement bassin
    tableau[3][4]="B"
    tableau[3][5]="B"
    tableau[3][6]="B"
 
    tableau[8][4]="C"
    tableau[8][5]="C"
    tableau[8][6]="C"
    tableau[9][3]="C"
    tableau[9][4]="C"      #positionnement chats
    tableau[9][5]="C"
    tableau[9][6]="C"
    tableau[9][7]="C"
    tableau[10][3]="C"
    tableau[10][4]="C"
    tableau[10][5]="C"
    tableau[10][6]="C"
    tableau[10][7]="C"
 
    tableau[7][5]="ç"      # positionnement chaf 
 
    # positionnement des robots
    a= randint(0,len(tableau)-1)
    b= randint(0,len(tableau)-1)
 
    for i in range (9):
        a=randint(0,len(tableau)-1)
        b=randint(0,len(tableau)-1)
 
        while tableau[a][b]!="0":
             a=randint(0,len(tableau)-1)
             b=randint(0,len(tableau)-1)
        tableau[a][b]='R'
 
 
    #affichage de tableau ligne par ligne
    for i in range (len(tableau)):
        print (tableau[i])
    return tableau
 
#choix du chat    
def depchats(tab):
 
    for i in range (0,1):
        print ("quel chat déplacez vous ?")
        x=int(input("la coordonéée verticale = "))
        y=int(input("la coordonée horizontale ="))
        z=int(input("bas gauche (1), bas (2), bas droite (3), gauche (4), droite (6), haut gauche (7), haut (8), haut droite (9)"))
 
       # print(tab[x][y])
 
        if tab[x][y]=='C':
            if z == 1 and tab[x+1][y-1] == "0":
                tab[x+1][y-1]="C"
                tab[x][y]="0"
 
            else:
                print ("pas possible")
 
            if z==2 and tab[x+1][y] =="0":
                tab[x+1][y]="C"
                tab[x][y]="0"
 
            else:
                print ("pas possible")
 
            if z==3 and tab[x+1][y+1] =="0":
                tab[x+1][y+1]="C"
                tab[x][y]="0"
            else:
                    print ("pas possible")
 
            if z==4 and tab[x][y-1] =="0":
                tab[x][y-1]="C"
                tab[x][y]="0"
            else:
                    print ("pas possible")
 
            if z==6 and  tab[x][y+1]=="0":
                tab[x][y+1]="C"
                tab[x][y]="0"
            else:
                    print ("pas possible")
 
            if z==7 and  tab[x-1][y-1]=="0":
                 tab[x-1][y-1]="C"
                 tab[x][y]="0"
            else:
                     print ("pas possible")
 
            if z==8 and  tab[x-1][y]=="0":
                tab[x-1][y]="C"
                tab[x][y]="0"
            else:
                    print ("pas possible")
 
            if z==9 and  tab[x-1][y+1]=="0":
                tab[x-1][y+1]="C"
                tab[x][y]="0"
            else:
                    print ("pas possible")
 
    return tab            
 
tableau = tab(Taille_grille)
depchats(tableau)
 
print(tableau)

Invité · 22/05/2022, 22h01

@Sve@r
PySimpleGUI c'est du tkinter apparemment ! Donc pas plus joli... J'ai regardé quelques exemples, c'est le même truc has been que tkinter ! Je ne comprends pas que tkinter ne soit pas mis à jour graphiquement... Aucune idée du pourquoi du comment mais c'est quand même sacrément moche, sauf à vouloir donner un aspect rétro à son logiciel (mon excuse permanente ^^).

Et oui les chat1 chat2 ... c'était pas ma meilleure idée.

Tu connais la position du robot. Donc te suffit de boucler sur un déplacement hypothétique et tant que ce déplacement te fait sortir le robot du plateau tu recommences.

Je préfère préciser qu'il faut faire en sorte de ne pas bloquer le jeu dans une boucle ! C'est à dire qu'il faut retirer de la liste des déplacements tirés au sort ceux qui se révèlent impossible, car le hasard peut tirer au sort 3 milliards de fois d'affilés la direction qui envoie le pion dans un mur.

Tu es parti du plateau de jeu et tu lui as placé les robots, les chats, les gardiens etc. Et arrivé à la fin, tu ne peux pas gérer tes pions parce que tu n'as pas de pions, tu as juste un plateau contenant des lettres.

Pas sûr de comprendre, il me paraît assez simple de gérer les déplacements sans faire de POO, non ? Si le joueur clique sur le bouton D8 et qu'à cette position il y a un chat (lettre C) et que le joueur veut l'envoyer au Nord et si cette position est libre alors remplacer dans le tableau la case vide par un C et vider la case d'origine... Grosso modo.

**Sve@r** · 23/05/2022, 08h51

Envoyé par LeNarvalo

Je préfère préciser qu'il faut faire en sorte de ne pas bloquer le jeu dans une boucle ! C'est à dire qu'il faut retirer de la liste des déplacements tirés au sort ceux qui se révèlent impossible, car le hasard peut tirer au sort 3 milliards de fois d'affilés la direction qui envoie le pion dans un mur.

Tu peux mais si le ratio "déplacements autorisés/déplacement total" est à ton avantage tu peux laisser pisser, statistiquement tu finis par sortir un truc valide assez vite. M'est déjà arrivé de coder des trucs analogues (exemple générer des jeux de tests en m'arrangeant pour que tous les tests soient tous différents donc boucle tant que testX déjà sorti dans les X-1 autres et je sortais toujours). Après évidemment ça dépend aussi d'autres facteurs comme par exemple "j'ai besoin que le robot se déplace en temps réel" et effectivement là vaut mieux éviter les essais inutiles pour aller plus vite.

Envoyé par LeNarvalo

Pas sûr de comprendre, il me paraît assez simple de gérer les déplacements sans faire de POO, non ? Si le joueur clique sur le bouton D8 et qu'à cette position il y a un chat (lettre C) et que le joueur veut l'envoyer au Nord et si cette position est libre alors remplacer dans le tableau la case vide par un C et vider la case d'origine... Grosso modo.

On peut toujours faire sans POO, toujours. Toutefois c'est quand-même bien plus pratique de faire avec. Tu veux déplacer le chat N tu écris chat[n].move(X, Y, jeu) et hop, si tu as bien codé la méthode move() ça place et le chat à sa position X/Y et ça modifie le jeu en conséquence.
Et rappelons que tu as aussi conseillé la POO dans ton premier post

Alors oui effectivement dans certains cas (ton exemple) ça va. Mais avec ta méthode, pour déplacer les robots il faut alors parcourir tout le jeu pour en extraire la position desdits robots afin de pouvoir ensuite les déplacer. Donc recalculer des positions qu'on aurait pu avoir mémorisé à l'origine et donc ça prend du temps. Et là on tombe dans un dilemne assez classique de "vaut-il mieux recalculer n fois les mêmes valeurs ou les mémoriser" et dont la réponse dépend de pas mal de facteurs dont déjà la RAM que ça va prendre (et aujourd'hui, de la RAM on en a pas mal

)

Invité · 23/05/2022, 19h42

Malheureusement le ratio déplacements possibles / impossibles peut ne pas être très élevé imagine un angle plus un autre obstacle ne laissant qu'une chance sur 4 de tomber sur la seule direction possible... M'enfin je viens de faire des tests c'est quand même ultra peu probable de rester bloquer...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
>>> def toto():
	text = "NSEW"
	C = ""
	st = time.time()
	while C != "N":
		C = random.choice(text)
	delai = round(time.time()-st,2)
	return delai
 
>>> for i in range(100000000):
	delai = toto()
	if delai > 1:
		print(i, delai)
 
 
>>> #NADA

Mais avec ta méthode, pour déplacer les robots il faut alors parcourir tout le jeu pour en extraire la position desdits robots afin de pouvoir ensuite les déplacer. Donc recalculer des positions qu'on aurait pu avoir mémorisé à l'origine et donc ça prend du temps.

Hum, oui effectivement une perte de temps à ce niveau sauf à mettre les positions concernées dans une liste ou mieux un dictionnaire plutôt qu'une instance de classe si on veut s'en passer.

**fatbob** · 24/05/2022, 15h44

Plutôt que de faire de gros paquets de variables (chat1, chat2...), comme délicatement suggéré par Sve@r, il est plus efficace de passer par des listes.

Première version : notions de base basiques, chaque chat est un dictionnaire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
terrain = [['.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.'],
        ['.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.'],
        ['.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.'],
        ['.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.'],
        ['.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.'],
        ['.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.'],
        ['.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.'],
        ['.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.'],
        ['.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.'],
        ['.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.'],
        ['.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.']]
 
chats = [{'x':4, 'y':6, 'car':'c'}, {'x':3, 'y':2, 'car':'C'}]
 
for chat in chats:
    terrain[chat['x']][chat['y']] = chat['car']
 
for ligne in terrain:
    print(''.join(ligne))

2ème possibilité, avec des objets (avec en prime une initialisation du terrain plus efficace) :

C'est vraiment super basique pour rester simple à comprendre mais normalement la plus grosse partie de la structure est là

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
class Jeu:
    def __init__(self):
        self.terrain = Terrain()
        self.chats = [Chat(4,6), Chat(3,2, True)]
 
    def joue_un_tour(self):
        for chat in self.chats:
            chat.move('N')
 
    def display(self):
        print('')
        grille = self.terrain.init()
        for chat in self.chats:
            grille[chat.get_y()][chat.get_x()] = chat.get_char() # y est en premier en raison de la construction de la grille
                                                                 # C'est pour rester simpliste
        for ligne in grille:
            print(''.join(ligne))
 
    def run(self):
        self.display()
        self.joue_un_tour()
        self.display()
 
 
class Terrain:
    def init(self):
        return [['.' for i in range(11)] for j in range(11)]
 
class Chat:
    def __init__(self, x, y, is_chaf=False):
        self.is_chaf = is_chaf
        self.x = x
        self.y = y
 
    def get_char(self):
        if self.is_chaf:
            return 'C'
        else:
            return 'c'
 
    def move(self, direction):
        if direction == 'N':
            self.y -= 1
        elif direction == 'S':
            self.y += 1
        elif direction == 'E':
            self.x += 1
        elif direction == 'O':
            self.x -= 1
 
    def get_x(self):
        return self.x
 
    def get_y(self):
        return self.y
 
 
j=Jeu()
j.run()

Cette seconde méthode parait plus compliquée au premier abord mais simplifiera grandement la suite.
En fait, il faudrait faire un objet 'jeu' (qui gèrera tout), un 'terrain', un 'joueur', et un pour chaque autre acteur du jeu (robot, chat, bassin, gardien)
Les joueurs pourront indiquer les directions des déplacements... Mais évidemment, tout cela complique le code et rendrait plus difficile la compréhension (et accessoirement, ce serait moi qui ferais l'exercice :-) )

ici, juste pour évoquer la dynamique, j'ai mis une méthode run qui affiche la grille avec deux chats dans une position (dont un chaf), déplace les chats vers le haut et réaffiche la grille.
Pas d'interaction, pas de calculs compliqués, c'est juste la première étape.
Pour la suite des développement, il faudra y aller étape par étape.
Ajouter un objet pour les joueurs, ajouter pour ces joueurs le moyen de saisir les données pour les pions qu'ils manipulent...
Ajouter les autres pions, faire les méthodes de déplacement
Pour bien avancer, il ne faut pas lésiner sur les print un peu partout pour voir comment évoluent les contenus des variables...
Bref, mettre en place des méthodes de développement qui permettent d'arriver au résultat attendu autrement que par hasard :-)

Regarder le module "random" pour gérer le hasard (google python random)

Comme dit plus haut, il est possible de faire de l'héritage pour factoriser certaines méthodes (joueurs, robots, chats peuvent hériter de pion pour partager les position et les méthodes de déplacement...) mais ce n'est pas forcément urgent.

**Sve@r** · 24/05/2022, 16h32

Envoyé par fatbob

C'est vraiment super basique pour rester simple à comprendre mais normalement la plus grosse partie de la structure est là

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
class Jeu:
    def __init__(self):
        self.terrain = Terrain()
        ...
 
class Terrain:
    def init(self):
        return [['.' for i in range(11)] for j in range(11)]

Attention à ne pas non plus tomber dans l'excès de la POO pour faire genre "voyez comme je suis full POO". La classe "Terrain" n'est rien de plus qu'une simple fonction terrain qui pourrait parfaitement se faire directement dans le __init__du jeu. Ou si vraiment on veut séparer les actions (pourquoi pas) en faire alors une méthode de la classe "Jeu". Et si on veut on peut alors la mettre en méthode privée car elle n'a pas besoin d'être utilisée par un tiers

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
class Jeu:
    @staticmethod
    def __create():
        return [['.' for i in range(11)] for j in range(11)]
 
    def __init__(self):
        self.terrain = Jeu.__create()

**fatbob** · 24/05/2022, 18h57

Tout à fait exact.
C'est juste pour montrer un peu une organisation de code poo appliquée à ce cas sans trop entrer dans des techniques avancées.
Et il n'est pas dit que le terrain ne devrait pas intégrer quelques méthodes. Je n'ai pas poussé l'analyse plus loin que ça.

**fatbob** · 25/05/2022, 08h38

Pour détailler un peu ma remarque précédente (j'étais sur un téléphone).
Déjà, à la réflexion, je pense que les éléments de "bassin", plutôt que des acteurs, sont des caractéristiques de cases du terrain (on pourrait imaginer des tas d'autres caractéristiques - nourriture, pièges...).
Dans ce cas, le terrain ne peut plus se contenter d'être une liste de liste de points.
Dans mon expérience, l'approche "full poo" comme tu dis, est plus facile à faire évoluer. C'est à dire que dans ce cas, si j'ai une classe "terrain" et même une classe "case", je peux facilement faire évoluer les caractéristiques du terrain et des cases sans avoir à modifier le reste du programme. Si les "capsules" sont bien délimitées, l'évolution se résume à ajouter des fonctionnalités sans avoir trop de refactoring à faire.

Par ailleurs, comme les objets sont, de base, copiés par référence, je peux facilement créer plusieurs façon de les retrouver.

Par exemple, si j'ai un objet "terrain", il peut avoir une collection de cases pour représenter leur emplacement, mais je peux aussi référencer les cases spéciales ou autres dans des listes séparées pour y accéder plus efficacement.
Le fait d'avoir un objet "terrain" me permet de gérer toute cette complexité de façon totalement transparente au niveau du jeu qui se contente d'être un grand ordonnanceur.

Alors oui, partir sur des objets qui ne font qu'encapsuler des objets déjà existant (finalement, une liste est un objet, nespa), c'est pas très KISS. Mais ici, dans le cas d'un terrain de jeu, il est à peu près certain que si on le laisse sous forme de liste de '.' basique, il faudra faire du refactoring ou alors inclure dans le "jeu" toutes les méthodes qui devraient normalement relever de la gestion du "terrain".

...Par contre, plus de nouvelle d'antoine43211234 ?
C'est marrant cette façon de poser des questions et de ne plus revenir si la réponse n'est pas donnée dans la journée (ou avant la date de rendu de l'exercice)... Ça laisse songeur quant au plateau de la balance qui pèse le plus lourd entre "envie d'apprendre" et "envie de faire résoudre un exercice par quelqu'un d'autre"

**Arioch** · 25/05/2022, 08h51

Envoyé par fatbob

Ça laisse songeur quant au plateau de la balance qui pèse le plus lourd entre "envie d'apprendre" et "envie de faire résoudre un exercice par quelqu'un d'autre"

On en voit passer un paquet ici.

**fatbob** · 25/05/2022, 09h53

Je m'en doute.
D'un autre côté, c'est intéressant d'échanger sur les pratiques...

**Sve@r** · 25/05/2022, 16h56

Envoyé par fatbob

Déjà, à la réflexion, je pense que les éléments de "bassin", plutôt que des acteurs, sont des caractéristiques de cases du terrain (on pourrait imaginer des tas d'autres caractéristiques - nourriture, pièges...).
Dans ce cas, le terrain ne peut plus se contenter d'être une liste de liste de points.
Dans mon expérience, l'approche "full poo" comme tu dis, est plus facile à faire évoluer. C'est à dire que dans ce cas, si j'ai une classe "terrain" et même une classe "case", je peux facilement faire évoluer les caractéristiques du terrain et des cases sans avoir à modifier le reste du programme. Si les "capsules" sont bien délimitées, l'évolution se résume à ajouter des fonctionnalités sans avoir trop de refactoring à faire.

Par ailleurs, comme les objets sont, de base, copiés par référence, je peux facilement créer plusieurs façon de les retrouver.

Par exemple, si j'ai un objet "terrain", il peut avoir une collection de cases pour représenter leur emplacement, mais je peux aussi référencer les cases spéciales ou autres dans des listes séparées pour y accéder plus efficacement.
Le fait d'avoir un objet "terrain" me permet de gérer toute cette complexité de façon totalement transparente au niveau du jeu qui se contente d'être un grand ordonnanceur

Tout à fait. La granularité de tes objets dépend bien évidemment de ce que tu veux leur faire faire. J'ai créé une fois un solveur de sudoku, j'avais un objet "case" et un objet "zone" (ligne/colonne/carré ça reste qu'une zone à la base). Et chaque case connaissait sa zone "ligne", sa zone "colonne" et sa zone "carré" tandis que chaque zone connaissait ses cases.

Envoyé par fatbob

Alors oui, partir sur des objets qui ne font qu'encapsuler des objets déjà existant (finalement, une liste est un objet, nespa),

Il est vrai

Envoyé par fatbob

...Par contre, plus de nouvelle d'antoine43211234 ?
C'est marrant cette façon de poser des questions et de ne plus revenir si la réponse n'est pas donnée dans la journée (ou avant la date de rendu de l'exercice)... Ça laisse songeur quant au plateau de la balance qui pèse le plus lourd entre "envie d'apprendre" et "envie de faire résoudre un exercice par quelqu'un d'autre"

Bah oui, des fois c'est comme ça. Tant pis, s'il n'a pas besoin de nous ça ne m'empêche pas d'échanger avec les autres (dont toi). Ca nous enrichit nous et c'est là l'important.

**fatbob** · 25/05/2022, 17h25

Envoyé par Sve@r

J'ai créé une fois un solveur de sudoku...

Moi aussi mais j'avais fait façon fainéant (pour tester la programmation par contraintes...

Le code complet tient en 30 lignes (c'est sale, c'est du python 2 mais c'est pas mal, les contraintes, dommage que je n'ai jamais à les utiliser dans mon boulot)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
import constraint
init_grid = [int(e) for e in 
            list(""" 003 008 060
                     105 070 000
                     000 100 009
 
                     060 009 700
                     000 827 000
                     009 500 080
 
                     500 006 000
                     000 080 207
                     020 700 800 """.replace('\n','').replace(' ',''))]
for j in range(0,81,9):
    print [init_grid[i] for i in range(j, j+9)]
print
 
# Ca commence ici
p = constraint.Problem()
 
vals = range(1,10) # Les valeurs
cells = range(81) # Les cases du sudoku
 
p.addVariables(cells, vals)
 
# Définitions des fameuses zones
rows = [[cells[i] for i in range(j, j+9)] for j in range(0,81,9)]
cols = [[cells[i + j*9] for j in range(9)] for i in range(9)]
squares = [[cells[i + k + l + j*9] for j in range(3) for i in range(3)] for l in range(0,81,27) for k in range(0,9,3)]
 
# Et hop, les contraintes
for group in rows + cols + squares:
    p.addConstraint(constraint.AllDifferentConstraint(), group)
 
# Ajout des Contraintes sur les valeurs des cellules déjà alimentées
for i, cell in enumerate(init_grid):
    if cell!=0:
        print i, cells[i], cell
        p.addConstraint(constraint.InSetConstraint([cell]), [i])
 
# On laisse la bibliothèque résoudre le problème
s = p.getSolution()
 
# Affichage du résultat
for j in range(0,81,9):
    print [s[i] for i in range(j, j+9)]

Projet jeu de plateau EscaT Game

Python

Discussions similaires

Partager

Partager