JDR_Pitavy/jeuderôleavectk.py

import tkinter as tk
import random

#--class
class Personne:
    def __init__(self, nom, cat):
        self.__nom = nom
        self.__xp = 1
        self.__cat = cat
        self.__pot = 2
        if self.__cat == 'guerrier':
            self.__hp = 20
        elif self.__cat == 'mage':
            self.__hp = 20
        elif self.__cat == 'voleur':
            self.__hp = 30
        elif self.__cat == 'elfe':
            self.__hp = 22
        if cat == 'guerrier':
            self.__inv = ['epee', 'potion']
        elif cat == 'mage':
            self.__inv = ['baton', 'potion']
        elif cat == 'voleur':
            self.__inv = ['dague', 'potion']
        elif cat == 'elfe':
            self.__inv = ['arc', 'potion']
        if self.get_cat() == 'guerrier' or self.get_cat() == 'mage':
            self.__coefAtq = 10
        elif self.get_cat() == 'voleur':
            self.__coefAtq = 3
        elif self.get_cat() == 'elfe':
            self.__coefAtq = 8
        if self.get_cat() == 'guerrier':
            self.__coefDef = 8
        elif self.get_cat() == 'mage':
            self.__coefDef = 7
        elif self.get_cat() == 'voleur':
            self.__coefDef = 9
        elif self.get_cat() == 'elfe':
            self.__coefDef = 10
        
    def get_nom(self):
        return self.__nom
    
    def get_hp(self):
        return self.__hp
    
    def get_xp(self):
        return self.__xp
    
    def get_cat(self):
        return self.__cat
    
    def get_pot(self):
        return self.__pot
    
    def get_inv(self):
        return self.__inv
    
    def get_coef_atq(self):
        return self.__coefAtq
    
    def get_coef_def(self):
        return self.__coefDef
    
    def jet_attaque(self):
        return random.randint(1, 20) + (self.get_xp() * self.get_coef_atq())
                
    def jet_defense(self):
        return random.randint(1, 20) + (self.get_xp() * self.get_coef_def())
        
    def change_pdv(self, nb_pdv):
        self.__hp += nb_pdv
        
    def change_exp(self, nb_exp):
        self.__xp += nb_exp

# Fonction pour gérer les tours de jeu
def tour(attaquant, defenseur):
    global nb_tour, output_text
    nb_tour += 1
    liste_tour.reverse()
    attaquant = liste_tour[0]
    defenseur = liste_tour[1]
    nb_potions = joueur.get_pot()

    output_text.insert(tk.END, f"\nTour n° {nb_tour} (attaquez sur tour pair et defendez sur un tour impair")

    if attaquant == 'joueur':
        action = action_var.get()
        if action == "Attaque":
            dmg = joueur.jet_attaque()
            shield = bot.jet_defense()
            if dmg > shield:
                nb_pdv = (-1) * random.randint(1, 8)
                bot.change_pdv(nb_pdv)
                output_text.insert(tk.END, f"\nVous attaquez et infligez { -nb_pdv } pts de dégâts à l'ennemi !")
            elif dmg < shield:
                nb_pdv = (-1) * random.randint(1, 4)
                joueur.change_pdv(nb_pdv)
                output_text.insert(tk.END, f"\nVous perdez et recevez { -nb_pdv } pts de dégâts de l'ennemi !")
            else:
                output_text.insert(tk.END, "\nParade parfaite, aucun joueur ne perd de points de vie.")
        elif action == "Potion":
            if nb_potions > 0:
                joueur.change_pdv(10)
                joueur.__pot -= 1
                output_text.insert(tk.END, f"\nVous utilisez une potion de soin. Il vous reste {joueur.get_pot()} potion(s).")
            else:
                output_text.insert(tk.END, "\nVous n'avez plus de potions.")
        elif action == "Défendre":
            shield = joueur.jet_defense()
            dmg = bot.jet_attaque()
            if shield > dmg:
                output_text.insert(tk.END, f"\nVous défendez parfaitement l'attaque de l'ennemi!")
            else:
                nb_pdv = (-1) * random.randint(1, 4)
                joueur.change_pdv(nb_pdv)
                output_text.insert(tk.END, f"\nVous recevez { -nb_pdv } pts de dégâts en dépit de votre défense !")
    else:
        dmg = bot.jet_attaque()
        action = action_var.get()
        if action == "Défense":
            shield = joueur.jet_defense()
            if dmg > shield:
                nb_pdv = (-1) * random.randint(1, 8)
                joueur.change_pdv(nb_pdv)
                output_text.insert(tk.END, f"\nL'ennemi vous attaque et inflige { -nb_pdv } pts de dégâts !")
            elif dmg < shield:
                nb_pdv = (-1) * random.randint(1, 4)
                bot.change_pdv(nb_pdv)
                output_text.insert(tk.END, f"\nVous parvenez à infliger { -nb_pdv } pts de dégâts à l'ennemi !")
            else:
                output_text.insert(tk.END, "\nParade parfaite, aucun joueur ne perd de points de vie.")
    
    # Mise à jour des labels
    joueur_hp_label.config(text=f"HP Joueur: {joueur.get_hp()}")
    bot_hp_label.config(text=f"HP Bot: {bot.get_hp()}")
    joueur_potion_label.config(text=f"Potions: {joueur.get_pot()}")
    
    if joueur.get_hp() <= 0:
        output_text.insert(tk.END, "\nDEFAITE! Vous avez perdu!")
    elif bot.get_hp() <= 0:
        output_text.insert(tk.END, "\nVICTOIRE! Vous avez gagné!")

