Programmation (le retour du topic des geeks qui se lavent pas, ou peu)

rem on désactive l'écho local
@echo off
cls
rem on copie les polices
rem %windir% correspond ordinairement à C:\Windows\
copy polices\mapolice.ttf %windir%\Fonts\mapolice.ttf
...etc...
rem si Windows n'est pas un Windows de type NT,le programme quitte
rem sous Windows NT,le programme s'arrete automatiquement à la derniere ligne

if not "OS"=="Windows_NT" exit

#Combat en mode texte par AristA (épique !)
import random, sys, math

NOMDUJEU = "Combat en mode texte"
POINTS = 100

#Fonctions : #########################

def lancer(nbr=1, m=None):
    a = 0
    if m != None:
        print(m)
    if nbr == 1:
        print("\n>>Le dé est lancé...")
        a = random.randint(1,6)
        print("  -Lancé : {}\n".format(a))
    else:
        print("\n>>Les {} dés sont lancés...".format(nbr))
        for i in range(nbr):
            b = random.randint(1,6)
            print("  -Lancé {} : {}".format(i, b))
            a += b
        print("  -La somme des dés est de {}.\n".format(a))
    return a

def iAleatoire(maximum):
    """Renvoit True si le tirage est gagnant (r==1)"""
    r = random.randint(1,math.fabs(maximum))
    return r==1

def repNbr(maximum=999, minimum=0, m=""):
    """Demande un nombre."""
    message = ("La donnée entrée n'est pas correcte.")
    while 1:
        a = input(m)
        try:
            a = int(a)
            if a <= maximum:
                if a >= minimum:
                    return a
                else:
                    print(message, "(Nombre trop petit.)")
            else:
                print(message, "(Nombre trop élevé.)")
        except:
            print(message)

def defense(defenseur):
    print("{} se défend et triple sa défense.".format(defenseur.nom))
    return True

def attaque(attaquant, cible, spell=None):
    #Retourne les nouveaux pv de la cible
    annonce1 = "{} attaque...".format(attaquant.nom)
    annonce2 = "{} se défend...".format(cible.nom)
    annonce3 = "{} augmente les capacités de sa compétence...".format(attaquant.nom)
    if spell==None: #On fait une attaque de base.
        print("\n{} attaque {} !".format(attaquant.nom, cible.nom))
        c = cible.defense
        if cible.parade is True:
            c = c*3
        a = attaquant.basicAttack(lancer(m=annonce1)) - c
    else: #C'est à dire qu'on lance un sort.
        if cible == attaquant:
            print("\n{} utilise {} sur soi-même !".format(attaquant.nom, spell.nom))
            a = spell.dommages(attaquant,lancer(m=annonce3))
        else:
            print("\n{} utilise {} sur {} !".format(attaquant.nom, spell.nom, cible.nom))
            c = cible.defense
            if spell.genre == 'intel':
                a = spell.dommages(attaquant,lancer(m=annonce3)) - (c/3)
            else:
                if cible.parade is True:
                    c = c*3
                if cible is heros:
                    a = spell.dommages(attaquant,lancer(m=annonce3)) - (c*lancer(m=annonce2)/3.5)
                else: a = spell.dommages(attaquant,lancer(m=annonce3)) - (c*lancer(m=annonce2)/5)
        if spell.effet != None: #Il faut appliquer l'effet.
            b = lancer(m="{} lance le dé pour infliger {}...".format(attaquant.nom, spell.effet.nom))
            if spell.effet.win.count(b)>0:
                print("Lancé réussi !")
                if cible.etat.count(spell.effet)<1:
                    cible.etat.append(spell.effet)
                    print("{} est sous l'état {} désormais.".format(cible.nom, spell.effet.nom))
                else:
                    print("{} est déjà sous l'état {} !".format(cible.nom, spell.effet.nom))
            else:
                print("Lancé raté... \n{} ne subit aucun effet supplémentaire.".format(cible.nom))
    a = round(a)
    if spell == None:
        if a < 1:
            a = 1
    else:
        if spell.degats>0 and a<1:
            a=1
        elif spell.degats<0 and a>1:
            a=-1
    if a > 0: print("{} a perdu {} PV suite à l'attaque de {}.".format(cible.nom, round(a), attaquant.nom))
    else: print("{} a regagné {} PV suite à son attaque.".format(cible.nom, math.fabs(round(a))))
    if spell is None: return round(cible.hp - a)
    else: return round(cible.hp - a), attaquant.mp - spell.cout

