Comment réparer TypeError: méthode non liée doit être appelée avec l'instance Dropper comme premier argument

Question

J'écris un jeu où une pierre tombe et vous utilisez la souris pour que votre chef ne soit pas écrasé. Lorsque la roche tombe de l'écran, deux roches supplémentaires apparaissent et tombent. Cela continue jusqu'à ce que votre personnage soit frappé.

Cependant, j'ai obtenu l'erreur:

TypeError: unbound method additonal_drop() must be called with Dropper instance as first argument (got nothing instead) 

Je ne sais pas ce que je devrais mettre dans le (). Quelqu'un peut-il m'expliquer cette erreur?

En outre, comment puis-je obtenir l'image-objet Dropper pour ne pas être visible?

Voici mon code:

from livewires import games, color 
import random 

games.init(screen_width = 640, screen_height = 480, fps = 50) 


class Chef(games.Sprite): 

    image = games.load_image("chef.bmp") 

    def __init__(self): 
     super(Chef, self).__init__(image = Chef.image, 
            x = games.mouse.x, 
            bottom = games.screen.height) 
    def update(self): 
     """ Move to mouse x position. """ 
     self.x = games.mouse.x 

     if self.left < 0: 
      self.left = 0 

     if self.right > games.screen.width: 
      self.right = games.screen.width 

     self.check() 

    def check(self): 
     """ Check if hit by rocks. """ 
     for rock in self.overlapping_sprites: 
      rock.end_game() 

class Rock(games.Sprite): 
    """ 
    A rock which falls to the ground. 
    """ 
    image = games.load_image("rock.bmp") 
    speed = 1 

    def __init__(self, x = 320, y = 90): 
     """ Initialize a rock object. """ 
     super(Rock, self).__init__(image = Rock.image, 
            x = x, y = y, 
            dy = Rock.speed) 

    def end_game(self): 
     """ End the game. """ 
     end_message = games.Message(value = "Game Over", 
            size = 90, 
            color = color.red, 
            x = games.screen.width/2, 
            y = games.screen.height/2, 
            lifetime = 2 * games.screen.fps, 
            after_death = games.screen.quit) 
     games.screen.add(end_message) 

    def update(self): 
     """ Check if bottom edge has reached screen bottom. """ 
     if self.bottom > games.screen.height: 
      self.destroy() 
      Dropper.additonal_drop() 


class Dropper(games.Sprite): 
    """ 
    A invisible sprite that drops the rocks. 
    """ 
    image = games.load_image("rock.bmp") 
    def __init__(self, y = 55, speed = 2, odds_change = 200): 
     """ Initialize the dropper object. """ 
     super(Dropper, self).__init__(image = Dropper.image, 
             x = games.screen.width/2, y = y, 
             dx = speed) 

     self.odds_change = odds_change 
     self.time_til_drop = 0 


    def update(self): 
     """ Determine if direction needs to be reversed. """ 
     if self.left < 0 or self.right > games.screen.width: 
      self.dx = -self.dx 
     elif random.randrange(self.odds_change) == 0: 
      self.dx = -self.dx 

    def additonal_drop(self): 
     new_rock = Rock(x = self.x) 
     games.screen.add(new_rock) 

     new_rock = Rock(x = self.x) 
     games.screen.add(new_rock) 


def main(): 
    """ Play the game. """ 
    wall_image = games.load_image("wall.jpg", transparent = False) 
    games.screen.background = wall_image 

    the_chef = Chef() 
    games.screen.add(the_chef) 

    the_rock = Rock() 
    games.screen.add(the_rock) 

    the_dropper = Dropper() 
    games.screen.add(the_dropper) 

    games.mouse.is_visible = False 

    games.screen.event_grab = True 
    games.screen.mainloop() 

# start it up! 
main() 

Answer 1

Essayez de définir la classe Rock avec un paramètre supplémentaire dropper:

def __init__(self, x = 320, y = 90, dropper=Dropper()): 

dropper sera l'instance Dropper. Ensuite, créez Rock instances de l'intérieur Dropper comme suit:

Rock(x=self.x, dropper=self) 

Cela passera l'instance Dropper il self à chaque instance Rock que l'instance Dropper crée. Dans l » __init__()Rock, sauf une référence au Dropper exemple:

self.dropper = dropper 

Appel additional_drop() avec:

self.dropper.additional_drop()