---
# System prepended metadata

title: MAIN

---

# MAIN 
```python=
import Joueurs.sorcier as Sorcier
import Joueurs.chevalier as Chevalier
import Joueurs.elfe as Elfe

import Ennemis.loup_garou as Loup_garou
import Ennemis.troll as Troll
import Ennemis.Vampire as Vampire
from Joueurs import elfe


# Définir le nombre de joueurs

def nombre_joueur():
    nombre_joueur = int(input(" 1. solo \n 2. multijoueur \n"))

    if nombre_joueur == 1:
        creer_joueur(1)
        return

    if nombre_joueur == 2:
        print("Les deux joueurs ne peuvent pas avoir le même personnage.")
        creer_joueur(2)
        return


# Création objet (personnages)
def creer_joueur(nombre_joueur):
    global ennemi
    choix_classe = int(input("Quel personnage incarnerez-vous aujourd'hui?\n 1: Sorcier \n 2: Chevalier \n 3: Elfe \n"))

    if choix_classe == 1:
        joueur = Sorcier.sorcier()
        nom = str(input("nom J1 : "))
        joueur.nom = nom
        print(joueur.nom, " incarne le sorcier du marais sombre, il pourra alors utiliser une potion de soin.")

    if choix_classe == 2:
        joueur = Chevalier.Chevalier()
        nom = str(input("nom J1: "))
        joueur.nom = nom
        print(joueur.nom, " est sacré chevalier de la couronne des bois lointain")

    if choix_classe == 3:
        joueur = Elfe.Elfe()
        nom = str(input("nom J1 : "))
        joueur.nom = nom
        print(joueur.nom, " vois ses oreilles grandir est devient l'elfe protecteur de la foret ancienne.")

    if nombre_joueur == 1:

        adversaire_hasard = 0
        adversaire_hasard = rd.randint(1, 3)

        if adversaire_hasard == 1:
            ennemi = Loup_garou.Loup_garou()
            print(joueur.nom, " affronte le terrible loup-garou")
            ennemi.nom = 'Loup garou'

        if adversaire_hasard == 2:
            ennemi = Troll.Troll()
            print(joueur.nom, " réveille le troll de son sommeil et va en subir les conséquences!")
            ennemi.nom = 'Troll'

        if adversaire_hasard == 3:
            ennemi = Vampire.Vampire()
            print(joueur.nom, " défie le vampire")
            ennemi.nom = 'Vampire'

        return jouer(nombre_joueur, joueur, ennemi)

    if nombre_joueur == 2:

        choix_classe2 = int(input("Quel héro incarnerez-vous? \n 1: Sorcier \n 2: Chevalier \n 3: Elfe \n"))

        if choix_classe != 1 and choix_classe2 == 1:
            ennemi = Sorcier.Sorcier()
            nom = str(input("nom J2 "))
            ennemi.nom = nom
            print(ennemi.nom, " incarne le sorcier du marais sombre, il pourra alors utiliser une potion de soin.")
            return jouer(nombre_joueur, joueur, ennemi)

        if choix_classe != 2 and choix_classe2 == 2:
            ennemi = Chevalier.Chevalier()
            nom = str(input("nom J2 : "))
            ennemi.nom = nom
            print(ennemi.nom, "est sacré chevalier de la couronne des bois lointain.")
            return jouer(nombre_joueur, joueur, ennemi)

        if choix_classe != 3 and choix_classe2 == 3:
            ennemi = Elfe.Elfe()
            nom = str(input("nom J2: "))
            ennemi.nom = nom
            print(ennemi.nom, " vois ses oreilles grandir est devient l'elfe protecteur de la foret ancienne.")
            return jouer(nombre_joueur, joueur, ennemi)


def tour_sorcier(joueur, ennemi):
    print("Tour de", joueur.nom)

    if joueur.parer == True:
        joueur.set_parer()

    tour = 0
    tour = int(input("\n 1 ensorceler \n 2 potion de soin \n 3 parer \n"))

    if tour == 1:
        joueur.ensorceler(ennemi)
    elif tour == 2:
        joueur.se_soigner()
    elif tour == 3:
        if joueur.cooldown_parer == 0:
            joueur.set_parer()


def tour_elfe(joueur, ennemi):
    print("\nTour de", joueur.nom)

    if joueur.parer == True:
        joueur.set_parer()

    tour = 0
    tour = int(input("\n 1 coup d'épée \n 2 parer \n"))

    if tour == 1:
        joueur.coup_epee(ennemi)
    elif tour == 2:
        if joueur.cooldown_parer == 0:
            joueur.set_parer()


def tour_chevalier(joueur, ennemi):
    print("\nTour de", joueur.nom)

    if joueur.parer == True:
        joueur.set_parer()

    tour = 0
    tour = int(input("\n 1 jeter sa lance \n 2 parer \n"))

    if tour == 1:
        joueur.attaque_lance(ennemi)
    elif tour == 2:
        if joueur.cooldown_parer == 0:
            joueur.set_parer()


def tour_ennemi(joueur, ennemi):
    print("\nTour de ", ennemi.nom)

    ennemi.attaque(joueur)
    if type(ennemi) == type(Vampire.Vampire):
        ennemi.voler_hp(joueur)


def jouer(nombre_joueur,joueur,ennemi):
    i = 0
    while joueur.mort == False or ennemi.mort == False:
        print("\nTOUR", i + 1)
        i += 1
        joueur.set_mort()
        ennemi.set_mort()
        if joueur.mort == True or ennemi.mort == True:
            if joueur.mort == True:
                print("GAME OVER!")
                return
            if ennemi.mort == True:
                print("VICTOIRE! Vous pouvez maintenant déliverer les prisonnier de votre ennemi!")
                return

        # pour jouer seul
        if nombre_joueur == 1:
            time.sleep(3)
            if type(joueur) == type(elfe.Elfe()):
                tour_elfe(joueur, ennemi)

            from Joueurs import sorcier
            if type(joueur) == type(Sorcier.sorcier()):
                tour_sorcier(joueur, ennemi)

            if type(joueur) == type(Chevalier.Chevalier()):
                tour_chevalier(joueur, ennemi)

            joueur.dec_cooldown_joueur()

            time.sleep(3)
            tour_ennemi(joueur, ennemi)
            ennemi.dec_cooldown_ennemi()

        # pour jouer a 2
        if nombre_joueur == 2:
            # 1er joueur
            time.sleep(3)
            if type(joueur) == type(Elfe.Elfe()):
                tour_elfe(joueur, ennemi)

            if type(joueur) == type(Sorcier.Sorcier()):
                tour_sorcier(joueur, ennemi)

            if type(joueur) == type(Chevalier.Chevalier()):
                tour_chevalier(joueur, ennemi)

            # 2e joueur
            time.sleep(3)
            if type(ennemi) == type(Elfe.Elfe()):
                tour_elfe(ennemi, joueur)

            if type(ennemi) == type(Sorcier.Sorcier()):
                tour_sorcier(ennemi, joueur)

            if type(ennemi) == type(Chevalier.Chevalier()):
                tour_chevalier(ennemi, joueur)


# Appels fonctions
nombre_joueur()

# Fin du jeu
print("FIN")
time.sleep(3)
print("Ce monde à encore besoin de vous et de vos stratagèmes, revenez à l'occasion")
```

