Flipper auf dem Picopad

  # SPDX-FileCopyrightText : 2026 Detlef Gebhardt, written for CircuitPython 10.0.3
# SPDX-FileCopyrightText : Copyright (c) 2026 Detlef Gebhardt
# SPDX-Filename          : Flipper-Spiel
# SPDX-License-Identifier: https://dgebhardt.de
import time
import board
import busio
import displayio
import terminalio
import digitalio
import fourwire
import bitmaptools
from adafruit_display_text import label
from adafruit_display_shapes.circle import Circle
from adafruit_display_shapes.roundrect import RoundRect
from adafruit_st7789 import ST7789
import adafruit_imageload
import random
import math
import pwmio
import microcontroller

# Anzahl Kugeln
kugeln = 6

# speaker aktivieren
speak = pwmio.PWMOut(board.GP15, frequency=4000, variable_frequency=True)

# 2 Zoll 320x240 Waveshare Display
cs=board.GP21
dc=board.GP17
reset=board.GP20
bl=board.GP16
# Release any resources currently in use for the displays
displayio.release_displays()
spi = busio.SPI(board.GP18, board.GP19)
display_bus = fourwire.FourWire(spi, command=dc, chip_select=cs, reset=reset)
display = ST7789(display_bus, rotation=0, width=240, height=320, backlight_pin=bl, rowstart=0, colstart=0)
display.brightness = 1
main = displayio.Group()
display.root_group = main

key_A = digitalio.DigitalInOut(board.GP7)
key_A.switch_to_input(pull=digitalio.Pull.UP)
key_B = digitalio.DigitalInOut(board.GP6)
key_B.switch_to_input(pull=digitalio.Pull.UP)
keyUp = digitalio.DigitalInOut(board.GP2)
keyUp.switch_to_input(pull=digitalio.Pull.UP)
keyLeft = digitalio.DigitalInOut(board.GP4)
keyLeft.switch_to_input(pull=digitalio.Pull.UP)
keyRight = digitalio.DigitalInOut(board.GP5)
keyRight.switch_to_input(pull=digitalio.Pull.UP)
key_X = digitalio.DigitalInOut(board.GP9)
key_X.switch_to_input(pull=digitalio.Pull.UP)
key_Y = digitalio.DigitalInOut(board.GP8)
key_Y.switch_to_input(pull=digitalio.Pull.UP)

  
  

  # read score from file
datei = open("txt/score.txt", "r")
score = datei.readline()
datei.close()

# Intro for the score
intro_0,bg_intro0 = adafruit_imageload.load("images/score.bmp")
bg_intro0.make_transparent(0)
bg_tile_grid_intr = displayio.TileGrid(intro_0, pixel_shader=bg_intro0, x=0,y=0)
main.append(bg_tile_grid_intr)
# the label for the score
label_1 = label.Label(font=terminalio.FONT, text=str(score), scale=2, color=0xffffff, line_spacing=1)
label_1.anchor_point = (0, 0)
label_1.anchored_position = (120-6*len(score), 60)
main.append(label_1)
while True:
    if key_A.value == False or key_B.value == False or key_X.value == False or key_Y.value == False :
        main.remove(label_1)
        main.remove(bg_tile_grid_intr)
        break

# Load the sprite sheets for the table and the flippers(bitmap)
bitmap, palette = adafruit_imageload.load("/images/background.bmp", bitmap=displayio.Bitmap, palette=displayio.Palette)
backgr_group = displayio.TileGrid(bitmap, pixel_shader=palette)

sprite_sheet, palette = adafruit_imageload.load("/images/flipper.bmp", bitmap=displayio.Bitmap, palette=displayio.Palette)
palette.make_transparent(1)
flipperl = displayio.TileGrid(sprite_sheet, pixel_shader=palette, width=1, height=1, tile_width=32, tile_height=32, default_tile=0)
flipperl_group = displayio.Group(scale=1)
flipperl_group.append(flipperl)
flipperr = displayio.TileGrid(sprite_sheet, pixel_shader=palette, width=1, height=1, tile_width=32, tile_height=32, default_tile=0)
flipperr_group = displayio.Group(scale=1)
flipperr_group.append(flipperr)
lock = displayio.TileGrid(sprite_sheet, pixel_shader=palette, width=1, height=1, tile_width=32, tile_height=32, default_tile=0)
lock_group = displayio.Group(scale=1)
lock_group.append(lock)