def gameOver():
    print("Vous avez perdu... Le jeu s'arrête ici pour vous."
          "\nUn petit souvenir de votre personnage :")
    heros.affResume()
    heros.affSort()
    input("Appuyez sur Entrée pour quitter.")
    sys.exit()

def creerProtagoniste():
    while 1:
        pts = POINTS
        m = "\nIl vous reste {} points à attribuer."
        nom = input("Entrez le nom de votre héros : ").capitalize()
        if nom == "":
            nom = "Sriden"
        print("\nVous disposez de {} points à distribuer pour déterminer les\n "
              "caractéristiques de votre héros, {}. Attribuez les avec soin et,\n "
              "surtout, dépensez les tous !".format(pts, nom))
        print("\nCombien de Point de Vie (PV) ? Cela déteminera l'endurance de votre\n "
              "héros en combat. Minimum : 1 (sinon vous mourrez tout de suite)")
        print(m.format(pts))
        hp = repNbr(pts, 1)
        pts -= hp
        print("\nCombien de Point de Magie (MP) ? Cela déterminera combien de sorts\n "
              "pourra lancer votre héros.")
        print(m.format(pts))
        mp = repNbr(pts)
        pts -= mp
        print("\nCombien d'Attaque ? Cela déterminera la puissance des attaques de\n "
              "base et des sorts physiques de votre héros.")
        print(m.format(pts))
        attaque = repNbr(pts)
        pts -= attaque
        print("\nCombien d'Intelligence ? Cela déterminera la puissance des sorts\n "
              "magiques de votre héros.")
        print(m.format(pts))
        intel = repNbr(pts)
        pts -= intel
        print("\nCombien de Défense ? Cela déterminera votre abilité à résister aux\n "
              "différentes attaques adverses.")
        print(m.format(pts))
        defense = repNbr(pts)
        pts-= defense
        heros = Protagoniste(nom, hp, mp, attaque, intel, defense)
        heros.affResume()
        print("\nC'est correct ? (Oui/Non)")
        cont = input().lower()
        if cont == "oui" or cont == "o":
            print("Votre héros {} a bien été créé !\n".format(nom))
            break
        else:
            print("Dans ce cas, on recommence.\n")
    return heros

def newEnn(adv, nom=""):
    """Retourne l'adversaire."""
    if nom == "":
        nom = adv.nom
    a = Protagoniste(nom, adv.hp, adv.mp, adv.attaque, adv.intel, adv.defense)
    a.sorts = adv.sorts
    return a

def choixCible(adv):
    print("\n>>Quel cible ?")
    i=0
    for adversaire in adv:
        i+=1
        print("  {}. {}".format(i,adversaire.nom))
    rep = repNbr(i, 1)
    return rep-1

def menuCombat():
    """Affichage des options."""
    print("\n>>Que faire ?"
          "\n  1. Attaquer"
          "\n  2. Sort"
          "\n  3. Se défendre"
          "\n  4. Objet"
          "\n  5. Passer son tour.")
    action = repNbr(5,1)
    return action

def menuSort():
    """Retourne le sort choisi"""
    i = heros.affSorts()+1
    print("  {}. Annuler.".format(i))
    while 1:
        rep = repNbr(i, 1)
        if rep == i:
            return None
        elif heros.mp < heros.sorts[rep-1].cout:
            print("Vous n'avez pas assez de MP pour lancer ce sort !")
        else: return heros.sorts[rep-1]

