300 lines
5.5 KiB
Python
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())
|