Discussion :

[moithibault]

Bonsoir ,

j'ai un défis , il faut que je réalise ce jeu :
http://www.mediafire.com/?zzy0dfinjid
ce jeu codé par seb_parfait que je doit 'refaire' en python.
J'aimerais bien que quelqu'un d'expérimenté puisse m'aider à la conception de l'algorythme jusqu'a la réalisation du jeu . Je débute en python et aprez avoir vu des sources similaires (puissance 4...) Je n'est pas encore le niveau requis pour ce genre d'expérience .
Si vous pouviez m'aider pour quoi que se soit sa serait génial
TRANSMETTEZ VOTRE SAVOIR , Thibault

[N.tox]

Salut, je vois bien l'organistaion comme ça :

Une classe Tableau, qui possède .... un tableau (whoaaaa c'est [dégngue]) qui aurait pour élément des instances de classe Case, et une méthode pour remttre à l'état 0 les qui ne sont ni pénétrables, ni remplies (voir ci-après)

Une classe Case donc, qui aurait :
ø un attribut parent qui serait un référence vers l'objet Tableau
ø un attribut state qui serait un integer qui représenterait l'état de la case (0:libre, -1: impénétrable, 1:vert rempli, 2: vert duplication, 3: vert mouvement, 4: rouge rempli, etc...)
ø une méthode clicked, qui changerait l'état des case voisines (accessibles depuis l'attribut parent (qui ne serait en fait rien d'autre que l'objet Tableau crée)

Voilà très grosso merdo le concept, qui je le répète est très généralisé, et sera plus ou moins revu au niveau des valeurs suivant la méthode de représentation (graphique) choisie.

Si tu débute en python, lis donc d'abord le cours de Gérard Swinnen (la partie sur Tkinter), sinon si tu es assez à l'aise, tu peux envisager une solution avec Pygame (module qui exige une certaine aisance avec python, mais aussi un aisance avec les sprites etc... déconseillé pour les débutant dans ce domaine... sinon bah fonces )

NB: si je ne te donne pas plus d'indications, c'est voulu, tu comprendras et retiendras bien mieux si tu apprends par toi même (enfin avec des bouquins quand même), qu'avec une solution toute faite

[moithibault]

Merci c'est super gentil de ta part , j'ai déjà commencé à faire le graphique du jeu , pour mon niveau j'ai [quasi] tout lu le super tuto de Swinnen (3/4).

Je reviens quand j'ai un probléme! merci

[moithibault]

Bonjour
, j'ai un petit probléme au niveau de mon code ,

Voilà ce que j'ai fait pour la création de mon plateau de jeux , il est semblable à ça :


○○○○○○○○
○○○○○○○○
○○○○○○○○
○○○○○○○○
○○○○○○○○
○○○○○○○○
○○○○○○○○
○○○○○○○○

8*8

Voici le code:

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
def play(plat):
        ligne=0
        pos_x=0
        pos_y=60
        decalage_x=75
        decalage_y=65
        i=0
 
 
        while(ligne<8):
            pos_x=pos_x+decalage_x
            cate= plat[i]
            plateau(pos_x,pos_y,25,cate)	.bacterie()
            ligne=ligne+1
            i=i+1
        pos_x=0
        pos_y=pos_y+decalage_y
        while(ligne<16):
            pos_x=pos_x+decalage_x
            cate= plat[i]
            plateau(pos_x,pos_y,25,cate)	.bacterie()
            ligne=ligne+1
            i=i+1
 
        pos_x=0
        pos_y=pos_y+decalage_y
        while(ligne<24):
            pos_x=pos_x+decalage_x
            cate= plat[i]
            plateau(pos_x,pos_y,25,cate)	.bacterie()
            ligne=ligne+1
            i=i+1
 
        pos_x=0
        pos_y=pos_y+decalage_y
        while(ligne<32):
            pos_x=pos_x+decalage_x
            cate= plat[i]
            plateau(pos_x,pos_y,25,cate)	.bacterie()
            ligne=ligne+1
            i=i+1
 
        pos_x=0
        pos_y=pos_y+decalage_y
        while(ligne<40):
            pos_x=pos_x+decalage_x
            cate= plat[i]
            plateau(pos_x,pos_y,25,cate)	.bacterie()
            ligne=ligne+1
            i=i+1
 
        pos_x=0
        pos_y=pos_y+decalage_y
        while(ligne<48):
            pos_x=pos_x+decalage_x
            cate= plat[i]
            plateau(pos_x,pos_y,25,cate)	.bacterie()
            ligne=ligne+1
            i=i+1
 
        pos_x=0
        pos_y=pos_y+decalage_y
        while(ligne<56):
            pos_x=pos_x+decalage_x
            cate= plat[i]
            plateau(pos_x,pos_y,25,cate)	.bacterie()
            ligne=ligne+1
            i=i+1
 
        pos_x=0
        pos_y=pos_y+decalage_y
        while(ligne<64):
            pos_x=pos_x+decalage_x
            cate= plat[i]
            plateau(pos_x,pos_y,25,cate)	.bacterie()
            ligne=ligne+1
            i=i+1

L'argument 'plat' est une suite de 64nombres , ils serviront a différencer les différents type de trous (remplis rouge , remplis noir.....)

plat est sous cette forme:
'0000000000001001001000000000000000000000000000000000000000000000'


Ensuite j'ai une class qui contient une méthode , elle sert a différencier les différents trous (elle est appelé dans le code de création du tableau ci-dessus: plateau(arguments).bacterie() ) :

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
#Les bactériee
class plateau:
 
    def __init__(self, x =0, y =0, r =40,cate=0):
        self.pos_x = x
        self.pos_y = y
        self.rayon = r
        self.cate=cate
        #BACTERIE et TROU 
    def bacterie(self):
        #vide
        if(self.cate==0):
            corp.create_oval(self.pos_x-self.rayon,
                         self.pos_y-self.rayon, 
                         self.pos_x+self.rayon,
                         self.pos_y+self.rayon,
                         fill="#C9DFEF"
                         )
            #vert
        elif(self.cate==1):
            corp.create_oval(self.pos_x-self.rayon,
                         self.pos_y-self.rayon, 
                         self.pos_x+self.rayon,
                         self.pos_y+self.rayon,
                         fill="green")
              #rouge          
        elif(self.cate==2):
            corp.create_oval(self.pos_x-self.rayon,
                         self.pos_y-self.rayon, 
                         self.pos_x+self.rayon,
                         self.pos_y+self.rayon,
                         fill="red"
                        )
            #trou noir         
        elif(self.cate==3):
            corp.create_oval(self.pos_x-self.rayon,
                         self.pos_y-self.rayon, 
                         self.pos_x+self.rayon,
                         self.pos_y+self.rayon,
                         fill="black"
                        )
 
             #possibilité rouge         
        elif(self.cate==4):
            corp.create_oval(self.pos_x-self.rayon,
                         self.pos_y-self.rayon, 
                         self.pos_x+self.rayon,
                         self.pos_y+self.rayon,
                         fill="pink"
                        )
 
             #possibilité verte         
        elif(self.cate==5):
            corp.create_oval(self.pos_x-self.rayon,
                         self.pos_y-self.rayon, 
                         self.pos_x+self.rayon,
                         self.pos_y+self.rayon,
                         fill="#C2F955"
                        )
        else:
            corp.create_oval(self.pos_x-self.rayon,
                         self.pos_y-self.rayon, 
                         self.pos_x+self.rayon,
                         self.pos_y+self.rayon, 
                         fill="black")

Tout ça pour vous dire que si je change ma chaine 'plat' par :
'0000000000000000000000000000000000000000000000000000000000011100'



Rien ne se passe , les trou sont tous noirs
D'ou viens le probléme et il n'y a pas un moyen d'écourter mon code en ce qui concerne la création du plateau de jeu?

MERCIIII

[moithibault]

Ah je pense que c'est une histoire de type de variable , je demande des INT alors que se sont des STRING

[moithibault]

C'est bien ça , j'ai changé pour garder le type string , par contre ma fonction de création de plateau est simplifiable?

[N.tox]

Oulà oui, y'a moyen de grandement simplifier, ou en tous cas de faire quelque chose de plus flexible, et de plus lisible... Non, je ne vais pas te montrer , j'ai fais un truc de mon côté, mais c'est intimement lié aux mécanismes du jeu (rien de graphique pour autant), continues avec ce que tu as, que tu te frotte un peu plus aux problématiques que le gameplay occasionne, j'te montrerais un peu plus tard ce que j'ai fait...

Toutefois, une chose qui simplifierait grandement ton code actuel, ce serait que le plateau soit dans un fichier du style :

Code :

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

1
2
3
4
5
6
7
8
00000000
00000000
00011000
00100100
00100100
00011000
00000000
00000000

Ça sera non seulement plus simple pour créer un plateau hors code, mais aussi in-code, puisque tu peux lire fichier ligne par ligne ex:

Code :

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

1
2
3
4
f_in=open('./MyFile', 'r')
for line in f_in:
    line = line.strip() #permet d'enlever les espaces et les retours
                        # à la ligne au début et à la fin de cette dernière

Graphiquement, le truc le plus simple (ou en tous cas ce qui me semble le plus simple), c'est d'utiliser des boutons pour les cases... tu utilises bien Tkinter ?

[moithibault]

Merci de tes conseils je vais essayé de réadapter mon code pour acceuillir tes conseils , voici un petit screenshot de mon jeu actuel , j'avait (puisque je vais optez pour le technique que tu m'as dit) mis les map dans un array , puis une incrémentation pour les charger par contre pour avoir mes maps en miniature j'ai du dupliquer ma fonction car le canvas qui acceuilé les maps changé et j'ai pas reussi a mettre le nom du canvas en argument sans que ça me mette une erreur.
Voilà l'image:
http://photomaniak.com/upload/out.ph..._screenbac.png