ball = [200, 260, 0xffff00]
x_ball = ball[0]
y_ball = ball[1]

circle_1 = Circle(120, 60, 10, fill=0x555555)
circle_obstacle1 = Circle(120, 60, 6, fill=0xff0000)
circle_2 = Circle(65, 100, 10, fill=0x555555)
circle_obstacle2 = Circle(65, 100, 6, fill=0x00ff00)
circle_3 = Circle(175, 100, 10, fill=0x555555)
circle_obstacle3 = Circle(175, 100, 6, fill=0x00ff00)
circle_4 = Circle(120, 158, 10, fill=0x555555)
circle_obstacle4 = Circle(120, 158, 6, fill=0xff0000)
circle_5 = Circle(80, 180, 10, fill=0x555555)
circle_obstacle5 = Circle(80, 180, 6, fill=0xffff00)
circle_6 = Circle(160, 180, 10, fill=0x555555)
circle_obstacle6 = Circle(160, 180, 6, fill=0xffff00)
bonus_hole = Circle(120, 210, 10, fill=0xaf3232)
circle_ball = Circle(ball[0], ball[1], 6, fill=ball[2])

  
  

  # Draw the label for the score
updating_score = label.Label(font=terminalio.FONT, text = "",scale=2, color=0xffffff, line_spacing=1)
updating_score.anchor_point = (0, 0)
updating_score.anchored_position = (80, 25)
    
text_balls = label.Label(terminalio.FONT, text=str(kugeln), color=0xffffff)
balls_group = displayio.Group(scale=2, x=170, y=250)
balls_group.append(text_balls)

label = label.Label(terminalio.FONT, text="start with 'up'", color=0xffff00)
text_label = displayio.Group(scale=2, x=40, y=295)
text_label.append(label)
    
main.append(backgr_group)
main.append(updating_score)
main.append(circle_1)
main.append(circle_2)
main.append(circle_3)
main.append(circle_4)
main.append(circle_5)
main.append(circle_6)
main.append(circle_obstacle1)
main.append(circle_obstacle2)
main.append(circle_obstacle3)
main.append(circle_obstacle4)
main.append(circle_obstacle5)
main.append(circle_obstacle6)
main.append(bonus_hole)
main.append(lock_group)
main.append(flipperl_group)
main.append(flipperr_group)
main.append(circle_ball)
main.append(balls_group)
main.append(text_label)

  
  

  def ball_launch(launch, ball):    # Start
    x_ball = ball[0]
    y_ball = ball[1]
    lock.x = 185
    lock.y = 190
    lock[0] = 7
    for i in range (0, 9):
        y_ball -= 20
        circle_ball.y = y_ball
        time.sleep(0.02)
    lock.x = 190
    lock.y = 205
    lock[0] = 3
    launchspeed = random.randint(3, 18)
    for i in range (0, launchspeed):
        x_ball -= 10
        y_ball = int(104 - math.sqrt(9604 - (x_ball-118)*(x_ball-118)))
        circle_ball.x = x_ball
        circle_ball.y = y_ball
        time.sleep(0.02)
    launch = False
    ball[0] = x_ball
    ball[1] = y_ball
    return launch

def init():
    lock.x = 190
    lock.y = 205
    lock[0] = 3
    flipperl.x = 70
    flipperl.y = 225
    flipperl[0] = 1
    flipperr.x = 130
    flipperr.y = 225
    flipperr[0] = 4

def speaker():
    if sound:
        speak.frequency = 4000
        speak.duty_cycle = 10000
        time.sleep(0.05)
        speak.duty_cycle = 0
    else:
        display.brightness = 0.01
        time.sleep(0.05)
        display.brightness = 1

