-
-
Save GravenilvecTV/9ee31bc10ba662f6b04774cecdd7003f to your computer and use it in GitHub Desktop.
| from model.player import Player | |
| from model.weapon import Weapon | |
| knife = Weapon("Couteau", 3) | |
| player1 = Player("Graven", 20, 3) | |
| # donne un couteau faisant 3 dégats au joueur ! | |
| player1.set_weapon(knife) | |
| player2 = Player("Bob", 20, 5) | |
| player1.attack_player(player2) | |
| print(player1.get_pseudo(), "attaque", player2.get_pseudo()) | |
| print("Bienvenue au joueur", player1.get_pseudo(), "/ Points de vie:", player1.get_health(), "/ Attaque:", player1.get_attack_value()) | |
| print("Bienvenue au joueur", player2.get_pseudo(), "/ Points de vie:", player2.get_health(), "/ Attaque:", player2.get_attack_value()) |
| class Player: | |
| def __init__(self, pseudo, health, attack): | |
| self.pseudo = pseudo | |
| self.health = health | |
| self.attack = attack | |
| self.weapon = None | |
| print("Bienvenue au joueur", pseudo, "/Points de vie: ", health, "/ Attaque", attack) | |
| def get_pseudo(self): | |
| return self.pseudo | |
| def get_health(self): | |
| return self.health | |
| def get_attack_value(self): | |
| return self.attack | |
| def damage(self, damage): | |
| self.health -= damage | |
| def attack_player(self, target_player): | |
| damage = self.attack | |
| # si le joueur a une arme | |
| if self.has_weapon(): | |
| # ajoute les dégats de l'arme au point d'attaque du joueur | |
| damage += self.weapon.get_damage_amount() | |
| target_player.damage(damage) | |
| # méthode pour changer l'arme du joueur | |
| def set_weapon(self, weapon): | |
| self.weapon = weapon | |
| # méthode pour verifier si le joueur a une arme | |
| def has_weapon(self): | |
| return self.weapon is not None |
| class Weapon: | |
| def __init__(self, name, damage): | |
| self.name = name | |
| self.damage = damage | |
| def get_name(self): | |
| return self.name | |
| def get_damage_amount(self): | |
| return self.damage |
@KataKatis ce se bien de mettre aussi ton code...
Wow alors là ça devient chaud... J'ai passé pas loin de 2h00 en regroupant le corrigé du TP + mon propre code pour arrive à qqch de "correct". Par correct, j'entend qui ne n'est pas full buggé haha. Genre je lance le programme et il s'exécute sans erreurs...
Voici le code (aucune idée comment faire un rendu sur 3 pages... Je colle tout à la suite :
from Model.player import player
from Model.weapon import weapon
#player
player1 = player("Graven", 20, 3)
player2 = player("Bob", 15, 5)
#weapon
knife = weapon("knife", 5)
bloodthirst = weapon("bloodthirst", 200)
player1.set_weapon(knife)
print(player1.get_pseudo(), "attaque", player2.get_pseudo(), "!")
player1.attack_player(player2)
print(player2.get_pseudo(), "est maintenant à :", player2.get_health(), "PV")
player2.set_weapon(bloodthirst)
print(player2.get_pseudo(), "attaque", player1.get_pseudo(), "!")
player2.attack_player(player1)
class player:
def __init__(self, pseudo, health, attack):
self.pseudo = pseudo
self.health = health
self.attack = attack
self.weapon = None
print("Bienvenu au joueur :", pseudo, "/ PV :", health, "/ Attack :", attack, "/ Weapon", self.weapon)
def get_pseudo(self):
return self.pseudo
def get_health(self):
return self.health
def get_attack(self):
return self.attack
def damage(self, damage):
self.health -= damage
if self.health < 0:
print("Ho non, le joueur à subit trop de dégâts (", damage, ") !!!", self.pseudo, "est mort !")
else:
print("Aie... vous venez de subir", damage, "dégats !")
def attack_player(self, target_player):
damage = self.attack
if self.has_weapon():
damage += self.weapon.get_damage_amount()
target_player.damage(damage)
def set_weapon(self, weapon):
self.weapon = weapon
if weapon == "None":
print(self.pseudo, "n'a plus d'arme équipée !")
else:
print(self.pseudo, "est maintenant équipé d'un :", weapon.get_name())
def has_weapon(self):
return self.weapon is not None
class weapon:
def __init__(self, name, damage):
self.name = name
self.damage = damage
def get_name(self):
return self.name
def get_damage_amount(self):
return self.damage
Bonjour quelqu'un a une idée de comment faire en sorte que le programme ne puisse pas se lancer si le joueur est mort ( self.health <=0 )
Bonjour quelqu'un a une idée de comment faire en sorte que le programme ne puisse pas se lancer si le joueur est mort ( self.health <=0 )
dans main.py à la fin de ton programme tu fais une simple boucle if :
if player2.get_health() > 0:
print("{} aie ... Il ne vous reste plus que {} points de vie"
.format(player2.get_pseudo(), player2.get_health()))
else:
print("{} est mort ... {} a gagné".format(
player2.get_pseudo(), player1.get_pseudo()))
hello Graven, merci pour le tuto.
Cependant, il me semble qu'il y a une petite erreur au niveau de la fonction def attack_player() où l'on essai d'ajouter les degat causés par l'arme d'attaque, a ce niveau précisement : damage += self.weapon.get_damage_amount() -- à mon avis, ici on accède à l'attribut damage de weapon pour ajouter le nombre de dégât. Et donc on ecrira plutot ceci :damage += self.weapon.damage
On pourrait faire ce que tu propose, cela revient au meme, mais justement il a créé des getters pour acceder aux proprietes de l'objet pour ne pas utiliser directement la propriete.
Cela vient des habitudes dans d'autres langages où on encapsule les proprietes en les definissant en private (pour empecher leur modifications hors de leur classes), et on permet leur utilisations via des getters/setters:
pour une propriete private $name en PHP par exemple, on créer le getter public get_name(){ return $name;}
Hello Graven ! Tout d'abord merci pour tes cours, c'est vraiment super pour débuter.
J'ai une question pour toi sur ce TP :
Si je souhaite indiquer que mon personnage s'équipe d'une arme, j'ai choisi d'ajouter dans la méthode set_weapon, cette instruction:
print(self.pseudo, "s'équipe avec", self.weapon.get_name())
Or, cela ne convient pas et je me retrouve avec une erreur de ce type :
Reddev s'équipe avec <bound method Weapon.get_name of <model.weapon.Weapon object at 0x000001C3DB12B908>>As-tu une idée ? Merci d'avance.
Hello Graven ! Tout d'abord merci pour tes cours, c'est vraiment super pour débuter.
J'ai une question pour toi sur ce TP :
Si je souhaite indiquer que mon personnage s'équipe d'une arme, j'ai choisi d'ajouter dans la méthode set_weapon, cette instruction:
print(self.pseudo, "s'équipe avec", self.weapon.get_name())
Or, cela ne convient pas et je me retrouve avec une erreur de ce type :
Reddev s'équipe avec <bound method Weapon.get_name of <model.weapon.Weapon object at 0x000001C3DB12B908>>As-tu une idée ? Merci d'avance.
FanDeGraven --> tu à juste oublié des parenthèses quelques part :) !
Merci beaucoup pour tout ce que tu fais :) !
Je suis le seul a pas avoir réussi ce tp?
Bonjour, C'est pas plutot apprendre le python ?
Bonsoir à tous.
voici mon code:
from model.player import Player
from model.weapon import Weapon
print("********************************")
print(" VEGETA VS GOKU ")
print("********************************")
gun1 = Weapon("AK-47", 58)
gun2 = Weapon("RPG-7", 165)
player1 = Player("Vegeta", 200, 22)
player2 = Player("Goku", 200, 35)
# donne une arme faisant des dégats au joueur
player1.set_weapon(gun1)
player2.set_weapon(gun2)
# attaque !!!
player1.attack_player(player2)
print(player1.get_pseudo(), "attaque", player2.get_pseudo())
print("Bienvenue au joueur", player1.get_pseudo(), "/ Points de vie:", player1.get_health(), "/ Attaque", player1.get_attack_value())
print("Bienvenue au joueur", player2.get_pseudo(), "/ Points de vie:", player2.get_health(), "/ Attaque", player2.get_attack_value())
player2.attack_player(player1)
print(player2.get_pseudo(), "attaque", player1.get_pseudo())
print("Bienvenue au joueur", player2.get_pseudo(), "/ Points de vie:", player2.get_health(), "/ Attaque", player2.get_attack_value())
print("Bienvenue au joueur", player1.get_pseudo(), "/ Points de vie:", player1.get_health(), "/ Attaque", player1.get_attack_value())
print("Vegeta est KO")
print("Fin du combat !")
class Player:
def __init__(self, pseudo, health, attack):
self.pseudo = pseudo
self.health = health
self.attack = attack
self.weapon = None
print("Bienvenue au joueur", pseudo, "/ Points de vie:", health, "/ Attaque", attack)
def get_pseudo(self):
return self.pseudo
def get_health(self):
return self.health
def get_attack_value(self):
return self.attack
def damage(self, damage):
self.health -= damage
def attack_player(self, target_player):
damage = self.attack
# si le joueur à une arme
if self.has_weapon():
# ajoute les dégats de l'arme au point d'attaque du joueur
damage += self.weapon.get_damage_amount()
target_player.damage(damage)
# méthode pour changer l'arme du joueur
def set_weapon(self, weapon):
self.weapon = weapon
# méthode pour verifier si le joueur a une arme
def has_weapon(self):
return self.weapon is not None
class Weapon:
def __init__(self, name, damage):
self.name = name
self.damage = damage
def get_name(self):
return self.name
def get_damage_amount(self):
return self.damage
Rhaayayaya sa se complique, j'espere que je suis pas le seul qui est perdue, franchement je comprends plus rien là!
hello Graven, merci pour le tuto. Cependant, il me semble qu'il y a une petite erreur au niveau de la fonction def attack_player() où l'on essai d'ajouter les degat causés par l'arme d'attaque, a ce niveau précisement : damage += self.weapon.get_damage_amount() -- à mon avis, ici on accède à l'attribut damage de weapon pour ajouter le nombre de dégât. Et donc on ecrira plutot ceci :
damage += self.weapon.damage
Je pense la même chose
Merci Graven good job.
Je suis un ancien génération basic pascal c dbase foxpro aujourd'hui je suis de retour.
Rhaayayaya sa se complique, j'espere que je suis pas le seul qui est perdue, franchement je comprends plus rien là!
Moi aussi suis perdu
Rhaayayaya sa se complique, j'espere que je suis pas le seul qui est perdue, franchement je comprends plus rien là!
Moi aussi suis perdu
la même
Ça devient sérieux
Mon prog:
Main:
LES OBJETS
from Joueur_G7 import joueur
from Modele_G7.Arme_G7 import weapon
player5=joueur("Djity", 100,5)
player6=joueur("Billy", 90,4)
player7=joueur("Siwe", 120,10)
knife= weapon("couteau", 7)
print("Le joueur", player5.get_username(), "à au départ", player5.get_life(), "avec une puissance d'attaque égale à", player5.get_fight())
player5.degats(5)
print("Le joueur", player5.get_username(), "à au départ", player5.get_life(), "avec une puissance d'attaque égale à", player5.get_fight())
player5.set_weapon_name(knife.name)
player5.set_weapon(knife.power)
print("Le joueur", player5.get_username(), "à toujours", player5.get_life(), "de vie mais avec une puissance d'attaque maintenant égale à", player5.get_fight())
player5.attack_player(player6)
print("Le joueur", player6.get_username(), "a par conséquent", player6.get_life(), "de vie!")
Classe Joueur (je lai nomée joueur_G7)
class joueur:
def init(self, nomdut, vie, attaque):
self.username = nomdut
self.life = vie
self.fight = attaque
self.weapon = None
print("Bienvenue au joueur", nomdut, "point de vie", vie, "attaque", attaque ) # j'aurai pu mettre self.username
def get_username(self):
return self.username
def get_life(self):
return self.life
def get_fight(self):
return self.fight
def get_weapon(self):
return self.weapon is not None
def degats(self, damage):
self.life -= damage
def set_weapon_name(self, armee):
self.weapon = armee
print("Maintenant vous êtes équipé d'un", armee, "!")
def set_weapon(self, powerarme):
self.fight += powerarme
print("Waouh! votre puissance d'attaque à augmenté de", powerarme, "points de dégats!")
def attack_player(self, cible): # ne pas oublier que self veut dire toi même
print("le Joueur", self.get_username(), "attaque le joueur", cible.get_username())
cible.degats(self.fight)
print("Aie! le joueur", cible.get_username(), "vient de subir", self.fight, "points de dégats!")
enfin la class arme:
class weapon:
def __init__(self, nom, puissance):
self.name = nom
self.power = puissance
print("Il existe désormais dans le jeu un", self.name, "de puissance", self.power)
def get_name(self):
return self.name
def get_power(self):
return self.power
En fait l'appel de la classe weapon dans la classe player n'a pas l'air de marcher car je crois que weapon doit forcement être appelé dans le main... javoue j'ai pas creusé plus que ça ;-)
bonsoir voila mon code mais il me donne une erreur a la ligne 7 de jeu
aidez moi svp
jeu
from model.player import player
from model.armement import arme
pistolle = arme("pistolle ", 5)from model.player import player
from model.armement import arme
pistolle = arme("pistolle ", 5)
player1 = player("ahmed ", 20 , 50)
player1.set_arme(self = pistolle)
player2 = player("adnan ", 50 , 40)
player1.attak_player(player2)
print(player1.pseudo, "attaque ", player2.pseudo)
print("bonjour ", player1.pseudo, "votre sant ", player1.health, player1.attak)
print("bnjour" , player2.pseudo ,"votre sant ", player2.health, player2.attak)
player1 = player("ahmed ", 20 , 50)
player1.set_arme(self = pistolle)
player2 = player("adnan ", 50 , 40)
player1.attak_player(player2)
print(player1.pseudo, "attaque ", player2.pseudo)
print("bonjour ", player1.pseudo, "votre santer ", player1.health, player1.attak)
print("bnjour" , player2.pseudo ,"votre sant er", player2.health, player2.attak)
player
class player:
def init(self, pseudo, attak, health,):
self.pseudo = pseudo
self.attak = attak
self.health = health
self.arme = None
def get_pseudo(self):
return self.pseudo
def damage(self, damage):
self.health -= damage
def attak_player(self, attak_player):
attak_player = self.attak
si le joueur a une arme
if self.has_arme():
# ajoute les dégats de l'arme au point d'attaque du joueur
self.arme.damage1 += self.arme.get_damage()
attak_player.damage(self.arme.get_damage)
# méthode pour changer l'arme du joueur
def set_arme(self, arme):
self.arme = arme
# méthode pour verifier si le joueur a une arme
def has_arme(self):
return self.arme is not None
arme
class arme:
def init(self, name , damage):
self.name = name
self.damage1 = damage
def get_name(self):
return self.name
def get_damage(self):
return self.damage1
bonjour Graven ... whaoo le TP de ouf ... là on voit les objets Python avec un "O" majuscule ... je regarderai à l'avenir les jeux différemment ... je n'ose imaginer le nombre de lignes de code ds certains jeux :) ... c'est plus facile de faire des dégâts avec un joystick ;) ...
main
from modele.personnage import Personnage #importe l'Objet Personnage du fichier modele/personnage.py
from modele.arme import Arme #importe l'Objet Arme du fichier modele/arme.py
couteau = Arme("croc sanglant", 30)
baton = Arme("sorciere", 50)
j1 = Personnage("Chris", 100, 10)
j1.set_arme(couteau)
j2 = Personnage("Graven", 100, 10)
j2.set_arme(baton)
j1.attaque_joueur(j2)
print(j1.get_pseudo(), "attaque", j2.get_pseudo(), "avec", j1.arme.nom, "ayant", j1.arme.degat, "degats")
print(j1.get_pseudo(), "/vie", j1.get_vie(), "/attaque", j1.get_attaque())
print(j2.get_pseudo(), "/vie", j2.get_vie(), "/attaque", j2.get_attaque())
print(j2.get_pseudo(), "à subit", j1.get_attaque(), "points de degat")
j2.attaque_joueur(j1)
print(j2.get_pseudo(), "attaque", j1.get_pseudo(), "avec", j2.arme.nom, "ayant", j2.arme.degat, "degats")
print(j1.get_pseudo(), "/vie", j1.get_vie(), "/attaque", j1.get_attaque())
print(j2.get_pseudo(), "/vie", j2.get_vie(), "/attaque", j2.get_attaque())
print(j1.get_pseudo(), "à subit", j2.get_attaque(), "points de degat")personnage : sauvé en fichier personnage.py dans le répertoire modele
class Personnage:
def __init__(self, pseudo, vie, magie):
self.pseudo = pseudo
self.vie = vie
self.attaque = magie
print("bienvenue", pseudo, "/vie", vie, "/magie", magie)
def get_pseudo(self):
return self.pseudo
def get_vie(self):
return self.vie
def get_attaque(self):
return self.attaque
def degat(self, degat):
self.vie -= degat
def attaque_joueur(self, target):
#target.degat(self.attaque)
degat = self.attaque
# si le joueur a une arme
if self.has_arme():
# ajoute les dégats de l'arme au point d'attaque du joueur
self.attaque += self.arme.get_degat()
target.degat(self.attaque)
# méthode pour changer l'arme du joueur
def set_arme(self, arme):
self.arme = arme
# méthode pour verifier si le joueur a une arme
def has_arme(self):
return self.arme is not Nonearme : sauvé en fichier arme.py dans le répertoire modele
class Arme:
def __init__(self, nom, degat):
self.nom = nom
self.degat = degat
def get_nom(self):
return self.nom
def get_degat(self):
return self.degatrésultat
bienvenue Chris /vie 100 /magie 10
bienvenue Graven /vie 100 /magie 10
Chris attaque Graven avec croc sanglant ayant 30 degats
Chris /vie 100 /attaque 40
Graven /vie 60 /attaque 10
Graven à subit 40 points de degat
Graven attaque Chris avec sorciere ayant 50 degats
Chris /vie 40 /attaque 40
Graven /vie 60 /attaque 60
Chris à subit 60 points de degat
"Chris se TP près d'une source de Heal récupère ainsi 200 points de vie ... il lance son sort éclat de givre sur Graven qui le gèle sur place
Graven grâce à son pouvoir du feu sort de son immobilité et lance une boule de feu qui poursuit Chris etc .... :)"
Bonjour Graven ... j'ai intégré une partie de la leçon 8 les héritages en Python ... le guerrier ... personnage et arme ne changent pas .
A chaque appele de l'objet arme les dégâts se cumulent ... je ne suis pas arrive a résoudre ce bug .. normal je ne suis qu'un bébé dev ;) .
ps : j'ai utilisé Bing IA sur Edge pour m'aidé ... impressionnant les réponses qu'on reçoit ... vivement tes vidéos sur le sujet ;)
Cependant avec la méthode ternaire en Python ...(False, True)[condition] ... elle se mélange les pinceaux ;)
main
from modele.personnage import Personnage
from modele.arme import Arme
from modele.guerrier import Guerrier
couteau = Arme("croc sanglant", 30)
baton = Arme("sorciere", 40)
masse = Arme('casse tête', 50)
j1 = Personnage("Chris", 100, 10)
j1.set_arme(couteau)
j2 = Personnage("le mage", 100, 10)
j2.set_arme(baton)
j3 = Guerrier('la louve', 100, 10, 30)
j3.set_arme(masse)
j1.attaque_joueur(j2)
print('\n', j1.get_pseudo(), "attaque", j2.get_pseudo(), "avec", j1.arme.nom, "ayant", j1.arme.degat, "degats")
print(j1.get_pseudo(), "/vie", j1.get_vie(), "/attaque", j1.get_attaque())
print(j2.get_pseudo(), "/vie", j2.get_vie(), "/attaque", j2.get_attaque())
print(j2.get_pseudo(), "à subit", j1.get_attaque(), "points de degat")
j2.attaque_joueur(j1)
print('\n', j2.get_pseudo(), "attaque", j1.get_pseudo(), "avec", j2.arme.nom, "ayant", j2.arme.degat, "degats")
print(j1.get_pseudo(), "/vie", j1.get_vie(), "/attaque", j1.get_attaque())
print(j2.get_pseudo(), "/vie", j2.get_vie(), "/attaque", j2.get_attaque())
print(j1.get_pseudo(), "à subit", j2.get_attaque(), "points de degat")
j1.attaque_joueur(j3)
print('\n', j1.get_pseudo(), "attaque", j3.get_pseudo(), "avec", j1.arme.nom, "ayant", j1.arme.degat, "degats")
print(j1.get_pseudo(), "/vie", j1.get_vie(), "/attaque", j1.get_attaque())
print(j3.get_pseudo(), "/vie", j3.get_vie(), "/attaque", j3.get_attaque(), '/armure', j3.get_armure())
print(j3.get_pseudo(), "à absorbée", j1.get_attaque(), "points de degat")
j3.attaque_joueur(j2)
print('\n', j3.get_pseudo(), "attaque", j2.get_pseudo(), "avec", j3.arme.nom, "ayant", j3.arme.deguat, "degats")
print(j3.get_pseudo(), "/vie", j3.get_vie(), "/attaque", j3.get_attaque())
print(j2.get_pseudo(), "/vie", j2.get_vie(), "/attaque", j2.get_attaque())
print(j2.get_pseudo(), "à subit", j3.get_attaque(), "points de degat")guerrier
from modele.personnage import Personnage
class Guerrier(Personnage):
def __init__(self, pseudo, vie, magie, armure):
super().__init__(pseudo, vie, magie)
self.armure = armure
def degat(self, degat):
if self.armure > 0:
self.armure -= 10
degat = 0
super().degat(degat)
def blade(self):
self.armure = 30
print('armure rechargée')
def get_armure(self):
return self.armureAttention ce code n'est pas complet ... il faut ajouter les Objets Personnage et Arme du code précèdent
résultat
bienvenue Chris /vie 100 /magie 10
bienvenue le mage /vie 100 /magie 10
bienvenue la louve /vie 100 /magie 10
Chris attaque le mage avec croc sanglant ayant 30 degats
Chris /vie 100 /attaque 40
le mage /vie 60 /attaque 10
le mage à subit 40 points de degat
le mage attaque Chris avec sorciere ayant 40 degats
Chris /vie 50 /attaque 40
le mage /vie 60 /attaque 50
Chris à subit 50 points de degat
Chris attaque la louve avec croc sanglant ayant 30 degats
Chris /vie 50 /attaque 70 # ici les dégâts de l'arme se sont cumulés 10 + 30 +30
la louve /vie 100 /attaque 10 /armure 20
la louve à absorbée 70 points de degat
la louve attaque le mage avec casse tête ayant 50 degats
la louve /vie 100 /attaque 60
le mage /vie 0 /attaque 50
le mage à subit 60 points de degat
Salut Graven j'ai découvert ta chaine y'a pas longtemps et j'adore tes TP (honnêtement celui-ci je sais pas trop si je l'ai réussi) mais je voudrais te demander comment faire pour afficher le nom de l'arme (parce que j'ai essayé et ça me met un truc bizarre) ? Donc si quelqu'un de la commu est chaud je voudrais bien qu'on m'explique comment faire.
Bonjour OriginalNPC ...
difficile de te répondre sans ton code ... dans mon code ...
couteau = Arme("croc sanglant", 30)
j1 = Personnage("Chris", 100, 10)
j1.set_arme(couteau)les Objets
class Personnage:
def __init__(self, pseudo, vie, magie):
self.pseudo = pseudo
...,
# méthode pour changer l'arme du joueur
def set_arme(self, arme):
self.arme = armeclass Arme:
def __init__(self, nom, degat):
self.nom = nom
...,
def get_nom(self):
return self.nomje l'affiche avec la commande print
print(j1.get_pseudo(), "attaque", j2.get_pseudo(), "avec", j1.arme.nom, "ayant", j1.arme.degat, "degats")
#ou simplifié fonctionne également
print(j1.pseudo, "attaque", j2.pseudo, "avec", j1.arme.nom, "ayant", j1.arme.degat, "dégâts")pour afficher que le nom de l'arme
print(j1.arme.nom)attention le code n'est pas complet ... ce sont les lignes pour afficher le nom de l'arme du joueur 1 .
Voilà mon code ^^ (sinon t'a mis apprendre le java dans le titre du git)
Main.py
from model.player import Player
from model.weapon import Weapon
player1 = Player("YaY", 20, 3)
player2 = Player("Graven", 20, 3)
Knife = Weapon("Couteau", 5)
player1.set_weapon(Knife)
player1.attack_player(player2)
print(player1.get_pseudo(), "attaque", player2.get_pseudo(), "!")
print(player1.get_pseudo(), ": ", player1.get_healt(), " pv / ", player2.get_pseudo(), ": ", player2.get_healt(), "pv")Player.py
class Player:
def __init__(self, pseudo, healt, attack, weapon=None):
self.pseudo = pseudo
self.healt = healt
self.attack = attack
self.weapon = weapon
print("Bienvenue au joueur: ", self.pseudo, "/ points de vie: ", self.healt, "/ attaque: ", self.attack)
def get_pseudo(self):
return self.pseudo
def get_healt(self):
return self.healt
def get_attack_value(self):
return self.attack
def set_weapon(self, weapon):
self.weapon = weapon
def damage(self, damage):
self.healt -= damage
def attack_player(self, target_player):
if self.weapon != None:
self.attack += self.weapon.damage
target_player.damage(self.attack)Weapon.py
class Weapon:
def __init__(self, name, damage):
self.name = name
self.damage = damage
def get_name(self):
return self.name
def get_damage(self):
return self.name
Persos je sais déjà coder en python mais tes vidéos sont super et les TP j'en raffole pour l'idée moi g tout fait en un fichier car flemme de faire des modules. Ce fut du 10min ou 6 jsp donc c du bordel deso d'avance mais ca marche. Voici mon code:
class Weapon:
def init(self, name, damage):
self.name = name
self.damage = damage
print("La nouvelle arme", name, "a été créée avec succès et possède", damage, "points de dégâts")
def get_weapon_damage(self):
return self.damage
def get_weapon_name(self):
return self.name
class Player:
def init(self, pseudo, pv, pa):
self.pseudo = pseudo
self.pv = pv
self.pa = pa
self.weapon = None
print("Bienvenue au joueur", pseudo, "/ PV:", pv, "/ PA:", pa)
def set_weapon(self, weapon):
self.weapon = weapon
def get_weapon_attributes(self):
if self.weapon:
w_dmg = self.weapon.get_weapon_damage()
w_name = self.weapon.get_weapon_name()
return w_name, w_dmg
else:
return None, None
def get_pseudo(self):
return self.pseudo
def dammage(self, dammage):
self.pv -= dammage
def dmg_player(self, target):
if self.weapon != None:
w_dmg = self.weapon.get_weapon_damage()
dammage = self.pa + w_dmg
else:
dammage = self.pa
target.dammage(dammage)
def get_pv(self):
return self.pv
couteau = Weapon("couteau", 5)
baton = Weapon('baton', 3)
Player1 = Player("Marc", 10, 1)
Player2 = Player("Antonin", 10, 3)
Player1.set_weapon(baton)
Player2.set_weapon(couteau)
print(Player1.get_weapon_attributes())
Player1.dmg_player(Player2)
print(Player2.get_pv())
Moi g concaténée les deux atack (arme et initial) mais on peut simplement mettre l'arme même ci c plus logic de conter comme les dgt init comme la force du gars
Bonjour à tous, voici ma version :
Weapon.py
# Création de la classe d'arme
class Weapon:
def __init__(self, name, damage):
self.name = name
self.damage = damage
def get_name(self):
return self.name
def get_damage_amount(self):
return self.damage
Player.py
# Création de la classe du joueur
class Player :
def __init__(self, pseudo, health, attack):
self.pseudo = pseudo
self.health = health
self.attack = attack
self.weapon = None
print("Bienvenue au joueur {} / Vie : {} / Attaque : {}".format(pseudo, health, attack))
def get_pseudo(self):
return self.pseudo
def get_health(self):
return self.health
def get_attack(self):
return self.attack
def damage(self, damage):
self.health -= damage
print("Aie... vous venez de subir {} points de dégâts !".format(damage))
def attack_player(self, target_player):
damage = self.attack
# Si le joueur à une arme
if self.has_weapon():
# Ajout des points d'attaque de l'arme au joueur
damage += self.weapon.get_damage_amount()
target_player.damage(damage)
# Méthode pour changer l'amre du joueur
def set_weapon(self, weapon):
self.weapon = weapon
def get_weapon_name(self):
if self.weapon is not None:
return self.weapon.get_name()
else:
return "Aucune arme"
# Méthode pour vérifier si le joueur à une arme
def has_weapon(self):
return self.weapon is not None
Main.py
# Importations des librairies
from models.Player import Player
from models.Weapon import Weapon
# Création des armes
knife = Weapon("Couteau", 8)
pistol = Weapon("Pistolet", 10)
# Création des joueurs
player1 = Player("Pcommander", 20, 2)
player2 = Player("Tcommander", 20, 2)
# Attribution des armes aux joueurs
player1.set_weapon(knife)
player2.set_weapon(pistol)
# Attaque du P1 sur P2
player1.attack_player(player2)
print("{} attaque {}".format(player1.get_pseudo(),player2.get_pseudo()))
# Affichages des caractéristiques après attaque
print("Bienvenue au joueur {} / Vie : {} / Attaque : {} / Arme : {}".format(player1.get_pseudo(), player1.get_health(), player1.get_attack(), player1.get_weapon_name()))
print("Bienvenue au joueur {} / Vie : {} / Attaque : {} / Arme : {}".format(player2.get_pseudo(), player2.get_health(), player2.get_attack(), player2.get_weapon_name()))
Bonjour Graven, merci pour tes cours ça m'aide beaucoup parce que je viens de débuter dans le python. Je essayer de faire le tp (j'ai pas réussi à tout mais c'est pas grave parce que j'ai compris l'idée global). Alors voila mon problème : lorsque je fais player2.set_weapon(knife) il me dit : 'Weapon' object is not callable je comprend pas du tout parce que j'ai bien pris la correction sur ton code. J'espère que toi ou quelqu'un qui voie mon message m'aidera et dit moi si tu a besoin de voir mon code.
Encore merci, continu tes videos et fais ce que tu aimes.