J'ai réussi à simplifier la fonction play , qui sert à crée le plateau ( oui celle avec plein de boucles) Voilà gros raccourcis plus qu'une boucle :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
def play(plat,pos_x=0,pos_y=60,decalage_x=75,decalage_y=65,rayon=25,div=1):
    ligne=0
    i=0
    while(ligne<64):
        if(ligne%8==0):
            pos_x=0
            pos_y=pos_y+decalage_y
        pos_x=pos_x+decalage_x
        cate= plat[i]
        plateau(pos_x,pos_y,rayon,cate,div)	.bacterie()
        ligne=ligne+1
        i=i+1

J'ai utilisé modulo , si c'est un multiple de 8 on reviens à la ligne =D



Sinon J'utilise bien tkinter (on peu le voir au logo de mes fenêtres) , et pour ce qui est du plateau chargé externement , tu parles du plateau qui est entrain de jouer , ou de chaque plateaux que j'utilise dans le jeu?

Et j'arrive pas à voir la différence entre une class qui contient plusieurs méthode et une série de fonctions , limite je trouve sa plus compliqué c'est quoi l'avantage d'une classe ?

[N.tox]

c'est juste plus clair, la version ultra courte de la définition d'une classe c'est que les classe sont des sacs dans lesquelles on y met des variables et des fonctions qui deviennent respectivement des attributs et des méthodes. Mais Une classe c'est quand même plus que cela ca permet de créer des objets, on peut mettre dans ces objets des méthode spéciales qui permette de les additionner, soustraire, incrémenter, appeler comme une fonction, imiter les container (listes) cad qu'on puisse y acceder via des indices (ex: x[1]), les faire itérer sur un ensemble de donnés spécifiques produites par un algorithme, etc... les possibilité sont nombreuses, on pourrait par exemple créer une classe Float, qui représenterait les float sous forme de fraction ce qui permettrait une plus grande précision, puis un sous-classe Fraction, qui elle ne se limiterait pas a des fraction du type (50/1e5)...