# PERSONNAGES
```python=
class Personnage():

    def __init__(self):

        self.pv = 100
        self.dps = 10
        self.vit = 1

        self.mort = False
        self.blesse = False
        self.parer = False

        self.is_joueur = False
        self.is_chevalier = False
        self.is_sorcier = False
        self.is_elfe = False

        self.is_ennemi = False
        self.is_troll = False
        self.is_loup_garou = False
        self.is_vampire = False

    def attaquer(self,target):
        if target.parer == True :
            print(target.nom," a paré le coup")
            return

        if target.is_troll == True:
            pv_avant = target.pv
            target.pv = target.pv - self.dps + self.dps*(1/2)
            print(target.nom," a perdu ",pv_avant - target.pv,"hp")
            print(target.nom," à maintenant", target.pv,"hp")
            return

        else:
            pv_avant = target.pv
            target.pv = target.pv - self.dps
            print(target.nom," a perdu ",pv_avant - target.pv,"hp")
            print(target.nom," à maintenant ", target.pv,"hp")

    def set_mort(self):
        if self.pv <= 0:
            self.mort = True
            print(self.nom,"est mort")

```
# JOUEURS
```python=
#import bibli#
import Personnage as Personnage

class Joueur(Personnage.Personnage):

    def __init__(self, nom='Joueur'):
        super().__init__()
        self.cooldown_1 = 0
        self.cooldown_2 = 0
        self.cooldown_parer = 0
        self.nom = nom

    def set_parer(self):
        if self.cooldown_parer != 0:
            print(self.nom," n'est plus en position pour parer")
            self.parer = False

        else:
            print(self.nom," est en position pour parer")
            self.parer = True
            self.cooldown_parer = 2


```
# chevalier
```python=
# IMPORTS #
import Joueurs.joueur as Joueur

class Chevalier(Joueur.Joueur):
    def __init__(self):
        super().__init__()
        self.pv_max = (Joueur.Joueur().pv*500)//100
        self.pv = (Joueur.Joueur().pv*500)//100
        self.dps = 200
        self.is_chevalier = True
        self.is_joueur = True

    def attaque_lance(self,target):
        print(self.nom,"envoie sa lance sur",target.nom)
        self.attaquer(target)
```
# elfe
```python=
import Joueurs.joueur as Joueur

class Elfe(Joueur.Joueur):
    def __init__(self):
        super().__init__()
        self.pv_max = (Joueur.Joueur().pv*450)//100
        self.pv = (Joueur.Joueur().pv*450)//100
        self.dps = 200
        self.is_elfe = True
        self.is_joueur = True

    def coup_epee(self,target):
        print(self.nom, " blesse  ", target.nom, "grace à son épée magique")
        self.attaquer(target)

```
# sorcier
```python=
import Joueurs.joueur as Joueur


class sorcier(Joueur.Joueur):

    def __init__(self):
        super().__init__()
        self.pv_max = (Joueur.Joueur().pv * 300) // 100
        self.pv = (Joueur.Joueur().pv * 300) // 100
        self.dps = 200
        self.is_sorcier = True
        self.is_joueur = True

    def se_soigner(self):
        if self.cooldown_1 == 0:
            print(self.nom, "récupère des hp grace à une potion")
            self.pv += 100
            print(self.nom, " a maintenant ", self.pv, "hp")
            self.cooldown_1 = 3
        else:
            print("le sorcier n'a pas eu le temps de finir sa potion, ensorcele ton ennemis pour te défendre ou parre "
                  "son attaque ")

    def ensorceler(self, target):
        print(self.nom, " utilise ses pouvoirs sur ", target.nom)
        self.attaquer(target)

```

