[Résolu] Python: oû est le problême? - un RPG qui devrait marcher. par popi31 - page 1

Je fesait un petit RPG pour m'entrénait au python, je sait que j'ai beaucoups défini dans tous les sens des fonctions qui s'entre apelle.... je donne toute la source desfois que ça vous intéresse, et l'erreur parrait sur une ligne ou je voix pas de difficulté... je qute commenté le message d'érreur sur la ligne en question....

#! /usr/bin/python
#! -*- coding: utf-8 -*-
# Rôle Playing Game en terminal.
# une idee originale de Narbonne Christophe
# 0.0.3.A
###############################
##
## Import de librairies
##
###############################
from random import random
from math import *
###############################
##
## Définition de la commande
##
## De Nettoiement de terminal
##
###############################
import os
import sys
osclient=sys.platform
if osclient == "win32": clear="cls"
if osclient[0] == "l" and osclient[1] == "i" and osclient[2] == "n": clear="clear"
def clearterm():
os.system(clear)
def readtime(t=0):
if osclient == "win32":
os.system("PAUSE")
if t==0:clearterm()
elif osclient[0] == "l" and osclient[1] == "i" and osclient[2] == "n":
print "appuyez entrée pour continuer"
os.system("read")
if t==0:clearterm()
###############################
###############################
###############################
######
###### Definition de fonctions
###### et de classes
###### Du R.P.G
######
###############################
###############################
###############################
###############################
##
## Definition de Classes
## R.P.G
##
###############################
class unite:
## I: Utilitaire
## I-1 Constructeur
## I-2 Duplicateur: unite_cible.newunit(unite_source)
## I-3 Identification precise: unite_a_identifier.identity()
## I-4 Identification succinte: unite_a_identifier.showstat()
## II: RPG
## II-1: Combat
## II-1-a controle d'etat des unite: unite.checkup()
## II-1-b calcul d'une attaque: attaquant.useabity(defenceur)
## II-2: Item
## II-2-a ajouter un item a l'inventaire en fin de combat: Joueur.addinv(mechant)
## II-2-b Incremente une a une toute les donnees de l'item a celle du Joueur:Joueur.useitem(item)
def __init__(self ,nom ,force ,taux ,pv ,ability ,pm ,xp ,lvl,item):
## definition de la fonction constructrice
## permest de definir toute les donnees de l'unite en donnans une succession de valeur entre les parenthese
"""constructeur: reclame Nom, Force, Taux de reussite des coups, PV,//
une liste de capacitee [nom,force, taux, magie,niveau, nom, force....], nombre de poits de magie, les points d'experience, XP, level, item type"""
self.nom=nom
self.force=force
self.taux=taux
self.pv=pv
self.pv_=pv
self.pm=pm
self.pm_=pm #les variable avec "_" a la fin sont les limites superieures (pour points de vie et point de magie)
self.xp=xp
self.xp_=xp # dans le cas des xp, xp_ c'est les xp qui servent a determiner le niveau et xp sont enleve pour payer des ameliorations de capacites ou de nouvelles capacites
self.lvl=lvl
self.dead=0
self.ability=ability
self.inventaire=[] #liste des items de l'inventaire
self.item=item #dans le cas d'un mechant, item qu'il est suceptible de donne
self.wins=0
self.fuite=0
self.money=0
def newunit(self, new):
## New unit sert a copier une unite car si on met en egalite 2 objet, la modification de l'un modifiera l'autre
## Sert a pouvoir massacrer une unite en gardant l'objet type en memoire
"""l'unite en argument devien pâle copie de celle a laquelle sapplique la methode"""
new.item, new.nom, new.force, new.taux, new.pv, new.pv_, new.pm, new.pm_, new.xp, new.xp_, new.lvl, new.ability, new.dead = self.item, self.nom, self.force, self.taux, self.pv_, self.pv_, self.pm_, self.pm_, self.xp_, self.xp_, self.lvl, self.ability, self.dead
def identity(self):
## Ientity est un showstat plus detaille et plus mis en page (prenant donc plus de place dans le terminal)
""" Carte d'identite de l'unite """
print """
Statistiques detaillees
nom:%s taux:%s
level:%s force:%s
vies:%s/%s magie:%s/%s
item au deces:%s experience:%s/%s """ % (self.nom, self.taux, self.lvl, self.force, self.pv, self.pv_, self.pm, self.pm_, self.item, self.xp, self.xp_)
readtime()
def showstat(self):
## Show stats: (utilise entre chaque coups au combat)
## Cette fonction montre sur le terminal les principales stat de l'unite
"""affiche les stats de l'unite"""
print "STATS DE %s \n force: %s vie: %s/%s magie: %s/%s xp: %s/%s level: %s " % (self.nom.upper(), self.force, self.pv, self.pv_, self.pm, self.pm_, self.xp, self.xp_, self.lvl)
def checkup(self):
## Checkup permet d'augmenter le niveau de l'unitee controlee
## Utilisee entre chaque coups pour upgrader ou verifier l'aspect mort de l'unite
"""contrôle le niveau et l'etat vivant de l'unite"""
if sqrt(self.xp_)>self.lvl: # augmentation des stats de l'unite
print "%s gagne un niveau: il gagne: %s mana, %s force, %s points de vie, monte son taux a %s" % (self.nom, int(exp(self.lvl)/2), self.lvl*2, self.lvl**2, sqrt(self.taux))
readtime(5)
self.lvl+=1
self.force+=self.lvl*2
self.pv_+=(self.lvl)**2
self.pv+=(self.lvl)**2
self.pm=int(self.pm_+(self.lvl)**2)
self.pm_=int(self.pm_+(self.lvl)**2)
self.taux=sqrt(self.taux)
if self.pv<=0: # unitee morte
if "fee en bouteille" in self.inventaire:
clearterm()
self.pv=0
self.useitem(self.inventaire.index("fee en bouteille"))
print "Votre fee vous vois en sale etat, elle saute de sa bouteille pour vous sauver, dites lui merci"
readtime()
else:
print "tu as perdu " + self.nom
self.dead=1
def useability(self, mechant,x):
## Useability, regarde la capacite x de self et l'utilise contrel'mechant
## Fondement du combat, correspond au fait de donner un coup (ou prendre fuite)
"""donne l'mechant et numereau de l'ability en cas de fuite, la fonction retourne "fuite". """
print self.ability[5*x] # 5*x est le debut de l'abilite (le nom) X suivi de ses 4 caracteristique (force,taux,cout de magie,niveau).
self.pm=self.pm-self.ability[5*x+2]
if ran()>(self.ability[5*x+3]): print 'le coup %s est un echec' % (self.ability[5*x],)
elif ran()<=(self.ability[5*x+3]):
if self.ability[5*x]=="fuite": return "fuite"
degats=int(ran()*self.force*self.ability[5*x+1])
mechant.pv-=degats
self.xp+=int(int(log(1+degats,1.5))*(log(mechant.xp_+mechant.force**7+mechant.pv_+mechant.pm_,5)/10)) #increment des XP
self.xp_+=int(int(log(1+degats,1.5))*(log(mechant.xp_+mechant.force**7+mechant.pv_+mechant.pm_,5)/10))
print "%s gagne %s points d'experience apres avoir inflige %s degats a %s" % (self.nom, int(int(log(1+degats,e))*(log(mechant.xp_+mechant.force**7+mechant.pv_+mechant.pm_,7)/10)), degats, mechant.nom)
readtime(2)
def addinv(self,mechant):
## Addinv: petite fonction utilisee en fin de combat pour gagner a pile ou face l'item type du mechant
"""offre une chance sur deux d'aqquerir l'item de l'mechant en argument"""
a=ran()
b=0
if len(self.inventaire)>=20:
print "besace pleine"
a=0
elif a>=0.5:
b=1
print ""
self.inventaire.append(mechant.item)
print "victoire! vous avez vaincu "+ mechant.nom+" vous trouvez dans sa besace %s $ et %s %s" % (mechant.money,b,mechant.item)
Joueur.wins+=1
Joueur.money+=mechant.money
def useitem(self, item):
## useitem : utilisation des items
## incremente les stats du hero des valeurs associees du tuple de l'item (implicite)
"""utilise l'item en argument"""
tupple=inventaire[self.inventaire[item]] #acquisition du tuple du dico des items.
self.inventaire.remove(self.inventaire[item]) #retrait de l'inventaire lie a l'utilisation
self.pv += tupple[0]
self.pv_ += tupple[1]
self.pm += tupple[2]
self.pm_ += tupple[3]
self.xp += tupple[4]
self.xp_ += tupple[4]
self.force += tupple[5]
if self.pv>self.pv_: self.pv=self.pv_
if self.pm>self.pm_: self.pm=self.pm_
#################################
##
## Definition fonctions simple
##
#################################
def ran():
## ran() = retourne une valeur entre 0 et 1 (genre 0.3589456321 ou 0.7854322154)
"""retourne un random classique"""
return (random())
def question(Q, propositions): # pour ceux qui se posent la question("c'est quoi cette question?", ["c'est dur", "cest facile"])
## question("je suis la question", ["je suis la premiere proposition", "Je suis la deuxieme", "Je suis la troisieme"])
## pose une question a propositions et retourne la valeur correspondant a la reponse (la valeur 0 correspond a la premiere proposition)
"""pose la question Q (1er argument) avec les proposition (liste et 2eme argument), retourne le numereau de la reponce voulue"""
t=0
while t==0:
print Q
x=0
while x<len(propositions):
print x, " - ", propositions[x]
x+=1
answer,t=asknumber(),1
if answer>=len(propositions) or answer<0:
t=0
print "Valeur en entree incorrecte"
clearterm()
return answer
def asknumber():
## prinsipalement utilise par la fonction question, cette fonction demende un chifre,
## elle controle son aspect "chiffrique" et retourne la reponce ou -9 si c'est pas une bone valeur qui a ete donnee (permet de comparer le resultat)
"""demande une valeur et controle que ce soit un entier puis la retourne (cas contraire retourne -9 pour pouvvoir etre compare et sorti d'intervalle)"""
answer=raw_input('entrez une valeur numerique entiere \n')
try: a=int(answer)
except: a=-9
return a
def buildlist(mode):
## buildlist est la fonction pour faire des listes de propositions pour questions: 3 modes
##1## mode 'capa' cre la liste des abilitys pour le combat
##2## mode 'boost' cre la liste des abilitys pour le menu ou on les boostent
##3## mode 'item' cre la liste des items de l'inventaire pour inventaire()
##4## mode 'sell' cre la liste du vendeur
"""retourne une liste des ability du joueur"""
liste=[]
if mode== 'capa':
for c in range((len(Joueur.ability))/5):
liste.append(str(Joueur.ability[c*5])+' force: %s , Taux de reussite: %s , Cout de magie: %s' % (Joueur.ability[c*5+1], Joueur.ability[c*5+3], Joueur.ability[c*5+2]))
elif mode == 'boost':
for c in range((len(Joueur.ability))/5):
liste.append(str(Joueur.ability[c*5])+' force: %s , Taux de reussite: %s , Cout de magie: %s, Niveau: %s, cout de xp :%s' % (Joueur.ability[c*5+1], Joueur.ability[c*5+3], Joueur.ability[c*5+2], Joueur.ability[c*5+4], Joueur.ability[c*5+4]**koefdecoutdecapa[Joueur.ability[c*5]]))
elif mode == 'item':
for x in range(len(Joueur.inventaire)):
nom=Joueur.inventaire[x]
liste.append("item: %s \n bonnus: vie: +%s/+%s magie: +%s/+%s xp: +%s force: +%s" %(nom,inventaire[nom][0],inventaire[nom][1],inventaire[nom][2],inventaire[nom][3],inventaire[nom][4],inventaire[nom][5]))
liste.append("quitter")
elif mode=='sell':
for nom in listemarchand:
liste.append("item: %s \n bonnus: vie: +%s/+%s magie: +%s/+%s xp: +%s force: +%s prix: %s$" %(nom,inventaire[nom][0],inventaire[nom][1],inventaire[nom][2],inventaire[nom][3],inventaire[nom][4],inventaire[nom][5],inventaire[nom][6]))
liste.append("quitter")
return liste
###################################
##
## Definition fonctions spesifique
##
###################################
def acheter():
print "vous voici chez le Marchant! il sait vendre des articles qui sont suseptible de vous interesser..."
print "il vous reste %s $" % Joueur.money
if len(Joueur.inventaire)>=20:
print"commence par utiliser tes items car ta besace est pleine"
return
answer=question("le marchand a en magasin ceci: que voulez vous?",buildlist("sell"))
if answer>len(listemarchand)-1:return
if Joueur.money<inventaire[listemarchand[answer]][6]:
print "dégage clochard"
return
Joueur.inventaire.append(listemarchand[answer])
Joueur.money-=inventaire[listemarchand[answer]][6]
def gestion_inventaire():
## Gestion_inventaire: cree une liste des items avec leurs proprietes
## Demande quel item utiliser verifie sa disponibilite.
"""interface de gestion de l'inventaire du joueur"""
listeinv=buildlist('item')
q=question('voici votre inventaire',listeinv)
if 0<=q<len(Joueur.inventaire): Joueur.useitem(q)
def find_an_ennemy(mechant):
## find_an_ennemy(mechant): mechant (predefini en unite) est l'objet qui sera utilise pour retenir l'mechant le temps du combat.
## utilise la disaine du niveau pour voir quels mechants peuvent être face au joueur.
"""determine un mechant au niveau du joueur."""
t=(ran())*Joueur.wins/10
mechant.money=int(t*1000)
if t<=1: carotte.newunit(mechant)
elif t<=2: boulet.newunit(mechant)
elif t<=7.5: bosse.newunit(mechant)
else :
Christophe.newunit(mechant)
print"He toi la bas, arette de massacrer tous mes monstres! Je vais te donner une leçon, tu vas voir que face a moi tu vas moins faire ton malin!"
raw_input()
rep=1
mechant.force+=(Joueur.force/2)
mechant.pv+=(Joueur.pv_/2)
mechant.pv_ += (Joueur.pv_/2)
mechant.xp_ += (Joueur.xp_-Joueur.xp)
mechant.money=(10^(Joueur.lvl))
print "face a un tel adversaire, vous devriez vite utiliser des objet ou de l'experience...."
while 0<rep<=len(listactions):
rep=question("Voulez vous:", listactions)
if rep==1:
print "bienvenu dans ce menu:"
c=question("quelle aptitude voulez vous ameliorer d'un niveau?", buildlist('boost'))
if Joueur.ability[c*5+4]**koefdecoutdecapa[Joueur.ability[c*5]]<Joueur.xp:
Joueur.xp-=Joueur.ability[c*5+4]**koefdecoutdecapa[Joueur.ability[c*5]]
Joueur.ability[5*c+1]+=(Joueur.ability[5*c+1])*0.3
Joueur.ability[5*c+2]=sqrt(Joueur.ability[5*c+2])
Joueur.ability[5*c+4]+=1
elif rep == 2:
print "pas de commmerçant en ville"
print "vous avez %s $ dans votre besace... avous d'attendre le marchant pour en faire bon usage" % Joueur.money
elif rep==3: gestion_inventaire()
elif rep==4: Joueur.identity()
elif rep==5: pass
def qcombat(attaquant,mechant):
## qcombat(attaquant,mechant): gere un coup de l'attaquant a son mechant
## utilise par combat(), elle permet d'avoir les même regles de combat quelque soit l'attaquant.
"""1er argument attaquant, 2eme argument defenceur, gere un coup."""
capa=buildlist('capa')
print """a %s de jouer""" % attaquant.nom
if attaquant == Joueur:
answer=question("quelle attaque utilisez vous?", capa)
while attaquant.ability[5*answer+3]>=attaquant.pm:
if attaquant.pm<=0:attaquant.pm=1
answer=question("quelle attaque utilisez vous?", capa)
else :
X=0
while X < (len(attaquant.ability))/5 :
if attaquant.ability[5*X+2]<attaquant.pm:
answer=X
break
X+=1
valeur=attaquant.useability(mechant,answer)
attaquant.showstat()
if valeur == "fuite": return 'end'
return ""
def combat( mechant, surprise):
## combat:
## mechant est l'objet de type unite mechant, l'effet de surprise dit si c'est le joueur qui donne le 1er coup.
"""gere tout un combat, 1er argument: mechant (de type unite) et 2eme effet de surptise (si 1 alors Joueur 1er a frapper)"""
print "UN combat est engage! youhou! vas y avoir du fight!! adversaire: %s, en voici les STATS" % (mechant.nom,)
mechant.identity()
x=0
if surprise==1:
x+=1
print "tour:", x
print "vous beneficiez de l'effet de surprise"
t=qcombat(Joueur,mechant)
Joueur.checkup()
mechant.checkup()
readtime()
while mechant.dead==0 and Joueur.dead==0 and t!='end':
x+=1
print "tour:", x
t=qcombat(mechant,Joueur)
mechant.checkup()
Joueur.checkup
if mechant.dead!=0 or Joueur.dead!=0 or t=='end': break
x+=1
readtime()
print 'tour:', x
t=qcombat(Joueur,mechant)
Joueur.checkup()
mechant.checkup()
readtime()
if t== "end":
print"vous avez fuis"
Joueur.fuite+=1
elif mechant.dead==1:Joueur.addinv(mechant)
else: print "balala, perdre contre un(e) %s, n'est ce pas ridicule?" % mechant.nom
###############################
###############################
###############################
######
###### CODE
######
################################
################################
################################
###################################################
##
## Definition des principales listes et variables
##
###################################################
# pour implementer le jeu d'une unite, il faut ajouter ici un nouvel mechant, definir son item dans le dictionnaire inventaire et ajouter des chances de rencontrer l'mechant dans find_an_ennemy.
# kefdecoutdecapa est un dictionnaire repertoriant les koefficiants de cout en points du niveau de capa
koefdecoutdecapa={"coup de poing":2, "fuite":1.58, "super coup de poing":3, "attendre":1 }
# mechant est une unite qui sera l'adversaire du joueur au long du jeu, il sera resete entre chaque combat.
mechant=unite(1,1,1,1,1,1,1,1,1)
# liste des actions propose entre chaques combat.
listactions=['continuer le combat', "utiliser vos points d'experience", "aller chez le commerçant", "utiliser des items","regarder ses stats","quitter le jeu"]
# definition des unitees
##rappel: unite(nom,force,taux de reussite, points de vie, liste des capacitees(nom,force, cout de magie, taux de reussite, niveau), poinst de magie, experience, niveau, nom d'items)
#joueur (raw input permet au joueur de choisir son nom)
Joueur=unite(raw_input('nom du joueur\n'), 10 , 0.6, 100, ["coup de poing" , 2,0,0.98,2, "fuite" , 0,0,0.5,2, "super coup de poing" , 10,5,0.85,4, "attendre",0,0,1,1], 25, 0, 0,"none")
Joueur.inventaire.append("fee en bouteille")
Joueur.inventaire.append("fee en bouteille")
Joueur.inventaire.append("fee en bouteille")
clearterm()
print "vous commencez le jeu avec 3 fees en bouteilles, elles vous remonteront la vie d'elle meme au dernier moment pour vous sauver la mise \n \n"
readtime()
#definition des type de mechants
carotte=unite("carotte",2,0.7,10,["coup de poil",4,0,0.9,2],10,10,0,"carotte vichi")# cf ligne 64 a 80
boulet=unite("boulet",5,0.8,20,["coup dechaîne",8,0,0.7,3],60,100,5,'poid de force')
bosse=unite("bosse",15,0.70,75,["coup douloureux",20,10,0.8,5,"ptitcoup",8,0,0.7,4],50,400,10,'pommade')
Christophe=unite("Christophe",100,0.99999,1000,["Coup de clavier",100,0,0.98,7],10000,10000,100,"Linux Kernel")
#definition des diferents inventaires.
inventaire={"carotte vichi":(50,0,5,0,0,0),"poid de force":(0,5,0,0,0,0.5),'pommade':(1000,50,50,5,20,0.7),"Linux Kernel":(1000000000,100000,1000000000,1000000,9999999999,20),"fee en bouteille":(2000000000,0,20,0,0,0,50000),"potion de restauration":(2000000000,0,2000000000,0,0,0,5000),"potion de vie mineure":(500,10,10,5,0,0,1500)} #'nom de l'item':(pv,pv_,pm,pm_,xp,force,cout(si a vendre)),
listemarchand=["potion de vie mineure","potion de restauration","fee en bouteille"]
# definition de rep pour pouvoir comparer a 5 dans la boucle while.
rep=1
####################################
##
## Le code de l'apres definition.
##
####################################
while rep!=5 or Joueur.dead==1:
rep=1
find_an_ennemy(mechant)
combat(mechant,1)
print Joueur.wins
if Joueur.dead==1 : break
while 0<rep<=len(listactions):
rep=question("Voulez vous:", listactions)
if rep==1:
print "bienvenu dans ce menu:"
c=question("quelle aptitude voulez vous ameliorer d'un niveau?", buildlist('boost'))
if Joueur.ability[c*5+4]**koefdecoutdecapa[Joueur.ability[c*5]]<Joueur.xp:
Joueur.xp-=Joueur.ability[c*5+4]**koefdecoutdecapa[Joueur.ability[c*5]]
Joueur.ability[5*c+1]+=(Joueur.ability[5*c+1])*0.3
Joueur.ability[5*c+2]=sqrt(Joueur.ability[5*c+2])
Joueur.ability[5*c+4]+=1
elif rep == 2:
if Joueur.money < 1500:
print "pas de commmerçant qui vous laissent rentrer la bourse si légère. CLOCHARD!"
print "vous avez %s $ dans votre besace... à vous d'attendre la tolérence du marchant pour en faire bon usage (1800$)" % Joueur.money
else:
acheter()
elif rep==3: gestion_inventaire()
elif rep==4: Joueur.identity()
elif rep==5: pass