Les classes ne paraissent pas très utiles au tout début (d'ailleurs on pourrait s'en passer, mais ce serait vraiment faire Paris-Lille en passant par Marseille, penches-toi sérieusement dessus, tu verras que ça en vaut le coup.

Dans le code que j'ai fait de mon côté, le gameplay réside dans deux classes, pour un poil plus d'une centaine de lignes, sans les commentaires. Tu n'auras qu'a demander, et je le posterais. Je vais maintenant développer la partie graphique qui les utilisera...

Dans tous les cas, malgrés ton code qui m'effraie (pas hyper "sexy" (toujours 400 fois mieux que ce que c'était ), et puis je suis une sacrée feignasse...), t'as l'air de bien t'en sortir, et c'est très bien

EDIT:

j'avait (puisque je vais optez pour le technique que tu m'as dit) mis les map dans un array

Attention, faire les map dans un fichier, n'empêche en rien de les traduires en array. D'ailleurs mon intention quand je t'ai donné l'astuce des fichiers maps était bien entendu que tu traduises ces dernier en maps depuis le code :

Code :

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

1
2
3
4
5
6
7
f_in=open('./MyMap','r')
tableau=[]
for ligne in f_in:
    tableau.append([])
    for char in ligne.strip():
        etat=int(char)
        tableau[-1].append([Une case avec un etat défini par la variable etat])