# ENNEMIS
```python=
import Personnage as Personnage


class Ennemi(Personnage.Personnage):

    def __init__(self, nom='Ennemi'):
        super().__init__()
        self.cooldown_1 = 0
        self.nom = nom

    def dec_cooldown_ennemi(self):
        if self.cooldown_1 != 0:
            self.cooldown_1 -= 1
```
# loug-garou
```python=
import Ennemis.ennemi as Ennemi

class Loup_garou(Ennemi.Ennemi):
    #constructeur
    def __init__(self):
        super().__init__()
        self.pv_max = (Ennemi.Ennemi().pv*500)//100
        self.pv = (Ennemi.Ennemi().pv*500)//100
        self.dps = 200
        self.is_loup_garou = True
        self.is_ennemi = True

    def attaque(self,target):
        print(self.nom, " plante ses griffes sur ", target.nom)
        self.attaquer(target)

```
# troll
```python=
import Ennemis.ennemi as Ennemi
class Troll(Ennemi.Ennemi):

    def __init__(self):
        super().__init__()
        self.pv_max = (Ennemi.Ennemi().pv*400)//100
        self.pv = (Ennemi.Ennemi().pv*400)//100
        self.dps = 200
        self.is_troll = True
        self.is_ennemi = True

    def attaque (self,target):
        print(self.nom, " donne un coup de pied à", target.nom)
        self.attaquer(target)

```
# vampire
```
import Ennemis.ennemi as Ennemi
class Vampire(Ennemi.Ennemi):
    def __init__(self):
        super().__init__()
        self.pv_max = (Ennemi.Ennemi().pv*400)//100
        self.pv = (Ennemi.Ennemi().pv*400)//100
        self.dps = 200
        self.is_vampire = True
        self.is_ennemi = True


    def voler_hp(self,target):
            print(self.nom, " vole des hp de ", target.nom)
            self.pv = self.pv + (target.pv*(1/10))
            print(self.nom, " a maintenant ", self.pv, "hp")

    def attaque(self,target):
        print(self.nom, " plante ses crocs dans le cou de ", target.nom)
        self.attaquer(target)
```