ÉDIT:je vous passerait ma version du code en éditant se code sauf si vous en voulais pas, mais si ne serai-ce que ça puisse intéresser une personne, je pense que ce n'est pas perdu...
ReÉdit: J'ai fait des effort de lisibilité du fait de la publicaation de mon code... (commentaires+ définition de fontions)

Merci de vous intéresser a ce code (qui je pense peut être assez interessant car simple et mieu commenté pourait carrément avoir une visée pédagogique)

popi31

16 décembre 2006 à 23:07:18

Si la violence ne résout pas ton problème c'est que tu n'as pas été assez violent.

alexises

16 décembre 2006 à 23:24:40

je teste et je te dit quoi
ton code est encore bouger
mon interpréteur ne me ment pas

EDIT : j'ai mal compris le sujet désoler

16 décembre 2006 à 23:31:36

pourtant la ligne est toute bête! il y a pas de difficulté ou quoi.... je n'arrive pa a voir, j'ai cherché bien longtemps mais la j'arrive pas.... il y a les 2 points, les espaces sont pas des tabs (car quant on mélange plusieurs type d'indentation sa galère un peu)

la, je sèche.... mais ça buggue

Pmol

17 décembre 2006 à 10:32:15

Ligne 68 : Il te manque une parenthèse.

Il y a encore d'autres bugs dans ton code, je ne vais pas tous les corriger