je pense que pour un jeu, l'aspect graphique doit être évidemment pris en considération et qu'une vague idée de la façon dont on s'y prendra est fort utile, mais le plus important, le plus prioritaire (après les règles évidemment) c'est le gameplay. Je pense sincèrement que l'aspect graphique doit être dans les dernières choses à coder/réaliser. Si on peut coder le gameplay et le faire tourner sans cet aspect graphique, c'est tout bon : on peut comme ça par la suite s'en servir quelque soit l'interface graphique choisie. Et ce genre de choses est souvent plus facile en passant par des classes.

"Tu pouvais pas dire ça plus tôt..."
Gnark gnark gnark, non

[moithibault]

Merci , oui moi je code un peu 'à l'arrache' , j'ai un peu tout fait en même temps car le fait de buter sur quelquechose me donner envie de continuer quelque chose d'utile par la suite.
Je vais un peu étudier les class car je ne suis pas clair dessus ..
C'est sympa de faire un truc de ton côté , j'essayes de faire quelque chose de meilleur et je repost ça dans la semaine

ps: J'ai 17ans et j'ai mon oral defrançais (bac) Mardi , et autant dire que ma fascination pour python me fait totalement oublier mes révisions!

[N.tox]

C'est pas bien, le bac, même si pour l'avoir t'apprends plein de trucs qui te serviront pas dans la vie, aujourd'hui en France si t'as pas le bac, peu d'employeurs seront prêt à te donner ta chance, je parle en connaissance de cause, et du coup tu peux facilement te retrouver à faire un taff de base (souvent bien chiant et pas bien payé...). Au pire redoubles autant de fois que nécessaires jusqu'à ce que tu l'aies.

[moithibault]

Oui , mais tu sais le français ....Je suis en 1ére S (scientifique) , le BAC c'est pour l'année prochaine là c'est juste les épreuves anticipées de souffrance

C'est parti je code

[moithibault]

Je comprend pas ton code:

Code :

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

1
2
3
4
5
6
7
8
 
f_in=open('./MyMap','r')
tableau=[]
for ligne in f_in:
    tableau.append([])
    for char in ligne.strip():
        etat=int(char)
        tableau[-1].append([Une case avec un etat défini par la variable etat])

Parce que j'ai mis toutes les maps dans un fichier et j'aimrais les récupérer dans un array , mais je ne sais aps comment délimiter chaque map , j'aimerais dire au code de supprminer les espaces et retour (comme tu le l'a montré) et inscrusté dans l'array une valeur tout les 64 caractéres..

[N.tox]

Je pensais en fait à une map par fichier, c'est plus simple et moins coûteux en ressources matérielles : pas besoin de parcourir 36 maps avant d'arriver à la 37ème (en admettant que ce soit celle-là que l'on veux) ou bien même de toutes les stocker en mémoires (c'est encore pire )

et inscrusté dans l'array une valeur tout les 64 caractéres..

Je reste sur ma lancée, l'array doit représenter une map, pas plus.

"Plus feignant tu dois être,
si bon programmeur tu veux être."
-proverbe informatique zen-

[moithibault]

Ah ok , donc il y aura 27 fichiers dans le dossier map
Sinon est-il possible d'assigner à un bouton deux fonctions? , car j'aimerais lors d'un click sur un bouton fermer le fenetre et executer une autre fonction simultanémment , possible?

[N.tox]

Tu peux toujours assigner comme comande à ton bouton une fonction qui ferme la fenêtre et exécute une autre fonction.

dans le forum Tkinter y'a un message en post-it, dans ce dernier j'ai posté un lien vers un document vraiment complet sur Tkinter, conjugué au bouquin de Swinnen qui montre comment se servir simplement de Tkinter, tu as beaucoup de possibilités qui s'offrent à toi. Ca te prendra spurement un peu de temps d'explorer tout Tkinter, donc survole ce qui t'intéresse .

Un autre lien vraiment nécessaire pour exploiter les capacités des classes :
http://docs.python.org/reference/dat...l-method-names

[moithibault]

Merci

Sinon j'ai fait un dossier map avec toutes mes maps séparés , map1,map2....map27.

Code :

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

1
2
3
4
5
6
7
8
 
