-
-
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 |
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 None
arme : 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.degat
ré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.armure
Attention 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 = arme
class Arme:
def __init__(self, nom, degat):
self.nom = nom
...,
def get_nom(self):
return self.nom
je 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()))
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!")