def menuObjet():
    i = heros.affObjets()+1
    print("  {}. Annuler.".format(i))
    while 1:
        rep = repNbr(i, 1)
        if rep == i:
            return None
        else: return heros.objets[rep-1]

def testMorts(adv):
    testwin = True
    morts = list()
    i = 0
    for nadv in adv:
        if nadv.vivant() is True:
            testwin = False
        else:
            print("{} est mort !".format(nadv.nom))
            morts.append(i)
        i += 1
    for ide in morts:
        adv.pop(ide)
    return adv, testwin
           
def affrontement(adv):
    """Renvoit True (win) ou False (loose) en fonction de l'issue."""
    global heros
    #Rappel du combat
    advlit = ""
    i = 0
    for nadv in adv:
        i += 1
        advlit += nadv.nom
        if i < len(adv):
            advlit += ", "
    print("\n{} contre {}.".format(heros.nom, advlit))
    tour = 0
    while 1:
        tour+=1
        print("\n>>Tour {}.".format(tour))
        heros.tour()
        for nadv in adv:
            nadv.tour()
        if heros.hp<=0:
            print("{} est mort !".format(heros.nom))
            return False
        adv, testwin = testMorts(adv)
        if testwin is True:
            print("Victoire !")
            return True
        #Tour du héros
        while 1:
            action = menuCombat()
            heros.parade = False
            if action == 1:
                #Attaquer
                nadv = choixCible(adv)
                adv[nadv].hp = attaque(heros, adv[nadv])
                break
            elif action == 2:
                #Sort
                spell = menuSort()
                if spell != None:
                    if spell.degats>0:
                        nadv = choixCible(adv)
                        adv[nadv].hp, heros.mp = attaque(heros, adv[nadv], spell)
                        break
                    else: #Sort de soin
                        heros.hp, heros.mp = attaque(heros, heros, spell)
                        break
            elif action == 3:
                #Se défendre
                heros.parade = defense(heros)
                break
            elif action == 4:
                #Inventaire
                obj = menuObjet()
                if obj != None:
                    heros = obj.use(heros)
                    heros.objets[obj.position(heros)].qte -= 1
                    if heros.objets[obj.position(heros)].qte<1:
                        heros.objets.remove(obj)
                    break
            elif action == 5:
                #Passer son tour.
                break
        #Morts des ennemis
        adv, testwin = testMorts(adv)
        if testwin is False:
            print("\n>>Tour des ennemis.")
            #Tour des ennemis
            for nadv in range(len(adv)):
                input("Appuyez sur Entrée...")
                adv[nadv].parade = False
                adv[nadv] = iArtificielle(adv[nadv])
                if heros.hp<=0:
                    print("{} est mort !".format(heros.nom))
                    return False
        input("Appuyez sur Entrée...")

def iArtificielle(monstre):
    #Super intelligence artificielle 3000
    action = False
    if monstre.hp/monstre.maxhp < 10:
        if iAleatoire(3) is True and action is False: #On se défend
            monstre.parade = defense(monstre)
            action = True
    else:
        if iAleatoire(5) is True and action is False: #On se défend
            monstre.parade = defense(monstre)
            action = True
    if iAleatoire(2) is True and action is False: #On lance un sort
        if monstre.sorts != []:
            spell = random.choice(monstre.sorts)
            if spell != None and monstre.mp - spell.cout >= 0:
                heros.hp, monstre.mp = attaque(monstre, heros, spell)
                action = True
    if action is False:
        heros.hp = attaque(monstre, heros)
    return monstre
       
def choisirSort():
    print("\nLe vieillard vous montre sa besace, remplie de divers parchemins avec différentes inscriptions\n"
          "sur chacun d'eux :")
    i = vieux.affSorts()
    choix = repNbr(i,1)
    return vieux.sorts[choix-1]

