第二个循环忽略按钮按下

Question

我正在尝试在运行 Python 2.7 的 Raspberry Pi 上编写一个带有一些点亮街机按钮的反应游戏，并且第一个灯/按钮按下序列效果很好，但在第二个灯亮起后，按钮按下将无法及时注册。

def FastButtons(btn):
    btn.was_held = True
    Choice = random.choice([17, 22, 5, 24, 16])
    RedButton.when_pressed = FastPush
    BlueButton.when_pressed = FastPush
    YellowButton.when_pressed = FastPush
    GreenButton.when_pressed = FastPush
    WhiteButton.when_pressed = FastPush
    FastGo(Choice)

def FastGo(led):
    global FastButtonTime
    if led == 17:
        leds.Red.on()
        sleep(FastButtonTime)
        leds.Red.off()
    elif led == 22:
        leds.Blue.on()
        sleep(FastButtonTime)
        leds.Blue.off()
    elif led == 24:
        leds.Yellow.on()
        sleep(FastButtonTime)
        leds.Yellow.off()
    elif led == 5:
        leds.Green.on()
        sleep(FastButtonTime)
        leds.Green.off()
    elif led == 16:
        leds.White.on()
        sleep(FastButtonTime)
        leds.White.off()

def FastPush(btn):
    global GameOver
    global FastButtonTime
    if GreenButton.was_held:
        led = btn.pin.number
        if led  == 17:
                status = leds.Red.is_lit
        elif led == 22:
                status = leds.Blue.is_lit
        elif led == 24:
                status = leds.Yellow.is_lit
        elif led == 5:
                status = leds.Green.is_lit
        elif led == 16:
                status = leds.White.is_lit

        if status:
            print ("it's Active")
            if FastButtonTime > .3:
                FastButtonTime = FastButtonTime - .05
                print FastButtonTime
            leds.off()
            Winner = True
        else:
            print ("it's not active")
            Loser()
            GreenButton.was_held = False
            GameOver = True
            Winner = False
        if Winner:
            sleep(1)
            FastButtons(GreenButton)

第二次通过时，直到FastGo定义中的sleep完成后，它才会注册按钮按下，从而导致玩家输掉游戏

Answer 1

我想我想通了为什么在对嵌套函数的执行方式进行了一些研究之后它不会第二次处理，并且因为FastPush调用FastButtons ，它必须等待该过程完成才能接受另一个按钮按下。

因此，我将所有代码重组为一个 function，使用按下按钮的速度来验证输赢，而不是灯的 state。

如果有人知道如何制作它以便在用户花费太长时间而不妨碍按下按钮的能力时灯会关闭，那就太棒了，就像现在这样。 它会一直亮着，直到按下按钮。

我的新 function 对于任何感兴趣的人来说都是这样的

def FastButtons(btn):
        if not BlueButton.was_held and not WhiteButton.was_held:
                btn.was_held = True
                global Winner
                TimeAllowed = 1.5
                while True:
                        if not Winner:
                                blink(leds)
                                sleep(2)
                        led = random.choice([17, 22, 5, 24, 16])

                        if led == 17:
                                leds.Red.on()
                                start = time()
                                RedButton.wait_for_press()
                                stop = time()
                        elif led == 22:
                                leds.Blue.on()
                                start = time()
                                BlueButton.wait_for_press()
                                stop = time()
                        elif led == 24:
                                leds.Yellow.on()
                                start = time()
                                YellowButton.wait_for_press()
                                stop = time()
                        elif led == 5:
                                leds.Green.on()
                                start = time()
                                GreenButton.wait_for_press()
                                stop = time()
                        elif led == 16:
                                leds.White.on()
                                start = time()
                                WhiteButton.wait_for_press()
                                stop = time()
                        TotalTime = stop - start
                        print (TotalTime)

                        if TotalTime < TimeAllowed:
                                Winner = True
                                leds.off()
                                if TimeAllowed > .3:
                                        TimeAllowed = TimeAllowed - .05
                                RandomSleep = random.uniform(0.5, 3.5)
                                sleep (RandomSleep)
                        else:
                                FastLoser()
                                break

def FastLoser():
        global Winner
        Loser()
        GreenButton.was_held = False
        Winner = False