added Funktional, Undo Doodle
This commit is contained in:
englingvi103466 committed
1 parent
8431a9955a
commit
c269b7f6b8
4 files changed
+342
No files matched your search
@@ -0,0 +1,89 @@
|
||||
import pygame
|
||||
|
||||
|
||||
class Game:
|
||||
def __init__(self):
|
||||
pygame.init()
|
||||
self.screen = pygame.display.set_mode((800, 600))
|
||||
pygame.display.set_caption("Undo Doodle")
|
||||
self.clock = pygame.time.Clock()
|
||||
|
||||
# Der Zustand ist eine Liste von Strichen.
|
||||
# Jeder Strich ist eine Liste von Punkten (tuples).
|
||||
initial_state = []
|
||||
|
||||
# Die Historie speichert die aufeinanderfolgenden, immutablen Zustände
|
||||
self.history = [initial_state]
|
||||
|
||||
self.drawing = False
|
||||
self.current_stroke = []
|
||||
|
||||
@property
|
||||
def current_state(self):
|
||||
"""Liefert den aktuellen Zustand (oberstes Element der Historie)."""
|
||||
return self.history[-1]
|
||||
|
||||
def run(self):
|
||||
running = True
|
||||
while running:
|
||||
running = self.handle_events()
|
||||
self.update()
|
||||
self.draw()
|
||||
self.clock.tick(60)
|
||||
pygame.quit()
|
||||
|
||||
def handle_events(self):
|
||||
for event in pygame.event.get():
|
||||
if event.type == pygame.QUIT:
|
||||
return False
|
||||
|
||||
elif event.type == pygame.KEYDOWN:
|
||||
# Mit 'u' oder Strg+Z einen Schritt zurückgehen (Undo)
|
||||
if event.key == pygame.K_u or (event.key == pygame.K_z and (pygame.key.get_mods() & pygame.KMOD_CTRL)):
|
||||
if len(self.history) > 1:
|
||||
self.history.pop()
|
||||
print("Undo ausgeführt!")
|
||||
|
||||
elif event.type == pygame.MOUSEBUTTONDOWN:
|
||||
if event.button == 1: # Linke Maustaste gedrückt
|
||||
self.drawing = True
|
||||
self.current_stroke = [event.pos]
|
||||
|
||||
elif event.type == pygame.MOUSEMOTION:
|
||||
if self.drawing:
|
||||
self.current_stroke.append(event.pos)
|
||||
|
||||
elif event.type == pygame.MOUSEBUTTONUP:
|
||||
if event.button == 1 and self.drawing:
|
||||
self.drawing = False
|
||||
if self.current_stroke:
|
||||
# IMMUTABLE ANSATZ:
|
||||
# Erstelle einen völlig neuen Zustand (neue Liste),
|
||||
# anstatt den alten Zustand direkt zu verändern.
|
||||
new_strokes = self.current_state + [self.current_stroke]
|
||||
self.history.append(new_strokes)
|
||||
self.current_stroke = []
|
||||
|
||||
return True
|
||||
|
||||
def update(self):
|
||||
pass
|
||||
|
||||
def draw(self):
|
||||
self.screen.fill((255, 255, 255)) # Hintergrund weiß füllen
|
||||
|
||||
# 1. Zeichne alle fertigen Striche aus dem aktuellen Zustand
|
||||
for stroke in self.current_state:
|
||||
if len(stroke) > 1:
|
||||
pygame.draw.lines(self.screen, (0, 0, 0), False, stroke, 3)
|
||||
|
||||
# 2. Zeichne den aktuellen Strich während des Ziehens in einer Vorschau-Farbe
|
||||
if self.drawing and len(self.current_stroke) > 1:
|
||||
pygame.draw.lines(self.screen, (120, 120, 120), False, self.current_stroke, 3)
|
||||
|
||||
pygame.display.flip()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
game = Game()
|
||||
game.run()
|
||||
@@ -0,0 +1,98 @@
|
||||
"""Basisklasse ``Game`` für einfache pygame-Anwendungen."""
|
||||
|
||||
import pygame
|
||||
|
||||
|
||||
class Game:
|
||||
"""Basisklasse für pygame-Spiele.
|
||||
|
||||
Unterklassen passen das Verhalten durch Überschreiben von
|
||||
:meth:`handle_event`, :meth:`update_game` und :meth:`draw_game` an.
|
||||
"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
title: str,
|
||||
fps: int = 60,
|
||||
size: tuple[int, int] = (640, 400),
|
||||
) -> None:
|
||||
"""Legt Fenstertitel, Bildrate und Fenstergröße fest.
|
||||
|
||||
Args:
|
||||
title: Titel des Fensters.
|
||||
fps: Maximale Bilder pro Sekunde.
|
||||
size: Fenstergröße als (Breite, Höhe) in Pixeln.
|
||||
"""
|
||||
self.title: str = title
|
||||
self.fps: int = fps
|
||||
self.size: tuple[int, int] = size
|
||||
self.clock: pygame.time.Clock = pygame.time.Clock()
|
||||
self.dt: float = 0
|
||||
self.screen: pygame.Surface | None = None
|
||||
|
||||
def init_game(self) -> None:
|
||||
"""Initialisiert pygame und erzeugt das Fenster."""
|
||||
pygame.init()
|
||||
pygame.display.set_caption(self.title)
|
||||
self.screen = pygame.display.set_mode(self.size)
|
||||
|
||||
def game_loop(self) -> None:
|
||||
"""Führt die Hauptschleife aus, bis Events oder Update ``False`` liefern."""
|
||||
while True:
|
||||
# Berechnung der Zeitdifferenz seit dem letzten Frame
|
||||
self.dt = self.clock.tick(self.fps) / 1000
|
||||
if self.event_handling() == False:
|
||||
break
|
||||
if self.update_game() == False:
|
||||
break
|
||||
self.draw_game()
|
||||
|
||||
def exit_game(self) -> None:
|
||||
"""Beendet pygame."""
|
||||
pygame.quit()
|
||||
|
||||
def event_handling(self) -> bool:
|
||||
"""Verteilt alle anstehenden Events an :meth:`handle_event`.
|
||||
|
||||
Bleibt in der Unterklasse unverändert.
|
||||
|
||||
Returns:
|
||||
``False``, sobald ein Event das Spiel beenden soll, sonst ``True``.
|
||||
"""
|
||||
for event in pygame.event.get():
|
||||
if not self.handle_event(event):
|
||||
return False
|
||||
return True
|
||||
|
||||
def handle_event(self, event: pygame.event.Event) -> bool:
|
||||
"""Verarbeitet ein einzelnes Event.
|
||||
|
||||
Wird in der Unterklasse überschrieben.
|
||||
|
||||
Args:
|
||||
event: Das zu verarbeitende pygame-Event.
|
||||
|
||||
Returns:
|
||||
``False`` bei ``pygame.QUIT``, sonst ``True``.
|
||||
"""
|
||||
if event.type == pygame.QUIT:
|
||||
return False
|
||||
return True
|
||||
|
||||
def update_game(self) -> bool:
|
||||
"""Aktualisiert den Spielzustand um einen Frame.
|
||||
|
||||
Returns:
|
||||
``False``, wenn das Spiel beendet werden soll, sonst ``True``.
|
||||
"""
|
||||
return True
|
||||
|
||||
def draw_game(self) -> None:
|
||||
"""Zeichnet den aktuellen Frame und bringt ihn zur Anzeige."""
|
||||
pygame.display.flip()
|
||||
|
||||
def run(self) -> None:
|
||||
"""Startet das Spiel: Initialisierung, Hauptschleife, Beenden."""
|
||||
self.init_game()
|
||||
self.game_loop()
|
||||
self.exit_game()
|
||||
@@ -0,0 +1,146 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Installiert die Abhängigkeiten aus pyproject.toml in die aktuelle Python-Umgebung.
|
||||
|
||||
Ersatz für "Install requirements" aus PyCharm, wenn das Projekt eine pyproject.toml
|
||||
statt einer requirements.txt hat. Kein Build, keine besondere Projektstruktur nötig,
|
||||
nur Standardbibliothek (Python >= 3.11).
|
||||
|
||||
Benutzung:
|
||||
In PyCharm: Rechtsklick auf diese Datei -> Run 'install_dependencies'
|
||||
Im Terminal (venv aktiv): python install_dependencies.py
|
||||
|
||||
Ohne Parameter wird ALLES installiert:
|
||||
[project].dependencies + alle [project.optional-dependencies] + alle [dependency-groups]
|
||||
|
||||
Abweichendes Verhalten:
|
||||
python install_dependencies.py --extra dev nur Basis + Extra "dev"
|
||||
python install_dependencies.py --group test nur Basis + Gruppe "test"
|
||||
python install_dependencies.py --no-main --group dev
|
||||
python install_dependencies.py --list nur anzeigen, nichts installieren
|
||||
python install_dependencies.py --write requirements.txt schreiben statt installieren
|
||||
python install_dependencies.py --write -o reqs.txt
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import sys
|
||||
|
||||
if sys.version_info < (3, 11):
|
||||
sys.exit("Dieses Skript braucht Python 3.11 oder neuer (tomllib). "
|
||||
f"Aktuell: {sys.version.split()[0]}")
|
||||
|
||||
import argparse
|
||||
import subprocess
|
||||
import tempfile
|
||||
import tomllib
|
||||
from pathlib import Path
|
||||
|
||||
PROJECT_DIR = Path(__file__).resolve().parent
|
||||
|
||||
|
||||
def resolve_group(groups: dict, name: str, seen: set[str] | None = None) -> list[str]:
|
||||
"""Löst eine Dependency-Group inkl. {include-group = "..."} rekursiv auf."""
|
||||
seen = set() if seen is None else seen
|
||||
if name in seen:
|
||||
raise ValueError(f"Zyklische include-group: {name}")
|
||||
if name not in groups:
|
||||
raise KeyError(f"Dependency-Group '{name}' nicht gefunden")
|
||||
seen.add(name)
|
||||
result: list[str] = []
|
||||
for entry in groups[name]:
|
||||
if isinstance(entry, str):
|
||||
result.append(entry)
|
||||
elif isinstance(entry, dict) and "include-group" in entry:
|
||||
result.extend(resolve_group(groups, entry["include-group"], seen))
|
||||
return result
|
||||
|
||||
|
||||
def collect(data: dict, extras: list[str], groups: list[str], no_main: bool) -> list[str]:
|
||||
project = data.get("project", {})
|
||||
optional = project.get("optional-dependencies", {})
|
||||
dep_groups = data.get("dependency-groups", {})
|
||||
deps: list[str] = []
|
||||
|
||||
if not no_main:
|
||||
deps.extend(project.get("dependencies", []))
|
||||
for extra in extras:
|
||||
if extra not in optional:
|
||||
raise KeyError(f"Optional-Dependency '{extra}' nicht gefunden")
|
||||
deps.extend(optional[extra])
|
||||
for group in groups:
|
||||
deps.extend(resolve_group(dep_groups, group))
|
||||
|
||||
# Duplikate entfernen, Reihenfolge behalten
|
||||
return list(dict.fromkeys(d.strip() for d in deps if d.strip()))
|
||||
|
||||
|
||||
def main() -> int:
|
||||
p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
|
||||
p.add_argument("-p", "--pyproject", type=Path, default=PROJECT_DIR / "pyproject.toml",
|
||||
help="Pfad zur pyproject.toml (Standard: neben diesem Skript)")
|
||||
p.add_argument("--extra", action="append", default=None,
|
||||
help="nur diese optional-dependencies (mehrfach möglich)")
|
||||
p.add_argument("--group", action="append", default=None,
|
||||
help="nur diese dependency-groups (mehrfach möglich)")
|
||||
p.add_argument("--no-main", action="store_true", help="[project].dependencies weglassen")
|
||||
p.add_argument("--list", action="store_true", help="Abhängigkeiten nur anzeigen")
|
||||
p.add_argument("--write", action="store_true", help="requirements-Datei schreiben statt installieren")
|
||||
p.add_argument("-o", "--output", type=Path, default=PROJECT_DIR / "requirements.txt",
|
||||
help="Zieldatei für --write")
|
||||
args = p.parse_args()
|
||||
|
||||
if not args.pyproject.exists():
|
||||
print(f"{args.pyproject} nicht gefunden", file=sys.stderr)
|
||||
return 1
|
||||
data = tomllib.loads(args.pyproject.read_text(encoding="utf-8"))
|
||||
all_extras = list(data.get("project", {}).get("optional-dependencies", {}))
|
||||
all_groups = list(data.get("dependency-groups", {}))
|
||||
|
||||
# Ohne --extra/--group: alles. Mit einem davon: nur das Gewählte.
|
||||
selective = args.extra is not None or args.group is not None
|
||||
extras = (args.extra or []) if selective else all_extras
|
||||
groups = (args.group or []) if selective else all_groups
|
||||
|
||||
try:
|
||||
deps = collect(data, extras, groups, args.no_main)
|
||||
except (KeyError, ValueError) as e:
|
||||
print(f"Fehler: {e.args[0]}", file=sys.stderr)
|
||||
print(f" Vorhandene --extra: {', '.join(all_extras) or '(keine)'}", file=sys.stderr)
|
||||
print(f" Vorhandene --group: {', '.join(all_groups) or '(keine)'}", file=sys.stderr)
|
||||
return 1
|
||||
|
||||
parts = ([] if args.no_main else ["Basis"]) + [f"extra:{e}" for e in extras] + [f"group:{g}" for g in groups]
|
||||
print(f"Auswahl: {', '.join(parts) or '(nichts)'}")
|
||||
|
||||
if args.list:
|
||||
print("\n".join(deps) or "(keine Abhängigkeiten)")
|
||||
return 0
|
||||
|
||||
content = f"# Automatisch erzeugt aus {args.pyproject.name} – nicht von Hand bearbeiten\n" + "\n".join(deps) + "\n"
|
||||
|
||||
if args.write:
|
||||
args.output.write_text(content, encoding="utf-8")
|
||||
print(f"{len(deps)} Abhängigkeiten -> {args.output}")
|
||||
return 0
|
||||
|
||||
if not deps:
|
||||
print("Keine Abhängigkeiten gefunden – nichts zu tun.")
|
||||
return 0
|
||||
|
||||
if sys.prefix == sys.base_prefix:
|
||||
print("WARNUNG: Es ist kein virtuelles Environment aktiv – es wird in die globale "
|
||||
f"Python-Installation installiert:\n {sys.prefix}", file=sys.stderr)
|
||||
if sys.stdin.isatty() and input("Trotzdem fortfahren? [j/N] ").strip().lower() not in ("j", "ja", "y", "yes"):
|
||||
return 1
|
||||
|
||||
with tempfile.NamedTemporaryFile("w", suffix=".txt", delete=False, encoding="utf-8") as tmp:
|
||||
tmp.write(content)
|
||||
tmp_path = Path(tmp.name)
|
||||
try:
|
||||
print(f"Installiere {len(deps)} Abhängigkeiten in {sys.prefix}\n")
|
||||
return subprocess.call([sys.executable, "-m", "pip", "install", "-r", str(tmp_path)])
|
||||
finally:
|
||||
tmp_path.unlink(missing_ok=True)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
@@ -0,0 +1,9 @@
|
||||
[project]
|
||||
name = "wuerfel"
|
||||
version = "0.1.0"
|
||||
dependencies = [
|
||||
"pygame-ce",
|
||||
]
|
||||
|
||||
[project.optional-dependencies]
|
||||
dev = ["pytest", "ruff", "pytest-cov"]
|
||||
Reference in new issue
Block a user