17 décembre 2006 à 11:00:02

merci, c'es celuila que j'arrivait pas a corrigé, je vai me débrouiller pour les autres ;-)

17 décembre 2006 à 11:06:27

Pour t'aider à débugguer : quand Python indique une erreur à la ligne N, regarde à la ligne N-1, souvent les erreurs se cachent là.

17 décembre 2006 à 13:16:13

bonne astuce, dans le code proposé, il y avait un autre exemplaire de manque de parenthèse au bug reporté a la ligne suivante... la il veux bien fonctionne tant qu'on utilise pas l'inventaire...
Merci beaucoup pmol.

19 décembre 2006 à 12:47:24

up petit up, je sait pas ou publier se code, mais j'aimerait bien avoir des retours dessu si il y a des gens qui trouvent se code intéressant...

17 mai 2007 à 0:33:07

je pense que l'over comentation du code peut ouvrir l'acces a la lecture comme si étudier ce code était un tuto sur le python...

Anonyme

17 mai 2007 à 9:34:36

Tu devrais être plus modulaire, et faire plusieurs fichiers.

17 mai 2007 à 12:35:19

ee... c'est a dire?

(je sait pas faire "include" en python donc, je m'interdit encore le "multi fichier..." et modulaire serait rempacer toutes les valeur fixe par des variable modifiable depuis un "fichier de configuration"? c'est ça?

(merci de la réponse qui plus est constructive) ;-))