# Fonction pour démarrer le jeu
def start_game():
    global joueur, bot, nb_tour, liste_tour, suiv_tour
    nb_tour = 0
    suiv_tour = nb_tour + 1
    liste_tour = ['bot', 'joueur']

    # Choix du joueur
    nom = name_var.get()
    classe_input = class_var.get().upper()

    if classe_input == "A":
        classe = "guerrier"
    elif classe_input == "Z":
        classe = "mage"
    elif classe_input == "E":
        classe = "voleur"
    elif classe_input == "R":
        classe = "elfe"
    else:
        output_text.insert(tk.END, "\nClasse invalide! Choisissez A pour guerrier, Z pour mage, E pour voleur ou R pour elfe.")
        return
    
    joueur = Personne(nom, classe)

    # Création du bot
    bot = rand()

    output_text.insert(tk.END, f"\nDébut du combat : {joueur.get_nom()} (Joueur) contre {bot.get_nom()} (Bot)")
    
    joueur_hp_label.config(text=f"HP Joueur: {joueur.get_hp()}")
    bot_hp_label.config(text=f"HP Bot: {bot.get_hp()}")
    joueur_potion_label.config(text=f"Potions: {joueur.get_pot()}")
    
    output_text.insert(tk.END, f"\nAcutel: Tour n° {nb_tour} (attaquez sur tour pair et defendez sur un tour impair)")

# Random bot generator
def rand():
    name = ["Darius", "Garen", "Zac", "Ashe", "Elise", "Gwen"]
    cat = ["guerrier", "mage", "voleur", "elfe"]
    name_r = random.choice(name)
    cat_r = random.choice(cat)
    return Personne(name_r, cat_r)

# Interface graphique Tkinter
root = tk.Tk()
root.title("Baldur's Bait")
root.geometry("600x500")

# Widgets
name_var = tk.StringVar()
class_var = tk.StringVar()
action_var = tk.StringVar(value="Attaque")

name_label = tk.Label(root, text="Nom du joueur:")
name_label.pack()
name_entry = tk.Entry(root, textvariable=name_var)
name_entry.pack()

# Ajout des informations sur les classes
class_info_label = tk.Label(root, text="Classes disponibles:\n"
                                       "Guerrier (HP 20, Attaque et Défense élevées)\n"
                                       "Mage (HP 20, Attaque élevée, Défense moyenne)\n"
                                       "Voleur (HP 30, Attaque faible, Défense élevée)\n"
                                       "Elfe (HP 22, Attaque moyenne, Défense très élevée)")
class_info_label.pack()

class_label = tk.Label(root, text="Classe:\n"
                                   "A pour Guerrier / Z pour Mage / E pour Voleur / R pour Elfe")
class_label.pack()

class_entry = tk.Entry(root, textvariable=class_var)
class_entry.pack()

start_button = tk.Button(root, text="Commencer le jeu", command=start_game)
start_button.pack()

stats = tk.Label(root, text="Les statistiques sont affichées ici:")
stats.pack()

joueur_hp_label = tk.Label(root, text="HP Joueur:")
joueur_hp_label.pack()

bot_hp_label = tk.Label(root, text="HP Bot:")
bot_hp_label.pack()

joueur_potion_label = tk.Label(root, text="Potions:")
joueur_potion_label.pack()

action_label = tk.Label(root, text="Action:")
action_label.pack()

action_menu = tk.OptionMenu(root, action_var, "Attaque", "Potion", "Défense")
action_menu.pack()

tour_button = tk.Button(root, text="Lancer", command=lambda: tour(joueur, bot))
tour_button.pack()

output_text = tk.Text(root, height=10)
output_text.pack()

# Démarrer l'interface
root.mainloop()