Files
matrixmania/async/Rennbahn.py
T
2026-11-12 13:29:50 +01:00

300 lines
5.5 KiB
Python

import asyncio
import turtle
import math
# =====================================
# BILDSCHIRM
# =====================================
screen = turtle.Screen()
screen.setup(900, 650)
screen.bgcolor("black")
screen.title("Rennbahn - Reeborg & Sophia")
screen.tracer(0)
ampel_phase = "OL_UR"
# Sperre für die Kreuzung
kreuzung = asyncio.Lock()
# =====================================
# EINE ACHTERBAHN MIT ZWEI SPUREN
# =====================================
def position(t, spur):
# Grundform der Achterbahn
x = 250 * math.sin(t)
y = 145 * math.sin(2 * t)
# Senkrechter Versatz für die zwei Fahrspuren
dx = 250 * math.cos(t)
dy = 290 * math.cos(2 * t)
laenge = math.sqrt(dx**2 + dy**2)
abstand = 10 * spur * math.sin(t)**2
x += abstand * (-dy / laenge)
y += abstand * (dx / laenge)
return x, y
def zeichne_strecke():
strecke = turtle.Turtle()
strecke.hideturtle()
strecke.speed(0)
strecke.color("#777777")
strecke.pensize(3)
# Beide Spuren derselben Achterbahn
for spur in [-1, 1]:
strecke.penup()
for i in range(1001):
t = i * 2 * math.pi / 1000
x, y = position(t, spur)
if i == 0:
strecke.goto(x, y)
strecke.pendown()
else:
strecke.goto(x, y)
strecke.penup()
screen.update()
# =====================================
# AMPEL-ANZEIGE
# =====================================
anzeige = turtle.Turtle()
anzeige.hideturtle()
anzeige.penup()
anzeige.color("white")
anzeige.goto(0, 260)
def zeige_ampel():
anzeige.clear()
anzeige.write(
"AMPEL: " + ampel_phase,
align="center",
font=("Arial", 18, "bold")
)
screen.update()
# =====================================
# AMPEL
# =====================================
async def ampel():
global ampel_phase
while True:
await asyncio.sleep(5)
async with kreuzung:
if ampel_phase == "OL_UR":
ampel_phase = "OR_UL"
else:
ampel_phase = "OL_UR"
print("🚦 Ampel schaltet auf:", ampel_phase)
zeige_ampel()
# =====================================
# AUTO BEWEGEN
# =====================================
async def fahren(auto, start, ende, spur):
schritte = max(1, int(abs(ende - start) * 60))
for i in range(1, schritte + 1):
t = start + (ende - start) * i / schritte
x, y = position(t, spur)
alte_x, alte_y = auto.position()
winkel = math.degrees(
math.atan2(y - alte_y, x - alte_x)
)
auto.setheading(winkel)
auto.goto(x, y)
screen.update()
await asyncio.sleep(0.02)
# =====================================
# KREUZUNG ÜBERQUEREN
# =====================================
async def kreuzung_ueberqueren(
auto, name, spur, t, gruen
):
# Bis kurz vor die Kreuzung fahren
einstieg = t - 0.12
await fahren(auto, t - 0.5, einstieg, spur)
# Warten, bis die Ampel grün ist
while True:
if ampel_phase == gruen:
await kreuzung.acquire()
if ampel_phase == gruen:
break
kreuzung.release()
print(name, "wartet auf Grün...")
await asyncio.sleep(1)
print(name, "hat Grün und überquert die Kreuzung!")
try:
# Kreuzung in kleinen Schritten überqueren
await fahren(auto, einstieg, t + 0.12, spur)
finally:
kreuzung.release()
# =====================================
# REEBORG - BLAUES AUTO
# =====================================
async def reeborg():
auto = turtle.Turtle()
auto.shape("turtle")
auto.color("#008cff")
auto.pensize(4)
auto.speed(0)
spur = 1
# Start oben links
t = -3 * math.pi / 4
x, y = position(t, spur)
auto.penup()
auto.goto(x, y)
print("🔵 Reeborg startet!")
while True:
# Erste Kreuzung: OL -> UR
await kreuzung_ueberqueren(
auto, "🔵 Reeborg", spur, 0, "OL_UR"
)
# Rechte Kehre
await fahren(auto, 0.12, math.pi - 0.12, spur)
# Zweite Kreuzung: OR -> UL
await kreuzung_ueberqueren(
auto, "🔵 Reeborg", spur, math.pi, "OR_UL"
)
# Linke Kehre
await fahren(
auto, math.pi + 0.12,
2 * math.pi - 0.12, spur
)
# =====================================
# SOPHIA - ROTES AUTO
# =====================================
async def sophia():
auto = turtle.Turtle()
auto.shape("turtle")
auto.color("#ff3030")
auto.pensize(4)
auto.speed(0)
spur = -1
# Start unten links
t = -math.pi / 4
x, y = position(t, spur)
auto.penup()
auto.goto(x, y)
print("🔴 Sophia startet!")
while True:
# Erste Kreuzung: UL -> OR
await kreuzung_ueberqueren(
auto, "🔴 Sophia", spur, 0, "OR_UL"
)
# Rechte Kehre
await fahren(auto, 0.12, math.pi - 0.12, spur)
# Zweite Kreuzung: UR -> OL
await kreuzung_ueberqueren(
auto, "🔴 Sophia", spur, math.pi, "OL_UR"
)
# Linke Kehre
await fahren(
auto, math.pi + 0.12,
2 * math.pi - 0.12, spur
)
# =====================================
# HAUPTPROGRAMM
# =====================================
async def main():
zeichne_strecke()
zeige_ampel()
await asyncio.gather(
ampel(),
reeborg(),
sophia()
)
asyncio.run(main())