MaAaD

17 mai 2007 à 12:44:06

Je débute en Python mais j'ai cru comprendre que Bigloo voulait dire que tu devrais créer des modules pour importer tes classes et fonctions. Mais ce n'est peut-être pas du tout ca, je répète que je débute :-°

17 mai 2007 à 12:59:33

super ti nain> C'est effectivement ce que MaAaD a dit : tu peux séparer tes fonctions selon leur effet dans différents modules, que tu enregistres en .py (par exemple combats.py). Après, tu pourras les utiliser depuis d'autres fichiers en les important (par exemple, from combats import *)

segiso

17 mai 2007 à 13:09:59

Hey, super ti nain, pas mal ton script, je t'avouerais que j'ai pas pris le temps de tout lire :-°

, mais je l'ai testé, si je peux me permettre, voici un ou deux conseils...
Tout d'abord, dans quel but as-tu devellopé ce script? Uniquement entrainement ou tu t'amusais un peu??
Ensuite, tu pourrais utiliser

from random import randrange

, au moyen d'un petit tuple, tu pourrait créer plusieurs nom d'adversaires, perso au debut je tombe toujours sur carrote ;-)
Bon alors j'en arrive à ce que je voulais vraiment te dire : je ne suis pas très POO, surtout en python, mais Tkinter de permettrait de faire une version "graphique", basique certes mais beaucoup plus amusante de ton mini-jeu?
Que ce qui s'y connaissent un peu me répondent...
a plus et bon courage.

