diff --git a/.idea/matrixmania.iml b/.idea/matrixmania.iml
index 3d02032..676a157 100644
--- a/.idea/matrixmania.iml
+++ b/.idea/matrixmania.iml
@@ -4,7 +4,7 @@
-
+
\ No newline at end of file
diff --git a/.idea/misc.xml b/.idea/misc.xml
index cd70baf..44bcdac 100644
--- a/.idea/misc.xml
+++ b/.idea/misc.xml
@@ -3,5 +3,5 @@
-
+
\ No newline at end of file
diff --git a/apollo.py b/apollo.py
index 3ab1ba7..f53516b 100644
--- a/apollo.py
+++ b/apollo.py
@@ -39,4 +39,4 @@ class Apollo(Moon):
if __name__ == "__main__":
apollo = Apollo()
- apollo.start() # bzw. die Start-Methode eurer Game-Klasse
\ No newline at end of file
+ apollo.start()
\ No newline at end of file
diff --git a/compute.py b/compute.py
index 2c02aef..93d00ab 100644
--- a/compute.py
+++ b/compute.py
@@ -104,6 +104,8 @@ def print_matrix(matrix: Matrix) -> None:
"""Print a matrix as a nicely formatted table."""
print(tabulate(matrix, tablefmt="grid"))
+def rot_3D(angle: float, axis: str) -> list[list[float]]
+
if __name__ == "__main__":
a = [[1, 2], [3, 4]]
diff --git a/game.py b/game.py
new file mode 100644
index 0000000..e88c245
--- /dev/null
+++ b/game.py
@@ -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()
\ No newline at end of file
diff --git a/install_dependencies.py b/install_dependencies.py
new file mode 100644
index 0000000..5a20e39
--- /dev/null
+++ b/install_dependencies.py
@@ -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())
diff --git a/moon.py b/moon.py
index 8da135c..3f210fe 100644
--- a/moon.py
+++ b/moon.py
@@ -53,10 +53,10 @@ class Moon(Game):
def draw_game(self) -> None:
"""Zeichnet Erde und Mond."""
- self.clear() # falls Game das anders macht: anpassen
+ self.clear()
self.draw_earth()
self.draw_body(self.absolut(self.pos), MOON_RADIUS, WHITE)
- self.display() # Bild anzeigen
+ self.display()
def draw_earth(self) -> None:
"""Zeichnet die Erde ins Zentrum."""
diff --git a/pyproject.toml b/pyproject.toml
index 3a776b1..d9f90c0 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,4 +1,7 @@
[project]
name = "matrixmania"
version = "0.1.0"
-dependencies = ["tabulate", "ruff"]
\ No newline at end of file
+dependencies = ["tabulate", "ruff"]
+
+[project.optional-dependencies]
+dev = ["pytest", "ruff", "pytest-cov"]
\ No newline at end of file