f_in=open('./map','r')
partie=[]
for ligne in f_in:
    partie.append([])
    for char in ligne.strip():
        etat=int(char)
        partie[-1].append([])

Le probléme :

Code :

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

1
2
IOError: [Errno 13] Permission denied: './map'
>>>

Pourtant mon dossier n'est pas utilisé par une autre application ..Comment faire dans ce cas ?

[N.tox]

open permet d'ouvrir un fichier, pas un dossier.

admettons l'arborescence suivante:

Code :

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

1
2
3
4
5
+--#[ maps ]
|  +- map01
|  +- map02
|
+- test.py

dans test.py, pour ouvrir le fichier map01 :

Code :

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

map=open('./maps/map01','r')

et os.listdir permet d'obtenir la liste de touts les fichiers et dossier dans le dossier passé en paramètre:

Code :

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

1
2
3
4
5
6
import os
for object_name in os.listdir('./maps'):
    if os.path.isdir('./maps/'+object_name):
        print './maps/'+object_name, 'is a folder'
    else:
        print './maps/'+object_name, 'is a file'

[moithibault]

Voilà j'ai fait ma fonction :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
def charger_map(nom):
     f_in=open("maps/"+nom,'r')
     t = f_in.read()
     for t in f_in:
            t = t.strip()
     partie.append(t)
     f_in.close()
 
 
 
 
charger_map("map1")

Probléme : La chaine renvoyé me met les retour chariot /n , pourtant j'ai bien mis :

Code :

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

1
2
 for t in f_in:
            t = t.strip()

J'ai même essayez :

Code :

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

1
2
3
4
5
6
def charger_map(nom):
     f_in=open("maps/"+nom,'r')
     t = f_in.read()
     t=t.rstrip()
     partie.append(t)
     f_in.close()

Mais en vain...Help.




EDIT:Gros probléme, j'en peu plus 3h que j'essayez que j'essaye de corriger le truc mais rien à faire je péte un cable

Donc je vais vous mettre mon code:

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
 
#****************[4]*********ON  ANALYSE LE CLICK!
def analyse(cate,position):
 
                  print "position:",
                  print position
                  print "categorie: "+cate+"\n"
 
 
 
#Plateau
class plateau:
 
    "ma classe plateau"
    def __init__(self, x =0, y =0, r =40,cate=0,Canvas="corp",position=0):
         self.pos_x,self.pos_y,self.rapositionn,self.cate,self.Canvas,self.position = x,y,r,cate,Canvas,position	
 
         global vert,rouge,vide,trou,contour_vert,contour_rouge,contour_vide,contour_trou,remplissage,contour	
         vert,rouge,vide,trou,contour_vert,contour_rouge,contour_vide,contour_trou="#9FE400","#E50404","#C9DFEF","#333333","#9FE400","#E50404","#00ccff","#333333"
 
#****************[2]*********CREATION      DES PIONS SELON LA CATEGORIE    
    def bacterie(self):
 
        if(self.cate=="0"):
            remplissage=vide
            contour=contour_vide
        elif(self.cate=="1"):
            remplissage=vert
            contour=contour_vert  
        elif(self.cate=="2"):
            remplissage=rouge
            contour=contour_rouge 
        elif(self.cate=="3"):
            remplissage=trou
            contour=contour_trou
        elif(self.cate=="4"):
            remplissage=vert
            contour=contour_trou
        elif(self.cate=="5"):
            remplissage=rouge
            contour=contour_trou 
        elif(self.cate=="6"):
            remplissage=vide
            contour=contour_rouge
        elif(self.cate=="7"):
            remplissage=vide
            contour=contour_vert
        tchuck=str(self.position+1)		
        self.Canvas.create_oval(self.pos_x-self.rapositionn,
                                self.pos_y-self.rapositionn,
                                self.pos_x+self.rapositionn,
                                self.pos_y+self.rapositionn,
                                fill=remplissage,
                                outline=contour,
                                tag=tchuck)
        print "Pion numéro:",self.position,"\n categorie:",self.cate,"\n\n"
#****************[3]*********ON ENVOIE LE CLIQUE A ANALYSER
 
        self.Canvas.tag_bind(tchuck,"<Button-1>",lambda event : analyse(self.cate,self.position))			
 
 
 
 
 
 
 
#fin de la class plateau
 