PS : comme je l'ai dit, je n'ai pas lu l'integralité du script, donc arrêtez moi si je dis des conneries...

17 mai 2007 à 13:55:45

c'était pour un entrainement simpas et qui semble avoir un interet et une phase de test du programme pas trop pénible (vu que c'est un jeu....)
donc, in fact, ce que je vait faire, c'est faire un script avec toutes les def et un script avec le programme lui même... c'est bien ça...

(le code une fois les classe, les fonction et les variables définies, donne:

while rep!=5 or Joueur.dead==1:
rep=1
find_an_ennemy(mechant)
combat(mechant,1)
print Joueur.wins
if Joueur.dead==1 : break
while 0<rep<=len(listactions):
rep=question("Voulez vous:", listactions)
if rep==1:
print "bienvenu dans ce menu:"
c=question("quelle aptitude voulez vous améliorer d'un niveau?", buildlist('boost'))
if Joueur.ability[c*5+4]**koefdecoutdecapa[Joueur.ability[c*5]]<Joueur.xp:
Joueur.xp-=Joueur.ability[c*5+4]**koefdecoutdecapa[Joueur.ability[c*5]]
Joueur.ability[5*c+1]+=(Joueur.ability[5*c+1])*0.3
Joueur.ability[5*c+2]=sqrt(Joueur.ability[5*c+2])
Joueur.ability[5*c+4]+=1
elif rep == 2:
print "pas de commmerçant en ville"
print "vous avez %s $ dans votre besace... avous d'attendre le marchant pour en faire bon usage" % Joueur.money
elif rep==3: gestion_inventaire()
elif rep==4: Joueur.identity()
elif rep==5: pass

ce qui est un code plus concis certes ;-)
(mais a coté je fait 3 scripts, un définition des fonctions, un définition des classes et un définition des variable??)

