Salut,
D'abord j'espère avoir posté dans la bonne section...
Comme il est dit dans le titre, je viens vers vous pour avoir un avis sur ma façon de programmer, savoir si je fais bien les choses, si je suis sur la bonne voie, sur la logique etc.
J'ai bien conscience qu'il n'est pas forcément agréable d'éplucher un programme fait pas un débutant (première fois que je tente de vraiment penser en objets) mais cela me serait d'une grande aide pour progresser.

Concernant le programme, c'est assez simple. Il s'agit de faire combattre deux personnages, aux attributs différents et de déterminer un vainqueur.
Je me suis librement inspiré des règles de donjons et dragons (inspiré est le mot car j'avoue ne pas saisir toute la complexité des règles ^^).

La class item est en cours, donc celle-ci est je pense vraiment cracra...

Voilà, je remercie par avance les personnes qui prendront le temps de lire tout ça.

C'est ici : http://pastebin.com/yjg4kXqQ

ou bien 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
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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
 
# -*- coding: utf-8 *-*
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#
# Petit passe temps : Combat entre 2 perso
# (un peu inspiré des règles D20)
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#
 
import time
import random
 
 
class Perso:
    "Création d'un perso, Perso standard"
    def __init__(self, sname, shp, sstrength, sdext, sca, sarmure, sarme):
        self.name = sname          # Nom
        self.hp = shp              # Points de vie
        self.strength = sstrength  # Force
        self.dext = sdext          # Dextérité
        self.ca = sca              # Classe d'armure (mettre 0)
        self.armure = sarmure      # Armure
        self.arme = sarme          # Arme
 
 
class Item:
    "A revoir, la logique etc"
    def __init__(self):
        self.table_armes = { \
        'arme1': {'Nom': 'Dague', 'Desc': 'ddesc', 'Poids': 500, 'Degats': 10, 'Cpt_privi': 'dext'}, \
        'arme2': {'Nom': 'Rapière', 'Desc': 'ddesc', 'Poids': 1500, 'Degats': 20, 'Cpt_privi': 'strength'}, \
        'arme3': {'Nom': 'Hache', 'Desc': 'ddesc', 'Poids': 3000, 'Degats': 30, 'Cpt_privi': 'strength'} \
        }
 
    def crea_arme(self, arme_id):
        "Donne une arme au personnage - A travailler"
        return self.table_armes[arme_id]
 
    def desc_arme(self, arme_id):
        "Information concernant une arme - A travailler"
        print "Arme : " + self.table_armes[arme_id]['Nom']
        print "Description : " + self.table_armes[arme_id]['Desc']
        print "Poids : " + str(self.table_armes[arme_id]['Poids']) + " Gr"
        print "Dégats : 1d" + str(self.table_armes[arme_id]['Degats'])
        print "Compétance à privilégier : " + self.table_armes[arme_id]['Cpt_privi']
 
 
class Duel:
    "Duel entre deux perso"
    def __init__(self):
        self.initiative = False
 
    def calcul_init(self, perso1, perso2):  # Calcul d'initiative'
        # D20 : dext + jet 1d20
        jet_perso1 = perso1.dext + random.randrange(1, 20)
        jet_perso2 = perso2.dext + random.randrange(1, 20)
        # un peu de texte histoire de décrire (pas certain que ce soit une bonne idée de placer ça là)
        print perso1.name + " : " + str(perso1.dext) + " dext"
        print "    > le jet de dés donne une initiative de " + str(jet_perso1) \
        + " pour " + perso1.name
        print perso2.name + " : " + str(perso2.dext) + " dext"
        print "    > le jet de dés donne une initiative de " + str(jet_perso2) \
        + " pour " + perso2.name
        if jet_perso1 >= jet_perso2:
            print perso1.name + " attaque le premier"
            self.initiative = False  # on bascule le switch pour déterminé qui a l'initiative (voir stdr_fight())
        else:
            print perso2.name + " attaque le premier"
            self.initiative = True
 
    def calcul_ca(self, perso):
        # D20 : Permet de calculer la CA (classe d'armure)
        # Sera utilié pour déterminer quelle puissance est nécessaire pour porter un coup
        # 10 + Armure + Dextérité
        perso.ca = 10 + perso.armure + perso.dext
        print perso.name + " CA : " + str(perso.ca)
 
    def stdr_fight(self, perso1, perso2):
        "Le combat en lui même"
        # Tant que l'un des personnages est en vie
        while (perso1.hp >= 0) and (perso2.hp >= 0):
            time.sleep(2)
            print "_____________________________________________"
            # on vérifie le switch initiative pour savoir qui attaque
            if self.initiative == False:
                self.attaque(perso1, perso2)
                self.initiative = True  # on bascule le switch, permet au second perso d'attaquer
            else:
                self.attaque(perso2, perso1)
                self.initiative = False
            if (perso1.hp <= 0):  # si l'un des perso n'a plus de points de vie
                self.victoire(perso2, perso1)  # on lance victoire()
                break  # on brise la boucle while
            elif (perso2.hp <= 0):
                self.victoire(perso1, perso2)
                break
 
    def attaque(self, attaquant, defenseur):
        "Permet de déterminé si le coup porte"
        puiss_attaqu = 0  # variable qui contient la puissance de l'attaque
        print attaquant.name + " donne un coup à " + defenseur.name + " avec " + attaquant.arme['Nom']
        #  On calcul l'attaque via jet_attaque()
        puiss_attaqu = self.jet_attaque(attaquant)
        # on vérifie que la CA est dépassée par l'attaque (puiss_attaqu)
        if puiss_attaqu >= defenseur.ca:
            #  Puis on retire les pts de vie selon le calcul effectué par jet_degat()
            defenseur.hp = defenseur.hp - self.jet_degats(attaquant)
            if defenseur.hp > 0:  # si le def est en vie
                print "    > " + defenseur.name + " perd " + str(puiss_attaqu) \
                + " points de vie. " + str(defenseur.hp) + " restants"
            else:  # Si non, on change le message en indiquant la mort du perso
                print "    > " + defenseur.name + " perd " + str(puiss_attaqu) \
                + " points de vie et s'écroule sur le sol"
        else:  # dans le cas ou le coup porté manque la cible (cad si puiss_attaqu < defenseur.ca)
            print "    > Le coup manque la cible. Jet d'attaque :"\
            + str(puiss_attaqu) + " | CA de la cible : " + str(defenseur.ca)
 
    def jet_attaque(self, perso):
        # Calcul du jet d'attaque
        # ~D20 : 1d20 + force + dextérité
        return random.randrange(1, 20) + perso.strength + perso.dext
 
    def jet_degats(self, perso):
        # Calcul du jet de dégats
        # ~D20 : dégats = Degats(1,?) + Cpt_privi + Poids(poids_conv())
        # ---------------------------solution temporaire au bonus Cpt_privi
        perso_cpt = perso.arme['Cpt_privi']
        if perso_cpt == 'dext':
            perso_cpt = perso.dext
        else:
            perso_cpt = perso.strength
        # ---------------------------/solution temporaire au bonus  Cpt_privi
        return random.randrange(1, perso.arme['Degats']) + perso_cpt + self.poids_conv(perso.arme['Poids'])
 
    def poids_conv(self, poids):
        "Tableau de convertion poids-Malus/Bonus"
        table_poids = {500: 0, 1500: -2, 3000: -4}
        return table_poids[poids]
        pass
 
    def victoire(self, vainqueur, perdant):
        print "__________________Fin du duel_________________"
        # Simple message indiquant le gagnant
        print vainqueur.name + " remporte le combat contre " + perdant.name
        print vainqueur.name + " a " + str(vainqueur.hp) + \
        " points de vie restant"
 
 
#test création arme (voir perso) + affichage info arme
crea_item = Item()
#crea_item.desc_arme("arme1")  # semble ok
 
# Création des persos
# pour mémoire (name,   hp,str,dext,ca0, armure, arme)
perso1 = Perso("Karadoc", 50, 8, 2, 0, 5, crea_item.crea_arme('arme3'))
perso2 = Perso("Perceval", 50, 3, 5, 0, 0, crea_item.crea_arme('arme1'))
 
cmb1 = Duel()
 
#calcul de l'initiative
cmb1.calcul_init(perso1, perso2)
 
#calcul de la CA
cmb1.calcul_ca(perso1)
cmb1.calcul_ca(perso2)
 
# Puis le combat
cmb1.stdr_fight(perso1, perso2)