def boutique(buyer):
    return buyer

#Classes : ############################
     
class Protagoniste:
    def __init__(self, nom, hp, mp, attaque, intel, defense):
        self.nom = nom
        self.lvl = 1
        self.pts = 0
        self.hp = hp
        self.mp = mp
        self.maxhp = hp
        self.maxmp = mp
        self.attaque = attaque
        self.intel = intel
        self.defense = defense
        self.etat = list()
        self.sorts = list()
        self.objets = list()
        self.parade = False
    def basicAttack(self, des):
        #Attaque de base, retourne les dégâts de l'attaque.
        x = ((2*des) + (self.attaque*2.8))/3
        return round(x)
    def learn(self, sort):
        #Apprend un sort au protagoniste
        if self.sorts.count(sort)<1:
            self.sorts.append(sort)
    def give(self,objet,x=1):
        #Donne un objet au protagoniste
        for i in range(x):
            if self.objets.count(objet)<1:
                self.objets.append(objet)
            else:
                self.objets[objet.position(self)].qte += 1
    def vivant(self):
        return self.hp > 0
    def maxhpmp(self):
        if self.hp > self.maxhp:
            self.hp = self.maxhp
        if self.mp > self.maxmp:
            self.mp = self.maxmp
        if self.mp < 0:
            self.mp = 0
        if self.hp < 0:
            self.hp = 0
    def tour(self):
        """A lancer à chaque tour"""
        #Régénération en mana et en hp.
        if self.vivant() is True:
            hp = round(((self.defense/1.5)+(self.maxhp/20))/7)
            mp = round(((self.intel/1.5)+(self.maxmp/20))/7)
            if self.hp+hp > self.maxhp:
                hp = self.maxhp - self.hp
            if self.mp+mp > self.maxmp:
                mp = self.maxmp - self.mp
            self.hp += hp
            self.mp += mp
            if hp > 0 and mp > 0:
                print("  -{} régénére {} PV et {} MP.".format(self.nom, hp, mp))
            elif hp > 0 and mp == 0:
                print("  -{} régénére {} PV.".format(self.nom, hp))
            elif hp == 0 and mp > 0:
                print("  -{} régénére {} MP.".format(self.nom, mp))
            #Application des dégâts des effets.
            if self.etat != None:
                for e in self.etat:
                    efDeg = e.degats
                    if self.hp-efDeg > self.maxhp:
                        efDeg = self.maxhp-self.hp
                    self.hp -= efDeg
                    if e.degats > 0:
                        print("  -{} perd {} PV suite à l'effet {}.".format(self.nom, efDeg, e.nom))
                    elif e.degats < 0:
                        print("  -{} regagne {} PV grâce à l'effet {}.".format(self.nom, math.fabs(efDeg), e.nom))
            self.maxhpmp()
            print("  -{} a {}/{} PV et {}/{} MP.".format(self.nom, self.hp, self.maxhp, self.mp, self.maxmp))
    def levelUp(self):
        self.lvl+=1
        print("Vous gagnez un nouveau niveau ! Vous êtes désormais niveau {}.".format(self.lvl))
        print("Vous gagnez 2 Points de Vie et 1 Point de Magie !")
        self.hpmax+=2
        self.mpmax+=1
        self.points += 10
        self.affResume()
        while 1:
            pts = self.points
            print("\nVous gagnez {} points à dépenser dans vos différentes caractéristiques.".format(pts))
            a1 = repNbr(0,pts,"Points de Vie ({}pts restants) : ".format(pts))
            pts -= a1
            a2 = repNbr(0,pts,"Points de Magie ({}pts restants) : ".format(pts))
            pts -= a2
            a3 = repNbr(0,pts,"Attaque ({}pts restants) : ".format(pts))
            pts -= a3
            a4 = repNbr(0,pts,"Intelligence ({}pts restants) : ".format(pts))
            pts -= a4
            a5 = repNbr(0,pts,"Intelligence ({}pts restants) : ".format(pts))
            pts -= a5
            print("\nIl vous reste {} point(s).".format(pts))
            self.maxhp += a1
            self.maxmp += a2
            self.attaque += a3
            self.intel += a4
            self.defense += a5
            self.affResume()
            print("\nC'est correct ? (Oui/Non)")
            rep = input().lower()
            if a == "o" or a == "oui":
                self.points -= a1+a2+a3+a4+a5
                print("Votre personnage a bien eu ses caractéristiques modifiées !")
                break
            else:
                self.maxhp -= a1
                self.maxmp -= a2
                self.attaque -= a3
                self.intel -= a4
                self.defense -= a5
        self.reposer()
    def reposer(self):
        """Remet les hp et les mp au max."""
        self.hp = self.hpmax
        self.mp = self.mpmax
    def affObjets(self):
        print("\nListe des objets :")
        i = 0
        for obj in self.objets:
            i+=1
            a = "  {}. "
            a += obj.aff()
            print(a.format(i))
        return i
    def affSorts(self):
        print("\n>>Liste des sorts :")
        i = 0
        for sort in self.sorts:
            i += 1
            a = "  {}. "
            a += sort.aff(self)
            print(a.format(i))
        return i
    def affResume(self):
        print("\n>>Résumé de votre personnage :"
              "\n  -Nom : {}\n  -PV : {}\n  -MP : {}\n  -Attaque : {}\n  "
              "-Intelligence : {} \n  -Défense : {}".format(self.nom, self.hp, self.mp, self.attaque, self.intel, self.defense))