#****************[1]*********Creation du plateau de jeu!
def play(plat,pos_x=0,pos_y=0,decalage_x=75,decalage_y=65,rapositionn=25,Canvas=corp):
 
    position=0
    while(position<64):
 
        if(position%8==0):
            pos_x=0
            pos_y=pos_y+decalage_y
        pos_x=pos_x+decalage_x
        cate= plat[position]
        plateau(pos_x,pos_y,rapositionn,cate,Canvas,position).bacterie()
        print "position:",position
        position=position+1

ps: en commentaire : #****************[nombre]********* , nombre signifie l'étape du cheminement .

Le probléme:
Si le Canvas est corp alors le premier pion cliqué afficher en position : 3 , et le dernier pion qu'on peu cliquer est l'avant-antépénultiemme , je comprend pas pourquoi! Ensuite sa ne m'affiche pas dans la console de 'position :' pour le pion numéro 0 , sa affiche quand Canvas != corp:

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
Pion numéro: 0 
 categorie: 3 
 
 
position: 0
Pion numéro: 1 
 categorie: 1 
 
 
position: 1
Pion numéro: 2 
 categorie: 0 
 
 
position: 2
Pion numéro: 3 
 categorie: 0 
 
 
position: 3
Pion numéro: 4 
 categorie: 0 
 
etc....

Et quand le Canvas est le corp sa me me met ça :

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
position: 63
Pion numéro: 0 
 categorie: 3 
 
 
position: 0
Pion numéro: 1 
 categorie: 1 
 
 
position: 1
Pion numéro: 2 
 categorie: 0 
 
 
position: 2
Pion numéro: 3 
 categorie: 0

grrr , moi ce que je veux c'est que la position = le numéro du pion ... et que sa aye de 0 à 63 .
S'il vous plait ça me bloque depuis trop longtemps

[N.tox]

Voilà j'ai fait ma fonction :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
def charger_map(nom):
     f_in=open("maps/"+nom,'r')
     t = f_in.read()
     for t in f_in:
            t = t.strip()
     partie.append(t)
     f_in.close()
 
 
 
 
charger_map("map1")

Probléme : La chaine renvoyé me met les retour chariot /n , pourtant j'ai bien mis :

Code :

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

1
2
 for t in f_in:
            t = t.strip()

1°) jamais dans le code que je t'ai donné, je n'ai utilitsé la méthode read. Read lit tout un fichier, ce qui amène la "tête de lecture" à la fin de celui-ci, et donc la boucle suivante n'a plus rien sur quoi boucler, et ne bouclera donc pas.

2°) boucler sur un fichier nous retourne à chaque itération un LIGNE du fichier

3°) partie.append(t) doit se trouver DANS la boucle, sinon quel intérêt ?

4°) dans l'hypothèse où tu supprime l'instruction où tu lit tout le fichier, et met "partie.append(t)" dans la boucle, tu obtiendrait un liste de chaîne de caractères. je ne pense pas que cela soit ton but.

revoici donc le code posté que je t'ai posté précédement, avec des notes en plus :

Code :

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

1
2
3
4
5
6
7
f_in=open('./MyMap','r') #ouverture d'un fichier
tableau=[] #création d'une liste
for ligne in f_in: #pour chaque lignes dans le fichier
    tableau.append([]) #ajoute un liste dans la liste
    for char in ligne.strip(): #pour chaque caractères dans la ligne (dénué de retours à la ligne grace à strip())
        etat=int(char) #etat reçoit l'entier qu'est censé représenter le caractère
        tableau[-1].append([Une case avec un état défini par la variable etat]) #ici je parle d'un objet case, donc d'un classe, ou plus exactement de la creation d'une instance de cette dernière.

Conclusion, qui ne va pas te faire plaisir :
Si tu as lu aussi bien le bouquin de Swinnen, que le bout de code que je t'avais posté, et bien relis-le, et expérimentes en même temps. Lire un bouquin de prog sans expérimentation ne sert à rien, on ne retient que par l'expérience. Je te dis ça parce que "partie.append(t)" hors de la boucle me semble très révélateur : tu ne maitrises pas assez les bases de la programmation. Donc mieux vaut oublier ton jeu pour une semaine ou deux, le temps de te faire de vraies bases, bien solides.

De mon côté, j'écris un tuto, qui explique un peu tous les concepts (niveau intermédiaire) mis en oeuvre dans le code que j'ai fait, mais je n'expliquerais pas les bases.

PS : si le bouquin de swinnen te semble un peu trop long, tu as toujours ceci, plus résumé
http://docs.python.org/tutorial/