et si tu été juste face a des carottes, j'ai une esplication, c'est car c'est le méchant "bas level" donc tant que tu a pas passé le niveau ee 10 je croix... tu n'est que face a des carottes...
mais bon, j'ai mis des noms déconneur, c'est un script pour mamuser, je pourait définir d'autre type de méchant...

j'ai commencé il y a déja un moment une version avec tk mais j'ai vite abandonner, (j'avait défini la fonction qui pose une question en tk)car il faudrait tout tout tout coder pour le tk c'est a dire que je n'arrive pas a repasser de la fenetre au terminal en fesant une succession de pop-up...

effectivement, je pourait faire un tuple de prénom (mais laisser le nom car faut savoir si on doit s'attendre a un coup de poil ou...) ....

17 mai 2007 à 17:35:03

En fait tu ne défini pas tes variables dans un autre fichier (sauf évidemment si tu compte faire commme pour la plus part des jeux un fichier config pour modifier rapidement le jeu sans passer par la source), tu ne met que tes fonctions et classes dans un ou deux fichier différents. Je n'ai pas lu ton code mais tu peux faire un fichier avec les classes et fonctions qui s'appliquent aux "méchants", et un autre fichier avec les classes et fonction de ton héros, par exemple. Et si tu avais utilisé une interface graphique tu aurais créé un fichier avec les classes et fonctions pour l'interface.
Bon sur ce, je me replonge dans le tuto de G.Swinnen, @+

18 mai 2007 à 0:24:23

dans un souci d'équité la classe du héro est exactement la même que celle de l'ennemi ;-)
mais, oui.. je voix.. et par défaut, je suppose que si je présise pas l'adresse du script, ça regarde a l'adresse relative...

Python: oû est le problême?

un RPG qui devrait marcher.

Python: oû est le problême?

Supprimer

Modérer

Signaler le message aux modérateurs