class Sort:
    def __init__(self, nom, degats, ratio, cout, genre="intel", effet=None):
        self.nom = nom
        self.degats = degats
        self.genre = genre
        self.ratio = ratio
        self.cout = cout
        self.effet = effet
    def degatsBase(self, lanceur):
        if self.genre == "intel":
            a = lanceur.intel*self.ratio
        elif self.genre == "attaque":
            a = lanceur.attaque*self.ratio
        else:
            print("#Erreur : Sort de genre indéterminé.")
            a = 0
        if self.degats>0:
            return self.degats+a
        else: return self.degats-a
    def dommages(self, lanceur, des):
        b = des*self.cout/4
        if self.degats>0:
            return self.degatsBase(lanceur)+b
        else: return self.degatsBase(lanceur)-b
    def aff(self,lanceur):
        a, b = "{} ({} MP): ", ""
        if self.degats > 0:
            if self.genre == "intel":
                a += "Inflige {} dégâts magiques à l'adversaire. "
            elif self.genre == "attaque":
                a += "Inflige {} dégâts physiques à l'adversaire. "
        elif self.degats < 0:
            if self.genre == "intel":
                a += "Permet de regagner {} PV (ratio magique). "
            elif self.genre == "attaque":
                a += "Permet de regagner {} PV (ratio physique). "
        a = a.format(self.nom,self.cout,math.fabs(self.degatsBase(lanceur)))
        if self.effet != None:
            if self.effet.degats > 0:
                b = "\n  Peut également infliger {}, qui retire {} PV par tour à l'adversaire. "
            elif self.effet.degats < 0:
                b = "\n  Peut également infliger {}, qui vous redonne {} PV par tour. "
            else:
                b = "\n  Peut également infliger {}, qui ne blesse pas l'adversaire. "
            b = b.format(self.effet.nom, math.fabs(self.effet.degats))
        return a + b

class Effet: #Les effets altèrent l'état des protagonistes.
    def __init__(self, nom, lancersGagnants=[1], degatsParTour=0):
        self.nom = nom
        self.win = lancersGagnants
        self.degats = degatsParTour

