Altstand nach old_version/ eingefroren (untracked). Monolith ersetzt durch main.py + Paket loader_game/. Neu: run.sh/run.command mit venv+requirements, .gitignore, docs/ANALYSE.md, 35 Tests. Secrets entfernt. Gelöscht: loader_game.py, qr_scan*.py, INSTALL_README.txt.
This commit is contained in:
Project Bridge committed
1 parent
6a2c891c3e
commit
de550e1d4d
24 files changed
+2269
-1008
No files matched your search
+16
@@ -0,0 +1,16 @@
|
|||||||
|
# Eingefrorener Altstand (bewusst NICHT versioniert)
|
||||||
|
old_version/
|
||||||
|
|
||||||
|
# Virtuelle Umgebung und Python-Artefakte
|
||||||
|
.venv/
|
||||||
|
__pycache__/
|
||||||
|
*.py[cod]
|
||||||
|
|
||||||
|
# Laufzeitdaten (Spielername, lokale Ergebnisse, Logs)
|
||||||
|
runtime/
|
||||||
|
*.log
|
||||||
|
|
||||||
|
# Editor- und OS-Kram
|
||||||
|
.idea/
|
||||||
|
.vscode/
|
||||||
|
.DS_Store
|
||||||
@@ -1,3 +0,0 @@
|
|||||||
python.exe -m pip install --upgrade pip
|
|
||||||
|
|
||||||
pip install pillow pyzbar opencv-python numpy pygame pygetwindow requests pyautogui
|
|
||||||
@@ -1,2 +1,131 @@
|
|||||||
# Habegger_loader_game
|
# Habegger Trailer Load
|
||||||
|
|
||||||
|
Kofferlager-Spiel für Messe-/Eventbetrieb: Koffer laufen von rechts ein und
|
||||||
|
müssen im Auflieger möglichst dicht gestapelt werden. Ziel ist eine hohe
|
||||||
|
Beladung in Prozent.
|
||||||
|
|
||||||
|
Neu aufgesetzt für macOS (Apple Silicon) mit Controller-Unterstützung.
|
||||||
|
Die Analyse des Altstands und die Liste der behobenen Fehler stehen in
|
||||||
|
[`docs/ANALYSE.md`](docs/ANALYSE.md).
|
||||||
|
|
||||||
|
## Voraussetzungen
|
||||||
|
|
||||||
|
* Python 3.10 oder neuer (getestet: 3.12)
|
||||||
|
* macOS oder Linux – sonst nichts. `pygame` bringt SDL2 selbst mit,
|
||||||
|
Kamera-, Brew- oder Systembibliotheken werden **nicht** gebraucht.
|
||||||
|
|
||||||
|
## Start
|
||||||
|
|
||||||
|
```bash
|
||||||
|
./run.sh # Fenster
|
||||||
|
./run.sh --fullscreen # Vollbild (Eventbetrieb)
|
||||||
|
```
|
||||||
|
|
||||||
|
`run.sh` legt beim ersten Start `.venv/` an und installiert `requirements.txt`
|
||||||
|
automatisch. Ändert sich `requirements.txt`, wird neu installiert.
|
||||||
|
|
||||||
|
Auf macOS lässt sich das Spiel auch per Doppelklick auf **`run.command`**
|
||||||
|
starten (beim ersten Mal ggf. Rechtsklick → Öffnen wegen Gatekeeper).
|
||||||
|
|
||||||
|
Optionen:
|
||||||
|
|
||||||
|
| Option | Bedeutung |
|
||||||
|
| --- | --- |
|
||||||
|
| `--fullscreen` | Vollbild starten (F11 schaltet jederzeit um) |
|
||||||
|
| `--name "Anna"` | Spielername setzen (sonst der zuletzt gespeicherte) |
|
||||||
|
| `--seed 42` | feste Zufallsfolge, reproduzierbare Koffer-Sequenzen |
|
||||||
|
| `--smoke 10` | Selbsttest: bestätigt das Intro automatisch, spielt 10 s ohne Eingaben und beendet sich |
|
||||||
|
|
||||||
|
## Steuerung
|
||||||
|
|
||||||
|
| Aktion | Tastatur | Controller (Xbox-Layout) |
|
||||||
|
| --- | --- | --- |
|
||||||
|
| Einrasten an der Barriere | `Space` / `Enter` | A |
|
||||||
|
| Koffer drehen (wenn er passt) | `←` | X / D-Pad links |
|
||||||
|
| Auf einen Koffer obendrauf setzen | `↑` | Y / D-Pad hoch |
|
||||||
|
| Spiel beenden | `Esc` | B |
|
||||||
|
| Vollbild umschalten | `F11` | – |
|
||||||
|
|
||||||
|
Stick und D-Pad werden beide ausgewertet, Controller-Hotplug funktioniert
|
||||||
|
(der Name des erkannten Controllers steht beim Start im Terminal).
|
||||||
|
|
||||||
|
## Projektstruktur
|
||||||
|
|
||||||
|
```
|
||||||
|
main.py Einstiegspunkt (Fenster, Hauptschleife, CLI)
|
||||||
|
run.sh / run.command Start inkl. venv + Installation
|
||||||
|
requirements.txt pygame
|
||||||
|
case_sequences.txt Koffersequenzen (Datenbestand)
|
||||||
|
loader_game/
|
||||||
|
config.py Masse, Tempi, Farben, Texte, Pfade
|
||||||
|
assets.py Bilder/Sounds/Fonts laden und cachen
|
||||||
|
sequences.py Einlesen und Validieren der Sequenzdatei
|
||||||
|
case.py Koffer: Geometrie und Einlaufbewegung
|
||||||
|
trailer.py Stapelregeln im Auflieger (reine Logik)
|
||||||
|
input_map.py Tastatur/Controller → Action
|
||||||
|
scene.py Zeichnen
|
||||||
|
intro.py Tutorialbild, Ampel, Reissverschluss
|
||||||
|
game.py Zustandsmaschine des Spiels
|
||||||
|
storage.py Laufzeitdaten (letzter Spielername)
|
||||||
|
net.py optionaler Punkte-Upload
|
||||||
|
tests/test_logic.py 35 Tests (ohne Fenster)
|
||||||
|
docs/ANALYSE.md Analyse Altstand + Fehlerliste
|
||||||
|
old_version/ eingefrorener Altstand (nicht versioniert)
|
||||||
|
runtime/ Laufzeitdaten (nicht versioniert)
|
||||||
|
```
|
||||||
|
|
||||||
|
## Konfiguration
|
||||||
|
|
||||||
|
Alle Werte stehen in `loader_game/config.py` – Auflösung, Bänder, Auflieger,
|
||||||
|
Tempo, Farben, Texte. Gezeichnet wird immer in der virtuellen Auflösung
|
||||||
|
1920×1080; `pygame.SCALED` skaliert automatisch auf die tatsächliche
|
||||||
|
Fenstergrösse (Retina, 1440×900, 4K …).
|
||||||
|
|
||||||
|
Punkte-Upload (standardmässig aus):
|
||||||
|
|
||||||
|
```bash
|
||||||
|
export HAG_SCORE_URL="https://…/api/submit_points.php"
|
||||||
|
export HAG_SCORE_API_KEY="…"
|
||||||
|
```
|
||||||
|
|
||||||
|
Zugangsdaten gehören in die Umgebung, **nicht** in den Quellcode.
|
||||||
|
|
||||||
|
## Sequenzdatei
|
||||||
|
|
||||||
|
`case_sequences.txt`: Sequenzen durch Leerzeilen getrennt, pro Zeile ein
|
||||||
|
Koffer als `breite,höhe,rotiert` in Einheiten von 100×100 Pixeln.
|
||||||
|
`rotiert=True` dreht den Koffer beim Einlaufen um 90°.
|
||||||
|
|
||||||
|
```
|
||||||
|
3,1,False
|
||||||
|
1,2,True # effektiv 2 Einheiten breit, 1 hoch
|
||||||
|
```
|
||||||
|
|
||||||
|
Ungültige Zeilen werden beim Start mit Meldung übersprungen.
|
||||||
|
|
||||||
|
## Tests
|
||||||
|
|
||||||
|
```bash
|
||||||
|
.venv/bin/python -m unittest discover -s tests -v
|
||||||
|
```
|
||||||
|
|
||||||
|
Getestet werden Sequenz-Parsing, Layout-Invarianten, Kofferbewegung,
|
||||||
|
Stapelregeln, komplette Spieldurchläufe (bis Spielende) und die
|
||||||
|
Laufzeitdaten. Kein Fenster, kein Ton nötig.
|
||||||
|
|
||||||
|
## Laufzeitdaten
|
||||||
|
|
||||||
|
`runtime/` (in `.gitignore`): zuletzt verwendeter Spielername. Per
|
||||||
|
`HAG_RUNTIME_DIR` umlenkbar (nutzen die Tests).
|
||||||
|
|
||||||
|
## Eingefrorener Altstand
|
||||||
|
|
||||||
|
`old_version/` enthält die Dateien vor dem Umbau – ebenfalls in `.gitignore`,
|
||||||
|
also **nicht** versioniert. Details: `old_version/FROZEN.md`.
|
||||||
|
|
||||||
|
## Nächste Schritte
|
||||||
|
|
||||||
|
1. Namenseingabe direkt am Controller (Buchstabe für Buchstabe, alternativ
|
||||||
|
Tastatur) – ersetzt QR-Scanner und `last_user.txt`.
|
||||||
|
2. Mehrere Durchgänge ohne Neustart des Programms (zurück zur Namenseingabe).
|
||||||
|
3. Entscheiden, ob und wohin die Punkte gesendet werden.
|
||||||
@@ -0,0 +1,84 @@
|
|||||||
|
# Analyse Altstand (01.11.2026)
|
||||||
|
|
||||||
|
Grundlage: `old_version/loader_game.py` (656 Zeilen), `old_version/qr_scan.py`
|
||||||
|
(188 Zeilen), `old_version/qr_scan_old.py` (160 Zeilen),
|
||||||
|
`old_version/case_sequences.txt` (6 Sequenzen).
|
||||||
|
|
||||||
|
## 1. Wie der Altstand funktioniert hat
|
||||||
|
|
||||||
|
```
|
||||||
|
qr_scan.py ──► last_user.txt ──► subprocess: python loader_game.py
|
||||||
|
│ │
|
||||||
|
└ Kamera + pyzbar + HTTP-API └ pygame-Spiel, ein Durchgang, dann sys.exit()
|
||||||
|
```
|
||||||
|
|
||||||
|
* **`qr_scan.py`**: öffnet die Webcam, liest QR-Codes, fragt eine externe API
|
||||||
|
(`hag.putschgi.ch/.../qr.php?action=verify_hash`) nach Gültigkeit und Name,
|
||||||
|
schreibt `mail`/`name` in `last_user.txt` und startet das Spiel als
|
||||||
|
Unterprozess. Danach wieder Scanner – so kam der nächste Spieler dran.
|
||||||
|
* **`loader_game.py`**: ein Durchgang. Ein Koffer läuft von rechts ein; der
|
||||||
|
Spieler kann ihn an die Barriere snappen (Space/A), drehen (←/X) oder auf
|
||||||
|
einen anderen Koffer stapeln (↑/Y). Kollidiert er ungebremst, wird er mit
|
||||||
|
einer Lücke eingereiht. Ist die Barriere hinter dem Heck, ist Schluss.
|
||||||
|
Punktzahl = belegte Fläche im Auflieger, wird per `curl` an
|
||||||
|
`submit_points.php` geschickt.
|
||||||
|
* **`case_sequences.txt`**: 6 Koffersequenzen, Zeilen `breite,höhe,rotiert`,
|
||||||
|
Sequenzen durch Leerzeilen getrennt. Das Spiel zieht sich zufällig eine.
|
||||||
|
|
||||||
|
## 2. Gefundene Fehler und Risiken
|
||||||
|
|
||||||
|
| # | Fund | Wirkung | Status im Neustand |
|
||||||
|
| --- | --- | --- | --- |
|
||||||
|
| 1 | **Secrets im Quellcode**: `API_SECRET = "ddlK…"` in `qr_scan.py`, `api_key=hag-trailer-8051` in `loader_game.py` | Zugangsdaten liegen in der Git-Historie | entfernt; Endpunkt + Schlüssel nur noch per `HAG_SCORE_URL` / `HAG_SCORE_API_KEY` aus der Umgebung → **alte Schlüssel rotieren** |
|
||||||
|
| 2 | `pygame.event.set_grab(True)` | Maus/Tastatur werden gefangen; auf macOS unangenehm, Esc kommt nicht mehr durch | entfernt |
|
||||||
|
| 3 | Feste 1920×1080-Vollbildannahme | MacBook (Retina/1440×900) → Fenster grösser als der Bildschirm | virtuelle Auflösung + `pygame.SCALED`, Fenster/`--fullscreen`, F11 |
|
||||||
|
| 4 | Windows-Annahmen: `subprocess.run(["python", …])`, `pygetwindow`/`pyautogui`, `python.exe` in der Install-Doku | läuft so nicht auf macOS | kein Subprozess mehr, Scanner gestrichen |
|
||||||
|
| 5 | **Doppelte Drehlogik**: `Case.rotated` **und** getauschte Masse; `draw()` skaliert bei `rotated` auf `(height, width)` und dreht zusätzlich um 90° | verzerrte/falsch gedrehte Koffer, schwer nachvollziehbar | nur noch `units_w`/`units_h`; Grafik wird einmalig passend erzeugt |
|
||||||
|
| 6 | Zufällige Zusatzdrehung in `Case.__init__` (`random.choice([True, False])`) | die „Next"-Vorschau zeigt etwas anderes als der Koffer, der wirklich kommt | Zufallsdrehung entfernt, Vorschau stimmt jetzt |
|
||||||
|
| 7 | `can_place_on_top()` und `animate_place_on_top()` prüfen **unterschiedliche** Regeln (Barriere-Ausrichtung fehlt in der Animation) | „OnTop möglich!" wird angekündigt, dann landet der Koffer woanders oder gar nicht | eine einzige Regel: `Trailer.find_platform()` |
|
||||||
|
| 8 | Zwei verschiedene Fehlschlag-Pfade (`fail_snap` einmal mit `sound_place`, einmal mit `sound_fail`) | inkonsistentes Feedback, verwirrende Punktevergabe | ein Pfad (`_stack_with_gap`), definierter Sound + Shake |
|
||||||
|
| 9 | Blockierende Animationsschleifen (`for` + `pygame.time.delay` mitten im Event-Loop) | Events stauen sich, keine `dt`-Basis, Ruckler; 120-fps-Ziel war so nicht erreichbar | Animationen laufen über `elapsed/duration` im Update, 60 fps |
|
||||||
|
| 10 | `Case.move()` startet den Roll-Sound und kehrt zurück; Sound hängt an `Channel(1)` | erster Frame ohne Bewegung; Kanal-Kollisionen mit anderen Sounds | Roll-Sound beim Spawn, Stopp beim Platzieren, eigener Kanal |
|
||||||
|
| 11 | Blankes `except:` an 6 Stellen (Bilder, Sequenzen, Punkte-Upload) | Fehler bleiben unsichtbar, z. B. Tippfehler in `case_sequences.txt` fallen still auf die Notfall-Sequenz zurück | gezielte Exceptions + Warnungen beim Start |
|
||||||
|
| 12 | `last_user.txt` wird mit `utf-8-sig` geschrieben und mit `utf-8` gelesen | BOM landet im Spielernamen; Datei liegt im Programmordner | `runtime/last_player.json`, Ordner ist in `.gitignore` |
|
||||||
|
| 13 | `calculate_load_percent()` summiert die Fläche **aller** Koffer, auch der aufgesetzten | Beladung ist „gefühlt" zu hoch; `min(100, …)` verdeckt das nur | bewusst beibehalten (Spielbalance), aber dokumentiert und getestet |
|
||||||
|
| 14 | Toter/doppelter Code: `global current_case` zweimal in `draw_game`, `can_use_on_top` in `spawn_case`, `transition_counter`, `state`/`PLAYING`, `entry_angle` (immer 0), `frame_color`, `game_started` | unnötige Verwirrung | entfernt |
|
||||||
|
| 15 | Kein Neustart möglich: Spiel endet mit `sys.exit()` | jeder Spieler braucht einen neuen Prozess (Aufgabe des Scanners) | Spiel ist eine Klasse; Aufrufer entscheidet (Neustart/Beenden) |
|
||||||
|
| 16 | `cap = cv2.VideoCapture(0)` in der Endlosschleife, `cv2.namedWindow()` pro Frame | Kamerahandle-Leak, Flackern | mit dem QR-Scanner entfallen (pyzbar/opencv nicht mehr nötig) |
|
||||||
|
| 17 | Keine `requirements.txt`, kein venv, Installation nur als Windows-Befehlskette | auf dem Mac nicht reproduzierbar | `requirements.txt` + `run.sh` (venv + Auto-Install) |
|
||||||
|
| 18 | Spieler kam nur über die API, ohne Server kein Spielstart | Abhängigkeit von einem fremden Server | Name kommt künftig vom Controller (Schritt 2) |
|
||||||
|
|
||||||
|
## 3. Was der Neustand anders macht
|
||||||
|
|
||||||
|
* **Struktur statt Monolith**: `main.py` + Paket `loader_game/` mit je einem
|
||||||
|
Modul pro Aufgabe (siehe `loader_game/__init__.py`).
|
||||||
|
* **Logik ohne pygame**: `case.py`, `trailer.py`, `sequences.py` lassen sich
|
||||||
|
ohne Fenster testen (35 Tests).
|
||||||
|
* **Zeitbasiert**: alles rechnet in Sekunden (`dt`), nicht in Frames.
|
||||||
|
* **Eine Wahrheit für Regeln**: Stapelregeln leben ausschliesslich in
|
||||||
|
`Trailer`, Zeichnen ausschliesslich in `scene.py`.
|
||||||
|
* **Konfiguration an einer Stelle**: `config.py` (Masse, Tempi, Farben, Texte).
|
||||||
|
* **Eingabe abstrahiert**: `input_map.py` bildet Tastatur **und** Controller auf
|
||||||
|
`Action.PRIMARY/LEFT/RIGHT/UP/DOWN/BACK` ab – die Basis für die
|
||||||
|
Controller-Namenseingabe.
|
||||||
|
* **Nur noch eine Abhängigkeit**: `pygame` (kein numpy, kein opencv, kein
|
||||||
|
pyzbar, kein requests, kein pyautogui).
|
||||||
|
|
||||||
|
## 4. Bewusst *nicht* geändert
|
||||||
|
|
||||||
|
* Spielmechanik und Balance (Tempo 720/240 px/s entspricht den alten 6/2 px pro
|
||||||
|
Frame bei 120 fps; Snap-Schwelle, Lücken-Logik, Beladungsformel).
|
||||||
|
* `case_sequences.txt` (Datenbestand bleibt unverändert).
|
||||||
|
* Grafiken, Sounds, Fonts.
|
||||||
|
* Der Punkte-Upload existiert weiter, ist aber ohne konfigurierten Endpunkt
|
||||||
|
stumm geschaltet.
|
||||||
|
|
||||||
|
## 5. Offene Punkte (nächste Schritte)
|
||||||
|
|
||||||
|
1. **Controller-Namenseingabe**: Buchstabe für Buchstabe per D-Pad/Stick,
|
||||||
|
alternative Eingabe über die Tastatur. Ersetzt `last_user.txt`/QR-Scanner.
|
||||||
|
2. **Mehrere Durchgänge ohne Prozess-Neustart** (Rückkehr zur Namenseingabe
|
||||||
|
statt Beenden).
|
||||||
|
3. Entscheiden, ob der Punkte-Upload wieder aktiv genutzt wird – und wohin.
|
||||||
|
4. `images/*.png` haben ein defektes sRGB-Profil (libpng-Warnung beim Laden,
|
||||||
|
rein kosmetisch).
|
||||||
-656
@@ -1,656 +0,0 @@
|
|||||||
import pygame
|
|
||||||
import random
|
|
||||||
import sys
|
|
||||||
import os
|
|
||||||
import subprocess
|
|
||||||
import numpy as np
|
|
||||||
import time
|
|
||||||
|
|
||||||
|
|
||||||
SCREEN_WIDTH = 1920
|
|
||||||
SCREEN_HEIGHT = 1080
|
|
||||||
FPS = 120
|
|
||||||
|
|
||||||
TOP_BAR_HEIGHT = SCREEN_HEIGHT // 8
|
|
||||||
GAME_AREA_HEIGHT = SCREEN_HEIGHT // 1.6
|
|
||||||
BOTTOM_BAR_HEIGHT = SCREEN_HEIGHT // 4
|
|
||||||
|
|
||||||
TRAILER_WIDTH = int(SCREEN_WIDTH * 0.885416666667)
|
|
||||||
TRAILER_HEIGHT = int(SCREEN_HEIGHT * 0.2778)
|
|
||||||
TRAILER_X = (SCREEN_WIDTH - TRAILER_WIDTH) // 4
|
|
||||||
TRAILER_Y = TOP_BAR_HEIGHT + 200
|
|
||||||
|
|
||||||
CASE_SPEED_SLOW = 2
|
|
||||||
CASE_SPEED_FAST = 6
|
|
||||||
CASE_COLORS = [(200, 0, 0), (0, 200, 0), (0, 0, 200)]
|
|
||||||
SNAP_THRESHOLD = 60
|
|
||||||
FAST_TO_SLOW_DISTANCE = 120
|
|
||||||
|
|
||||||
UNIT_LENGTH = TRAILER_HEIGHT // 3
|
|
||||||
UNIT_HEIGHT = TRAILER_HEIGHT // 3
|
|
||||||
|
|
||||||
pygame.init()
|
|
||||||
pygame.joystick.init()
|
|
||||||
if pygame.joystick.get_count() > 0:
|
|
||||||
joystick = pygame.joystick.Joystick(0)
|
|
||||||
joystick.init()
|
|
||||||
print(f"Controller erkannt: {joystick.get_name()}")
|
|
||||||
else:
|
|
||||||
print("Kein Controller gefunden.")
|
|
||||||
pygame.mixer.init()
|
|
||||||
sound_fail = pygame.mixer.Sound("fail.ogg")
|
|
||||||
sound_fail.set_volume(0.6)
|
|
||||||
sound_place = pygame.mixer.Sound("place.ogg")
|
|
||||||
sound_place.set_volume(0.6)
|
|
||||||
sound_roll = pygame.mixer.Sound("roll.ogg")
|
|
||||||
sound_roll.set_volume(0.3)
|
|
||||||
current_case_visible = True
|
|
||||||
|
|
||||||
# Animationssteuerung
|
|
||||||
transition_fps = 60
|
|
||||||
transition_counter = 0
|
|
||||||
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
def generate_beep(frequency=440, duration_ms=500, volume=0.5):
|
|
||||||
sample_rate = 44100
|
|
||||||
n_samples = int(sample_rate * (duration_ms / 1000.0))
|
|
||||||
t = np.linspace(0, duration_ms / 1000.0, n_samples, False)
|
|
||||||
wave = np.sin(2 * np.pi * frequency * t) * volume
|
|
||||||
audio = (wave * 32767).astype(np.int16)
|
|
||||||
return pygame.sndarray.make_sound(np.column_stack([audio, audio]))
|
|
||||||
|
|
||||||
|
|
||||||
sound_tut1 = generate_beep(440, 600)
|
|
||||||
sound_tut2 = generate_beep(440, 400)
|
|
||||||
sound_tuuut = generate_beep(600, 1000)
|
|
||||||
pygame.display.set_caption("Habegger Loader Game")
|
|
||||||
pygame.event.set_grab(True)
|
|
||||||
clock = pygame.time.Clock()
|
|
||||||
|
|
||||||
font = pygame.font.SysFont(None, 48)
|
|
||||||
|
|
||||||
PLAYING = 1
|
|
||||||
state = PLAYING
|
|
||||||
shake_timer = 0
|
|
||||||
|
|
||||||
stacked_cases = []
|
|
||||||
case_sequence = []
|
|
||||||
case_index = 0
|
|
||||||
current_case = None
|
|
||||||
collision_x = TRAILER_X
|
|
||||||
|
|
||||||
def load_instruction_image():
|
|
||||||
try:
|
|
||||||
image = pygame.image.load("images/tutorial.png")
|
|
||||||
return pygame.transform.scale(image, (SCREEN_WIDTH, SCREEN_HEIGHT))
|
|
||||||
except:
|
|
||||||
return None
|
|
||||||
|
|
||||||
instruction_image = load_instruction_image()
|
|
||||||
|
|
||||||
def show_instruction_screen():
|
|
||||||
if not instruction_image:
|
|
||||||
return
|
|
||||||
waiting = True
|
|
||||||
while waiting:
|
|
||||||
screen.blit(instruction_image, (0, 0))
|
|
||||||
pygame.display.flip()
|
|
||||||
for event in pygame.event.get():
|
|
||||||
if event.type == pygame.QUIT:
|
|
||||||
pygame.quit()
|
|
||||||
sys.exit()
|
|
||||||
elif (event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE) or \
|
|
||||||
(event.type == pygame.JOYBUTTONDOWN and event.button == 0):
|
|
||||||
waiting = False
|
|
||||||
|
|
||||||
|
|
||||||
def generate_fill_sequence():
|
|
||||||
global case_sequence
|
|
||||||
try:
|
|
||||||
with open("case_sequences.txt", "r") as f:
|
|
||||||
sets = f.read().strip().split("\n\n")
|
|
||||||
chosen = random.choice(sets).strip().split("\n")
|
|
||||||
sequence = []
|
|
||||||
for line in chosen:
|
|
||||||
parts = line.strip().split(",")
|
|
||||||
if len(parts) == 3:
|
|
||||||
w, h, rot = int(parts[0]), int(parts[1]), parts[2].strip().lower() == 'true'
|
|
||||||
sequence.append({'w': w, 'h': h, 'rotated': rot})
|
|
||||||
case_sequence = sequence
|
|
||||||
except:
|
|
||||||
case_sequence = [{'w': 2, 'h': 1, 'rotated': False}, {'w': 1, 'h': 2, 'rotated': False}]
|
|
||||||
|
|
||||||
|
|
||||||
def load_background():
|
|
||||||
try:
|
|
||||||
image = pygame.image.load("images/background.png")
|
|
||||||
return pygame.transform.scale(image, (SCREEN_WIDTH, GAME_AREA_HEIGHT))
|
|
||||||
except:
|
|
||||||
return None
|
|
||||||
|
|
||||||
|
|
||||||
background_image = load_background()
|
|
||||||
|
|
||||||
case_images = {}
|
|
||||||
|
|
||||||
|
|
||||||
def load_case_images():
|
|
||||||
for w in range(1, 5):
|
|
||||||
for h in range(1, 4):
|
|
||||||
key = f"case_w{w}_h{h}"
|
|
||||||
path = f"images/{key}.png"
|
|
||||||
if os.path.exists(path):
|
|
||||||
case_images[key] = pygame.image.load(path).convert_alpha()
|
|
||||||
|
|
||||||
|
|
||||||
load_case_images()
|
|
||||||
|
|
||||||
|
|
||||||
class Case:
|
|
||||||
def animate_snap(self):
|
|
||||||
pygame.mixer.Channel(1).stop()
|
|
||||||
global collision_x
|
|
||||||
# Snap-Animation: langsam einrasten an die Rückwand
|
|
||||||
target_x = collision_x
|
|
||||||
steps = 10
|
|
||||||
delta = (self.x - target_x) / steps
|
|
||||||
for _ in range(steps):
|
|
||||||
self.x -= delta
|
|
||||||
draw_game()
|
|
||||||
pygame.display.flip()
|
|
||||||
pygame.time.delay(int(1000 / transition_fps))
|
|
||||||
self.x = target_x
|
|
||||||
self.placed = True
|
|
||||||
self.snapped = True
|
|
||||||
collision_x = self.x + self.width
|
|
||||||
|
|
||||||
def mark_occupied(self):
|
|
||||||
for base in reversed(stacked_cases):
|
|
||||||
height_ok = base.y - self.height >= TRAILER_Y
|
|
||||||
width_ok = self.width <= base.width
|
|
||||||
space_free = all(not (
|
|
||||||
other.y + other.height == base.y and
|
|
||||||
other.x < base.x + base.width and
|
|
||||||
other.x + other.width > base.x
|
|
||||||
) for other in stacked_cases) and not getattr(base, 'occupied', False)
|
|
||||||
if height_ok and width_ok and space_free:
|
|
||||||
base.occupied = True
|
|
||||||
break
|
|
||||||
|
|
||||||
def can_place_on_top(self):
|
|
||||||
if self.placed:
|
|
||||||
return False
|
|
||||||
for base in reversed(stacked_cases):
|
|
||||||
if base.y <= TRAILER_Y:
|
|
||||||
continue
|
|
||||||
height_ok = base.y - self.height >= TRAILER_Y
|
|
||||||
width_ok = self.width <= base.width
|
|
||||||
aligned_with_barrier = abs(base.x + base.width - collision_x) < 5
|
|
||||||
space_free = all(not (
|
|
||||||
other.y + other.height == base.y and
|
|
||||||
other.x < base.x + base.width and
|
|
||||||
other.x + other.width > base.x
|
|
||||||
) for other in stacked_cases)
|
|
||||||
if height_ok and width_ok and aligned_with_barrier and space_free:
|
|
||||||
return True
|
|
||||||
return False
|
|
||||||
|
|
||||||
def __init__(self, size=None):
|
|
||||||
self.rotated = False
|
|
||||||
global case_index
|
|
||||||
if not case_sequence:
|
|
||||||
generate_fill_sequence()
|
|
||||||
if size is None:
|
|
||||||
size = case_sequence[case_index % len(case_sequence)]
|
|
||||||
case_index += 1
|
|
||||||
self.length_units, self.height_units = size['w'], size['h']
|
|
||||||
if size['rotated']:
|
|
||||||
self.length_units, self.height_units = self.height_units, self.length_units
|
|
||||||
elif self.height_units * UNIT_LENGTH <= TRAILER_WIDTH and self.length_units * UNIT_HEIGHT <= TRAILER_HEIGHT and random.choice(
|
|
||||||
[True, False]):
|
|
||||||
self.length_units, self.height_units = self.height_units, self.length_units
|
|
||||||
self.width = self.length_units * UNIT_LENGTH
|
|
||||||
self.height = self.height_units * UNIT_HEIGHT
|
|
||||||
self.x = SCREEN_WIDTH
|
|
||||||
self.spawn_y = TRAILER_Y + TRAILER_HEIGHT - self.height
|
|
||||||
self.y = self.spawn_y
|
|
||||||
self.entry_angle = 0
|
|
||||||
|
|
||||||
self.color = random.choice(CASE_COLORS)
|
|
||||||
self.placed = False
|
|
||||||
self.allow_snap = False
|
|
||||||
self.snapped = False
|
|
||||||
self.occupied = False
|
|
||||||
|
|
||||||
def move(self):
|
|
||||||
if not self.placed and not pygame.mixer.Channel(1).get_busy():
|
|
||||||
pygame.mixer.Channel(1).play(sound_roll, loops=-1)
|
|
||||||
return
|
|
||||||
|
|
||||||
distance_to_obstacle = self.x - collision_x
|
|
||||||
speed = CASE_SPEED_FAST if distance_to_obstacle > FAST_TO_SLOW_DISTANCE else CASE_SPEED_SLOW
|
|
||||||
self.x -= speed
|
|
||||||
if self.x <= collision_x + SNAP_THRESHOLD:
|
|
||||||
self.allow_snap = True
|
|
||||||
|
|
||||||
def collides_with_barrier(self):
|
|
||||||
return not self.snapped and self.x <= collision_x
|
|
||||||
|
|
||||||
def draw(self, surface):
|
|
||||||
angle = getattr(self, 'entry_angle', 0)
|
|
||||||
if self.rotated:
|
|
||||||
key = f"case_w{self.height_units}_h{self.length_units}"
|
|
||||||
else:
|
|
||||||
key = f"case_w{self.length_units}_h{self.height_units}"
|
|
||||||
image = case_images.get(key)
|
|
||||||
if image:
|
|
||||||
if self.rotated:
|
|
||||||
image_to_draw = pygame.transform.scale(image, (self.height, self.width))
|
|
||||||
else:
|
|
||||||
image_to_draw = pygame.transform.scale(image, (self.width, self.height))
|
|
||||||
if self.rotated:
|
|
||||||
image_to_draw = pygame.transform.rotate(image_to_draw, 90)
|
|
||||||
if angle != 0:
|
|
||||||
image_to_draw = pygame.transform.rotate(image_to_draw, angle)
|
|
||||||
rect = image_to_draw.get_rect(center=(self.x + self.width // 2, self.y + self.height // 3))
|
|
||||||
surface.blit(image_to_draw, rect)
|
|
||||||
else:
|
|
||||||
surface.blit(image_to_draw, (self.x, self.y))
|
|
||||||
else:
|
|
||||||
pygame.draw.rect(surface, self.color, (self.x, self.y, self.width, self.height))
|
|
||||||
|
|
||||||
def animate_tip(self):
|
|
||||||
global current_case_visible
|
|
||||||
current_case_visible = False
|
|
||||||
key = f"case_w{self.length_units}_h{self.height_units}"
|
|
||||||
image = case_images.get(key)
|
|
||||||
if image:
|
|
||||||
original = pygame.transform.scale(image, (self.width, self.height)).convert_alpha()
|
|
||||||
else:
|
|
||||||
original = pygame.Surface((self.width, self.height), pygame.SRCALPHA)
|
|
||||||
pygame.draw.rect(original, self.color, (0, 0, self.width, self.height))
|
|
||||||
steps = 10
|
|
||||||
for step in range(steps + 1):
|
|
||||||
angle = step * (90 / steps)
|
|
||||||
rotated = pygame.transform.rotate(original, angle)
|
|
||||||
new_rect = rotated.get_rect(bottomleft=(self.x, self.y + self.height))
|
|
||||||
draw_game()
|
|
||||||
screen.blit(rotated, new_rect)
|
|
||||||
pygame.display.flip()
|
|
||||||
pygame.time.delay(int(1000 / transition_fps))
|
|
||||||
self.width, self.height = self.height, self.width
|
|
||||||
self.length_units, self.height_units = self.height_units, self.length_units
|
|
||||||
self.rotated = not getattr(self, 'rotated', False)
|
|
||||||
self.x = max(collision_x + SNAP_THRESHOLD // 2, self.x)
|
|
||||||
self.y = TRAILER_Y + TRAILER_HEIGHT - self.height
|
|
||||||
current_case_visible = True
|
|
||||||
|
|
||||||
def animate_place_on_top(self):
|
|
||||||
pygame.mixer.Channel(1).stop()
|
|
||||||
global current_case_visible, collision_x
|
|
||||||
for base in reversed(stacked_cases):
|
|
||||||
height_ok = base.y - self.height >= TRAILER_Y
|
|
||||||
width_ok = self.width <= base.width
|
|
||||||
space_free = all(not (
|
|
||||||
other.y + other.height == base.y and
|
|
||||||
other.x < base.x + base.width and
|
|
||||||
other.x + other.width > base.x
|
|
||||||
) for other in stacked_cases)
|
|
||||||
if height_ok and width_ok and space_free:
|
|
||||||
start_y = self.y
|
|
||||||
target_y = base.y - self.height
|
|
||||||
steps = 10
|
|
||||||
for step in range(steps):
|
|
||||||
self.y = start_y - ((start_y - target_y) * (step + 1) / steps)
|
|
||||||
draw_game()
|
|
||||||
pygame.display.flip()
|
|
||||||
pygame.time.delay(int(1000 / transition_fps))
|
|
||||||
self.y = target_y
|
|
||||||
start_x = self.x
|
|
||||||
target_x = base.x + base.width - self.width
|
|
||||||
for step in range(steps):
|
|
||||||
self.x = start_x - ((start_x - target_x) * (step + 1) / steps)
|
|
||||||
draw_game()
|
|
||||||
pygame.display.flip()
|
|
||||||
pygame.time.delay(int(1000 / transition_fps))
|
|
||||||
self.x = target_x
|
|
||||||
self.placed = True
|
|
||||||
self.snapped = True
|
|
||||||
self.mark_occupied()
|
|
||||||
collision_x = self.x + self.width
|
|
||||||
return True
|
|
||||||
current_case_visible = True
|
|
||||||
return False
|
|
||||||
|
|
||||||
def snap_to_wall(self):
|
|
||||||
global collision_x
|
|
||||||
self.x = collision_x
|
|
||||||
self.placed = True
|
|
||||||
self.snapped = True
|
|
||||||
collision_x = self.x + self.width
|
|
||||||
|
|
||||||
def fail_snap(self):
|
|
||||||
pygame.mixer.Channel(1).stop()
|
|
||||||
global collision_x
|
|
||||||
self.x = collision_x + SNAP_THRESHOLD
|
|
||||||
self.placed = True
|
|
||||||
collision_x = self.x + self.width
|
|
||||||
|
|
||||||
|
|
||||||
def draw_progress_bar(surface, percent):
|
|
||||||
bar_width = SCREEN_WIDTH * 0.25
|
|
||||||
bar_height = 30
|
|
||||||
x = SCREEN_WIDTH - bar_width - 140
|
|
||||||
y = TOP_BAR_HEIGHT // 2 - bar_height // 2
|
|
||||||
gap = 8
|
|
||||||
segment_width = (bar_width - 4 * gap) / 5
|
|
||||||
red = min(255, int(percent * 2.55))
|
|
||||||
green = max(0, 255 - int(percent * 2.55))
|
|
||||||
color = (red, green, 0)
|
|
||||||
for i in range(5):
|
|
||||||
segment_x = x + i * (segment_width + gap)
|
|
||||||
pygame.draw.rect(surface, (50, 50, 50), (segment_x, y, segment_width, bar_height), border_radius=10)
|
|
||||||
if percent >= (i + 1) * 20:
|
|
||||||
pygame.draw.rect(surface, color, (segment_x, y, segment_width, bar_height), border_radius=10)
|
|
||||||
text = font.render(f"{int(percent)}%", True, (255, 255, 255))
|
|
||||||
surface.blit(text, (x + bar_width + 10, y))
|
|
||||||
|
|
||||||
|
|
||||||
def draw_title(surface):
|
|
||||||
title = font.render("Habegger Trailer Load", True, (255, 255, 255))
|
|
||||||
surface.blit(title, (40, TOP_BAR_HEIGHT // 2 - title.get_height() // 2))
|
|
||||||
|
|
||||||
|
|
||||||
def calculate_load_percent():
|
|
||||||
total_volume = TRAILER_WIDTH * TRAILER_HEIGHT
|
|
||||||
used_volume = sum([c.width * c.height for c in stacked_cases])
|
|
||||||
return min(100, (used_volume / total_volume) * 100)
|
|
||||||
|
|
||||||
|
|
||||||
next_queue = []
|
|
||||||
|
|
||||||
|
|
||||||
def draw_game(hide_trailer=False):
|
|
||||||
global current_case
|
|
||||||
global shake_timer
|
|
||||||
global transition_counter
|
|
||||||
|
|
||||||
if transition_counter > 0:
|
|
||||||
transition_counter -= 1
|
|
||||||
pygame.time.delay(int(1000 / FPS))
|
|
||||||
global current_case
|
|
||||||
global shake_timer
|
|
||||||
offset_x = random.randint(-5, 5) if shake_timer > 0 else 0
|
|
||||||
offset_y = random.randint(-5, 5) if shake_timer > 0 else 0
|
|
||||||
if shake_timer > 0:
|
|
||||||
shake_timer -= 1
|
|
||||||
screen.fill((0, 0, 0))
|
|
||||||
pygame.draw.rect(screen, (0, 0, 0), (0, 0, SCREEN_WIDTH, TOP_BAR_HEIGHT))
|
|
||||||
draw_title(screen)
|
|
||||||
percent = calculate_load_percent()
|
|
||||||
draw_progress_bar(screen, percent)
|
|
||||||
if background_image:
|
|
||||||
screen.blit(background_image, (0, TOP_BAR_HEIGHT))
|
|
||||||
else:
|
|
||||||
pygame.draw.rect(screen, (0, 0, 0), (0, TOP_BAR_HEIGHT, SCREEN_WIDTH, GAME_AREA_HEIGHT))
|
|
||||||
if not hide_trailer:
|
|
||||||
pygame.draw.rect(screen, (100, 100, 100),
|
|
||||||
(TRAILER_X + offset_x, TRAILER_Y + offset_y, TRAILER_WIDTH, TRAILER_HEIGHT))
|
|
||||||
for c in stacked_cases:
|
|
||||||
c.draw(screen)
|
|
||||||
if current_case and current_case_visible:
|
|
||||||
current_case.draw(screen)
|
|
||||||
pygame.draw.line(screen, (255, 0, 0), (collision_x, TRAILER_Y), (collision_x, TRAILER_Y + TRAILER_HEIGHT), 3)
|
|
||||||
pygame.draw.rect(screen, (0, 0, 0), (0, TOP_BAR_HEIGHT + GAME_AREA_HEIGHT, SCREEN_WIDTH, BOTTOM_BAR_HEIGHT))
|
|
||||||
if current_case and current_case.allow_snap:
|
|
||||||
on_top_possible = current_case.can_place_on_top()
|
|
||||||
if on_top_possible:
|
|
||||||
snap_text = font.render("OnTop möglich!", True, (255, 255, 0))
|
|
||||||
else:
|
|
||||||
snap_text = font.render("Snap bereit!", True, (0, 255, 0))
|
|
||||||
screen.blit(snap_text, (SCREEN_WIDTH - SCREEN_WIDTH // 3 - snap_text.get_width() // 2,
|
|
||||||
SCREEN_HEIGHT - BOTTOM_BAR_HEIGHT // 2 - snap_text.get_height() // 2))
|
|
||||||
|
|
||||||
# Vorschau "Next"
|
|
||||||
label = font.render("Next:", True, (255, 255, 255))
|
|
||||||
screen.blit(label, (40, SCREEN_HEIGHT - BOTTOM_BAR_HEIGHT + 10))
|
|
||||||
|
|
||||||
preview_x = 40
|
|
||||||
for i, case in enumerate(next_queue[:3]):
|
|
||||||
w_units = case['w']
|
|
||||||
h_units = case['h']
|
|
||||||
if case['rotated']:
|
|
||||||
w_units, h_units = h_units, w_units
|
|
||||||
key = f"case_w{w_units}_h{h_units}"
|
|
||||||
image = case_images.get(key)
|
|
||||||
w = w_units * UNIT_LENGTH
|
|
||||||
h = h_units * UNIT_HEIGHT
|
|
||||||
if image:
|
|
||||||
scaled = pygame.transform.scale(image, (w, h))
|
|
||||||
screen.blit(scaled, (preview_x, SCREEN_HEIGHT - BOTTOM_BAR_HEIGHT + 40))
|
|
||||||
else:
|
|
||||||
pygame.draw.rect(screen, CASE_COLORS[i % len(CASE_COLORS)],
|
|
||||||
(preview_x, SCREEN_HEIGHT - BOTTOM_BAR_HEIGHT + 40, w, h))
|
|
||||||
preview_x += max(w, 80) + 20
|
|
||||||
|
|
||||||
|
|
||||||
def spawn_case():
|
|
||||||
global running
|
|
||||||
global can_use_on_top
|
|
||||||
can_use_on_top = True
|
|
||||||
global case_sequence, case_index, next_queue
|
|
||||||
if not case_sequence:
|
|
||||||
generate_fill_sequence()
|
|
||||||
|
|
||||||
# Vorschau initial füllen
|
|
||||||
while len(next_queue) < 3:
|
|
||||||
index = (case_index + len(next_queue)) % len(case_sequence)
|
|
||||||
next_queue.append(case_sequence[index])
|
|
||||||
|
|
||||||
# aktuelles Case bestimmen
|
|
||||||
if case_index >= len(case_sequence):
|
|
||||||
return None
|
|
||||||
case_data = case_sequence[case_index % len(case_sequence)]
|
|
||||||
case_index += 1
|
|
||||||
|
|
||||||
# Vorschau nachrücken
|
|
||||||
if next_queue:
|
|
||||||
next_queue.pop(0)
|
|
||||||
while len(next_queue) < 3:
|
|
||||||
index = (case_index + len(next_queue)) % len(case_sequence)
|
|
||||||
next_queue.append(case_sequence[index])
|
|
||||||
|
|
||||||
return Case(size=case_data)
|
|
||||||
|
|
||||||
|
|
||||||
def show_start_sequence():
|
|
||||||
center_x = TRAILER_X + TRAILER_WIDTH // 2
|
|
||||||
center_y = TRAILER_Y + TRAILER_HEIGHT // 2
|
|
||||||
colors = [(255, 0, 0), (255, 200, 0), (0, 255, 0)]
|
|
||||||
delays = [1000, 1000, 1000] # ms pro Punkt
|
|
||||||
sounds = [sound_tut1, sound_tut2, sound_tuuut]
|
|
||||||
radius = 90
|
|
||||||
|
|
||||||
for i in range(3):
|
|
||||||
draw_game(hide_trailer=True)
|
|
||||||
pygame.draw.circle(screen, colors[i], (center_x, center_y), radius)
|
|
||||||
sounds[i].play()
|
|
||||||
pygame.display.flip()
|
|
||||||
pygame.time.delay(delays[i])
|
|
||||||
|
|
||||||
# Reißverschluss-Effekt
|
|
||||||
zip_sound = pygame.mixer.Sound("zip.ogg")
|
|
||||||
zip_sound.set_volume(1)
|
|
||||||
zip_sound.play()
|
|
||||||
duration = 200
|
|
||||||
steps = 60
|
|
||||||
for step in range(steps + 1):
|
|
||||||
width = int(TRAILER_WIDTH * (step / steps))
|
|
||||||
draw_game(hide_trailer=True)
|
|
||||||
pygame.draw.rect(screen, (100, 100, 100), (TRAILER_X, TRAILER_Y, width, TRAILER_HEIGHT))
|
|
||||||
pygame.display.flip()
|
|
||||||
pygame.time.delay(duration // steps)
|
|
||||||
|
|
||||||
pygame.time.delay(1000)
|
|
||||||
show_instruction_screen()
|
|
||||||
show_start_sequence()
|
|
||||||
current_case = spawn_case()
|
|
||||||
|
|
||||||
def show_game_over(score):
|
|
||||||
try:
|
|
||||||
with open("last_user.txt", "r", encoding="utf-8") as f:
|
|
||||||
lines = f.readlines()
|
|
||||||
username = lines[1].strip() if len(lines) > 1 else "Spieler"
|
|
||||||
try:
|
|
||||||
result = subprocess.run(
|
|
||||||
["curl", "-X", "POST", "https://hag.putschgi.ch/Yb54CO5Ypybx/api/submit_points.php",
|
|
||||||
"-d", f"name={username}",
|
|
||||||
"-d", f"score={int(score)}",
|
|
||||||
"-d", "api_key=hag-trailer-8051"],
|
|
||||||
capture_output=True, text=True
|
|
||||||
)
|
|
||||||
if result.returncode != 0 or not "success" in result.stdout.lower():
|
|
||||||
raise Exception("Serverfehler")
|
|
||||||
except:
|
|
||||||
error_text = font.render("Fehler: Punkte konnten nicht gesendet werden!", True, (255, 100, 100))
|
|
||||||
screen.blit(error_text, (SCREEN_WIDTH // 2 - error_text.get_width() // 2, SCREEN_HEIGHT // 2 + 60))
|
|
||||||
pygame.display.flip()
|
|
||||||
pygame.time.delay(2000)
|
|
||||||
except:
|
|
||||||
username = "Spieler"
|
|
||||||
pygame.mixer.stop()
|
|
||||||
if score >= 75:
|
|
||||||
message = f"Gratuliere {username}! Du hast {int(score)}% geladen! Drücke A oder SPACE um zu beenden."
|
|
||||||
else:
|
|
||||||
message = f"{username}, du hast {int(score)}% geladen. Drücke A oder SPACE um zu beenden."
|
|
||||||
overlay = pygame.Surface((SCREEN_WIDTH, SCREEN_HEIGHT))
|
|
||||||
overlay.set_alpha(220)
|
|
||||||
overlay.fill((0, 0, 0))
|
|
||||||
screen.blit(overlay, (0, 0))
|
|
||||||
text = font.render(message, True, (255, 255, 255))
|
|
||||||
screen.blit(text, (SCREEN_WIDTH // 2 - text.get_width() // 2,
|
|
||||||
SCREEN_HEIGHT // 2 - text.get_height() // 2))
|
|
||||||
pygame.display.flip()
|
|
||||||
waiting = True
|
|
||||||
while waiting:
|
|
||||||
for event in pygame.event.get():
|
|
||||||
if event.type == pygame.QUIT:
|
|
||||||
pygame.quit()
|
|
||||||
sys.exit()
|
|
||||||
elif (
|
|
||||||
(event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE) or
|
|
||||||
(event.type == pygame.JOYBUTTONDOWN and event.button == 0)
|
|
||||||
):
|
|
||||||
pygame.quit()
|
|
||||||
sys.exit()
|
|
||||||
running = True
|
|
||||||
can_use_tilt = True
|
|
||||||
can_use_on_top = True
|
|
||||||
game_finished = False
|
|
||||||
|
|
||||||
|
|
||||||
while running:
|
|
||||||
if not game_finished and collision_x > TRAILER_X + TRAILER_WIDTH:
|
|
||||||
show_game_over(calculate_load_percent())
|
|
||||||
game_finished = True
|
|
||||||
continue
|
|
||||||
if not game_finished and current_case is None and case_index >= len(case_sequence):
|
|
||||||
show_game_over(calculate_load_percent())
|
|
||||||
game_finished = True
|
|
||||||
continue
|
|
||||||
clock.tick(FPS)
|
|
||||||
if transition_counter > 0:
|
|
||||||
transition_counter -= 1
|
|
||||||
draw_game()
|
|
||||||
pygame.display.flip()
|
|
||||||
pygame.time.delay(int(1000 / FPS))
|
|
||||||
continue
|
|
||||||
for event in pygame.event.get():
|
|
||||||
if event.type == pygame.QUIT:
|
|
||||||
running = False
|
|
||||||
elif event.type == pygame.KEYDOWN or event.type == pygame.JOYBUTTONDOWN or event.type == pygame.JOYHATMOTION:
|
|
||||||
if state == PLAYING:
|
|
||||||
can_tip = current_case.length_units * UNIT_HEIGHT <= TRAILER_HEIGHT
|
|
||||||
if (
|
|
||||||
(event.type == pygame.KEYDOWN and event.key == pygame.K_LEFT) or
|
|
||||||
(event.type == pygame.JOYHATMOTION and event.value[0] == -1) or
|
|
||||||
(event.type == pygame.JOYBUTTONDOWN and event.button == 2)
|
|
||||||
):
|
|
||||||
if current_case and current_case.allow_snap and can_use_tilt and can_tip:
|
|
||||||
current_case.animate_tip()
|
|
||||||
can_use_tilt = False
|
|
||||||
elif (
|
|
||||||
(event.type == pygame.KEYDOWN and event.key == pygame.K_UP) or
|
|
||||||
(event.type == pygame.JOYHATMOTION and event.value[1] == 1) or
|
|
||||||
(event.type == pygame.JOYBUTTONDOWN and event.button == 3)
|
|
||||||
):
|
|
||||||
if current_case and current_case.allow_snap and can_use_on_top and current_case.can_place_on_top():
|
|
||||||
if current_case.animate_place_on_top():
|
|
||||||
transition_counter = transition_fps
|
|
||||||
sound_place.play()
|
|
||||||
stacked_cases.append(current_case)
|
|
||||||
current_case = spawn_case()
|
|
||||||
if current_case is None and not game_finished:
|
|
||||||
show_game_over(calculate_load_percent())
|
|
||||||
game_finished = True
|
|
||||||
continue
|
|
||||||
can_use_tilt = True
|
|
||||||
can_use_on_top = True
|
|
||||||
else:
|
|
||||||
current_case.fail_snap()
|
|
||||||
sound_place.play()
|
|
||||||
stacked_cases.append(current_case)
|
|
||||||
current_case = spawn_case()
|
|
||||||
if current_case is None and not game_finished:
|
|
||||||
show_game_over(calculate_load_percent())
|
|
||||||
game_finished = True
|
|
||||||
continue
|
|
||||||
shake_timer = 10
|
|
||||||
elif (
|
|
||||||
(event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE) or
|
|
||||||
(event.type == pygame.JOYBUTTONDOWN and event.button == 0)
|
|
||||||
):
|
|
||||||
if current_case and current_case.allow_snap:
|
|
||||||
current_case.animate_snap()
|
|
||||||
can_use_tilt = True
|
|
||||||
can_use_on_top = True
|
|
||||||
sound_place.play()
|
|
||||||
transition_counter = transition_fps
|
|
||||||
stacked_cases.append(current_case)
|
|
||||||
current_case = spawn_case()
|
|
||||||
|
|
||||||
if state == PLAYING:
|
|
||||||
if current_case is None:
|
|
||||||
continue
|
|
||||||
if current_case:
|
|
||||||
current_case.move()
|
|
||||||
if not game_finished:
|
|
||||||
can_tip = current_case.length_units * UNIT_HEIGHT <= TRAILER_HEIGHT
|
|
||||||
if collision_x + current_case.width > TRAILER_X + TRAILER_WIDTH and not current_case.can_place_on_top() and not current_case.allow_snap and not can_tip:
|
|
||||||
show_game_over(calculate_load_percent())
|
|
||||||
game_finished = True
|
|
||||||
continue
|
|
||||||
if calculate_load_percent() >= 99.9 and case_index >= len(case_sequence):
|
|
||||||
show_game_over(100)
|
|
||||||
game_finished = True
|
|
||||||
continue
|
|
||||||
if not current_case.placed and current_case.collides_with_barrier():
|
|
||||||
current_case.fail_snap()
|
|
||||||
if current_case.x + current_case.width > TRAILER_X + TRAILER_WIDTH:
|
|
||||||
if stacked_cases and stacked_cases[-1] == current_case:
|
|
||||||
stacked_cases.pop()
|
|
||||||
else:
|
|
||||||
stacked_cases.append(current_case)
|
|
||||||
can_use_tilt = True
|
|
||||||
can_use_on_top = True
|
|
||||||
sound_fail.play()
|
|
||||||
current_case = spawn_case()
|
|
||||||
shake_timer = 10
|
|
||||||
draw_game()
|
|
||||||
|
|
||||||
pygame.display.flip()
|
|
||||||
|
|
||||||
pygame.quit()
|
|
||||||
sys.exit()
|
|
||||||
@@ -0,0 +1,18 @@
|
|||||||
|
"""Habegger Loader Game – Spielpaket.
|
||||||
|
|
||||||
|
Aufbau (jedes Modul hat genau eine Aufgabe):
|
||||||
|
|
||||||
|
* :mod:`loader_game.config` – alle Masse, Farben, Tempi, Pfade
|
||||||
|
* :mod:`loader_game.assets` – Bilder, Sounds, Fonts laden und cachen
|
||||||
|
* :mod:`loader_game.sequences` – Einlesen von ``case_sequences.txt``
|
||||||
|
* :mod:`loader_game.case` – der Koffer (Geometrie und Bewegung)
|
||||||
|
* :mod:`loader_game.trailer` – Stapelregeln im Auflieger (reine Logik)
|
||||||
|
* :mod:`loader_game.input_map` – Tastatur/Controller → abstrakte Aktionen
|
||||||
|
* :mod:`loader_game.scene` – Zeichnen
|
||||||
|
* :mod:`loader_game.intro` – Tutorialbild + Ampel + Reissverschluss
|
||||||
|
* :mod:`loader_game.game` – Zustandsmaschine des Spiels
|
||||||
|
* :mod:`loader_game.storage` – Laufzeitdaten (letzter Spielername)
|
||||||
|
* :mod:`loader_game.net` – optionaler Punkte-Upload
|
||||||
|
"""
|
||||||
|
|
||||||
|
__version__ = "1.0.0"
|
||||||
@@ -0,0 +1,176 @@
|
|||||||
|
"""Laden und Zwischenspeichern aller Bilder, Sounds und Fonts."""
|
||||||
|
|
||||||
|
from __future__ import annotations
|
||||||
|
|
||||||
|
import array
|
||||||
|
import math
|
||||||
|
import re
|
||||||
|
|
||||||
|
import pygame
|
||||||
|
|
||||||
|
from . import config
|
||||||
|
|
||||||
|
_CASE_FILENAME = re.compile(r"^case_w(\d+)_h(\d+)\.png$")
|
||||||
|
|
||||||
|
|
||||||
|
class Assets:
|
||||||
|
"""Sammelstelle für alles, was aus Dateien kommt.
|
||||||
|
|
||||||
|
Muss **nach** ``pygame.init()`` und ``pygame.display.set_mode()``
|
||||||
|
instanziiert werden, weil ``convert_alpha()`` ein Display voraussetzt.
|
||||||
|
Fehlende Dateien führen nicht zum Absturz, sondern zu ``None`` – das
|
||||||
|
Spiel zeichnet dann einen farbigen Platzhalter bzw. bleibt stumm.
|
||||||
|
"""
|
||||||
|
|
||||||
|
def __init__(self) -> None:
|
||||||
|
self.font: pygame.font.Font | None = None
|
||||||
|
self.font_small: pygame.font.Font | None = None
|
||||||
|
self.background: pygame.Surface | None = None
|
||||||
|
self.instruction: pygame.Surface | None = None
|
||||||
|
self.sounds: dict[str, pygame.mixer.Sound] = {}
|
||||||
|
self._case_originals: dict[tuple[int, int], pygame.Surface] = {}
|
||||||
|
self._case_cache: dict[tuple[int, int], pygame.Surface] = {}
|
||||||
|
self._roll_channel: pygame.mixer.Channel | None = None
|
||||||
|
|
||||||
|
# ------------------------------------------------------------------
|
||||||
|
# Laden
|
||||||
|
# ------------------------------------------------------------------
|
||||||
|
def load(self) -> None:
|
||||||
|
self.font = self._load_font(config.FONT_SIZE)
|
||||||
|
self.font_small = self._load_font(config.FONT_SIZE_SMALL)
|
||||||
|
self.background = self._load_image(config.BACKGROUND_IMAGE, (config.SCREEN_WIDTH, config.GAME_AREA_HEIGHT))
|
||||||
|
self.instruction = self._load_image(config.TUTORIAL_IMAGE, (config.SCREEN_WIDTH, config.SCREEN_HEIGHT))
|
||||||
|
self._load_case_images()
|
||||||
|
self._load_sounds()
|
||||||
|
self._load_beeps()
|
||||||
|
|
||||||
|
def _load_font(self, size: int) -> pygame.font.Font:
|
||||||
|
try:
|
||||||
|
return pygame.font.Font(str(config.FONT_REGULAR), size)
|
||||||
|
except (OSError, pygame.error):
|
||||||
|
return pygame.font.SysFont(None, size)
|
||||||
|
|
||||||
|
@staticmethod
|
||||||
|
def _load_image(path, size: tuple[int, int] | None = None) -> pygame.Surface | None:
|
||||||
|
if not path.exists():
|
||||||
|
return None
|
||||||
|
try:
|
||||||
|
image = pygame.image.load(str(path))
|
||||||
|
image = image.convert_alpha() if image.get_alpha() is not None else image.convert()
|
||||||
|
except pygame.error:
|
||||||
|
return None
|
||||||
|
if size is not None:
|
||||||
|
image = pygame.transform.smoothscale(image, size)
|
||||||
|
return image
|
||||||
|
|
||||||
|
def _load_case_images(self) -> None:
|
||||||
|
if not config.IMAGES_DIR.is_dir():
|
||||||
|
return
|
||||||
|
for path in sorted(config.IMAGES_DIR.glob("case_w*_h*.png")):
|
||||||
|
match = _CASE_FILENAME.match(path.name)
|
||||||
|
if not match:
|
||||||
|
continue
|
||||||
|
key = (int(match.group(1)), int(match.group(2)))
|
||||||
|
try:
|
||||||
|
self._case_originals[key] = pygame.image.load(str(path)).convert_alpha()
|
||||||
|
except pygame.error:
|
||||||
|
continue
|
||||||
|
|
||||||
|
def _load_sounds(self) -> None:
|
||||||
|
if not pygame.mixer.get_init():
|
||||||
|
return
|
||||||
|
for name, path in config.SOUND_FILES.items():
|
||||||
|
if not path.exists():
|
||||||
|
continue
|
||||||
|
try:
|
||||||
|
self.sounds[name] = pygame.mixer.Sound(str(path))
|
||||||
|
except pygame.error:
|
||||||
|
continue
|
||||||
|
if "roll" in self.sounds:
|
||||||
|
self.sounds["roll"].set_volume(0.3)
|
||||||
|
for name in ("place", "fail"):
|
||||||
|
if name in self.sounds:
|
||||||
|
self.sounds[name].set_volume(0.6)
|
||||||
|
if "zip" in self.sounds:
|
||||||
|
self.sounds["zip"].set_volume(1.0)
|
||||||
|
pygame.mixer.set_num_channels(max(8, pygame.mixer.get_num_channels()))
|
||||||
|
self._roll_channel = pygame.mixer.Channel(1)
|
||||||
|
|
||||||
|
def _load_beeps(self) -> None:
|
||||||
|
if not pygame.mixer.get_init():
|
||||||
|
return
|
||||||
|
for index, spec in enumerate(config.INTRO_BEEPS, start=1):
|
||||||
|
self.sounds[f"beep{index}"] = self._make_beep(**spec)
|
||||||
|
|
||||||
|
# ------------------------------------------------------------------
|
||||||
|
# Koffer-Grafiken
|
||||||
|
# ------------------------------------------------------------------
|
||||||
|
def case_surface(self, units_w: int, units_h: int) -> pygame.Surface | None:
|
||||||
|
"""Skalierte Grafik für einen Koffer der Grösse ``units_w`` x ``units_h``.
|
||||||
|
|
||||||
|
Fehlt die passende Datei, wird die gespiegelte Variante um 90° gedreht.
|
||||||
|
Gibt ``None`` zurück, wenn es gar keine Grafik gibt.
|
||||||
|
"""
|
||||||
|
key = (units_w, units_h)
|
||||||
|
cached = self._case_cache.get(key)
|
||||||
|
if cached is not None:
|
||||||
|
return cached
|
||||||
|
|
||||||
|
size = (int(units_w * config.UNIT_LENGTH), int(units_h * config.UNIT_HEIGHT))
|
||||||
|
natural = self._case_originals.get(key)
|
||||||
|
surface: pygame.Surface | None
|
||||||
|
if natural is not None:
|
||||||
|
surface = pygame.transform.smoothscale(natural, size)
|
||||||
|
else:
|
||||||
|
mirrored_key = (units_h, units_w)
|
||||||
|
mirrored = self._case_originals.get(mirrored_key)
|
||||||
|
if mirrored is None:
|
||||||
|
return None
|
||||||
|
mirrored_size = (
|
||||||
|
int(units_h * config.UNIT_LENGTH),
|
||||||
|
int(units_w * config.UNIT_HEIGHT),
|
||||||
|
)
|
||||||
|
surface = pygame.transform.rotate(
|
||||||
|
pygame.transform.smoothscale(mirrored, mirrored_size), 90
|
||||||
|
)
|
||||||
|
self._case_cache[key] = surface
|
||||||
|
return surface
|
||||||
|
|
||||||
|
# ------------------------------------------------------------------
|
||||||
|
# Sound-Steuerung
|
||||||
|
# ------------------------------------------------------------------
|
||||||
|
def play(self, name: str, loops: int = 0) -> None:
|
||||||
|
sound = self.sounds.get(name)
|
||||||
|
if sound is None:
|
||||||
|
return
|
||||||
|
if name == "roll" and self._roll_channel is not None:
|
||||||
|
if not self._roll_channel.get_busy():
|
||||||
|
self._roll_channel.play(sound, loops=loops)
|
||||||
|
return
|
||||||
|
sound.play(loops=loops)
|
||||||
|
|
||||||
|
def stop_roll(self) -> None:
|
||||||
|
if self._roll_channel is not None:
|
||||||
|
self._roll_channel.stop()
|
||||||
|
|
||||||
|
def stop_all(self) -> None:
|
||||||
|
if pygame.mixer.get_init():
|
||||||
|
pygame.mixer.stop()
|
||||||
|
|
||||||
|
# ------------------------------------------------------------------
|
||||||
|
# Töne ohne Dateien (für das Intro)
|
||||||
|
# ------------------------------------------------------------------
|
||||||
|
@staticmethod
|
||||||
|
def _make_beep(frequency: int = 440, duration_ms: int = 500, volume: float = 0.5):
|
||||||
|
"""Erzeugt einen Sinuston als ``pygame.mixer.Sound`` (ohne numpy)."""
|
||||||
|
init = pygame.mixer.get_init()
|
||||||
|
if not init:
|
||||||
|
raise pygame.error("Mixer ist nicht initialisiert")
|
||||||
|
sample_rate, _, channels = init
|
||||||
|
sample_count = int(sample_rate * duration_ms / 1000.0)
|
||||||
|
buffer = array.array("h")
|
||||||
|
for index in range(sample_count):
|
||||||
|
value = int(math.sin(2 * math.pi * frequency * index / sample_rate) * volume * 32767)
|
||||||
|
for _ in range(channels):
|
||||||
|
buffer.append(value)
|
||||||
|
return pygame.mixer.Sound(buffer=buffer.tobytes())
|
||||||
@@ -0,0 +1,71 @@
|
|||||||
|
"""Der Koffer: Geometrie und Einlaufbewegung.
|
||||||
|
|
||||||
|
Bewusst ohne ``pygame``-Abhängigkeit, damit die Regeln testbar bleiben.
|
||||||
|
"""
|
||||||
|
|
||||||
|
from __future__ import annotations
|
||||||
|
|
||||||
|
from dataclasses import dataclass
|
||||||
|
|
||||||
|
from . import config
|
||||||
|
|
||||||
|
|
||||||
|
@dataclass
|
||||||
|
class Case:
|
||||||
|
"""Ein Koffer im Auflieger.
|
||||||
|
|
||||||
|
``units_w`` / ``units_h`` beschreiben die **aktuelle** Grundfläche in
|
||||||
|
Kasten-Einheiten. Eine Drehung tauscht die beiden Werte – es gibt also
|
||||||
|
keinen zusätzlichen ``rotated``-Schalter, der mit den Massen kollidieren
|
||||||
|
könnte (das war im Altstand eine Fehlerquelle).
|
||||||
|
"""
|
||||||
|
|
||||||
|
units_w: int
|
||||||
|
units_h: int
|
||||||
|
x: float
|
||||||
|
y: float
|
||||||
|
color: tuple[int, int, int] = config.CASE_COLORS[0]
|
||||||
|
placed: bool = False
|
||||||
|
snapped: bool = False
|
||||||
|
allow_snap: bool = False
|
||||||
|
can_rotate: bool = True
|
||||||
|
|
||||||
|
# -- Geometrie ------------------------------------------------------
|
||||||
|
@property
|
||||||
|
def width(self) -> float:
|
||||||
|
return self.units_w * config.UNIT_LENGTH
|
||||||
|
|
||||||
|
@property
|
||||||
|
def height(self) -> float:
|
||||||
|
return self.units_h * config.UNIT_HEIGHT
|
||||||
|
|
||||||
|
@property
|
||||||
|
def right(self) -> float:
|
||||||
|
return self.x + self.width
|
||||||
|
|
||||||
|
@property
|
||||||
|
def bottom(self) -> float:
|
||||||
|
return self.y + self.height
|
||||||
|
|
||||||
|
# -- Bewegung -------------------------------------------------------
|
||||||
|
def move(self, dt: float, wall_x: float) -> None:
|
||||||
|
"""Bewegt den Koffer nach links, mit Abbremsen kurz vor der Barriere."""
|
||||||
|
if self.placed:
|
||||||
|
return
|
||||||
|
distance = self.x - wall_x
|
||||||
|
speed = (
|
||||||
|
config.CASE_SPEED_FAST
|
||||||
|
if distance > config.FAST_TO_SLOW_DISTANCE
|
||||||
|
else config.CASE_SPEED_SLOW
|
||||||
|
)
|
||||||
|
self.x -= speed * dt
|
||||||
|
if self.x <= wall_x + config.SNAP_THRESHOLD:
|
||||||
|
self.allow_snap = True
|
||||||
|
|
||||||
|
def rotate_footprint(self) -> None:
|
||||||
|
"""Tauscht Breite und Höhe (nach einer 90°-Drehung)."""
|
||||||
|
self.units_w, self.units_h = self.units_h, self.units_w
|
||||||
|
|
||||||
|
def fits_trailer_height(self) -> bool:
|
||||||
|
"""Passt der Koffer nach einer Drehung noch in die Höhe des Aufliegers?"""
|
||||||
|
return self.width <= config.TRAILER_HEIGHT
|
||||||
@@ -0,0 +1,151 @@
|
|||||||
|
"""Zentrale Konfiguration: alle Masse, Farben, Tempi und Pfade.
|
||||||
|
|
||||||
|
Alle Geometrieangaben beziehen sich auf eine virtuelle Auflösung von
|
||||||
|
1920x1080. Das Fenster wird per ``pygame.SCALED`` automatisch auf die
|
||||||
|
tatsächliche Fenstergrösse skaliert – dadurch sieht das Spiel auf einem
|
||||||
|
MacBook (Retina, 1440x900, …) genauso aus wie auf einem 1080p-Monitor.
|
||||||
|
"""
|
||||||
|
|
||||||
|
from __future__ import annotations
|
||||||
|
|
||||||
|
import os
|
||||||
|
from pathlib import Path
|
||||||
|
|
||||||
|
# --------------------------------------------------------------------------
|
||||||
|
# Pfade
|
||||||
|
# --------------------------------------------------------------------------
|
||||||
|
BASE_DIR = Path(__file__).resolve().parent.parent
|
||||||
|
RUNTIME_DIR = BASE_DIR / "runtime"
|
||||||
|
|
||||||
|
IMAGES_DIR = BASE_DIR / "images"
|
||||||
|
FONTS_DIR = BASE_DIR / "fonts"
|
||||||
|
FONT_REGULAR = FONTS_DIR / "Tisa Sans Pro Regular.ttf"
|
||||||
|
|
||||||
|
BACKGROUND_IMAGE = IMAGES_DIR / "background.png"
|
||||||
|
TUTORIAL_IMAGE = IMAGES_DIR / "tutorial.png"
|
||||||
|
SEQUENCES_FILE = BASE_DIR / "case_sequences.txt"
|
||||||
|
|
||||||
|
SOUND_FILES = {
|
||||||
|
"roll": BASE_DIR / "roll.ogg",
|
||||||
|
"place": BASE_DIR / "place.ogg",
|
||||||
|
"fail": BASE_DIR / "fail.ogg",
|
||||||
|
"zip": BASE_DIR / "zip.ogg",
|
||||||
|
}
|
||||||
|
|
||||||
|
# --------------------------------------------------------------------------
|
||||||
|
# Fenster / Bildrate
|
||||||
|
# --------------------------------------------------------------------------
|
||||||
|
SCREEN_WIDTH = 1920
|
||||||
|
SCREEN_HEIGHT = 1080
|
||||||
|
WINDOW_TITLE = "Habegger Trailer Load"
|
||||||
|
FPS = 60
|
||||||
|
AUDIO_SAMPLE_RATE = 44100
|
||||||
|
DEFAULT_FULLSCREEN = False # per --fullscreen oder F11 umschaltbar
|
||||||
|
|
||||||
|
# --------------------------------------------------------------------------
|
||||||
|
# Layout (horizontale Bänder)
|
||||||
|
# --------------------------------------------------------------------------
|
||||||
|
TOP_BAR_HEIGHT = SCREEN_HEIGHT // 8 # 135
|
||||||
|
GAME_AREA_HEIGHT = int(SCREEN_HEIGHT / 1.6) # 675
|
||||||
|
BOTTOM_BAR_HEIGHT = SCREEN_HEIGHT // 4 # 270
|
||||||
|
|
||||||
|
# --------------------------------------------------------------------------
|
||||||
|
# Auflieger (grauer Kasten, in dem die Koffer gestapelt werden)
|
||||||
|
# --------------------------------------------------------------------------
|
||||||
|
TRAILER_WIDTH = int(SCREEN_WIDTH * 0.885416666667) # 1700
|
||||||
|
TRAILER_HEIGHT = int(SCREEN_HEIGHT * 0.2778) # 300
|
||||||
|
TRAILER_X = (SCREEN_WIDTH - TRAILER_WIDTH) // 4 # 55
|
||||||
|
TRAILER_Y = TOP_BAR_HEIGHT + 200 # 335
|
||||||
|
TRAILER_RIGHT = TRAILER_X + TRAILER_WIDTH
|
||||||
|
TRAILER_BOTTOM = TRAILER_Y + TRAILER_HEIGHT
|
||||||
|
|
||||||
|
# Eine Kasten-Einheit entspricht 100x100 Pixeln.
|
||||||
|
UNIT_LENGTH = TRAILER_HEIGHT // 3 # 100
|
||||||
|
UNIT_HEIGHT = TRAILER_HEIGHT // 3 # 100
|
||||||
|
MAX_UNITS_W = 4
|
||||||
|
MAX_UNITS_H = 3
|
||||||
|
|
||||||
|
# --------------------------------------------------------------------------
|
||||||
|
# Spieltempo (jetzt in Pixel pro Sekunde statt pro Frame)
|
||||||
|
# --------------------------------------------------------------------------
|
||||||
|
CASE_SPEED_FAST = 720 # früher: 6 px/Frame bei 120 fps
|
||||||
|
CASE_SPEED_SLOW = 240 # früher: 2 px/Frame bei 120 fps
|
||||||
|
FAST_TO_SLOW_DISTANCE = 120 # ab hier wird abgebremst
|
||||||
|
SNAP_THRESHOLD = 60 # ab hier darf eingerastet werden
|
||||||
|
PLATFORM_TOLERANCE = 5 # Toleranz für "bündig an der Barriere"
|
||||||
|
|
||||||
|
# Animationsdauern in Sekunden (vorher: 10 Frames à 16,6 ms)
|
||||||
|
ANIM_SNAP = 0.17
|
||||||
|
ANIM_ROTATE = 0.18
|
||||||
|
ANIM_STACK_STEP = 0.17
|
||||||
|
SHAKE_TIME = 0.12
|
||||||
|
SHAKE_AMPLITUDE = 5
|
||||||
|
|
||||||
|
# --------------------------------------------------------------------------
|
||||||
|
# Intro
|
||||||
|
# --------------------------------------------------------------------------
|
||||||
|
INTRO_DOT_COLORS = ((255, 0, 0), (255, 200, 0), (0, 255, 0))
|
||||||
|
INTRO_DOT_DELAY = 1.0
|
||||||
|
INTRO_DOT_RADIUS = 90
|
||||||
|
INTRO_ZIP_DURATION = 0.2
|
||||||
|
INTRO_BEEPS = (
|
||||||
|
{"frequency": 440, "duration_ms": 600, "volume": 0.5},
|
||||||
|
{"frequency": 440, "duration_ms": 400, "volume": 0.5},
|
||||||
|
{"frequency": 600, "duration_ms": 1000, "volume": 0.5},
|
||||||
|
)
|
||||||
|
|
||||||
|
# --------------------------------------------------------------------------
|
||||||
|
# Farben
|
||||||
|
# --------------------------------------------------------------------------
|
||||||
|
COLOR_TOP_BAR = (0, 0, 0)
|
||||||
|
COLOR_BOTTOM_BAR = (0, 0, 0)
|
||||||
|
COLOR_BACKGROUND = (0, 0, 0)
|
||||||
|
COLOR_TRAILER = (100, 100, 100)
|
||||||
|
COLOR_WALL = (255, 0, 0)
|
||||||
|
COLOR_WHITE = (255, 255, 255)
|
||||||
|
COLOR_HINT_SNAP = (0, 255, 0)
|
||||||
|
COLOR_HINT_STACK = (255, 255, 0)
|
||||||
|
COLOR_ERROR = (255, 100, 100)
|
||||||
|
COLOR_PROGRESS_TRACK = (50, 50, 50)
|
||||||
|
CASE_COLORS = ((200, 0, 0), (0, 200, 0), (0, 0, 200))
|
||||||
|
|
||||||
|
# --------------------------------------------------------------------------
|
||||||
|
# Fortschrittsbalken
|
||||||
|
# --------------------------------------------------------------------------
|
||||||
|
PROGRESS_BAR_SEGMENTS = 5
|
||||||
|
PROGRESS_BAR_WIDTH = int(SCREEN_WIDTH * 0.25)
|
||||||
|
PROGRESS_BAR_HEIGHT = 30
|
||||||
|
PROGRESS_BAR_RIGHT_MARGIN = 140
|
||||||
|
PROGRESS_BAR_GAP = 8
|
||||||
|
PROGRESS_BAR_RADIUS = 10
|
||||||
|
|
||||||
|
# --------------------------------------------------------------------------
|
||||||
|
# Texte
|
||||||
|
# --------------------------------------------------------------------------
|
||||||
|
FONT_SIZE = 48
|
||||||
|
FONT_SIZE_SMALL = 34
|
||||||
|
TITLE_TEXT = WINDOW_TITLE
|
||||||
|
NEXT_LABEL = "Next:"
|
||||||
|
NEXT_PREVIEW_COUNT = 3
|
||||||
|
NEXT_PREVIEW_SCALE = 0.6 # Vorschau-Koffer sind kleiner als im Auflieger
|
||||||
|
NEXT_PREVIEW_MARGIN = 20
|
||||||
|
HINT_SNAP = "Snap bereit!"
|
||||||
|
HINT_STACK = "OnTop möglich!"
|
||||||
|
GAME_OVER_GOOD = "Gratuliere {name}! Du hast {percent}% geladen!"
|
||||||
|
GAME_OVER_NORMAL = "{name}, du hast {percent}% geladen."
|
||||||
|
GAME_OVER_HINT = "Drücke A oder SPACE um zu beenden."
|
||||||
|
GAME_OVER_GOOD_PERCENT = 75
|
||||||
|
|
||||||
|
# --------------------------------------------------------------------------
|
||||||
|
# Spieler / Punkte-Server
|
||||||
|
# --------------------------------------------------------------------------
|
||||||
|
DEFAULT_PLAYER_NAME = "Spieler"
|
||||||
|
MAX_PLAYER_NAME_LENGTH = 14
|
||||||
|
|
||||||
|
# Der Punkte-Upload ist standardmässig deaktiviert. Zum Aktivieren:
|
||||||
|
# export HAG_SCORE_URL="https://…/api/submit_points.php"
|
||||||
|
# export HAG_SCORE_API_KEY="…"
|
||||||
|
# (Schlüssel gehören in die Umgebung, nicht in den Quellcode.)
|
||||||
|
SCORE_URL = os.environ.get("HAG_SCORE_URL", "")
|
||||||
|
SCORE_API_KEY = os.environ.get("HAG_SCORE_API_KEY", "")
|
||||||
|
SCORE_TIMEOUT = 5.0
|
||||||
@@ -0,0 +1,333 @@
|
|||||||
|
"""Zustandsmaschine des Spiels: Koffer einlaufen lassen, stapeln, auswerten."""
|
||||||
|
|
||||||
|
from __future__ import annotations
|
||||||
|
|
||||||
|
import enum
|
||||||
|
import random
|
||||||
|
from dataclasses import dataclass
|
||||||
|
|
||||||
|
from . import config, scene
|
||||||
|
from .case import Case
|
||||||
|
from .input_map import Action
|
||||||
|
from .net import submit_score
|
||||||
|
from .sequences import CaseSpec, FALLBACK_SEQUENCE
|
||||||
|
from .trailer import Trailer
|
||||||
|
|
||||||
|
|
||||||
|
class State(enum.Enum):
|
||||||
|
PLAYING = "playing"
|
||||||
|
GAME_OVER = "game_over"
|
||||||
|
|
||||||
|
|
||||||
|
@dataclass
|
||||||
|
class Animation:
|
||||||
|
"""Kurze Zwischenanimation für den aktuellen Koffer."""
|
||||||
|
|
||||||
|
kind: str # "snap" | "rotate" | "stack"
|
||||||
|
duration: float
|
||||||
|
start_x: float
|
||||||
|
start_y: float
|
||||||
|
target_x: float = 0.0
|
||||||
|
target_y: float = 0.0
|
||||||
|
base: Case | None = None
|
||||||
|
elapsed: float = 0.0
|
||||||
|
|
||||||
|
@property
|
||||||
|
def progress(self) -> float:
|
||||||
|
if self.duration <= 0:
|
||||||
|
return 1.0
|
||||||
|
return min(1.0, self.elapsed / self.duration)
|
||||||
|
|
||||||
|
|
||||||
|
class Game:
|
||||||
|
def __init__(
|
||||||
|
self,
|
||||||
|
assets,
|
||||||
|
sequences,
|
||||||
|
*,
|
||||||
|
name: str = config.DEFAULT_PLAYER_NAME,
|
||||||
|
rng: random.Random | None = None,
|
||||||
|
submit_scores: bool = True,
|
||||||
|
) -> None:
|
||||||
|
self.assets = assets
|
||||||
|
self.rng = rng or random.Random()
|
||||||
|
self.name = name
|
||||||
|
self.submit_scores = submit_scores
|
||||||
|
|
||||||
|
self.state = State.PLAYING
|
||||||
|
self.trailer = Trailer()
|
||||||
|
source = sequences if sequences else [list(FALLBACK_SEQUENCE)]
|
||||||
|
self.sequence: list[CaseSpec] = list(self.rng.choice(source))
|
||||||
|
|
||||||
|
self.index = 0
|
||||||
|
self.current: Case | None = None
|
||||||
|
self.animation: Animation | None = None
|
||||||
|
self.shake = 0.0
|
||||||
|
self.percent = 0.0
|
||||||
|
self.status_line = ""
|
||||||
|
self.status_is_error = False
|
||||||
|
|
||||||
|
self._spawn()
|
||||||
|
|
||||||
|
# ------------------------------------------------------------------
|
||||||
|
# Sequenz / Nachschub
|
||||||
|
# ------------------------------------------------------------------
|
||||||
|
def has_next(self) -> bool:
|
||||||
|
return self.index < len(self.sequence)
|
||||||
|
|
||||||
|
def upcoming(self, count: int = config.NEXT_PREVIEW_COUNT) -> list[CaseSpec]:
|
||||||
|
"""Die nächsten Koffer für die "Next"-Vorschau."""
|
||||||
|
return self.sequence[self.index : self.index + count]
|
||||||
|
|
||||||
|
def _spawn(self) -> None:
|
||||||
|
if not self.has_next():
|
||||||
|
self.current = None
|
||||||
|
self._finish()
|
||||||
|
return
|
||||||
|
spec = self.sequence[self.index]
|
||||||
|
self.index += 1
|
||||||
|
self.current = Case(
|
||||||
|
units_w=spec.units_w,
|
||||||
|
units_h=spec.units_h,
|
||||||
|
x=float(config.SCREEN_WIDTH),
|
||||||
|
y=float(config.TRAILER_BOTTOM - spec.units_h * config.UNIT_HEIGHT),
|
||||||
|
color=self.rng.choice(config.CASE_COLORS),
|
||||||
|
)
|
||||||
|
self._play("roll", loops=-1)
|
||||||
|
|
||||||
|
# ------------------------------------------------------------------
|
||||||
|
# Eingabe
|
||||||
|
# ------------------------------------------------------------------
|
||||||
|
def handle(self, action: Action) -> bool:
|
||||||
|
"""Verarbeitet eine Aktion. Rückgabe ``False`` = Spiel beenden."""
|
||||||
|
if action is Action.BACK:
|
||||||
|
return False
|
||||||
|
|
||||||
|
if self.state is State.GAME_OVER:
|
||||||
|
return action is not Action.PRIMARY
|
||||||
|
|
||||||
|
if self.animation is not None or self.current is None:
|
||||||
|
return True
|
||||||
|
|
||||||
|
case = self.current
|
||||||
|
if case.placed or not case.allow_snap:
|
||||||
|
return True
|
||||||
|
|
||||||
|
if action is Action.PRIMARY:
|
||||||
|
self._start_snap(case)
|
||||||
|
elif action is Action.LEFT:
|
||||||
|
self._start_rotate(case)
|
||||||
|
elif action is Action.UP:
|
||||||
|
self._start_stack(case)
|
||||||
|
return True
|
||||||
|
|
||||||
|
def _start_snap(self, case: Case) -> None:
|
||||||
|
self._stop_roll()
|
||||||
|
self.animation = Animation(
|
||||||
|
kind="snap",
|
||||||
|
duration=config.ANIM_SNAP,
|
||||||
|
start_x=case.x,
|
||||||
|
start_y=case.y,
|
||||||
|
target_x=self.trailer.wall_x,
|
||||||
|
target_y=case.y,
|
||||||
|
)
|
||||||
|
|
||||||
|
def _start_rotate(self, case: Case) -> None:
|
||||||
|
if not case.can_rotate or not case.fits_trailer_height():
|
||||||
|
return
|
||||||
|
self._stop_roll()
|
||||||
|
self.animation = Animation(
|
||||||
|
kind="rotate",
|
||||||
|
duration=config.ANIM_ROTATE,
|
||||||
|
start_x=case.x,
|
||||||
|
start_y=case.y,
|
||||||
|
)
|
||||||
|
|
||||||
|
def _start_stack(self, case: Case) -> None:
|
||||||
|
base = self.trailer.find_platform(case)
|
||||||
|
if base is not None:
|
||||||
|
self._stop_roll()
|
||||||
|
self.animation = Animation(
|
||||||
|
kind="stack",
|
||||||
|
duration=config.ANIM_STACK_STEP * 2,
|
||||||
|
start_x=case.x,
|
||||||
|
start_y=case.y,
|
||||||
|
target_x=base.right - case.width,
|
||||||
|
target_y=base.y - case.height,
|
||||||
|
base=base,
|
||||||
|
)
|
||||||
|
return
|
||||||
|
# Kein Platz obendrauf: wie im Altstand wird der Koffer mit Lücke
|
||||||
|
# eingereiht und das Spiel schüttelt sich.
|
||||||
|
self._stack_with_gap(case, sound="place")
|
||||||
|
|
||||||
|
# ------------------------------------------------------------------
|
||||||
|
# Update
|
||||||
|
# ------------------------------------------------------------------
|
||||||
|
def update(self, dt: float) -> None:
|
||||||
|
if self.shake > 0:
|
||||||
|
self.shake = max(0.0, self.shake - dt)
|
||||||
|
if self.state is not State.PLAYING:
|
||||||
|
return
|
||||||
|
|
||||||
|
if self.animation is not None:
|
||||||
|
self._advance_animation(dt)
|
||||||
|
return
|
||||||
|
|
||||||
|
case = self.current
|
||||||
|
if case is None:
|
||||||
|
self._finish()
|
||||||
|
return
|
||||||
|
|
||||||
|
case.move(dt, self.trailer.wall_x)
|
||||||
|
if not case.placed and case.x <= self.trailer.wall_x:
|
||||||
|
self._stack_with_gap(case, sound="fail")
|
||||||
|
return
|
||||||
|
self._check_dead_end(case)
|
||||||
|
|
||||||
|
def _advance_animation(self, dt: float) -> None:
|
||||||
|
animation = self.animation
|
||||||
|
case = self.current
|
||||||
|
if animation is None or case is None:
|
||||||
|
self.animation = None
|
||||||
|
return
|
||||||
|
|
||||||
|
animation.elapsed += dt
|
||||||
|
progress = animation.progress
|
||||||
|
|
||||||
|
if animation.kind == "snap":
|
||||||
|
case.x = animation.start_x + (animation.target_x - animation.start_x) * progress
|
||||||
|
elif animation.kind == "stack":
|
||||||
|
if progress <= 0.5:
|
||||||
|
factor = progress / 0.5
|
||||||
|
case.y = animation.start_y + (animation.target_y - animation.start_y) * factor
|
||||||
|
else:
|
||||||
|
factor = (progress - 0.5) / 0.5
|
||||||
|
case.y = animation.target_y
|
||||||
|
case.x = animation.start_x + (animation.target_x - animation.start_x) * factor
|
||||||
|
|
||||||
|
if progress >= 1.0:
|
||||||
|
self._finish_animation(animation)
|
||||||
|
|
||||||
|
def _finish_animation(self, animation: Animation) -> None:
|
||||||
|
self.animation = None
|
||||||
|
case = self.current
|
||||||
|
if case is None:
|
||||||
|
return
|
||||||
|
|
||||||
|
if animation.kind == "rotate":
|
||||||
|
case.rotate_footprint()
|
||||||
|
case.y = float(config.TRAILER_BOTTOM - case.height)
|
||||||
|
case.x = max(self.trailer.wall_x + config.SNAP_THRESHOLD // 2, case.x)
|
||||||
|
case.can_rotate = False
|
||||||
|
return
|
||||||
|
|
||||||
|
case.x, case.y = animation.target_x, animation.target_y
|
||||||
|
if animation.kind == "snap":
|
||||||
|
self.trailer.stack_at_wall(case)
|
||||||
|
else:
|
||||||
|
self.trailer.place_on_top(case, animation.base)
|
||||||
|
self._play("place")
|
||||||
|
self._next_round()
|
||||||
|
|
||||||
|
def _stack_with_gap(self, case: Case, *, sound: str) -> None:
|
||||||
|
self._stop_roll()
|
||||||
|
self.trailer.stack_with_gap(case)
|
||||||
|
if case.right > self.trailer.right:
|
||||||
|
self.trailer.remove(case)
|
||||||
|
self._play(sound)
|
||||||
|
self.shake = config.SHAKE_TIME
|
||||||
|
self._next_round()
|
||||||
|
|
||||||
|
def _next_round(self) -> None:
|
||||||
|
if self.trailer.overflow():
|
||||||
|
self._finish()
|
||||||
|
return
|
||||||
|
self._spawn()
|
||||||
|
|
||||||
|
def _check_dead_end(self, case: Case) -> None:
|
||||||
|
"""Ist der Koffer weder einrastbar, noch stapelbar, noch drehbar?"""
|
||||||
|
if case.allow_snap:
|
||||||
|
return
|
||||||
|
if self.trailer.wall_x + case.width <= self.trailer.right:
|
||||||
|
return
|
||||||
|
if self.trailer.find_platform(case) is not None:
|
||||||
|
return
|
||||||
|
if case.can_rotate and case.fits_trailer_height():
|
||||||
|
return
|
||||||
|
self._finish()
|
||||||
|
|
||||||
|
def _finish(self) -> None:
|
||||||
|
if self.state is State.GAME_OVER:
|
||||||
|
return
|
||||||
|
self.state = State.GAME_OVER
|
||||||
|
self._stop_roll()
|
||||||
|
self.percent = self.trailer.load_percent()
|
||||||
|
if self.percent >= 99.9:
|
||||||
|
self.percent = 100.0
|
||||||
|
if self.submit_scores:
|
||||||
|
ok, message = submit_score(self.name, self.percent)
|
||||||
|
if ok or config.SCORE_URL:
|
||||||
|
self.status_line = message
|
||||||
|
self.status_is_error = not ok
|
||||||
|
|
||||||
|
# ------------------------------------------------------------------
|
||||||
|
# Zeichnen
|
||||||
|
# ------------------------------------------------------------------
|
||||||
|
def draw(self, surface) -> None:
|
||||||
|
assets = self.assets
|
||||||
|
scene.draw_top_bar(surface, assets, self.trailer.load_percent())
|
||||||
|
scene.draw_background(surface, assets)
|
||||||
|
|
||||||
|
offset = (0, 0)
|
||||||
|
if self.shake > 0:
|
||||||
|
offset = (
|
||||||
|
self.rng.randint(-config.SHAKE_AMPLITUDE, config.SHAKE_AMPLITUDE),
|
||||||
|
self.rng.randint(-config.SHAKE_AMPLITUDE, config.SHAKE_AMPLITUDE),
|
||||||
|
)
|
||||||
|
scene.draw_trailer(surface, offset)
|
||||||
|
for stacked in self.trailer.stack:
|
||||||
|
scene.draw_case(surface, assets, stacked)
|
||||||
|
|
||||||
|
case = self.current
|
||||||
|
if case is not None:
|
||||||
|
angle = 0.0
|
||||||
|
if self.animation is not None and self.animation.kind == "rotate":
|
||||||
|
angle = -90.0 * self.animation.progress
|
||||||
|
scene.draw_case(surface, assets, case, angle=angle)
|
||||||
|
|
||||||
|
scene.draw_wall(surface, self.trailer.wall_x, offset)
|
||||||
|
scene.draw_bottom_bar(surface, assets, self.upcoming())
|
||||||
|
|
||||||
|
if case is not None and case.allow_snap and self.state is State.PLAYING:
|
||||||
|
scene.draw_hint(
|
||||||
|
surface, assets, self.trailer.find_platform(case) is not None
|
||||||
|
)
|
||||||
|
|
||||||
|
if self.state is State.GAME_OVER:
|
||||||
|
scene.draw_overlay_lines(
|
||||||
|
surface,
|
||||||
|
assets,
|
||||||
|
self.game_over_lines(),
|
||||||
|
status=self.status_line,
|
||||||
|
status_color=config.COLOR_ERROR if self.status_is_error else config.COLOR_HINT_SNAP,
|
||||||
|
)
|
||||||
|
|
||||||
|
def game_over_lines(self) -> list[str]:
|
||||||
|
percent = int(self.percent)
|
||||||
|
if self.percent >= config.GAME_OVER_GOOD_PERCENT:
|
||||||
|
first = config.GAME_OVER_GOOD.format(name=self.name, percent=percent)
|
||||||
|
else:
|
||||||
|
first = config.GAME_OVER_NORMAL.format(name=self.name, percent=percent)
|
||||||
|
return [first, config.GAME_OVER_HINT]
|
||||||
|
|
||||||
|
# ------------------------------------------------------------------
|
||||||
|
# Hilfen
|
||||||
|
# ------------------------------------------------------------------
|
||||||
|
def _play(self, name: str, loops: int = 0) -> None:
|
||||||
|
if self.assets is not None:
|
||||||
|
self.assets.play(name, loops=loops)
|
||||||
|
|
||||||
|
def _stop_roll(self) -> None:
|
||||||
|
if self.assets is not None:
|
||||||
|
self.assets.stop_roll()
|
||||||
@@ -0,0 +1,108 @@
|
|||||||
|
"""Tastatur und Controller → abstrakte Aktionen.
|
||||||
|
|
||||||
|
Die Aktionen sind absichtlich generisch gehalten. Die spätere Namenseingabe
|
||||||
|
per Controller benutzt dieselben Richtungen (Buchstabe weiter/zurück,
|
||||||
|
Position wechseln), deshalb gibt es hier keine spielspezifischen Namen.
|
||||||
|
"""
|
||||||
|
|
||||||
|
from __future__ import annotations
|
||||||
|
|
||||||
|
import enum
|
||||||
|
|
||||||
|
import pygame
|
||||||
|
|
||||||
|
from . import config
|
||||||
|
|
||||||
|
|
||||||
|
class Action(enum.Enum):
|
||||||
|
"""Abstrakte Eingabe – unabhängig davon, ob Tastatur oder Controller."""
|
||||||
|
|
||||||
|
PRIMARY = "primary" # Space / Enter / Controller A
|
||||||
|
LEFT = "left" # Pfeil links / D-Pad links
|
||||||
|
RIGHT = "right" # Pfeil rechts / D-Pad rechts
|
||||||
|
UP = "up" # Pfeil hoch / D-Pad hoch
|
||||||
|
DOWN = "down" # Pfeil runter / D-Pad runter
|
||||||
|
BACK = "back" # Esc / Controller B
|
||||||
|
|
||||||
|
|
||||||
|
#: Tastaturbelegung
|
||||||
|
KEY_ACTIONS: dict[int, Action] = {
|
||||||
|
pygame.K_SPACE: Action.PRIMARY,
|
||||||
|
pygame.K_RETURN: Action.PRIMARY,
|
||||||
|
pygame.K_KP_ENTER: Action.PRIMARY,
|
||||||
|
pygame.K_LEFT: Action.LEFT,
|
||||||
|
pygame.K_RIGHT: Action.RIGHT,
|
||||||
|
pygame.K_UP: Action.UP,
|
||||||
|
pygame.K_DOWN: Action.DOWN,
|
||||||
|
pygame.K_ESCAPE: Action.BACK,
|
||||||
|
}
|
||||||
|
|
||||||
|
#: Controller-Tasten (Xbox-Layout: 0=A, 1=B, 2=X, 3=Y)
|
||||||
|
BUTTON_ACTIONS: dict[int, Action] = {
|
||||||
|
0: Action.PRIMARY,
|
||||||
|
1: Action.BACK,
|
||||||
|
2: Action.LEFT,
|
||||||
|
3: Action.UP,
|
||||||
|
}
|
||||||
|
|
||||||
|
#: D-Pad, das als Hat gemeldet wird
|
||||||
|
HAT_ACTIONS: dict[tuple[int, int], Action] = {
|
||||||
|
(-1, 0): Action.LEFT,
|
||||||
|
(1, 0): Action.RIGHT,
|
||||||
|
(0, -1): Action.UP,
|
||||||
|
(0, 1): Action.DOWN,
|
||||||
|
}
|
||||||
|
|
||||||
|
#: Analogstick: ab diesem Ausschlag gilt eine Richtung als gewollt
|
||||||
|
AXIS_DEADZONE = 0.6
|
||||||
|
|
||||||
|
|
||||||
|
def actions_from_event(event: pygame.event.Event) -> list[Action]:
|
||||||
|
"""Übersetzt ein pygame-Event in null bis eine Aktion."""
|
||||||
|
if event.type == pygame.KEYDOWN:
|
||||||
|
action = KEY_ACTIONS.get(event.key)
|
||||||
|
return [action] if action else []
|
||||||
|
|
||||||
|
if event.type == pygame.JOYBUTTONDOWN:
|
||||||
|
action = BUTTON_ACTIONS.get(event.button)
|
||||||
|
return [action] if action else []
|
||||||
|
|
||||||
|
if event.type == pygame.JOYHATMOTION:
|
||||||
|
action = HAT_ACTIONS.get(tuple(event.value))
|
||||||
|
return [action] if action else []
|
||||||
|
|
||||||
|
if event.type == pygame.JOYAXISMOTION:
|
||||||
|
if event.axis == 0 and abs(event.value) >= AXIS_DEADZONE:
|
||||||
|
return [Action.RIGHT if event.value > 0 else Action.LEFT]
|
||||||
|
if event.axis == 1 and abs(event.value) >= AXIS_DEADZONE:
|
||||||
|
return [Action.DOWN if event.value > 0 else Action.UP]
|
||||||
|
return []
|
||||||
|
|
||||||
|
|
||||||
|
def connected_controllers() -> list[str]:
|
||||||
|
"""Namen aller angeschlossenen Controller (leer, wenn keiner da ist)."""
|
||||||
|
names = []
|
||||||
|
for index in range(pygame.joystick.get_count()):
|
||||||
|
try:
|
||||||
|
stick = pygame.joystick.Joystick(index)
|
||||||
|
stick.init()
|
||||||
|
names.append(stick.get_name())
|
||||||
|
except pygame.error:
|
||||||
|
continue
|
||||||
|
return names
|
||||||
|
|
||||||
|
|
||||||
|
def describe_controller_setup() -> str:
|
||||||
|
names = connected_controllers()
|
||||||
|
if not names:
|
||||||
|
return "Controller: keiner erkannt (Tastatur: Space=Snap, ←=Drehen, ↑=OnTop, Esc=Ende)"
|
||||||
|
return "Controller: " + ", ".join(names)
|
||||||
|
|
||||||
|
|
||||||
|
def controller_hint_lines() -> list[str]:
|
||||||
|
"""Kurzhilfe fürs Log beim Start."""
|
||||||
|
return [
|
||||||
|
describe_controller_setup(),
|
||||||
|
f"Zielauflösung {config.SCREEN_WIDTH}x{config.SCREEN_HEIGHT}, "
|
||||||
|
f"{config.FPS} fps",
|
||||||
|
]
|
||||||
@@ -0,0 +1,82 @@
|
|||||||
|
"""Tutorialbild, Ampel-Startsequenz und Reissverschluss-Effekt."""
|
||||||
|
|
||||||
|
from __future__ import annotations
|
||||||
|
|
||||||
|
import pygame
|
||||||
|
|
||||||
|
from . import config, scene
|
||||||
|
from .input_map import Action
|
||||||
|
|
||||||
|
|
||||||
|
class Intro:
|
||||||
|
"""Vorspann vor dem ersten Koffer.
|
||||||
|
|
||||||
|
Ablauf: Tutorialbild (wartet auf Bestätigung) → drei Punkte mit Ton →
|
||||||
|
Reissverschluss, der den Auflieger "öffnet".
|
||||||
|
"""
|
||||||
|
|
||||||
|
def __init__(self, assets) -> None:
|
||||||
|
self.assets = assets
|
||||||
|
self.phase = "instruction" if assets.instruction is not None else "countdown"
|
||||||
|
self.timer = 0.0
|
||||||
|
self.dot_index = 0
|
||||||
|
if self.phase == "countdown":
|
||||||
|
self._start_countdown()
|
||||||
|
|
||||||
|
# ------------------------------------------------------------------
|
||||||
|
def _start_countdown(self) -> None:
|
||||||
|
self.phase = "countdown"
|
||||||
|
self.timer = 0.0
|
||||||
|
self.dot_index = 0
|
||||||
|
self.assets.play("beep1")
|
||||||
|
|
||||||
|
def handle(self, action: Action) -> None:
|
||||||
|
if self.phase == "instruction" and action is Action.PRIMARY:
|
||||||
|
self._start_countdown()
|
||||||
|
|
||||||
|
def update(self, dt: float) -> bool:
|
||||||
|
"""Weiterrechnen; Rückgabe ``True``, wenn der Vorspann fertig ist."""
|
||||||
|
self.timer += dt
|
||||||
|
if self.phase == "countdown":
|
||||||
|
index = int(self.timer // config.INTRO_DOT_DELAY)
|
||||||
|
if index >= len(config.INTRO_DOT_COLORS):
|
||||||
|
self.phase = "zip"
|
||||||
|
self.timer = 0.0
|
||||||
|
self.assets.play("zip")
|
||||||
|
elif index != self.dot_index:
|
||||||
|
self.dot_index = index
|
||||||
|
self.assets.play(f"beep{index + 1}")
|
||||||
|
return False
|
||||||
|
if self.phase == "zip":
|
||||||
|
return self.timer >= config.INTRO_ZIP_DURATION
|
||||||
|
return False
|
||||||
|
|
||||||
|
# ------------------------------------------------------------------
|
||||||
|
def draw(self, surface: pygame.Surface) -> None:
|
||||||
|
if self.phase == "instruction":
|
||||||
|
surface.blit(self.assets.instruction, (0, 0))
|
||||||
|
return
|
||||||
|
|
||||||
|
scene.draw_top_bar(surface, self.assets, 0.0)
|
||||||
|
scene.draw_background(surface, self.assets)
|
||||||
|
scene.draw_bottom_bar(surface, self.assets, [])
|
||||||
|
|
||||||
|
if self.phase == "countdown":
|
||||||
|
if 0 <= self.dot_index < len(config.INTRO_DOT_COLORS):
|
||||||
|
pygame.draw.circle(
|
||||||
|
surface,
|
||||||
|
config.INTRO_DOT_COLORS[self.dot_index],
|
||||||
|
(
|
||||||
|
config.TRAILER_X + config.TRAILER_WIDTH // 2,
|
||||||
|
config.TRAILER_Y + config.TRAILER_HEIGHT // 2,
|
||||||
|
),
|
||||||
|
config.INTRO_DOT_RADIUS,
|
||||||
|
)
|
||||||
|
elif self.phase == "zip":
|
||||||
|
progress = min(1.0, self.timer / config.INTRO_ZIP_DURATION) if config.INTRO_ZIP_DURATION else 1.0
|
||||||
|
width = int(config.TRAILER_WIDTH * progress)
|
||||||
|
pygame.draw.rect(
|
||||||
|
surface,
|
||||||
|
config.COLOR_TRAILER,
|
||||||
|
(config.TRAILER_X, config.TRAILER_Y, width, config.TRAILER_HEIGHT),
|
||||||
|
)
|
||||||
@@ -0,0 +1,47 @@
|
|||||||
|
"""Optionaler Punkte-Upload.
|
||||||
|
|
||||||
|
Standardmässig **deaktiviert**: Es passiert nichts, solange ``HAG_SCORE_URL``
|
||||||
|
nicht gesetzt ist. Zugangsdaten kommen aus der Umgebung
|
||||||
|
(``HAG_SCORE_API_KEY``) – nicht aus dem Quellcode.
|
||||||
|
"""
|
||||||
|
|
||||||
|
from __future__ import annotations
|
||||||
|
|
||||||
|
import urllib.error
|
||||||
|
import urllib.parse
|
||||||
|
import urllib.request
|
||||||
|
|
||||||
|
from . import config
|
||||||
|
|
||||||
|
|
||||||
|
def submit_score(
|
||||||
|
name: str,
|
||||||
|
percent: float,
|
||||||
|
*,
|
||||||
|
url: str | None = None,
|
||||||
|
api_key: str | None = None,
|
||||||
|
timeout: float | None = None,
|
||||||
|
) -> tuple[bool, str]:
|
||||||
|
"""Sendet das Ergebnis. Rückgabe: ``(erfolgreich, meldung)``."""
|
||||||
|
endpoint = url if url is not None else config.SCORE_URL
|
||||||
|
if not endpoint:
|
||||||
|
return False, ""
|
||||||
|
|
||||||
|
payload = urllib.parse.urlencode(
|
||||||
|
{
|
||||||
|
"name": name,
|
||||||
|
"score": int(percent),
|
||||||
|
"api_key": api_key if api_key is not None else config.SCORE_API_KEY,
|
||||||
|
}
|
||||||
|
).encode("utf-8")
|
||||||
|
|
||||||
|
try:
|
||||||
|
request = urllib.request.Request(endpoint, data=payload)
|
||||||
|
with urllib.request.urlopen(request, timeout=timeout or config.SCORE_TIMEOUT) as response:
|
||||||
|
body = response.read().decode("utf-8", "replace")
|
||||||
|
except (urllib.error.URLError, OSError, ValueError) as exc:
|
||||||
|
return False, f"Punkte konnten nicht gesendet werden: {exc}"
|
||||||
|
|
||||||
|
if "success" not in body.lower():
|
||||||
|
return False, "Punkte konnten nicht gesendet werden (unerwartete Serverantwort)."
|
||||||
|
return True, "Punkte gesendet."
|
||||||
@@ -0,0 +1,205 @@
|
|||||||
|
"""Zeichenroutinen – alles, was Pixel auf den Bildschirm bringt."""
|
||||||
|
|
||||||
|
from __future__ import annotations
|
||||||
|
|
||||||
|
import pygame
|
||||||
|
|
||||||
|
from . import config
|
||||||
|
from .case import Case
|
||||||
|
from .sequences import CaseSpec
|
||||||
|
|
||||||
|
|
||||||
|
# --------------------------------------------------------------------------
|
||||||
|
# Hintergrund-Bänder
|
||||||
|
# --------------------------------------------------------------------------
|
||||||
|
def draw_top_bar(surface: pygame.Surface, assets, percent: float) -> None:
|
||||||
|
surface.fill(
|
||||||
|
config.COLOR_TOP_BAR, (0, 0, config.SCREEN_WIDTH, config.TOP_BAR_HEIGHT)
|
||||||
|
)
|
||||||
|
font = assets.font
|
||||||
|
title = font.render(config.TITLE_TEXT, True, config.COLOR_WHITE)
|
||||||
|
surface.blit(title, (40, config.TOP_BAR_HEIGHT // 2 - title.get_height() // 2))
|
||||||
|
_draw_progress_bar(surface, assets, percent)
|
||||||
|
|
||||||
|
|
||||||
|
def _draw_progress_bar(surface: pygame.Surface, assets, percent: float) -> None:
|
||||||
|
bar_width = config.PROGRESS_BAR_WIDTH
|
||||||
|
bar_height = config.PROGRESS_BAR_HEIGHT
|
||||||
|
x = config.SCREEN_WIDTH - bar_width - config.PROGRESS_BAR_RIGHT_MARGIN
|
||||||
|
y = config.TOP_BAR_HEIGHT // 2 - bar_height // 2
|
||||||
|
gap = config.PROGRESS_BAR_GAP
|
||||||
|
segment_width = (bar_width - (config.PROGRESS_BAR_SEGMENTS - 1) * gap) / config.PROGRESS_BAR_SEGMENTS
|
||||||
|
|
||||||
|
red = min(255, int(percent * 2.55))
|
||||||
|
green = max(0, 255 - int(percent * 2.55))
|
||||||
|
color = (red, green, 0)
|
||||||
|
|
||||||
|
for index in range(config.PROGRESS_BAR_SEGMENTS):
|
||||||
|
segment_x = x + index * (segment_width + gap)
|
||||||
|
rect = (segment_x, y, segment_width, bar_height)
|
||||||
|
pygame.draw.rect(surface, config.COLOR_PROGRESS_TRACK, rect, border_radius=config.PROGRESS_BAR_RADIUS)
|
||||||
|
if percent >= (index + 1) * 20:
|
||||||
|
pygame.draw.rect(surface, color, rect, border_radius=config.PROGRESS_BAR_RADIUS)
|
||||||
|
|
||||||
|
text = assets.font.render(f"{int(percent)}%", True, config.COLOR_WHITE)
|
||||||
|
surface.blit(text, (x + bar_width + 10, y))
|
||||||
|
|
||||||
|
|
||||||
|
def draw_background(surface: pygame.Surface, assets) -> None:
|
||||||
|
if assets.background is not None:
|
||||||
|
surface.blit(assets.background, (0, config.TOP_BAR_HEIGHT))
|
||||||
|
else:
|
||||||
|
pygame.draw.rect(
|
||||||
|
surface,
|
||||||
|
config.COLOR_BACKGROUND,
|
||||||
|
(0, config.TOP_BAR_HEIGHT, config.SCREEN_WIDTH, config.GAME_AREA_HEIGHT),
|
||||||
|
)
|
||||||
|
|
||||||
|
|
||||||
|
def draw_bottom_bar(surface: pygame.Surface, assets, upcoming: list[CaseSpec]) -> None:
|
||||||
|
surface.fill(
|
||||||
|
config.COLOR_BOTTOM_BAR,
|
||||||
|
(0, config.TOP_BAR_HEIGHT + config.GAME_AREA_HEIGHT, config.SCREEN_WIDTH, config.BOTTOM_BAR_HEIGHT),
|
||||||
|
)
|
||||||
|
top = config.SCREEN_HEIGHT - config.BOTTOM_BAR_HEIGHT
|
||||||
|
label = (assets.font_small or assets.font).render(config.NEXT_LABEL, True, config.COLOR_WHITE)
|
||||||
|
surface.blit(label, (40, top + 12))
|
||||||
|
|
||||||
|
preview_x = 40
|
||||||
|
for index, spec in enumerate(upcoming[: config.NEXT_PREVIEW_COUNT]):
|
||||||
|
image = _preview_surface(assets, spec)
|
||||||
|
height = image.get_height() if image is not None else 0
|
||||||
|
y = config.SCREEN_HEIGHT - config.NEXT_PREVIEW_MARGIN - height
|
||||||
|
if image is None:
|
||||||
|
width, height = _spec_size(spec)
|
||||||
|
y = config.SCREEN_HEIGHT - config.NEXT_PREVIEW_MARGIN - height
|
||||||
|
pygame.draw.rect(
|
||||||
|
surface,
|
||||||
|
config.CASE_COLORS[index % len(config.CASE_COLORS)],
|
||||||
|
(preview_x, y, width, height),
|
||||||
|
)
|
||||||
|
else:
|
||||||
|
width = image.get_width()
|
||||||
|
surface.blit(image, (preview_x, y))
|
||||||
|
preview_x += max(width, 60) + 20
|
||||||
|
|
||||||
|
|
||||||
|
_PREVIEW_CACHE: dict[tuple[int, int], pygame.Surface | None] = {}
|
||||||
|
|
||||||
|
|
||||||
|
def _preview_surface(assets, spec: CaseSpec) -> pygame.Surface | None:
|
||||||
|
"""Vorschau-Grafik in verkleinertem Massstab (gecacht)."""
|
||||||
|
key = (spec.units_w, spec.units_h)
|
||||||
|
if key in _PREVIEW_CACHE:
|
||||||
|
return _PREVIEW_CACHE[key]
|
||||||
|
image = assets.case_surface(spec.units_w, spec.units_h) if assets is not None else None
|
||||||
|
if image is not None:
|
||||||
|
size = (
|
||||||
|
max(1, int(image.get_width() * config.NEXT_PREVIEW_SCALE)),
|
||||||
|
max(1, int(image.get_height() * config.NEXT_PREVIEW_SCALE)),
|
||||||
|
)
|
||||||
|
image = pygame.transform.smoothscale(image, size)
|
||||||
|
_PREVIEW_CACHE[key] = image
|
||||||
|
return image
|
||||||
|
|
||||||
|
|
||||||
|
# --------------------------------------------------------------------------
|
||||||
|
# Auflieger
|
||||||
|
# --------------------------------------------------------------------------
|
||||||
|
def draw_trailer(surface: pygame.Surface, offset: tuple[int, int] = (0, 0)) -> None:
|
||||||
|
pygame.draw.rect(
|
||||||
|
surface,
|
||||||
|
config.COLOR_TRAILER,
|
||||||
|
(
|
||||||
|
config.TRAILER_X + offset[0],
|
||||||
|
config.TRAILER_Y + offset[1],
|
||||||
|
config.TRAILER_WIDTH,
|
||||||
|
config.TRAILER_HEIGHT,
|
||||||
|
),
|
||||||
|
)
|
||||||
|
|
||||||
|
|
||||||
|
def draw_wall(surface: pygame.Surface, wall_x: float, offset: tuple[int, int] = (0, 0)) -> None:
|
||||||
|
pygame.draw.line(
|
||||||
|
surface,
|
||||||
|
config.COLOR_WALL,
|
||||||
|
(wall_x + offset[0], config.TRAILER_Y + offset[1]),
|
||||||
|
(wall_x + offset[0], config.TRAILER_BOTTOM + offset[1]),
|
||||||
|
3,
|
||||||
|
)
|
||||||
|
|
||||||
|
|
||||||
|
# --------------------------------------------------------------------------
|
||||||
|
# Koffer
|
||||||
|
# --------------------------------------------------------------------------
|
||||||
|
def _spec_size(spec: CaseSpec) -> tuple[int, int]:
|
||||||
|
return (
|
||||||
|
int(spec.units_w * config.UNIT_LENGTH),
|
||||||
|
int(spec.units_h * config.UNIT_HEIGHT),
|
||||||
|
)
|
||||||
|
|
||||||
|
|
||||||
|
def draw_case(surface: pygame.Surface, assets, case: Case, angle: float = 0.0) -> None:
|
||||||
|
x, y = int(case.x), int(case.y)
|
||||||
|
width, height = int(case.width), int(case.height)
|
||||||
|
image = assets.case_surface(case.units_w, case.units_h) if assets is not None else None
|
||||||
|
if image is None:
|
||||||
|
pygame.draw.rect(surface, case.color, (x, y, width, height))
|
||||||
|
return
|
||||||
|
if angle:
|
||||||
|
rotated = pygame.transform.rotate(image, angle)
|
||||||
|
surface.blit(rotated, rotated.get_rect(bottomleft=(x, y + height)))
|
||||||
|
else:
|
||||||
|
surface.blit(image, (x, y))
|
||||||
|
|
||||||
|
|
||||||
|
# --------------------------------------------------------------------------
|
||||||
|
# Hinweise und Overlays
|
||||||
|
# --------------------------------------------------------------------------
|
||||||
|
def draw_hint(surface: pygame.Surface, assets, stack_possible: bool) -> None:
|
||||||
|
if stack_possible:
|
||||||
|
text, color = config.HINT_STACK, config.COLOR_HINT_STACK
|
||||||
|
else:
|
||||||
|
text, color = config.HINT_SNAP, config.COLOR_HINT_SNAP
|
||||||
|
rendered = assets.font.render(text, True, color)
|
||||||
|
surface.blit(
|
||||||
|
rendered,
|
||||||
|
(
|
||||||
|
config.SCREEN_WIDTH - config.SCREEN_WIDTH // 3 - rendered.get_width() // 2,
|
||||||
|
config.SCREEN_HEIGHT - config.BOTTOM_BAR_HEIGHT // 2 - rendered.get_height() // 2,
|
||||||
|
),
|
||||||
|
)
|
||||||
|
|
||||||
|
|
||||||
|
def draw_overlay_lines(
|
||||||
|
surface: pygame.Surface,
|
||||||
|
assets,
|
||||||
|
lines: list[str],
|
||||||
|
*,
|
||||||
|
status: str = "",
|
||||||
|
status_color: tuple[int, int, int] = config.COLOR_ERROR,
|
||||||
|
) -> None:
|
||||||
|
overlay = pygame.Surface((config.SCREEN_WIDTH, config.SCREEN_HEIGHT))
|
||||||
|
overlay.set_alpha(220)
|
||||||
|
overlay.fill((0, 0, 0))
|
||||||
|
surface.blit(overlay, (0, 0))
|
||||||
|
|
||||||
|
center_y = config.SCREEN_HEIGHT // 2
|
||||||
|
line_gap = 16
|
||||||
|
total_height = 0
|
||||||
|
rendered: list[pygame.Surface] = []
|
||||||
|
for line in lines:
|
||||||
|
image = assets.font.render(line, True, config.COLOR_WHITE)
|
||||||
|
rendered.append(image)
|
||||||
|
total_height += image.get_height() + line_gap
|
||||||
|
y = center_y - total_height // 2
|
||||||
|
for image in rendered:
|
||||||
|
surface.blit(image, (config.SCREEN_WIDTH // 2 - image.get_width() // 2, y))
|
||||||
|
y += image.get_height() + line_gap
|
||||||
|
|
||||||
|
if status:
|
||||||
|
small = assets.font_small.render(status, True, status_color)
|
||||||
|
surface.blit(
|
||||||
|
small,
|
||||||
|
(config.SCREEN_WIDTH // 2 - small.get_width() // 2, y + 20),
|
||||||
|
)
|
||||||
@@ -0,0 +1,107 @@
|
|||||||
|
"""Einlesen der Koffersequenzen aus ``case_sequences.txt``.
|
||||||
|
|
||||||
|
Dateiformat
|
||||||
|
-----------
|
||||||
|
Sequenzen sind durch Leerzeilen getrennt. Jede Zeile beschreibt einen Koffer::
|
||||||
|
|
||||||
|
breite,höhe,rotiert
|
||||||
|
|
||||||
|
* ``breite`` / ``höhe`` sind Kasten-Einheiten (1 Einheit = 100x100 Pixel).
|
||||||
|
* ``rotiert=True`` heisst: der Koffer wird beim Einlaufen um 90° gedreht,
|
||||||
|
Breite und Höhe werden also getauscht.
|
||||||
|
|
||||||
|
Beispiel::
|
||||||
|
|
||||||
|
3,1,False
|
||||||
|
1,2,True -> Koffer ist effektiv 2 Einheiten breit und 1 hoch
|
||||||
|
"""
|
||||||
|
|
||||||
|
from __future__ import annotations
|
||||||
|
|
||||||
|
import re
|
||||||
|
from dataclasses import dataclass
|
||||||
|
from pathlib import Path
|
||||||
|
|
||||||
|
from . import config
|
||||||
|
|
||||||
|
_TRUE_VALUES = {"true", "1", "ja", "yes", "x"}
|
||||||
|
|
||||||
|
|
||||||
|
@dataclass(frozen=True, slots=True)
|
||||||
|
class CaseSpec:
|
||||||
|
"""Ein Koffer aus der Sequenzdatei – bereits in Einlauf-Orientierung."""
|
||||||
|
|
||||||
|
units_w: int
|
||||||
|
units_h: int
|
||||||
|
|
||||||
|
def __post_init__(self) -> None:
|
||||||
|
if self.units_w < 1 or self.units_h < 1:
|
||||||
|
raise ValueError(f"Koffer muss mindestens 1x1 Einheiten gross sein: {self!r}")
|
||||||
|
|
||||||
|
@property
|
||||||
|
def label(self) -> str:
|
||||||
|
return f"{self.units_w}x{self.units_h}"
|
||||||
|
|
||||||
|
|
||||||
|
#: Notfall-Sequenz, falls die Datei fehlt oder unlesbar ist.
|
||||||
|
FALLBACK_SEQUENCE: tuple[CaseSpec, ...] = (CaseSpec(2, 1), CaseSpec(1, 2))
|
||||||
|
|
||||||
|
|
||||||
|
def parse_sequences(raw: str) -> tuple[list[list[CaseSpec]], list[str]]:
|
||||||
|
"""Zerlegt den Dateiinhalt in Sequenzen.
|
||||||
|
|
||||||
|
Rückgabe: ``(sequenzen, warnungen)``. Ungültige Zeilen werden gemeldet und
|
||||||
|
übersprungen – ein Tippfehler in der Datei soll das Spiel nicht verhindern.
|
||||||
|
"""
|
||||||
|
sequences: list[list[CaseSpec]] = []
|
||||||
|
warnings: list[str] = []
|
||||||
|
|
||||||
|
for block_number, block in enumerate(re.split(r"\n\s*\n", raw.strip()), start=1):
|
||||||
|
specs: list[CaseSpec] = []
|
||||||
|
for line_number, line in enumerate(block.splitlines(), start=1):
|
||||||
|
text = line.strip()
|
||||||
|
if not text:
|
||||||
|
continue
|
||||||
|
parts = [part.strip() for part in text.split(",")]
|
||||||
|
if len(parts) != 3:
|
||||||
|
warnings.append(
|
||||||
|
f"Block {block_number}, Zeile {line_number}: "
|
||||||
|
f"'breite,höhe,rotiert' erwartet, gefunden {text!r}"
|
||||||
|
)
|
||||||
|
continue
|
||||||
|
try:
|
||||||
|
units_w, units_h = int(parts[0]), int(parts[1])
|
||||||
|
except ValueError:
|
||||||
|
warnings.append(
|
||||||
|
f"Block {block_number}, Zeile {line_number}: keine ganzen Zahlen in {text!r}"
|
||||||
|
)
|
||||||
|
continue
|
||||||
|
rotated = parts[2].lower() in _TRUE_VALUES
|
||||||
|
if rotated:
|
||||||
|
units_w, units_h = units_h, units_w
|
||||||
|
if units_w < 1 or units_h < 1:
|
||||||
|
warnings.append(
|
||||||
|
f"Block {block_number}, Zeile {line_number}: ungültige Masse {text!r}"
|
||||||
|
)
|
||||||
|
continue
|
||||||
|
specs.append(CaseSpec(units_w, units_h))
|
||||||
|
if specs:
|
||||||
|
sequences.append(specs)
|
||||||
|
|
||||||
|
if not sequences:
|
||||||
|
warnings.append("Keine gültige Sequenz gefunden – es wird die Notfall-Sequenz benutzt.")
|
||||||
|
return sequences, warnings
|
||||||
|
|
||||||
|
|
||||||
|
def load_sequences(path: Path | None = None) -> tuple[list[list[CaseSpec]], list[str]]:
|
||||||
|
"""Liest die Sequenzdatei und liefert immer mindestens eine Sequenz."""
|
||||||
|
path = path or config.SEQUENCES_FILE
|
||||||
|
try:
|
||||||
|
raw = path.read_text(encoding="utf-8")
|
||||||
|
except OSError as exc:
|
||||||
|
return [list(FALLBACK_SEQUENCE)], [f"Sequenzdatei {path} nicht lesbar: {exc}"]
|
||||||
|
|
||||||
|
sequences, warnings = parse_sequences(raw)
|
||||||
|
if not sequences:
|
||||||
|
sequences = [list(FALLBACK_SEQUENCE)]
|
||||||
|
return sequences, warnings
|
||||||
@@ -0,0 +1,50 @@
|
|||||||
|
"""Laufzeitdaten (letzter Spielername).
|
||||||
|
|
||||||
|
Alles, was zur Laufzeit geschrieben wird, landet in ``runtime/`` – dieser
|
||||||
|
Ordner ist in ``.gitignore`` eingetragen. Über die Umgebungsvariable
|
||||||
|
``HAG_RUNTIME_DIR`` lässt sich der Ort umbiegen (praktisch für Tests).
|
||||||
|
"""
|
||||||
|
|
||||||
|
from __future__ import annotations
|
||||||
|
|
||||||
|
import json
|
||||||
|
import os
|
||||||
|
from pathlib import Path
|
||||||
|
|
||||||
|
from . import config
|
||||||
|
|
||||||
|
LAST_PLAYER_FILE = "last_player.json"
|
||||||
|
|
||||||
|
|
||||||
|
def runtime_dir() -> Path:
|
||||||
|
"""Verzeichnis für Laufzeitdaten; wird bei Bedarf angelegt."""
|
||||||
|
override = os.environ.get("HAG_RUNTIME_DIR")
|
||||||
|
path = Path(override) if override else config.RUNTIME_DIR
|
||||||
|
path.mkdir(parents=True, exist_ok=True)
|
||||||
|
return path
|
||||||
|
|
||||||
|
|
||||||
|
def load_last_player() -> str | None:
|
||||||
|
try:
|
||||||
|
data = json.loads((runtime_dir() / LAST_PLAYER_FILE).read_text(encoding="utf-8"))
|
||||||
|
except (OSError, ValueError):
|
||||||
|
return None
|
||||||
|
if not isinstance(data, dict):
|
||||||
|
return None
|
||||||
|
name = str(data.get("name", "")).strip()
|
||||||
|
return name or None
|
||||||
|
|
||||||
|
|
||||||
|
def save_last_player(name: str) -> None:
|
||||||
|
name = name.strip()[: config.MAX_PLAYER_NAME_LENGTH]
|
||||||
|
if not name:
|
||||||
|
return
|
||||||
|
try:
|
||||||
|
(runtime_dir() / LAST_PLAYER_FILE).write_text(
|
||||||
|
json.dumps({"name": name}, ensure_ascii=False, indent=2) + "\n",
|
||||||
|
encoding="utf-8",
|
||||||
|
)
|
||||||
|
except OSError:
|
||||||
|
# Laufzeitdaten sind nice-to-have – ein Schreibfehler darf das Spiel
|
||||||
|
# nicht stoppen.
|
||||||
|
pass
|
||||||
@@ -0,0 +1,124 @@
|
|||||||
|
"""Stapelregeln im Auflieger – reine Logik, ohne pygame.
|
||||||
|
|
||||||
|
Begriffe
|
||||||
|
--------
|
||||||
|
Barriere (``wall_x``)
|
||||||
|
Rechte Kante des bereits gestapelten Ladeguts. Neue Koffer werden dort
|
||||||
|
eingerastet. Reicht die Barriere über das Heck des Aufliegers hinaus, ist
|
||||||
|
das Spiel verloren.
|
||||||
|
|
||||||
|
Plattform
|
||||||
|
Ein bereits platzierter Koffer, auf den der aktuelle Koffer obendrauf
|
||||||
|
gesetzt werden darf (nur bündig an der Barriere, nicht zu schmal, und die
|
||||||
|
Fläche obendrauf muss frei sein).
|
||||||
|
"""
|
||||||
|
|
||||||
|
from __future__ import annotations
|
||||||
|
|
||||||
|
from . import config
|
||||||
|
from .case import Case
|
||||||
|
|
||||||
|
|
||||||
|
class Trailer:
|
||||||
|
"""Der Auflieger samt Stapel und Barrieren-Logik."""
|
||||||
|
|
||||||
|
def __init__(
|
||||||
|
self,
|
||||||
|
x: int = config.TRAILER_X,
|
||||||
|
y: int = config.TRAILER_Y,
|
||||||
|
width: int = config.TRAILER_WIDTH,
|
||||||
|
height: int = config.TRAILER_HEIGHT,
|
||||||
|
) -> None:
|
||||||
|
self.x = x
|
||||||
|
self.y = y
|
||||||
|
self.width = width
|
||||||
|
self.height = height
|
||||||
|
self.stack: list[Case] = []
|
||||||
|
self.wall_x: float = float(x)
|
||||||
|
|
||||||
|
# ------------------------------------------------------------------
|
||||||
|
# Masse
|
||||||
|
# ------------------------------------------------------------------
|
||||||
|
@property
|
||||||
|
def right(self) -> float:
|
||||||
|
return self.x + self.width
|
||||||
|
|
||||||
|
@property
|
||||||
|
def bottom(self) -> float:
|
||||||
|
return self.y + self.height
|
||||||
|
|
||||||
|
def reset(self) -> None:
|
||||||
|
self.stack.clear()
|
||||||
|
self.wall_x = float(self.x)
|
||||||
|
|
||||||
|
# ------------------------------------------------------------------
|
||||||
|
# Auswertung
|
||||||
|
# ------------------------------------------------------------------
|
||||||
|
def overflow(self) -> bool:
|
||||||
|
"""Ragt die Barriere über das Heck hinaus?"""
|
||||||
|
return self.wall_x > self.right
|
||||||
|
|
||||||
|
def load_percent(self) -> float:
|
||||||
|
"""Beladung in Prozent (Fläche der Koffer / Fläche des Aufliegers)."""
|
||||||
|
total = self.width * self.height
|
||||||
|
if total <= 0:
|
||||||
|
return 0.0
|
||||||
|
used = sum(case.width * case.height for case in self.stack)
|
||||||
|
return min(100.0, used / total * 100.0)
|
||||||
|
|
||||||
|
def find_platform(self, case: Case) -> Case | None:
|
||||||
|
"""Koffer, auf den ``case`` obendrauf gesetzt werden darf (oder ``None``)."""
|
||||||
|
for base in reversed(self.stack):
|
||||||
|
if base.y <= self.y:
|
||||||
|
continue # Oberkante = Auflieger-Oberkante
|
||||||
|
if base.y - case.height < self.y:
|
||||||
|
continue # oben kein Platz mehr
|
||||||
|
if case.width > base.width:
|
||||||
|
continue # zu breit für die Plattform
|
||||||
|
if abs(base.right - self.wall_x) >= config.PLATFORM_TOLERANCE:
|
||||||
|
continue # nicht bündig an der Barriere
|
||||||
|
if self._top_is_busy(base):
|
||||||
|
continue
|
||||||
|
return base
|
||||||
|
return None
|
||||||
|
|
||||||
|
def _top_is_busy(self, base: Case) -> bool:
|
||||||
|
"""Liegt schon ein Koffer auf ``base``?"""
|
||||||
|
for other in self.stack:
|
||||||
|
if other is base:
|
||||||
|
continue
|
||||||
|
if abs(other.bottom - base.y) <= 0.5 and other.x < base.right and other.right > base.x:
|
||||||
|
return True
|
||||||
|
return False
|
||||||
|
|
||||||
|
# ------------------------------------------------------------------
|
||||||
|
# Platzieren
|
||||||
|
# ------------------------------------------------------------------
|
||||||
|
def stack_at_wall(self, case: Case) -> None:
|
||||||
|
"""Koffer bündig an die Barriere schieben."""
|
||||||
|
case.x = self.wall_x
|
||||||
|
case.placed = True
|
||||||
|
case.snapped = True
|
||||||
|
self.stack.append(case)
|
||||||
|
self.wall_x = case.right
|
||||||
|
|
||||||
|
def stack_with_gap(self, case: Case) -> None:
|
||||||
|
"""Koffer mit einer Lücke einreihen (nach einer Kollision)."""
|
||||||
|
case.x = self.wall_x + config.SNAP_THRESHOLD
|
||||||
|
case.placed = True
|
||||||
|
self.stack.append(case)
|
||||||
|
self.wall_x = case.right
|
||||||
|
|
||||||
|
def place_on_top(self, case: Case, base: Case) -> None:
|
||||||
|
"""Koffer rechtsbündig auf ``base`` ablegen."""
|
||||||
|
case.y = base.y - case.height
|
||||||
|
case.x = base.right - case.width
|
||||||
|
case.placed = True
|
||||||
|
case.snapped = True
|
||||||
|
self.stack.append(case)
|
||||||
|
self.wall_x = case.right
|
||||||
|
|
||||||
|
def remove(self, case: Case) -> None:
|
||||||
|
"""Koffer wieder entfernen (er ragt über das Heck hinaus)."""
|
||||||
|
if case in self.stack:
|
||||||
|
self.stack.remove(case)
|
||||||
@@ -0,0 +1,173 @@
|
|||||||
|
#!/usr/bin/env python3
|
||||||
|
"""Einstiegspunkt des Habegger Loader Games.
|
||||||
|
|
||||||
|
Beispiele::
|
||||||
|
|
||||||
|
./run.sh # Fenster, letzter Spielername
|
||||||
|
./run.sh --fullscreen # Vollbild (Messe-/Eventbetrieb)
|
||||||
|
./run.sh --name "Anna" # Name direkt setzen
|
||||||
|
./run.sh --smoke 10 # Selbsttest ohne Eingabegeräte
|
||||||
|
"""
|
||||||
|
|
||||||
|
from __future__ import annotations
|
||||||
|
|
||||||
|
import argparse
|
||||||
|
import random
|
||||||
|
import sys
|
||||||
|
|
||||||
|
import pygame
|
||||||
|
|
||||||
|
from loader_game import config, storage
|
||||||
|
from loader_game.assets import Assets
|
||||||
|
from loader_game.game import Game, State
|
||||||
|
from loader_game.input_map import Action, actions_from_event, controller_hint_lines
|
||||||
|
from loader_game.intro import Intro
|
||||||
|
from loader_game.sequences import load_sequences
|
||||||
|
|
||||||
|
|
||||||
|
def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
|
||||||
|
parser = argparse.ArgumentParser(description="Habegger Loader Game")
|
||||||
|
parser.add_argument(
|
||||||
|
"--fullscreen",
|
||||||
|
action="store_true",
|
||||||
|
help="Vollbild starten (Standard: Fenster; F11 schaltet jederzeit um)",
|
||||||
|
)
|
||||||
|
parser.add_argument(
|
||||||
|
"--name",
|
||||||
|
default=None,
|
||||||
|
help="Spielername (sonst der zuletzt gespeicherte aus runtime/)",
|
||||||
|
)
|
||||||
|
parser.add_argument(
|
||||||
|
"--seed",
|
||||||
|
type=int,
|
||||||
|
default=None,
|
||||||
|
help="Zufalls-Seed für reproduzierbare Koffer-Sequenzen",
|
||||||
|
)
|
||||||
|
parser.add_argument(
|
||||||
|
"--smoke",
|
||||||
|
type=float,
|
||||||
|
default=None,
|
||||||
|
metavar="SEKUNDEN",
|
||||||
|
help="Selbsttest: bestätigt das Intro automatisch, spielt ohne Eingaben "
|
||||||
|
"und beendet sich nach N Sekunden",
|
||||||
|
)
|
||||||
|
return parser.parse_args(argv)
|
||||||
|
|
||||||
|
|
||||||
|
def create_screen(fullscreen: bool) -> pygame.Surface:
|
||||||
|
"""Fenster mit virtueller 1920x1080-Auflösung anlegen.
|
||||||
|
|
||||||
|
``pygame.SCALED`` sorgt dafür, dass alles automatisch auf die tatsächliche
|
||||||
|
Fenster-/Bildschirmgrösse skaliert wird (Retina, 1440x900, 4K …).
|
||||||
|
"""
|
||||||
|
flags = pygame.SCALED | (pygame.FULLSCREEN if fullscreen else pygame.RESIZABLE)
|
||||||
|
size = (config.SCREEN_WIDTH, config.SCREEN_HEIGHT)
|
||||||
|
try:
|
||||||
|
return pygame.display.set_mode(size, flags, vsync=1)
|
||||||
|
except pygame.error:
|
||||||
|
return pygame.display.set_mode(size, flags)
|
||||||
|
|
||||||
|
|
||||||
|
def _demo_action(game: Game, rng: random.Random) -> Action | None:
|
||||||
|
"""Einfache Auto-Strategie für den Selbsttest."""
|
||||||
|
case = game.current
|
||||||
|
if case is None or game.animation is not None or not case.allow_snap:
|
||||||
|
return None
|
||||||
|
return rng.choice([Action.PRIMARY, Action.PRIMARY, Action.PRIMARY, Action.UP, Action.LEFT])
|
||||||
|
|
||||||
|
|
||||||
|
def main(argv: list[str] | None = None) -> int:
|
||||||
|
args = parse_args(argv)
|
||||||
|
|
||||||
|
pygame.mixer.pre_init(config.AUDIO_SAMPLE_RATE, -16, 2, 512)
|
||||||
|
pygame.init()
|
||||||
|
if not pygame.display.get_init():
|
||||||
|
print("Kein Display verfügbar (ohne Bildschirm gestartet?).", file=sys.stderr)
|
||||||
|
return 1
|
||||||
|
|
||||||
|
pygame.display.set_caption(config.WINDOW_TITLE)
|
||||||
|
screen = create_screen(fullscreen=args.fullscreen)
|
||||||
|
|
||||||
|
assets = Assets()
|
||||||
|
assets.load()
|
||||||
|
|
||||||
|
for line in controller_hint_lines():
|
||||||
|
print(line)
|
||||||
|
|
||||||
|
sequences, warnings = load_sequences()
|
||||||
|
for warning in warnings:
|
||||||
|
print("Sequenz-Warnung:", warning, file=sys.stderr)
|
||||||
|
|
||||||
|
name = (args.name or storage.load_last_player() or config.DEFAULT_PLAYER_NAME).strip()
|
||||||
|
name = name[: config.MAX_PLAYER_NAME_LENGTH] or config.DEFAULT_PLAYER_NAME
|
||||||
|
storage.save_last_player(name)
|
||||||
|
|
||||||
|
rng = random.Random(args.seed)
|
||||||
|
intro: Intro | None = Intro(assets)
|
||||||
|
game: Game | None = None
|
||||||
|
clock = pygame.time.Clock()
|
||||||
|
|
||||||
|
running = True
|
||||||
|
smoke_remaining = args.smoke
|
||||||
|
smoke_timer = 0.0
|
||||||
|
|
||||||
|
while running:
|
||||||
|
dt = min(clock.tick(config.FPS) / 1000.0, 0.1)
|
||||||
|
|
||||||
|
for event in pygame.event.get():
|
||||||
|
if event.type == pygame.QUIT:
|
||||||
|
running = False
|
||||||
|
break
|
||||||
|
if event.type == pygame.KEYDOWN and event.key == pygame.K_F11:
|
||||||
|
pygame.display.toggle_fullscreen()
|
||||||
|
continue
|
||||||
|
for action in actions_from_event(event):
|
||||||
|
if intro is not None:
|
||||||
|
intro.handle(action)
|
||||||
|
if action is Action.BACK:
|
||||||
|
running = False
|
||||||
|
elif game is not None:
|
||||||
|
running = game.handle(action)
|
||||||
|
if not running:
|
||||||
|
break
|
||||||
|
|
||||||
|
if intro is not None:
|
||||||
|
if intro.update(dt):
|
||||||
|
intro = None
|
||||||
|
game = Game(assets, sequences, name=name, rng=rng)
|
||||||
|
elif smoke_remaining is not None and intro.phase == "instruction":
|
||||||
|
intro.handle(Action.PRIMARY)
|
||||||
|
elif game is not None:
|
||||||
|
game.update(dt)
|
||||||
|
|
||||||
|
if smoke_remaining is not None:
|
||||||
|
smoke_remaining -= dt
|
||||||
|
if smoke_remaining <= 0:
|
||||||
|
running = False
|
||||||
|
elif game is not None and intro is None:
|
||||||
|
smoke_timer -= dt
|
||||||
|
if smoke_timer <= 0:
|
||||||
|
smoke_timer = 0.25
|
||||||
|
action = _demo_action(game, rng)
|
||||||
|
if action is not None:
|
||||||
|
running = game.handle(action)
|
||||||
|
|
||||||
|
if intro is not None:
|
||||||
|
intro.draw(screen)
|
||||||
|
elif game is not None:
|
||||||
|
game.draw(screen)
|
||||||
|
pygame.display.flip()
|
||||||
|
|
||||||
|
if game is not None:
|
||||||
|
percent = game.percent if game.state is State.GAME_OVER else game.trailer.load_percent()
|
||||||
|
print(
|
||||||
|
f"Spiel beendet: Zustand={game.state.value}, "
|
||||||
|
f"Beladung={percent:.0f}%, Koffer im Auflieger={len(game.trailer.stack)}"
|
||||||
|
)
|
||||||
|
|
||||||
|
pygame.quit()
|
||||||
|
return 0
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
sys.exit(main())
|
||||||
-188
@@ -1,188 +0,0 @@
|
|||||||
import cv2
|
|
||||||
from pyzbar.pyzbar import decode
|
|
||||||
import numpy as np
|
|
||||||
from PIL import ImageFont, ImageDraw, Image
|
|
||||||
import os
|
|
||||||
import subprocess
|
|
||||||
import requests
|
|
||||||
import pygetwindow as gw
|
|
||||||
import pyautogui
|
|
||||||
import time
|
|
||||||
|
|
||||||
# Nach 2 Sekunden suchen wir das Fenster
|
|
||||||
time.sleep(2)
|
|
||||||
for w in gw.getWindowsWithTitle("QR Scanner"): # oder z. B. "pygame", "Loader", etc.
|
|
||||||
w.activate()
|
|
||||||
w.maximize() # optional
|
|
||||||
pyautogui.click(w.left + 100, w.top + 100) # sicherer Klick ins Fenster
|
|
||||||
break
|
|
||||||
|
|
||||||
API_URL = "https://hag.putschgi.ch/Yb54CO5Ypybx/api/qr.php?action=verify_hash"
|
|
||||||
API_SECRET = "ddlKC6sgE4EMvsU9VQeIVeYrsPGpE104"
|
|
||||||
|
|
||||||
# Fenstergröße & Farben
|
|
||||||
window_width, window_height = 1920, 1080
|
|
||||||
# Habegger Gold
|
|
||||||
COLOR_GREEN = (0, 255, 0)
|
|
||||||
COLOR_YELLOW = (0, 255, 255)
|
|
||||||
COLOR_BACKGROUND = (45, 46, 47) # HTML-Farbe #2d2e2f
|
|
||||||
COLOR_WHITE = (255, 255, 255)
|
|
||||||
COLOR_GOLD = (131, 188, 214) # BGR für Habegger-Gold
|
|
||||||
|
|
||||||
# Font & Logo
|
|
||||||
FONT_PATH = os.path.join("fonts", "Tisa Sans Pro Regular.ttf"
|
|
||||||
"") # Alternativ: Georgia.ttf, falls vorhanden
|
|
||||||
FONT_SIZE = 48
|
|
||||||
font = ImageFont.truetype(FONT_PATH, FONT_SIZE)
|
|
||||||
logo_path = "images/habegger_logo_goldbar_whitefont.png" # Logo mit sichtbarem Text
|
|
||||||
logo_pil = Image.open(logo_path).convert("RGBA")
|
|
||||||
logo_pil.thumbnail((300, 100))
|
|
||||||
logo_pil = Image.alpha_composite(Image.new("RGBA", logo_pil.size, (0, 0, 0, 0)), logo_pil)
|
|
||||||
logo_img = np.array(logo_pil)
|
|
||||||
logo_img = cv2.cvtColor(logo_img, cv2.COLOR_RGBA2BGRA)
|
|
||||||
|
|
||||||
def draw_unicode_text(cv2_image, text, position, color=COLOR_WHITE):
|
|
||||||
img_pil = Image.fromarray(cv2_image)
|
|
||||||
draw = ImageDraw.Draw(img_pil)
|
|
||||||
draw.text(position, text, font=font, fill=color)
|
|
||||||
return np.array(img_pil)
|
|
||||||
|
|
||||||
def parse_qr_data(data):
|
|
||||||
from urllib.parse import urlparse, parse_qs
|
|
||||||
if "?code=" in data:
|
|
||||||
parsed = urlparse(data)
|
|
||||||
query = parse_qs(parsed.query)
|
|
||||||
code = query.get("code", [""])[0]
|
|
||||||
return code
|
|
||||||
return None
|
|
||||||
|
|
||||||
|
|
||||||
def start_game(mail, name):
|
|
||||||
with open("last_user.txt", "w", encoding="utf-8-sig") as f:
|
|
||||||
f.write(f"{mail}\n{name}")
|
|
||||||
subprocess.run(["python", "loader_game.py"])
|
|
||||||
|
|
||||||
# Endlosschleife für den Scanner
|
|
||||||
while True:
|
|
||||||
detected_color = COLOR_GOLD
|
|
||||||
detected_time = None
|
|
||||||
cap = cv2.VideoCapture(0)
|
|
||||||
cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
|
|
||||||
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)
|
|
||||||
|
|
||||||
# Rahmenfarbe wird später im Loop anhand der Zeit gesetzt
|
|
||||||
last_display_text = ""
|
|
||||||
start_timer = None
|
|
||||||
game_started = False
|
|
||||||
|
|
||||||
while True:
|
|
||||||
success, frame = cap.read()
|
|
||||||
if not success:
|
|
||||||
break
|
|
||||||
|
|
||||||
decoded_objects = decode(frame)
|
|
||||||
if not decoded_objects:
|
|
||||||
inverted_frame = cv2.bitwise_not(frame)
|
|
||||||
decoded_objects = decode(inverted_frame)
|
|
||||||
|
|
||||||
# QR-Status zurücksetzen nach 5 Sek.
|
|
||||||
if detected_time and time.time() - detected_time >= 5.0:
|
|
||||||
detected_color = COLOR_GOLD
|
|
||||||
frame_color = COLOR_GOLD
|
|
||||||
|
|
||||||
if decoded_objects:
|
|
||||||
detected_time = time.time()
|
|
||||||
|
|
||||||
for obj in decoded_objects:
|
|
||||||
points = obj.polygon
|
|
||||||
if len(points) > 4:
|
|
||||||
hull = cv2.convexHull(np.array([point for point in points], dtype=np.float32))
|
|
||||||
points = hull.reshape(-1, 2)
|
|
||||||
for i in range(len(points)):
|
|
||||||
pt1 = tuple(points[i])
|
|
||||||
pt2 = tuple(points[(i + 1) % len(points)])
|
|
||||||
cv2.line(frame, pt1, pt2, COLOR_GREEN, 3)
|
|
||||||
|
|
||||||
data = obj.data.decode("utf-8")
|
|
||||||
code = parse_qr_data(data)
|
|
||||||
if not code:
|
|
||||||
detected_color = COLOR_YELLOW
|
|
||||||
detected_time = time.time()
|
|
||||||
last_display_text = "Kein gültiger QR-Code erkannt."
|
|
||||||
break
|
|
||||||
|
|
||||||
try:
|
|
||||||
res = requests.post(API_URL, json={"code": code, "auth": API_SECRET}, timeout=5)
|
|
||||||
print("RAW Response:", res.text)
|
|
||||||
result = res.json()
|
|
||||||
|
|
||||||
except Exception as e:
|
|
||||||
detected_color = COLOR_YELLOW
|
|
||||||
detected_time = time.time()
|
|
||||||
last_display_text = f"API Fehler: {e}"
|
|
||||||
break
|
|
||||||
|
|
||||||
if not result.get("valid"):
|
|
||||||
detected_color = COLOR_YELLOW
|
|
||||||
last_display_text = "Ungültiger Code."
|
|
||||||
elif result.get("registered"):
|
|
||||||
name = result.get("name", "Unbekannt")
|
|
||||||
detected_color = COLOR_GREEN
|
|
||||||
last_display_text = f"Hallo {name}!"
|
|
||||||
start_timer = time.time()
|
|
||||||
game_started = True
|
|
||||||
last_mail = code
|
|
||||||
last_name = name
|
|
||||||
else:
|
|
||||||
detected_color = COLOR_YELLOW
|
|
||||||
last_display_text = "QR gültig, aber nicht registriert."
|
|
||||||
detected_time = time.time()
|
|
||||||
break
|
|
||||||
|
|
||||||
if start_timer and time.time() - start_timer >= 5.0:
|
|
||||||
cap.release()
|
|
||||||
cv2.destroyAllWindows()
|
|
||||||
start_game(last_mail, last_name)
|
|
||||||
break
|
|
||||||
|
|
||||||
display_frame = np.full((window_height, window_width, 3), COLOR_BACKGROUND, dtype=np.uint8)
|
|
||||||
cam_h, cam_w = frame.shape[:2]
|
|
||||||
x_offset = (window_width - cam_w) // 2
|
|
||||||
y_offset = (window_height - cam_h) // 2
|
|
||||||
display_frame[y_offset:y_offset+cam_h, x_offset:x_offset+cam_w] = frame
|
|
||||||
|
|
||||||
display_frame = draw_unicode_text(display_frame,
|
|
||||||
"Scanne deinen QR-Code um das Spiel zu starten.",
|
|
||||||
(80, 100), COLOR_WHITE)
|
|
||||||
|
|
||||||
if last_display_text:
|
|
||||||
display_frame = draw_unicode_text(display_frame, last_display_text,
|
|
||||||
(80, window_height - 100), COLOR_WHITE)
|
|
||||||
|
|
||||||
# Kamera-Rahmen
|
|
||||||
if detected_time and time.time() - detected_time < 5.0:
|
|
||||||
current_color = detected_color
|
|
||||||
else:
|
|
||||||
current_color = COLOR_GOLD
|
|
||||||
|
|
||||||
cv2.rectangle(display_frame, (x_offset, y_offset),
|
|
||||||
(x_offset + cam_w, y_offset + cam_h), current_color, 6)
|
|
||||||
|
|
||||||
# Logo oben rechts ohne Alpha-Blending-Probleme
|
|
||||||
logo_pos = (window_width - logo_img.shape[1] - 40, 40)
|
|
||||||
overlay = np.zeros_like(display_frame, dtype=np.uint8)
|
|
||||||
overlay[logo_pos[1]:logo_pos[1]+logo_img.shape[0], logo_pos[0]:logo_pos[0]+logo_img.shape[1]] = logo_img[:, :, :3]
|
|
||||||
mask = logo_img[:, :, 3] # alpha channel
|
|
||||||
for c in range(3):
|
|
||||||
display_frame[logo_pos[1]:logo_pos[1]+logo_img.shape[0], logo_pos[0]:logo_pos[0]+logo_img.shape[1], c] = (
|
|
||||||
logo_img[:, :, c] * (mask / 255.0) + display_frame[logo_pos[1]:logo_pos[1]+logo_img.shape[0], logo_pos[0]:logo_pos[0]+logo_img.shape[1], c] * (1.0 - mask / 255.0)).astype(np.uint8)
|
|
||||||
|
|
||||||
cv2.namedWindow("QR Scanner", cv2.WINDOW_NORMAL)
|
|
||||||
cv2.setWindowProperty("QR Scanner", cv2.WND_PROP_FULLSCREEN, cv2.WINDOW_FULLSCREEN)
|
|
||||||
cv2.imshow("QR Scanner", display_frame)
|
|
||||||
|
|
||||||
key = cv2.waitKey(1)
|
|
||||||
if key == 27 or key == ord('q'):
|
|
||||||
cap.release()
|
|
||||||
cv2.destroyAllWindows()
|
|
||||||
exit()
|
|
||||||
-160
@@ -1,160 +0,0 @@
|
|||||||
import cv2
|
|
||||||
from pyzbar.pyzbar import decode
|
|
||||||
import time
|
|
||||||
import numpy as np
|
|
||||||
from urllib.parse import urlparse, parse_qs, unquote
|
|
||||||
from PIL import ImageFont, ImageDraw, Image
|
|
||||||
import os
|
|
||||||
import subprocess
|
|
||||||
|
|
||||||
# Fenstergröße & Farben
|
|
||||||
window_width, window_height = 1920, 1080
|
|
||||||
# Habegger Gold
|
|
||||||
COLOR_GREEN = (0, 255, 0)
|
|
||||||
COLOR_YELLOW = (0, 255, 255)
|
|
||||||
COLOR_BACKGROUND = (45, 46, 47) # HTML-Farbe #2d2e2f
|
|
||||||
COLOR_WHITE = (255, 255, 255)
|
|
||||||
COLOR_GOLD = (131, 188, 214) # BGR für Habegger-Gold
|
|
||||||
|
|
||||||
# Font & Logo
|
|
||||||
FONT_PATH = os.path.join("fonts", "Tisa Sans Pro Regular.ttf"
|
|
||||||
"") # Alternativ: Georgia.ttf, falls vorhanden
|
|
||||||
FONT_SIZE = 48
|
|
||||||
font = ImageFont.truetype(FONT_PATH, FONT_SIZE)
|
|
||||||
logo_path = "images/habegger_logo_goldbar_whitefont.png" # Logo mit sichtbarem Text
|
|
||||||
logo_pil = Image.open(logo_path).convert("RGBA")
|
|
||||||
logo_pil.thumbnail((300, 100))
|
|
||||||
logo_pil = Image.alpha_composite(Image.new("RGBA", logo_pil.size, (0, 0, 0, 0)), logo_pil)
|
|
||||||
logo_img = np.array(logo_pil)
|
|
||||||
logo_img = cv2.cvtColor(logo_img, cv2.COLOR_RGBA2BGRA)
|
|
||||||
|
|
||||||
def draw_unicode_text(cv2_image, text, position, color=COLOR_WHITE):
|
|
||||||
img_pil = Image.fromarray(cv2_image)
|
|
||||||
draw = ImageDraw.Draw(img_pil)
|
|
||||||
draw.text(position, text, font=font, fill=color)
|
|
||||||
return np.array(img_pil)
|
|
||||||
|
|
||||||
def parse_qr_data(data):
|
|
||||||
try:
|
|
||||||
parsed = urlparse(data)
|
|
||||||
query = parse_qs(parsed.query)
|
|
||||||
mail = query.get("mail", [""])[0]
|
|
||||||
name = query.get("name", [""])[0]
|
|
||||||
name = unquote(name, encoding="utf-8", errors="replace")
|
|
||||||
name = (name.replace("鐼", "ö")
|
|
||||||
.replace("ü", "ü")
|
|
||||||
.replace("ä", "ä")
|
|
||||||
.replace("Ö", "Ö")
|
|
||||||
.replace("Ãœ", "Ü")
|
|
||||||
.replace("Ãß", "ß"))
|
|
||||||
if "@habegger.ch" in mail.lower() and name.strip():
|
|
||||||
return mail.strip(), name.strip()
|
|
||||||
except:
|
|
||||||
pass
|
|
||||||
return None, None
|
|
||||||
|
|
||||||
def start_game(mail, name):
|
|
||||||
with open("last_user.txt", "w", encoding="utf-8-sig") as f:
|
|
||||||
f.write(f"{mail}\n{name}")
|
|
||||||
subprocess.run(["python", "loader_game.py"])
|
|
||||||
|
|
||||||
# Endlosschleife für den Scanner
|
|
||||||
while True:
|
|
||||||
detected_color = COLOR_GOLD
|
|
||||||
detected_time = None
|
|
||||||
cap = cv2.VideoCapture(0)
|
|
||||||
cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
|
|
||||||
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)
|
|
||||||
|
|
||||||
# Rahmenfarbe wird später im Loop anhand der Zeit gesetzt
|
|
||||||
last_display_text = ""
|
|
||||||
start_timer = None
|
|
||||||
game_started = False
|
|
||||||
|
|
||||||
while True:
|
|
||||||
success, frame = cap.read()
|
|
||||||
if not success:
|
|
||||||
break
|
|
||||||
|
|
||||||
decoded_objects = decode(frame)
|
|
||||||
# QR-Status zurücksetzen nach 5 Sek.
|
|
||||||
if detected_time and time.time() - detected_time >= 5.0:
|
|
||||||
detected_color = COLOR_GOLD
|
|
||||||
frame_color = COLOR_GOLD
|
|
||||||
|
|
||||||
if decoded_objects:
|
|
||||||
detected_time = time.time()
|
|
||||||
for obj in decoded_objects:
|
|
||||||
points = obj.polygon
|
|
||||||
if len(points) > 4:
|
|
||||||
hull = cv2.convexHull(np.array([point for point in points], dtype=np.float32))
|
|
||||||
points = hull.reshape(-1, 2)
|
|
||||||
for i in range(len(points)):
|
|
||||||
pt1 = tuple(points[i])
|
|
||||||
pt2 = tuple(points[(i + 1) % len(points)])
|
|
||||||
cv2.line(frame, pt1, pt2, COLOR_GREEN, 3)
|
|
||||||
|
|
||||||
data = obj.data.decode("utf-8")
|
|
||||||
mail, name = parse_qr_data(data)
|
|
||||||
|
|
||||||
if mail and name:
|
|
||||||
detected_color = COLOR_GREEN
|
|
||||||
last_display_text = f"Richtiger QR-Code: Hallo {name}"
|
|
||||||
detected_time = time.time()
|
|
||||||
start_timer = time.time()
|
|
||||||
game_started = True
|
|
||||||
last_mail = mail
|
|
||||||
last_name = name
|
|
||||||
else:
|
|
||||||
detected_color = COLOR_YELLOW
|
|
||||||
detected_time = time.time()
|
|
||||||
last_display_text = "Bitte dein HAG Last-Thursday Code scannen."
|
|
||||||
break
|
|
||||||
|
|
||||||
if start_timer and time.time() - start_timer >= 5.0:
|
|
||||||
cap.release()
|
|
||||||
cv2.destroyAllWindows()
|
|
||||||
start_game(last_mail, last_name)
|
|
||||||
break
|
|
||||||
|
|
||||||
display_frame = np.full((window_height, window_width, 3), COLOR_BACKGROUND, dtype=np.uint8)
|
|
||||||
cam_h, cam_w = frame.shape[:2]
|
|
||||||
x_offset = (window_width - cam_w) // 2
|
|
||||||
y_offset = (window_height - cam_h) // 2
|
|
||||||
display_frame[y_offset:y_offset+cam_h, x_offset:x_offset+cam_w] = frame
|
|
||||||
|
|
||||||
display_frame = draw_unicode_text(display_frame,
|
|
||||||
"Scanne deinen QR-Code um das Spiel zu starten.",
|
|
||||||
(80, 100), COLOR_WHITE)
|
|
||||||
|
|
||||||
if last_display_text:
|
|
||||||
display_frame = draw_unicode_text(display_frame, last_display_text,
|
|
||||||
(80, window_height - 100), COLOR_WHITE)
|
|
||||||
|
|
||||||
# Kamera-Rahmen
|
|
||||||
if detected_time and time.time() - detected_time < 5.0:
|
|
||||||
current_color = detected_color
|
|
||||||
else:
|
|
||||||
current_color = COLOR_GOLD
|
|
||||||
|
|
||||||
cv2.rectangle(display_frame, (x_offset, y_offset),
|
|
||||||
(x_offset + cam_w, y_offset + cam_h), current_color, 6)
|
|
||||||
|
|
||||||
# Logo oben rechts ohne Alpha-Blending-Probleme
|
|
||||||
logo_pos = (window_width - logo_img.shape[1] - 40, 40)
|
|
||||||
overlay = np.zeros_like(display_frame, dtype=np.uint8)
|
|
||||||
overlay[logo_pos[1]:logo_pos[1]+logo_img.shape[0], logo_pos[0]:logo_pos[0]+logo_img.shape[1]] = logo_img[:, :, :3]
|
|
||||||
mask = logo_img[:, :, 3] # alpha channel
|
|
||||||
for c in range(3):
|
|
||||||
display_frame[logo_pos[1]:logo_pos[1]+logo_img.shape[0], logo_pos[0]:logo_pos[0]+logo_img.shape[1], c] = (
|
|
||||||
logo_img[:, :, c] * (mask / 255.0) + display_frame[logo_pos[1]:logo_pos[1]+logo_img.shape[0], logo_pos[0]:logo_pos[0]+logo_img.shape[1], c] * (1.0 - mask / 255.0)).astype(np.uint8)
|
|
||||||
|
|
||||||
cv2.namedWindow("QR Scanner", cv2.WINDOW_NORMAL)
|
|
||||||
cv2.setWindowProperty("QR Scanner", cv2.WND_PROP_FULLSCREEN, cv2.WINDOW_FULLSCREEN)
|
|
||||||
cv2.imshow("QR Scanner", display_frame)
|
|
||||||
|
|
||||||
key = cv2.waitKey(1)
|
|
||||||
if key == 27 or key == ord('q'):
|
|
||||||
cap.release()
|
|
||||||
cv2.destroyAllWindows()
|
|
||||||
exit()
|
|
||||||
@@ -0,0 +1,3 @@
|
|||||||
|
# Laufzeitabhängigkeiten des Habegger Loader Games.
|
||||||
|
# Bewusst schlank gehalten: nur pygame (inkl. SDL2-Wheels für macOS/Windows/Linux).
|
||||||
|
pygame>=2.6,<3
|
||||||
Executable
+5
@@ -0,0 +1,5 @@
|
|||||||
|
#!/usr/bin/env bash
|
||||||
|
# macOS: Dieses Skript im Finder doppelklicken startet das Spiel.
|
||||||
|
# (Beim ersten Mal ggf. Rechtsklick → Öffnen, wegen Gatekeeper.)
|
||||||
|
cd "$(dirname "$0")" || exit 1
|
||||||
|
exec ./run.sh "$@"
|
||||||
@@ -0,0 +1,37 @@
|
|||||||
|
#!/usr/bin/env bash
|
||||||
|
# Startet das Habegger Loader Game.
|
||||||
|
#
|
||||||
|
# Beim ersten Start wird eine lokale virtuelle Umgebung (.venv) angelegt und
|
||||||
|
# requirements.txt installiert. Ändert sich requirements.txt, wird neu
|
||||||
|
# installiert. Alle Argumente werden an main.py weitergegeben, z. B.:
|
||||||
|
#
|
||||||
|
# ./run.sh --windowed
|
||||||
|
# ./run.sh --name "Anna" --seed 42
|
||||||
|
#
|
||||||
|
# Getestet auf macOS (arm64) und Linux.
|
||||||
|
set -euo pipefail
|
||||||
|
cd "$(dirname "$0")"
|
||||||
|
|
||||||
|
VENV=".venv"
|
||||||
|
PYTHON="${PYTHON:-python3}"
|
||||||
|
STAMP="$VENV/.requirements.sha256"
|
||||||
|
|
||||||
|
if [ ! -x "$VENV/bin/python" ]; then
|
||||||
|
echo "→ Lege virtuelle Umgebung an ($("$PYTHON" --version 2>&1))"
|
||||||
|
"$PYTHON" -m venv "$VENV"
|
||||||
|
fi
|
||||||
|
|
||||||
|
if command -v shasum >/dev/null 2>&1; then
|
||||||
|
REQ_HASH="$(shasum -a 256 requirements.txt | cut -d' ' -f1)"
|
||||||
|
else
|
||||||
|
REQ_HASH="$(sha256sum requirements.txt | cut -d' ' -f1)"
|
||||||
|
fi
|
||||||
|
|
||||||
|
if [ ! -f "$STAMP" ] || [ "$(cat "$STAMP")" != "$REQ_HASH" ]; then
|
||||||
|
echo "→ Installiere Abhängigkeiten aus requirements.txt"
|
||||||
|
"$VENV/bin/python" -m pip install --quiet --upgrade pip
|
||||||
|
"$VENV/bin/python" -m pip install --quiet -r requirements.txt
|
||||||
|
echo "$REQ_HASH" >"$STAMP"
|
||||||
|
fi
|
||||||
|
|
||||||
|
exec "$VENV/bin/python" main.py "$@"
|
||||||
@@ -0,0 +1,349 @@
|
|||||||
|
"""Tests für die Spiellogik (ohne Fenster, ohne Ton).
|
||||||
|
|
||||||
|
Aufruf::
|
||||||
|
|
||||||
|
.venv/bin/python -m unittest discover -s tests -v
|
||||||
|
"""
|
||||||
|
|
||||||
|
from __future__ import annotations
|
||||||
|
|
||||||
|
import os
|
||||||
|
import random
|
||||||
|
import tempfile
|
||||||
|
import unittest
|
||||||
|
from pathlib import Path
|
||||||
|
|
||||||
|
os.environ.setdefault("SDL_VIDEODRIVER", "dummy")
|
||||||
|
os.environ.setdefault("SDL_AUDIODRIVER", "dummy")
|
||||||
|
|
||||||
|
from loader_game import config, storage
|
||||||
|
from loader_game.case import Case
|
||||||
|
from loader_game.game import Game, State
|
||||||
|
from loader_game.input_map import Action
|
||||||
|
from loader_game.sequences import CaseSpec, load_sequences, parse_sequences
|
||||||
|
from loader_game.trailer import Trailer
|
||||||
|
|
||||||
|
|
||||||
|
class SequenceTests(unittest.TestCase):
|
||||||
|
def test_real_file_parses_into_six_sequences(self) -> None:
|
||||||
|
sequences, warnings = load_sequences()
|
||||||
|
self.assertEqual(warnings, [])
|
||||||
|
self.assertEqual(len(sequences), 6)
|
||||||
|
self.assertEqual(sequences[0][0], CaseSpec(3, 1))
|
||||||
|
self.assertEqual(sequences[0][3], CaseSpec(2, 1)) # aus "1,2,True"
|
||||||
|
|
||||||
|
def test_rotated_flag_swaps_dimensions(self) -> None:
|
||||||
|
sequences, _ = parse_sequences("1,3,True\n2,1,False")
|
||||||
|
self.assertEqual(sequences, [[CaseSpec(3, 1), CaseSpec(2, 1)]])
|
||||||
|
|
||||||
|
def test_blank_lines_separate_sequences(self) -> None:
|
||||||
|
sequences, _ = parse_sequences("1,1,False\n\n2,2,False\n\n")
|
||||||
|
self.assertEqual(len(sequences), 2)
|
||||||
|
|
||||||
|
def test_invalid_lines_warn_and_are_skipped(self) -> None:
|
||||||
|
sequences, warnings = parse_sequences("1,1\n1,1,False,extra\n0,1,False\n2,2,False")
|
||||||
|
self.assertEqual(sequences, [[CaseSpec(2, 2)]])
|
||||||
|
self.assertEqual(len(warnings), 3)
|
||||||
|
|
||||||
|
def test_garbage_falls_back_to_default(self) -> None:
|
||||||
|
sequences, warnings = parse_sequences("nur müll")
|
||||||
|
self.assertEqual(sequences, [])
|
||||||
|
# eine Meldung für die kaputte Zeile, eine für die fehlende Sequenz
|
||||||
|
self.assertEqual(len(warnings), 2)
|
||||||
|
|
||||||
|
def test_all_specs_fit_available_images(self) -> None:
|
||||||
|
sequences, _ = load_sequences()
|
||||||
|
for specs in sequences:
|
||||||
|
for spec in specs:
|
||||||
|
self.assertLessEqual(spec.units_w, config.MAX_UNITS_W, spec)
|
||||||
|
self.assertLessEqual(spec.units_h, config.MAX_UNITS_H, spec)
|
||||||
|
|
||||||
|
|
||||||
|
class LayoutTests(unittest.TestCase):
|
||||||
|
def test_bands_add_up_to_screen_height(self) -> None:
|
||||||
|
self.assertEqual(
|
||||||
|
config.TOP_BAR_HEIGHT + config.GAME_AREA_HEIGHT + config.BOTTOM_BAR_HEIGHT,
|
||||||
|
config.SCREEN_HEIGHT,
|
||||||
|
)
|
||||||
|
|
||||||
|
def test_trailer_fits_into_game_area(self) -> None:
|
||||||
|
self.assertGreaterEqual(config.TRAILER_X, 0)
|
||||||
|
self.assertLessEqual(config.TRAILER_RIGHT, config.SCREEN_WIDTH)
|
||||||
|
self.assertGreaterEqual(config.TRAILER_Y, config.TOP_BAR_HEIGHT)
|
||||||
|
self.assertLessEqual(
|
||||||
|
config.TRAILER_BOTTOM, config.TOP_BAR_HEIGHT + config.GAME_AREA_HEIGHT
|
||||||
|
)
|
||||||
|
|
||||||
|
def test_case_unit_is_square(self) -> None:
|
||||||
|
self.assertEqual(config.UNIT_LENGTH, config.UNIT_HEIGHT)
|
||||||
|
|
||||||
|
|
||||||
|
class CaseTests(unittest.TestCase):
|
||||||
|
def make_case(self, units_w: int = 2, units_h: int = 1, x: float | None = None) -> Case:
|
||||||
|
return Case(
|
||||||
|
units_w=units_w,
|
||||||
|
units_h=units_h,
|
||||||
|
x=float(config.SCREEN_WIDTH if x is None else x),
|
||||||
|
y=float(config.TRAILER_BOTTOM - units_h * config.UNIT_HEIGHT),
|
||||||
|
)
|
||||||
|
|
||||||
|
def test_moves_left_and_brakes_near_wall(self) -> None:
|
||||||
|
case = self.make_case()
|
||||||
|
start = case.x
|
||||||
|
case.move(1 / 60, wall_x=0)
|
||||||
|
fast_step = start - case.x
|
||||||
|
self.assertGreater(fast_step, 0)
|
||||||
|
|
||||||
|
case.x = float(config.FAST_TO_SLOW_DISTANCE - 20) # schon im Bremsbereich
|
||||||
|
before = case.x
|
||||||
|
case.move(1 / 60, wall_x=0)
|
||||||
|
slow_step = before - case.x
|
||||||
|
self.assertLess(slow_step, fast_step)
|
||||||
|
|
||||||
|
def test_allow_snap_only_near_wall(self) -> None:
|
||||||
|
case = self.make_case()
|
||||||
|
case.move(1 / 60, wall_x=0)
|
||||||
|
self.assertFalse(case.allow_snap)
|
||||||
|
|
||||||
|
case = self.make_case(x=config.SNAP_THRESHOLD + 2)
|
||||||
|
case.move(1 / 60, wall_x=0)
|
||||||
|
self.assertTrue(case.allow_snap)
|
||||||
|
|
||||||
|
def test_placed_case_does_not_move(self) -> None:
|
||||||
|
case = self.make_case()
|
||||||
|
case.placed = True
|
||||||
|
start = case.x
|
||||||
|
case.move(1 / 60, wall_x=0)
|
||||||
|
self.assertEqual(case.x, start)
|
||||||
|
|
||||||
|
def test_rotate_swaps_footprint_and_respects_trailer_height(self) -> None:
|
||||||
|
case = self.make_case(units_w=3, units_h=1)
|
||||||
|
self.assertTrue(case.fits_trailer_height())
|
||||||
|
case.rotate_footprint()
|
||||||
|
self.assertEqual((case.units_w, case.units_h), (1, 3))
|
||||||
|
|
||||||
|
wide = self.make_case(units_w=4, units_h=1)
|
||||||
|
self.assertFalse(wide.fits_trailer_height())
|
||||||
|
|
||||||
|
|
||||||
|
class TrailerTests(unittest.TestCase):
|
||||||
|
WALL = config.TRAILER_X + 500
|
||||||
|
|
||||||
|
def setUp(self) -> None:
|
||||||
|
self.trailer = Trailer()
|
||||||
|
|
||||||
|
def make_case(self, units_w: int, units_h: int) -> Case:
|
||||||
|
return Case(
|
||||||
|
units_w=units_w,
|
||||||
|
units_h=units_h,
|
||||||
|
x=float(config.TRAILER_RIGHT),
|
||||||
|
y=float(config.TRAILER_BOTTOM - units_h * config.UNIT_HEIGHT),
|
||||||
|
)
|
||||||
|
|
||||||
|
def add_base(self, units_w: int = 4, units_h: int = 1, y: float | None = None) -> Case:
|
||||||
|
"""Schwebender Koffer, rechtsbündig an der Barriere."""
|
||||||
|
base = Case(
|
||||||
|
units_w=units_w,
|
||||||
|
units_h=units_h,
|
||||||
|
x=0.0,
|
||||||
|
y=float(config.TRAILER_Y + 100 if y is None else y),
|
||||||
|
)
|
||||||
|
base.x = self.WALL - base.width
|
||||||
|
base.placed = True
|
||||||
|
base.snapped = True
|
||||||
|
self.trailer.stack.append(base)
|
||||||
|
self.trailer.wall_x = base.right
|
||||||
|
return base
|
||||||
|
|
||||||
|
# ------------------------------------------------------------------
|
||||||
|
def test_empty_trailer(self) -> None:
|
||||||
|
self.assertEqual(self.trailer.wall_x, self.trailer.x)
|
||||||
|
self.assertEqual(self.trailer.load_percent(), 0.0)
|
||||||
|
self.assertFalse(self.trailer.overflow())
|
||||||
|
self.assertIsNone(self.trailer.find_platform(self.make_case(1, 1)))
|
||||||
|
|
||||||
|
def test_snap_advances_wall_and_load(self) -> None:
|
||||||
|
case = self.make_case(4, 1)
|
||||||
|
self.trailer.stack_at_wall(case)
|
||||||
|
self.assertTrue(case.placed)
|
||||||
|
self.assertTrue(case.snapped)
|
||||||
|
self.assertEqual(self.trailer.wall_x, self.trailer.x + case.width)
|
||||||
|
expected = (
|
||||||
|
case.width * case.height / (self.trailer.width * self.trailer.height) * 100
|
||||||
|
)
|
||||||
|
self.assertAlmostEqual(self.trailer.load_percent(), expected)
|
||||||
|
|
||||||
|
def test_gap_placement_leaves_hole(self) -> None:
|
||||||
|
case = self.make_case(2, 1)
|
||||||
|
self.trailer.stack_with_gap(case)
|
||||||
|
self.assertEqual(case.x, self.trailer.x + config.SNAP_THRESHOLD)
|
||||||
|
self.assertFalse(case.snapped)
|
||||||
|
|
||||||
|
def test_platform_on_flat_ground_case_is_allowed(self) -> None:
|
||||||
|
# Ein flacher Koffer am Boden hat noch Platz darüber -> darf Plattform sein.
|
||||||
|
ground = self.make_case(4, 1)
|
||||||
|
self.trailer.stack_at_wall(ground)
|
||||||
|
self.assertEqual(ground.y, config.TRAILER_Y + config.TRAILER_HEIGHT - ground.height)
|
||||||
|
self.assertIs(self.trailer.find_platform(self.make_case(1, 1)), ground)
|
||||||
|
|
||||||
|
def test_no_platform_when_case_reaches_top(self) -> None:
|
||||||
|
# Ein 3 Einheiten hoher Koffer endet an der Oberkante -> kein Platz darüber.
|
||||||
|
ground = self.make_case(2, 3)
|
||||||
|
self.trailer.stack_at_wall(ground)
|
||||||
|
self.assertEqual(ground.y, config.TRAILER_Y)
|
||||||
|
self.assertIsNone(self.trailer.find_platform(self.make_case(1, 1)))
|
||||||
|
|
||||||
|
def test_platform_found_for_free_top(self) -> None:
|
||||||
|
base = self.add_base(units_w=4, units_h=1)
|
||||||
|
self.assertIs(self.trailer.find_platform(self.make_case(1, 1)), base)
|
||||||
|
|
||||||
|
def test_platform_rejects_too_wide_case(self) -> None:
|
||||||
|
self.add_base(units_w=2, units_h=1)
|
||||||
|
self.assertIsNone(self.trailer.find_platform(self.make_case(3, 1)))
|
||||||
|
|
||||||
|
def test_platform_rejects_case_not_aligned_with_wall(self) -> None:
|
||||||
|
base = self.add_base(units_w=4, units_h=1)
|
||||||
|
base.x -= 50 # nicht mehr bündig an der Barriere
|
||||||
|
self.assertIsNone(self.trailer.find_platform(self.make_case(1, 1)))
|
||||||
|
|
||||||
|
def test_platform_rejects_no_space_above(self) -> None:
|
||||||
|
self.add_base(units_w=4, units_h=1, y=config.TRAILER_Y + 50)
|
||||||
|
self.assertIsNone(self.trailer.find_platform(self.make_case(1, 1)))
|
||||||
|
|
||||||
|
def test_top_can_only_be_used_once(self) -> None:
|
||||||
|
base = self.add_base(units_w=4, units_h=1)
|
||||||
|
top = self.make_case(1, 1)
|
||||||
|
self.trailer.place_on_top(top, base)
|
||||||
|
self.assertEqual(top.bottom, base.y)
|
||||||
|
self.assertEqual(top.right, base.right)
|
||||||
|
self.assertIsNone(self.trailer.find_platform(self.make_case(1, 1)))
|
||||||
|
|
||||||
|
def test_overflow(self) -> None:
|
||||||
|
self.trailer.wall_x = self.trailer.right + 1
|
||||||
|
self.assertTrue(self.trailer.overflow())
|
||||||
|
|
||||||
|
|
||||||
|
class GameTests(unittest.TestCase):
|
||||||
|
def make_game(self, sequence_length: int = 30) -> Game:
|
||||||
|
sequences = [[CaseSpec(2, 1)] * sequence_length]
|
||||||
|
return Game(None, sequences, name="Test", rng=random.Random(7), submit_scores=False)
|
||||||
|
|
||||||
|
def update_until(self, game: Game, predicate, steps: int = 5000) -> bool:
|
||||||
|
for _ in range(steps):
|
||||||
|
if predicate():
|
||||||
|
return True
|
||||||
|
game.update(1 / 60)
|
||||||
|
return predicate()
|
||||||
|
|
||||||
|
def test_starts_with_a_case(self) -> None:
|
||||||
|
game = self.make_game()
|
||||||
|
self.assertIsNotNone(game.current)
|
||||||
|
self.assertEqual(game.index, 1)
|
||||||
|
self.assertEqual(len(game.upcoming()), 3)
|
||||||
|
|
||||||
|
def test_snapping_places_case_and_advances_wall(self) -> None:
|
||||||
|
game = self.make_game()
|
||||||
|
self.assertTrue(
|
||||||
|
self.update_until(game, lambda: bool(game.current and game.current.allow_snap))
|
||||||
|
)
|
||||||
|
game.handle(Action.PRIMARY)
|
||||||
|
self.update_until(game, lambda: game.animation is None)
|
||||||
|
self.assertEqual(len(game.trailer.stack), 1)
|
||||||
|
self.assertAlmostEqual(
|
||||||
|
game.trailer.wall_x, config.TRAILER_X + 2 * config.UNIT_LENGTH
|
||||||
|
)
|
||||||
|
|
||||||
|
def test_rotation_turns_the_case(self) -> None:
|
||||||
|
game = self.make_game()
|
||||||
|
case = game.current
|
||||||
|
case.x = float(game.trailer.wall_x + config.SNAP_THRESHOLD + 1)
|
||||||
|
case.allow_snap = True
|
||||||
|
game.handle(Action.LEFT)
|
||||||
|
self.update_until(game, lambda: game.animation is None)
|
||||||
|
self.assertEqual((case.units_w, case.units_h), (1, 2))
|
||||||
|
self.assertFalse(case.can_rotate)
|
||||||
|
|
||||||
|
def test_rotation_ignored_for_wide_cases(self) -> None:
|
||||||
|
game = Game(
|
||||||
|
None,
|
||||||
|
[[CaseSpec(4, 1)] * 5],
|
||||||
|
name="Test",
|
||||||
|
rng=random.Random(1),
|
||||||
|
submit_scores=False,
|
||||||
|
)
|
||||||
|
case = game.current
|
||||||
|
case.allow_snap = True
|
||||||
|
game.handle(Action.LEFT)
|
||||||
|
self.assertIsNone(game.animation)
|
||||||
|
self.assertEqual((case.units_w, case.units_h), (4, 1))
|
||||||
|
|
||||||
|
def test_missing_platform_stacks_with_gap(self) -> None:
|
||||||
|
game = self.make_game()
|
||||||
|
self.assertTrue(
|
||||||
|
self.update_until(game, lambda: bool(game.current and game.current.allow_snap))
|
||||||
|
)
|
||||||
|
game.handle(Action.UP) # es gibt nichts, worauf man stapeln könnte
|
||||||
|
self.assertEqual(len(game.trailer.stack), 1)
|
||||||
|
self.assertFalse(game.trailer.stack[0].snapped)
|
||||||
|
self.assertGreater(game.shake, 0)
|
||||||
|
|
||||||
|
def test_game_ends_when_trailer_overflows(self) -> None:
|
||||||
|
game = self.make_game(sequence_length=40)
|
||||||
|
self.assertTrue(
|
||||||
|
self.update_until(
|
||||||
|
game,
|
||||||
|
lambda: game.state is State.GAME_OVER,
|
||||||
|
steps=20000,
|
||||||
|
)
|
||||||
|
)
|
||||||
|
self.assertGreater(game.percent, 0)
|
||||||
|
self.assertLessEqual(game.percent, 100)
|
||||||
|
|
||||||
|
def test_game_ends_when_sequence_is_exhausted(self) -> None:
|
||||||
|
game = self.make_game(sequence_length=3)
|
||||||
|
for _ in range(20000):
|
||||||
|
if game.state is State.GAME_OVER:
|
||||||
|
break
|
||||||
|
if game.current is not None and game.current.allow_snap:
|
||||||
|
game.handle(Action.PRIMARY)
|
||||||
|
game.update(1 / 60)
|
||||||
|
self.assertIs(State.GAME_OVER, game.state)
|
||||||
|
self.assertEqual(len(game.trailer.stack), 3)
|
||||||
|
|
||||||
|
def test_back_quits_and_primary_confirms_game_over(self) -> None:
|
||||||
|
game = self.make_game(sequence_length=2)
|
||||||
|
self.assertTrue(game.handle(Action.PRIMARY))
|
||||||
|
self.assertFalse(game.handle(Action.BACK))
|
||||||
|
|
||||||
|
def test_game_over_lines_mention_player(self) -> None:
|
||||||
|
game = self.make_game(sequence_length=1)
|
||||||
|
game.percent = 80
|
||||||
|
lines = game.game_over_lines()
|
||||||
|
self.assertIn("Test", lines[0])
|
||||||
|
self.assertIn("80%", lines[0])
|
||||||
|
|
||||||
|
|
||||||
|
class StorageTests(unittest.TestCase):
|
||||||
|
def test_roundtrip_in_runtime_dir(self) -> None:
|
||||||
|
with tempfile.TemporaryDirectory() as tmp:
|
||||||
|
os.environ["HAG_RUNTIME_DIR"] = tmp
|
||||||
|
try:
|
||||||
|
self.assertIsNone(storage.load_last_player())
|
||||||
|
storage.save_last_player(" Anna ")
|
||||||
|
self.assertEqual(storage.load_last_player(), "Anna")
|
||||||
|
self.assertTrue((Path(tmp) / storage.LAST_PLAYER_FILE).exists())
|
||||||
|
finally:
|
||||||
|
del os.environ["HAG_RUNTIME_DIR"]
|
||||||
|
|
||||||
|
def test_empty_name_is_ignored(self) -> None:
|
||||||
|
with tempfile.TemporaryDirectory() as tmp:
|
||||||
|
os.environ["HAG_RUNTIME_DIR"] = tmp
|
||||||
|
try:
|
||||||
|
storage.save_last_player(" ")
|
||||||
|
self.assertIsNone(storage.load_last_player())
|
||||||
|
finally:
|
||||||
|
del os.environ["HAG_RUNTIME_DIR"]
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
unittest.main()
|
||||||
Reference in new issue
Block a user