def collision(x_ball, y_ball, points):
    # circle_obstacle1
    if (x_ball-120)*(x_ball-120) + (y_ball-60)*(y_ball-60) <= 200:
        circle_1.fill = 0xff0000
        direction[0] = direction[0] * (-1)
        points += 50
        speaker()
    else:
        circle_1.fill = 0x555555
    # circle_obstacle2
    if (x_ball-65)*(x_ball-65) + (y_ball-100)*(y_ball-100) <= 200:
        circle_2.fill = 0x00ff00
        direction[0] = direction[0] * (-1)
        points += 20
        speaker()
    else:
        circle_2.fill = 0x555555
    # circle_obstacle3
    if (x_ball-175)*(x_ball-175) + (y_ball-100)*(y_ball-100) <= 200:
        circle_3.fill = 0x00ff00
        direction[0] = direction[0] * (-1)
        points += 20
        speaker()
    else:
        circle_3.fill = 0x555555
    # circle_obstacle4
    if (x_ball-120)*(x_ball-120) + (y_ball-158)*(y_ball-158) <= 200:
        circle_4.fill = 0xff0000
        direction[0] = direction[0] * (-1)
        points += 50
        speaker()
    else:
        circle_4.fill = 0x555555
    # circle_obstacle5
    if (x_ball-80)*(x_ball-80) + (y_ball-180)*(y_ball-180) <= 200:
        circle_5.fill = 0xffff00
        direction[0] = direction[0] * (-1)
        points += 10
        speaker()
    else:
        circle_5.fill = 0x555555
    # circle_obstacle6
    if (x_ball-160)*(x_ball-160) + (y_ball-180)*(y_ball-180) <= 200:
        circle_6.fill = 0xffff00
        direction[0] = direction[0] * (-1)
        points += 10
        speaker()
    else:
        circle_6.fill = 0x555555
    updating_score.text = "{:06}".format(points)
    return points

def game_over(key_A, points, score):
    debounce = False
    label.text = "GAME OVER  (A)"   
    i = 0
    if points > int(score):
        score = points
        with open("txt/score.txt", "w") as f:
            f.write(str(score) + "\n")
        f.close()
    while True:
        for f in (4186, 3951, 3729, 3951, 4186):
            i = (i + 100) % 256
            if sound:
                speak.frequency = f
                speak.duty_cycle = 10000
                time.sleep(0.3)
                speak.duty_cycle = 0
                time.sleep(0.03)
            if key_A.value == False and not debounce:
                microcontroller.reset()
        speak.duty_cycle = 0  # speaker off
        time.sleep(0.5)

