Citation :
il est évident que j'aie été ambigu sur certains points, je m'en excuse.
Vue le nombre d'âneries que j'ai pu sortir depuis le début, tu es tout excusé

Pour transférer les achats, il faut utiliser les variables globales.
On peut créer une variable directement attachée au module du GE, mais de mon point de vue ça ne serait pas très propre.
Je repense aux systèmes de sauvegarde et de chargement, qui auront aussi accès aux variables globales.
En fait ce qui serait le plus propre c'est de créer une classe (un module) qui regrouperait les variables globales utilisées, le système d'initialisation, les fonctions de sauvegarde/chargement et d'autres fonctions si besoin. Ça permettrait aussi de regrouper toutes ces fonction en un seul .py, et ce serait plus compréhensible et facile d'accès.
Grâce à ces variables globales, tu pourras aussi accéder à la liste des objets en stock à partir d'un autre script (par exemple le script d'assemblage).
Ou alors si tu trouves ça trop compliqué pour toi, on en reste à 1 fonction = 1 .py.
Les variables globales sont telles que n'importe quel script lancé dans le GE peut accéder à ces variables, alors que deux scripts peuvent rarement communiquer entre eux aisément.
On défini une variable globale comme ceci :
GameLogic.variable = "ceci est une variable globale"
La variable 'GameLogic.variable' est alors créée. Elle peut aussi bien être une variable classique (nombre, texte, liste...) qu'une fonction ou même une classe (qui peut regrouper plusieurs fonctions et plusieurs variables).
L'utilité du dernier cas (la classe), c'est que tu peux y insérer toutes tes fonctions et toutes tes variables. Ça évite donc d'avoir plein de variables sur le module GameLogic ('GameLogic.variable1', 'GameLogic.variable2', GameLogic.liste1'...) et donc les conflits (vouloir créer une variable qui va en écraser une autre, ou création impossible...). De plus une classe peut être entièrement insérée dans un seul fichier .py et possède une cmmande qui permet d'initialiser ton jeu (chargement auto au lancement, déclaration dès le départ...).
Je posterais un exemple plus tard, là j'ai à faire
@+

EDIT : je t'ai fait un "petit" exemple :
met le sur un objet qui reste en permanence dans la scene (et dans le layer visible) (généralement je prend un empty qui ne sert qu'à l'initialisation et à rien d'autre). Relie le script à un sensor Always, et marque le contrôleur (coche la petite étoile) :
import pickle
class inventaire:
def __init__(self):
# initialisation des variables globales
self.filename = "Sauvegarde.sauvegarde"
self.argent = 0
self.objets = {}
# complete la ligne et remplace les '%' par ton prix :
self.prix = {"OBCoque1": % , "OBMoteur1": % , "OBCanon1": % }
# chargement au lancement du jeu (facultatif)
self.charger()
def charger(self):
try:
# chargement des donnees sauvees
self.fichier = open(self.filename, "rb")
self.argent = pickle.load(self.fichier)
self.objets = pickle.load(self.fichier)
self.fichier.close()
except:
# s'il n'y a pas de fichier de sauvegarde, on ne charge rien
pass
def sauver(self):
# on sauve les donnees de l'argent et des objets acquis
self.fichier = open(self.filename, "wb")
pickle.dump(self.argent, self.fichier)
pickle.dump(self.objets, self.fichier)
self.fichier.close()
def acheter(self, liste_achat):
for objet in liste_achat:
if objet in self.objets:
self.objets[objet] += liste_achat[objet]
else:
self.objets[objet] = liste_achat[objet]
GameLogic.inventaire = inventaire()
Pour le script de confirmation d'achat (attaché au plan 'Argent achat') :
cont = GameLogic.getCurrentControlleur()
own = cont.owner
achat = {}
somme_achat = 0
# complete la ligne, tout les objets pouvant etre achetes doivent y etre :
liste_objet = ["OBMoteur1", "OBCoque1", "OBCanon1"]
# on retient la liste des objets achetes et leur quantitee
for objet in liste_objet:
if own[objet] == 0:
pass
else:
achat[objet] = own[objet]
for objet in achat:
somme_achat += achat[objet]*GameLogic.inventaire.prix[objet]
GameLogic.inventaire.acheter(achat)
GameLogic.inventaire.argent += -somme_achat
Pour le panneau indiquant les valeurs, tu peux le relier au système de compte du nombre de pièce (un peu comme la somme totale).
Pour sauvegarder ton jeu, ajoute ce script au plan 'Sauvegarder' :
GameLogic.inventaire.sauver()
Pour charger ton jeu, ajoute ce script au plan 'charger' :
GameLogic.inventaire.charger()
Lorsque tu voudras faire ton système lors de l'assemblage, dans le script tu pourra accéder à tous les objets possédés et leur nombre avec 'GameLogic.inventaire.objets'.
Par contre je ne te garanti pas que les scripts marchent... me connaissant ça doit être bourré de fautes de syntaxes
@+
