Python Game Help: Comment avoir une fonction toujours vraie quand elle est vraie.

Question

Je fais un jeu python et j'ai un petit problème rapide. Il y a un couloir qui se divise à gauche et à droite. Quand vous allez à gauche, il y a une clé que vous obtenez et quand vous allez à droite il y a un ascenseur verrouillé. La clé est ce dont vous avez besoin pour déverrouiller l'ascenseur. Le problème se pose lorsqu'un utilisateur essaie de revenir en arrière dans un jeu et qu'ils reviennent dans le hall. Code ci-dessous:

def elevator(Lock): 
    if lock== 'unlock': 
     print "Unlocked" 

    else: 
     print "It is locked" 

def safe(): 
    print "obtain key" 
    right_left('True') 

def right_left(Key): 
    backward = ['back'] 
    left = ['left', 'Left'] 
    right = ['right', 'Right'] 
    choice = raw_input("Enter Command > ") 

    if Key == 'True': 
     print "Left or right?" 

     if choice== 'right': 
      elevator('Unlock') 
     elif choice == 'back': 
      back() 

    else: 
     if any (s in choice for s in backward): 
      back() 

     elif any (s in choice for s in left): 
      safe() 

     elif any (s in choice for s in right): 
      elevator() 

def back(): 
    print "Back in the game." 
    right_left('False') 

Le gros problème que j'ai est que si un utilisateur prend la clé et remonte à la salle à droite à gauche puis ils choisissent de revenir en arrière. S'ils retournent dans le jeu et retournent au début (ce qui n'est pas dans cet exemple/exemple), ils retourneront à la fonction 'back()' et continueront à la fonction 'right_left' avec Key = false. Mais cela doit être vrai. Je n'arrive pas à comprendre comment, une fois que 'right_left' est vrai, ce sera toujours vrai, peu importe ce que fera un utilisateur dans le futur. Merci et désolé c'est déroutant

Answer 1

Le problème est que votre structure s'appelle sur une pile sans fin d'appels right_left(), qui semble n'avoir aucun moyen d'échapper. Vous ne passez que deux chaînes différentes ('True', 'False') dans cette méthode, donc il n'y a pas d'état réel de l'utilisateur.

Vous devez effectuer une restructuration majeure des chemins pour l'utilisateur et séparer la décision de déplacement de la logique de la pièce. Ensuite, vous pouvez tenir une sorte de contexte pour l'utilisateur, et éventuellement un certain état pour les chambres. Cela bénéficierait d'une conception orientée objet, sinon vous devrez utiliser des globales pour conserver l'état des pièces.

Pour ce faire, avec des variables globales, vous pouvez définir des méthodes telles que:

# global variable to keep track 
rooms=['safe', 'closet','main'] 
currentRoom=rooms[0] 

# returns which the new room you are in. 
def move(fromRoom, direction): 

# main section 
while (response != "exit"): 
    choice = raw_input("Enter Command > ") 
    move(currentRoom, choice) 

# etc.. 

Answer 2

Cela sonne comme un bon problème pour le code orienté objet. Voir ci-dessous pour un exemple rapide. D'abord, vous pouvez créer un objet gameState comme suit:

class gameState(object): 
    def __init__(self): 
     self.hasKey = False 

    def pickUpKey(self): 
     self.hasKey = True 

    def hasKey(self): 
     return self.hasKey 

Ce jeu objet d'état peut aussi que d'être utilisé pour abriter plus d'informations sur jeu yoru, comme l'emplacement actuel par exemple.

Vous devrez alors créer une instance de l'objet gameState (à transmettre à chaque fonction ou à utiliser comme variable globale). Par exemple, votre main peut ressembler à:

def main(): 
    currentState = gameState() 
    main_game_loop(currentState)