school-horror-game/scripts/gegner_animation.py

154 lines
6.5 KiB
Python

"""Bilder laden und zeitbasierte Gegneranimationen abspielen."""
import json
import math
import os
from pathlib import Path
import pygame
# Sektoren ab Osten im Uhrzeigersinn (Pygame: y nach unten)
_SEKTOREN = ["east", "southeast", "south", "southwest", "west", "northwest", "north", "northeast"]
def richtung_aus_vektor(dx, dy, aktuell=None, hysterese_grad=8.0):
"""8-Richtungs-Name aus einem Vektor. Mit Hysterese, damit die Richtung an den
Sektorgrenzen nicht flackert."""
if dx == 0 and dy == 0:
return aktuell or "south"
winkel = math.degrees(math.atan2(dy, dx)) % 360.0
if aktuell in _SEKTOREN:
mitte = _SEKTOREN.index(aktuell) * 45.0
diff = (winkel - mitte + 180.0) % 360.0 - 180.0
if abs(diff) <= 22.5 + hysterese_grad:
return aktuell
return _SEKTOREN[int((winkel + 22.5) // 45) % 8]
class GegnerSprites:
"""Laedt die Sheets eines Gegners in einer Groesse und schneidet sie in Einzelbilder."""
def __init__(self, gegner="hausmeister", groesse=64, manifest_pfad=None):
if manifest_pfad is None:
manifest_pfad = Path(__file__).resolve().parents[1] / "data" / "textures" / "gegner" / "manifest.json"
if groesse not in (64, 128):
raise ValueError("Die Bildgroesse muss 64 oder 128 sein")
self.wurzel = os.path.dirname(os.path.abspath(manifest_pfad))
with open(manifest_pfad, encoding="utf-8") as f:
self.manifest = json.load(f)
self.richtungen = self.manifest["direction_order"]
E = self.manifest["enemies"][gegner]
G = E["sizes"][str(groesse)]
self.gegner, self.groesse = gegner, groesse
self.pivot = pygame.Vector2(G["pivot"])
self.zustaende = E["states"]
self.aliase = E["aliases"]
self.fuss_geschwindigkeit = {d: pygame.Vector2(v) for d, v in G["walk_foot_lock_velocity_px_s"].items()}
konvertieren = pygame.display.get_init() and pygame.display.get_surface() is not None
self.bilder = {}
for zustand, cfg in self.zustaende.items():
sheet = pygame.image.load(os.path.join(self.wurzel, G["sheets"][zustand]))
if konvertieren:
sheet = sheet.convert_alpha()
w = groesse
self.bilder[zustand] = {
d: [sheet.subsurface((i * w, r * w, w, w)).copy() for i in range(cfg["frames"])]
for r, d in enumerate(self.richtungen)
}
def bild(self, zustand, richtung, index):
return self.bilder[zustand][richtung][index]
class GegnerAnimator:
"""Spielt Zustaende per dt ab. Richtungswechsel und walk <-> run behalten die Schrittphase."""
def __init__(self, sprites, zustand="idle", richtung="south"):
self.sprites = sprites
self.richtung = richtung
self.zustand = None
self.phase = 0.0 # Bildposition als Kommazahl
self.fertig = False
self._treffer_gemeldet = False
self.tempo = 1.0 # Abspieltempo (1 = normal)
self.set_state(zustand)
# ------------------------------------------------------------ Zustand
def _aufloesen(self, zustand):
if zustand in self.sprites.zustaende:
c = self.sprites.zustaende[zustand]
return zustand, c["fps"], c["loop"], None
a = self.sprites.aliase[zustand]
if a.get("hold"):
return a["source"], 0, False, a["frame"]
return a["source"], a["fps"], a.get("loop", True), None
def set_state(self, zustand, neu_starten=False):
if zustand == self.zustand and not neu_starten:
return
quelle, fps, loop, halten = self._aufloesen(zustand)
gleiche_quelle = self.zustand is not None and self._aufloesen(self.zustand)[0] == quelle and halten is None
self.zustand = zustand
self.quelle, self.fps, self.loop, self.halten = quelle, fps, loop, halten
if not (gleiche_quelle and not neu_starten): # walk <-> run: Phase bleibt
self.phase = 0.0
self.fertig = halten is not None
self._treffer_gemeldet = False
def set_direction(self, richtung):
if richtung not in self.sprites.richtungen:
raise ValueError(f"Unbekannte Blickrichtung: {richtung}")
self.richtung = richtung # Phase bleibt erhalten
def blicke_nach(self, dx, dy):
self.richtung = richtung_aus_vektor(dx, dy, self.richtung)
# ------------------------------------------------------------ Zeit
@property
def anzahl(self):
return self.sprites.zustaende[self.quelle]["frames"]
@property
def index(self):
if self.halten is not None:
return self.halten
if self.loop:
return int(self.phase) % self.anzahl
return min(int(self.phase), self.anzahl - 1)
def update(self, dt):
"""dt in Sekunden. Gibt eine Liste von Ereignissen zurueck: 'treffer', 'fertig'."""
if not math.isfinite(dt) or dt < 0:
raise ValueError("dt muss eine endliche, nichtnegative Sekundenzahl sein")
if not math.isfinite(self.tempo) or self.tempo < 0:
raise ValueError("tempo muss endlich und nichtnegativ sein")
ereignisse = []
if self.halten is not None:
return ereignisse
self.phase += dt * self.fps * self.tempo
if self.loop:
self.phase %= self.anzahl
elif self.phase >= self.anzahl:
self.phase = float(self.anzahl)
if not self.fertig:
self.fertig = True
ereignisse.append("fertig")
hit = self.sprites.zustaende[self.quelle].get("hit_frame")
if hit is not None and not self._treffer_gemeldet and self.index >= hit:
self._treffer_gemeldet = True
ereignisse.insert(0, "treffer")
return ereignisse
# ------------------------------------------------------------ Zeichnen
def bild(self):
return self.sprites.bild(self.quelle, self.richtung, self.index)
def zeichnen(self, ziel, fuss_pos, kamera=(0, 0)):
"""Zeichnet so, dass der Pivot (Bodenpunkt) auf fuss_pos - kamera liegt."""
x = round(fuss_pos[0] - kamera[0] - self.sprites.pivot.x)
y = round(fuss_pos[1] - kamera[1] - self.sprites.pivot.y)
ziel.blit(self.bild(), (x, y))
def fussgeschwindigkeit(self):
"""Bildschirmgeschwindigkeit (px/s), bei der die Fuesse in der aktuellen Richtung nicht rutschen."""
v = self.sprites.fuss_geschwindigkeit[self.richtung]
return v * (self.fps / 7.0 if self.quelle == "walk" else 0.0) * self.tempo