class Objet:
    def __init__(self, nom, quantite, hpmodif, mpmodif):
        self.nom = nom
        self.hpmodif = hpmodif
        self.mpmodif = mpmodif
        self.qte = quantite
    def aff(self):
        a = "{} (x{})".format(self.nom, self.qte)
        t = False
        if self.hpmodif > 0:
            if t is False:
                a+= "\n  "
                t = True
            a+="Redonne {} PV. ".format(self.hpmodif)
        if self.mpmodif > 0:
            if t is False:
                a+= "\n  "
                t = True
            a+= "Redonne {} MP. ".format(self.mpmodif)
        return a
    def position(self, possesseur):
        i = 0
        for obj in possesseur.objets:
            if obj == self:
                return i
            i+=1
    def use(self, cible):
        cible.hp += self.hpmodif
        if self.hpmodif > 0:
            print("{} regagne {} PV grâce à l'utilisation de {}.".format(cible.nom, self.hpmodif, self.nom))
        cible.mp += self.mpmodif
        if self.mpmodif > 0:
            print("{} regagne {} MP grâce à l'utilisation de {}.".format(cible.nom, self.mpmodif, self.nom))
        cible.maxhpmp()
        return cible

#Contenu : ###########################
#Effets :
efSommeil = Effet("Sommeil")
efEtourdi = Effet("Etourdissement", [1,2])
efCicatrisation = Effet("Cicatrisation", [1,3], -7)
efPansement = Effet("Pansement", [1], -5)
efEmbrasement = Effet("Embrasement", [1,6], 7)
efImmolation = Effet("Immolation", [1,3], 11)
efSaignement = Effet("Saignement", [2,4,6], 5)

#Sorts :
#Sorts des monstres
soTaillade = Sort("Taillade",0.5,1.2,3,'attaque')
soJetdos = Sort("Jet d'os",3,0.6,2)
soGriffure = Sort("Griffure",5,0.4,2,'attaque')

#Sorts du héros
soBouleFeu = Sort("Boule de feu",9,1,3,effet=efEmbrasement)
soFlammes = Sort("Flammes",12,1.3,5,effet=efImmolation)
soSouffleRep = Sort("Souffle réptilien",15,1.5,7,effet=efImmolation)
soDecoupe = Sort("Découpe",2,1.5,3.5,'attaque')
soTrancher = Sort("Trancher",3,1.7,4.5,'attaque')
soInciser = Sort("Inciser",4,1.9,6,'attaque',efSaignement)
soSoin = Sort("Soin",-15,0.3,3.5)
soSoinU = Sort("Soin+",-20,0.4,5)
soSoinUU = Sort("Soin++",-25,0.55,8,effet=efCicatrisation)
soMedecine = Sort("Médecine",-7,0.2,3.5,'attaque')
soMedecineU = Sort("Médecine+",-15,0.35,5,'attaque',efPansement)

#Ennemis : #NOM, HP, MP, ATT, INTEL, DEF
enZombie = Protagoniste("Zombie",23,3,10,0,3)
enZombie.sorts = [soTaillade, soGriffure]
enSquelette = Protagoniste("Squelette",30,15,14,10,6)
enSquelette.sorts = [soJetdos]
enBourreau = Protagoniste("Bourreau",50,8,20,9,9)
enBourreau.sorts = [soTaillade,None]
enChien = Protagoniste("Chien",13,0,26,1,4)

#Objets :
obFioleRouge = Objet("Fiole rouge", 1, 20, 0)
obFioleBleue = Objet("Fiole bleue", 1, 0, 10)

#Jeu ! Enfin !
vieux = Protagoniste("Vieillard",1,1,0,0,0)

