add ammo tips

README_TIPS.md

@@ -106,24 +106,24 @@ for px, py in trinkbrunnen_positions:
 
 **So geht's:**
 
-1. Definiere einen Abstandsfaktor, z.B.:
+**Wo und wie den Abstandsfaktor einbauen?**
+
+1. **Definiere den Abstandsfaktor ganz oben in deiner Hauptdatei (z.B. `water-game.py`):**
 
 ```python
-DIST_FACTOR = 2.0  # 2.0 = doppelte Entfernung, 1.0 = Standard
+DIST_FACTOR = 2.0  # Beispielwert, kann angepasst werden
 ```
 
-2. Wende den Faktor auf alle Positionen und die Kartengröße an:
+2. **Wende den Faktor direkt nach dem Laden der Daten an:**
+
+- Nachdem du die Trinkbrunnen-Positionen und ggf. die Spieler-/Gegner-Positionen geladen hast, multipliziere sie mit dem Abstandsfaktor:
 
 ```python
-# Karte vergrößern
-scaled_map = pygame.transform.smoothscale(map_surface, (int(MAP_W * DIST_FACTOR), int(MAP_H * DIST_FACTOR)))
-WIN.blit(scaled_map, (0, 0))
+# Nach dem Laden der Trinkbrunnen-Positionen
+trinkbrunnen_positions = np.load('trinkbrunnen_pixel_positions.npy')
+trinkbrunnen_positions = [(int(px * DIST_FACTOR), int(py * DIST_FACTOR)) for px, py in trinkbrunnen_positions]
 
-# Positionen der Trinkbrunnen anpassen
-for px, py in trinkbrunnen_positions:
-    pygame.draw.circle(WIN, (0, 180, 255), (int(px * DIST_FACTOR), int(py * DIST_FACTOR)), 10)
-
-# Spieler und Gegner-Positionen ebenfalls multiplizieren
+# Spieler und Gegner ebenfalls anpassen (direkt nach deren Initialisierung):
 player.x *= DIST_FACTOR
 player.y *= DIST_FACTOR
 for enemy in enemies:
@@ -131,8 +131,48 @@ for enemy in enemies:
     enemy.y *= DIST_FACTOR
 ```
 
-- Wichtig: Wende den Faktor direkt nach dem Laden der Positionen an, damit alle Objekte synchron gestreckt werden.
-- So wird die Karte "größer" und die Wege zwischen den Trinkbrunnen länger!
+3. **Beim Rendern der Karte:**
+
+- Skaliere die Karte beim Anzeigen:
+
+```python
+scaled_map = pygame.transform.smoothscale(map_surface, (int(MAP_W * DIST_FACTOR), int(MAP_H * DIST_FACTOR)))
+WIN.blit(scaled_map, (0, 0))
+```
+
+**Tipp:**
+
+- Der Abstandsfaktor sollte immer am Anfang und nur einmal auf die Positionen angewendet werden, damit alle Objekte synchron gestreckt werden.
+- Passe ggf. auch die Spielfeldgröße (`WIDTH`, `HEIGHT`) an, wenn die Karte sehr groß wird.
+
+## Schnelles Skalieren der Karte nach dem Laden
+
+- Statt alle Positionen und Objekte zu multiplizieren, kannst du die Karte direkt nach dem Laden einmalig skalieren und die Originalkoordinaten beibehalten.
+- Das ist viel schneller und spart Rechenzeit!
+
+**So geht's:**
+
+1. **Karte nach dem Laden skalieren:**
+
+```python
+DIST_FACTOR = 2.0  # Beispielwert
+
+# Nach dem Laden der Karte (z.B. map_surface):
+scaled_map = pygame.transform.smoothscale(map_surface, (int(MAP_W * DIST_FACTOR), int(MAP_H * DIST_FACTOR)))
+```
+
+2. **Beim Rendern die Karte und alle Objekte mit dem Faktor verschieben:**
+
+```python
+WIN.blit(scaled_map, (0, 0))
+for px, py in trinkbrunnen_positions:
+    pygame.draw.circle(WIN, (0, 180, 255), (int(px * DIST_FACTOR), int(py * DIST_FACTOR)), 10)
+# Spieler, Gegner usw. ebenfalls mit DIST_FACTOR multiplizieren, aber nur beim Zeichnen!
+```
+
+- Die Positionsdaten bleiben im Speicher unverändert, nur die Darstellung wird gestreckt.
+- Das ist besonders bei großen Karten und vielen Objekten viel performanter.
+- Du kannst den Abstandsfaktor jederzeit ändern, ohne die Originaldaten zu verlieren.
 
 ## .exe erstellen (Windows)
 
@@ -215,7 +255,51 @@ def play_intro_video(win, video_path):
 - Nach dem Intro kannst du wie gewohnt den Titelbildschirm anzeigen.
 - Für Windows/Mac kann die Fenster-ID Methode abweichen, siehe Doku von pygame-vlc.
 
-## Zusätzliche Hinweise
+## Munition für den Spieler und Anzeige als Counter
 
-- Stelle sicher, dass alle Bilder und Daten im richtigen Pfad liegen.
-- Für komplexe Projekte nutze eine [PyInstaller spec file](https://pyinstaller.org/en/stable/spec-files.html).
+- So fügst du dem Spieler eine Munition-Variable hinzu und zeigst sie als Counter im Spiel an:
+
+**1. Munition im Player anlegen:**
+
+- Ergänze die Player-Klasse um ein Attribut, z.B.:
+
+```python
+class Player:
+    def __init__(self, x, y, image):
+        self.x = x
+        self.y = y
+        self.image = image
+        self.ammo = 10  # Startwert für Munition
+        # ...
+```
+
+**2. Munition beim Schießen verringern:**
+
+```python
+if player.ammo > 0:
+    bottles.append(TapWater(player.x, player.y, player.dir))
+    player.ammo -= 1
+else:
+    print("Keine Munition!")
+```
+
+**3. Munition beim Berühren eines Trinkbrunnens auffüllen:**
+
+```python
+MAX_AMMO = 10
+# ...
+if player_rect.colliderect(brunnen_rect):
+    player.ammo = MAX_AMMO
+```
+
+**4. Munition als Counter im HUD anzeigen:**
+
+- Im Haupt-Draw-Loop nach dem Zeichnen der Spielfläche:
+
+```python
+font = pygame.font.SysFont(None, 32)
+ammo_text = font.render(f"Wasser: {player.ammo}", True, (0, 0, 255))
+WIN.blit(ammo_text, (20, 20))
+```
+
+- So sieht der Spieler immer, wie viel Munition noch übrig ist!