debounce = False
launch = True
rolldown = False
hitback = False
direction = [0] 
points = 0
hit = time.monotonic()
roll = time.monotonic()
flip = time.monotonic()
ballspeed = 0
init()
circle_ball.x = x_ball
circle_ball.y = y_ball
last_tone = time.monotonic() - 4
sound = True

  
  

  while True:
    # Effekt vor Spielbeginn
    if kugeln == 6 and (time.monotonic() - last_tone) >= 4 and not sound:
        last_tone = time.monotonic()
        for i in range (5):
            display.brightness = 1
            time.sleep(0.05)
            display.brightness = 0.05
            time.sleep(0.05)
        display.brightness = 1
    # Ton vor Spielbeginn
    if kugeln == 6 and (time.monotonic() - last_tone) >= 4 and sound:
        last_tone = time.monotonic()
        tone = 0.25
        for f in (3300, 3490, 3920, 4400, 4940):
            i = random.randint(1,256)
            speak.frequency = f
            speak.duty_cycle = 10000
            time.sleep(tone)
            tone -= 0.04
            speak.duty_cycle = 0
            time.sleep(0.03)
        speak.duty_cycle = 0
        
    # Sound ausschalten
    if key_X.value == False:
        sound = False
    # Sound einschalten
    if key_Y.value == False:
        sound = True

    # rechten Flipper bewegen
    if keyRight.value == False and not debounce:
        debounce = True
        hit = time.monotonic()
        flipperr[0] = 6
        if y_ball >= 222 and y_ball <= 233 and x_ball >= 125 and x_ball <= 145:
            rolldown = False
            hitback = True
            ballspeed = -2
            i = random.randint(-1,1)
            if i == 1:
                direction[0] = 1
            else:
                direction[0] = -1
            hit = time.monotonic()
                
    # linken Flipper bewegen    
    if keyLeft.value == False and not debounce:
        debounce = True
        hit = time.monotonic()
        flipperl[0] = 3
        if y_ball >= 228 and y_ball <= 240 and x_ball >= 85 and x_ball <= 105:
            rolldown = False
            hitback = True
            ballspeed = -2
            i = random.randint(-1,1)
            if i == -1:
                direction[0] = -1
            else:
                direction[0] = 1
            hit = time.monotonic()
    
    # 'UP' druecken zum Abschuss
    if keyUp.value == False and kugeln > 0 and launch == True:
        label.text = ""
        debounce = True
        rolldown = True
        # Anzahl Restkugeln verringern
        kugeln -= 1
        text_balls.text = str(kugeln)
        updating_score.text = "{:06}".format(points)
        hit = time.monotonic()
        launch = ball_launch(launch, ball)
        x_ball = ball[0]
        y_ball = ball[1]
        rolldown = True                  
    #
    # bonus_hole
    #
    if (x_ball-120)*(x_ball-120) + (y_ball-210)*(y_ball-210) <= 200 and hitback ==False:
        bonus_hole.fill = 0xffffff
        circle_ball.fill = None
        label.text = "Bonus Ball"
        time.sleep(1)
        bonus_hole.fill = 0xaf3232
        label.text = ""
        x_ball = 120
        y_ball = 270
        circle_ball.x = 200
        circle_ball.y = 260
        ball[0] = 205
        ball[1] = 270
        circle_ball.fill = 0xffff00
        kugeln += 1
        text_balls.text = str(kugeln)
        launch = True
        rolldown = False
        ballspeed = 0      
    #
    # Ball rollt nach unten
    #
    if rolldown == True and (time.monotonic() - roll) > (0.1 + ballspeed):
        roll = time.monotonic()
        y_ball += 5
        ballspeed -= 0.002
        circle_ball.y = y_ball
        points = collision(x_ball, y_ball, points)
        if x_ball >= 20 and x_ball <= 100:
            y1 = 0.575 * x_ball + 180
            if y_ball >= y1:
                x_ball += 5
                y_ball = int(0.575 * x_ball + 180)
                circle_ball.x = x_ball
                circle_ball.y = y_ball
                
        if x_ball >= 130 and x_ball <= 216:
            y2 = -0.535 * x_ball + 300
            if y_ball >= y2:
                x_ball -= 5
                y_ball = int(-0.535 * x_ball + 300)
                circle_ball.x = x_ball
                circle_ball.y = y_ball  
        # Kugel rollt unten durch
        if y_ball >= 270:
            circle_ball.y = 340
            if sound:
                for f in range(4000, 2900, -30):
                    speak.frequency = f
                    speak.duty_cycle = 5000
                    time.sleep(0.01)
                time.sleep(0.2)
                speak.duty_cycle = 0
            # kurze Pause vor nächstem Schuss
            time.sleep(0.7) 
            # Game over
            if kugeln == 0:
                game_over(key_A, points, score)
            circle_ball.x = 200
            circle_ball.y = 260
            ball[0] = 205
            ball[1] = 270
            launch = True
            rolldown = False
            ballspeed = 0
    #    
    # Ball wird vom Flipper zurueckgeschossen
    #
    if hitback == True and (time.monotonic() - flip) > (ballspeed):
        flip = time.monotonic()
        ballspeed += 0.02
        x_ball -= 5 * direction[0]
        y_ball -= 4
        if x_ball >= 190 and y_ball > 104:
            direction[0] = 1
        if x_ball <= 40 and y_ball > 104:
            direction[0] = -1
        if y_ball <= int(104 - math.sqrt(9604 - (x_ball-112)*(x_ball-112))):
            hitback = False
            rolldown = True
            roll = time.monotonic()
            ballspeed = 0
        points = collision(x_ball, y_ball, points)
        circle_ball.x = x_ball
        circle_ball.y = y_ball
    # Flipper zurücksetzen        
    if time.monotonic() - hit > 0.1:
        debounce = False
        flipperl[0] = 1
        flipperr[0] = 4