print(">>{} par AristA, un jeu épique et mouvementé pour les plus tarés d'entre nous.\n".format(NOMDUJEU))
print(">>Dans quel mode jouer ?\n  -Test (t)\n  -Histoire (h)")
mode = input().lower()
if mode == 'h':
    print("Dans un monde où le chaos règne, dans un monde où la magie est devenue une arme, dans un monde \n"
          "où chacun est libre de se battre, vous voici arrivé. Oui, vous, épée à la main, brandie vers le \n"
          "ciel, fier et vaillant, prêt à tout pour combattre les dépravés et les hérétiques. Votre soif de \n"
          "sang est insatiable et, nerveusement, vous n'attendez que le combat.\n\nMais, pour cela, il vous "
          "faut déjà savoir qui vous êtes.\n")
    heros = creerProtagoniste()
    print("Vous pénétrez dans l'immense colisée où on lieu tous les affrontements, mais un viellard vous \n"
          "arrête en vous prenant par l'épaule. Vous vous retournez, surpris, et l'aïeul vous dit :\n\n"
          "« Vous allez vous battre ? Je vois. Vous savez, personne ne gange à main nues, pas même les \n"
          "plus braves et les plus vaillants des guerriers ; mais vous m'avez croisé, et j'admire votre \n"
          "obstination aveugle envers le combat. Je vous offre un sortilège, qui consommera vos Points de \n"
          "Magie lorsque vous le lancerez en combat. Tous les deux niveaux que vous gagnerez, où vous \n"
          "deviendrez plus fort, je vous en offrirait un autre, afin que vous puissiez diversifier \nvos techniques. »")
    vieux.sorts = [soBouleFeu,soDecoupe,soSoin,soMedecine]
    #vieux.objets =
    heros.learn(choisirSort())
    print("Vous vous apprêtez à partir, mais le vieillard vous retient encore une fois, cette fois en vous \n"
          "tendant des fioles bleues et rouges. « Vous en aurez besoin » vous assure-t-il alors que vous le \n"
          "quittez.\n")
    heros.give(obFioleRouge,2)
    heros.give(obFioleBleue,2)
    print("Mais déjà, votre premier combat se profile. Face à vous se dresse un premier groupe de monstres.\n"
          "La foule les acclame, impatiente de voir le massacre qu'ils vont faire de vous, mais vous ne\n"
          "l'entendez pas de cette oreille. Vous faites craquer vos doigts, et vous avancez au centre sableux\n"
          "de la large arène circulaire.\n")
else:
    heros = Protagoniste("Gérard",30,10,20,20,20)
    heros.sorts=[soBouleFeu,soFlammes,soSouffleRep,soDecoupe,soTrancher,soInciser,
                soSoin,soSoinU,soSoinUU,soMedecine,soMedecineU]
    heros.give(obFioleRouge,5)
    heros.give(obFioleBleue, 10)
    mode = 't'
v = True
while v:
    print(">>PREMIER COMBAT !\n")
    input("Appuyez sur Entrée pour continuer...")
    v = affrontement([newEnn(enZombie, "Zombie 1"),newEnn(enZombie, "Zombie 2"),newEnn(enSquelette)])
    if v is False: break
    print("Vous vous relevez, affaibli par le combat mais vaillant. La foule est déçue, elle voulait vous\n"
          "voir dévoré par les avides créatures. Mais ce n'est pas vous, vous êtes bien plus coriace que ça.\n")
    heros.levelUp()
    heros = boutique(heros)
    print("Vous vous relevez, tremblant.")
    #Bon je ferai la suite plus tard bande de moules
gameOver()

>>Combat en mode texte par AristA, un jeu épique et mouvementé pour les plus tarés d'entre nous.

>>Dans quel mode jouer ?
  -Test (t)
  -Histoire (h)

Traceback (most recent call last):
  File "./RPG.py", line 609, in <module>
    mode = input().lower()
  File "<string>", line 0
   
    ^
SyntaxError: unexpected EOF while parsing

while 1:
    for event in pygame.event.get():
        if event.type is QUIT:
            sys.exit()
           
    heros = heros.inputs(carte)
    for e in team:
        e.update(objects,carte)
    heros = carte.update(screen,heros)
    for obj in objects:
        obj.positionner(heros,carte)
    objects.draw(screen)
    team.draw(screen)

    pygame.display.flip()
    pygame.time.delay(2)