enne2/mice
1
0
Fork 0
Code Issues Pull Requests Projects Releases 1 Wiki Activity

Add comprehensive test suite for game mechanics and level handling

Browse Source 
- Introduced `test_final_level_flow.py` to validate final level transitions and game end scenarios.
- Created `test_game_over_flow.py` to ensure game over conditions trigger correctly based on rat counts.
- Implemented `test_keybindings.py` to verify keybinding configurations and their context-specific actions.
- Developed `test_level_editor.py` to assess level editor functionalities and layout computations.
- Added `test_level_io.py` for testing level data serialization and deserialization.
- Established `test_loop_logic_parity.py` to ensure consistent game state across multiple simulation runs.
- Created `test_non_regression.py` to simulate game behavior and capture states for future verification.
- Implemented `test_verify.py` to compare current game states against a golden master for regression detection.
This commit is contained in:
Matteo Benedetto
2026-05-19 22:18:43 +02:00
parent 486cd6b7c5
commit c7ed24483d
53 changed files with 10169 additions and 3886 deletions
Download Patch File Download Diff File Expand all files Collapse all files
ARM_APPIMAGE_PLAN.md
-76
View File
@@ -1,76 +0,0 @@
# Piano di distribuzione ARM con AppImage
Questo repository ora e pronto per essere portato dentro un bundle AppImage senza dipendere dalla directory corrente e senza scrivere nel filesystem montato in sola lettura dell'AppImage.
## Stato attuale
- Le risorse di runtime vengono risolte a partire dal root del progetto tramite `MICE_PROJECT_ROOT`.
- I dati persistenti (`scores.txt`, `user_profiles.json`) vengono scritti in una directory utente persistente:
- `MICE_DATA_DIR`, se impostata.
- altrimenti `${XDG_DATA_HOME}/mice`.
- fallback: `~/.local/share/mice`.
- E presente uno scaffold di packaging in `packaging/`.
## Strategia consigliata
1. Costruire l'AppImage su una macchina `aarch64` reale o in una chroot/container ARM.
2. Creare dentro `AppDir` un ambiente Python copiato localmente con `python -m venv --copies`.
3. Installare le dipendenze Python da `requirements.txt` dentro quel Python locale.
4. Copiare il gioco e gli asset in `AppDir/usr/share/mice`.
5. Bundlare le librerie native richieste da SDL2 e dai wheel Python dentro `AppDir/usr/lib`.
6. Usare `AppRun` per esportare `LD_LIBRARY_PATH`, `MICE_PROJECT_ROOT` e `MICE_DATA_DIR` prima del lancio di `rats.py`.
7. Generare il file finale con `appimagetool`.
## Perche costruire nativamente su ARM
- Un AppImage deve contenere binari della stessa architettura del target.
- `PySDL2`, `numpy` e `Pillow` portano con se librerie native o dipendenze native.
- Il cross-build da `x86_64` a `aarch64` e possibile, ma aumenta molto il rischio di incompatibilita su `glibc`, `libSDL2` e wheel Python.
## Comando di build
Da una macchina Linux `aarch64` con `python3`, `rsync`, `ldd`, `ldconfig` e `appimagetool` disponibili:
```bash
./packaging/build_appimage_aarch64.sh
```
Output previsto:
- `dist/AppDir`
- `dist/Mice-aarch64.AppImage`
## Dipendenze host richieste al builder ARM
Serve un sistema di build ARM con almeno:
- `python3`
- `python3-venv`
- `rsync`
- `glibc` userland standard
- `appimagetool`
- librerie di sviluppo/runtime installate sul builder, in particolare:
- `libSDL2`
- `libSDL2_ttf`
## Test minimi da fare sul target ARM
1. Avvio del gioco da shell.
2. Caricamento font e immagini.
3. Riproduzione audio WAV.
4. Salvataggio punteggi in `~/.local/share/mice/scores.txt`.
5. Creazione e lettura profili in `~/.local/share/mice/user_profiles.json`.
6. Cambio livello da `assets/Rat/level.dat`.
## Rischi residui
- La relocazione di un venv copiato dentro AppImage e pratica, ma va verificata sul target reale.
- Se il target ARM ha un userland molto vecchio, conviene costruire l'AppImage su una distro ARM con `glibc` piu vecchia del target.
- Se emergono problemi di relocazione del Python del venv, il passo successivo corretto e passare a un Python relocatable tipo `python-build-standalone` mantenendo invariato il launcher.
## File introdotti
- `runtime_paths.py`
- `packaging/appimage/AppRun`
- `packaging/appimage/mice.desktop`
- `packaging/build_appimage_aarch64.sh`
COLLISION_OPTIMIZATION.md
-221
View File
@@ -1,221 +0,0 @@
# Ottimizzazione Sistema di Collisioni con NumPy
## Sommario
Il sistema di collisioni del gioco è stato ottimizzato per gestire **oltre 200 unità simultanee** mantenendo performance elevate (50+ FPS).
## Problema Originale
### Analisi del Vecchio Sistema
1. **Metodo Rat.collisions()**: O(n²) nel caso peggiore
- Ogni ratto controllava tutte le unità nelle sue celle
- Controllo AABB manuale per ogni coppia
- Con molti ratti nella stessa cella, diventava O(n²)
2. **Calcoli bbox ridondanti**
- bbox calcolata in `draw()` ma usata anche in `collisions()`
- Nessun caching
3. **Esplosioni bombe**: Iterazioni multiple sulle stesse posizioni
- Loop annidati per ogni direzione dell'esplosione
- Controllo manuale di `unit_positions` e `unit_positions_before`
4. **Gas**: Controllo vittime a ogni frame anche quando non necessario
## Soluzione Implementata
### Nuovo Sistema: CollisionSystem (engine/collision_system.py)
#### Caratteristiche Principali
1. **Approccio Ibrido**
- < 10 candidati: Metodo semplice senza overhead NumPy
- ≥ 10 candidati: Operazioni vettorizzate con NumPy
- Ottimale per tutti gli scenari
2. **Spatial Hashing**
- Dizionari `spatial_grid` e `spatial_grid_before`
- Lookup O(1) per posizioni
- Solo candidati nella stessa cella vengono controllati
3. **Pre-allocazione Array NumPy**
- Arrays pre-allocati con capacità iniziale di 100
- Raddoppio dinamico quando necessario
- Riduce overhead di `vstack`/`append`
4. **Collision Layers**
- Matrice di collisione 6x6 per filtrare interazioni non necessarie
- Layers: RAT, BOMB, GAS, MINE, POINT, EXPLOSION
- Controllo O(1) se due layer possono collidere
5. **AABB Vettorizzato**
- Controllo collisioni bbox per N unità in una sola operazione
- Broadcasting NumPy per calcoli paralleli
### Struttura del Sistema
```python
class CollisionSystem:
- register_unit() # Registra unità nel frame corrente
- get_collisions_for_unit() # Trova tutte le collisioni per un'unità
- get_units_in_area() # Ottiene unità in più celle (esplosioni)
- check_aabb_collision_vectorized() # AABB vettorizzato
- _simple_collision_check() # Metodo semplice per pochi candidati
```
### Modifiche alle Unità
#### 1. Unit (units/unit.py)
- Aggiunto attributo `collision_layer`
- Inizializzazione con layer specifico
#### 2. Rat (units/rat.py)
- Usa `CollisionSystem.get_collisions_for_unit()`
- Eliminati loop manuali
- Tolleranza AABB gestita dal sistema
#### 3. Bomb (units/bomb.py)
- Esplosioni usano `get_units_in_area()`
- Raccolta posizioni esplosione → query batch
- Singola operazione per trovare tutte le vittime
#### 4. Gas (units/gas.py)
- Usa `get_units_in_cell()` per trovare vittime
- Separazione tra position e position_before
#### 5. Mine (units/mine.py)
- Controllo trigger con `get_units_in_cell()`
- Layer-based detection
### Integrazione nel Game Loop (rats.py)
```python
# Inizializzazione
self.collision_system = CollisionSystem(
self.cell_size, self.map.width, self.map.height
)
# Update loop (3 passaggi)
1. Move: Tutte le unità si muovono
2. Register: Registrazione nel collision system + backward compatibility
3. Collisions + Draw: Controllo collisioni e rendering
```
## Performance
### Test Results (250 unità su griglia 30x30)
**Stress Test - 100 frames:**
```
Total time: 332.41ms
Average per frame: 3.32ms
FPS capacity: 300.8 FPS
Target (50 FPS): ✓ PASS
```
### Confronto Scenari Reali
| Numero Unità | Frame Time | FPS Capacity |
|--------------|------------|--------------|
| 50 | ~0.5ms | 2000 FPS |
| 100 | ~1.3ms | 769 FPS |
| 200 | ~2.5ms | 400 FPS |
| 250 | ~3.3ms | 300 FPS |
| 300 | ~4.0ms | 250 FPS |
**Conclusione**: Il sistema mantiene **performance eccellenti** anche con 300+ unità, ben oltre il target di 50 FPS.
### Vantaggi per Scenari Specifici
1. **Molti ratti in poche celle**:
- Vecchio: O(n²) per celle dense
- Nuovo: O(n) con spatial hashing
2. **Esplosioni bombe**:
- Vecchio: Loop annidati per ogni direzione
- Nuovo: Singola query batch per tutte le posizioni
3. **Scalabilità**:
- Vecchio: Degrada linearmente con numero unità
- Nuovo: Performance costante grazie a spatial hashing
## Compatibilità
- **Backward compatible**: Mantiene `unit_positions` e `unit_positions_before`
- **Rimozione futura**: Questi dizionari possono essere rimossi dopo test estesi
- **Nessuna breaking change**: API delle unità invariata
## File Modificati
1. ✅ `requirements.txt` - Aggiunto numpy
2. ✅ `engine/collision_system.py` - Nuovo sistema (370 righe)
3. ✅ `units/unit.py` - Aggiunto collision_layer
4. ✅ `units/rat.py` - Ottimizzato collisions()
5. ✅ `units/bomb.py` - Esplosioni vettorizzate
6. ✅ `units/gas.py` - Query ottimizzate
7. ✅ `units/mine.py` - Detection ottimizzata
8. ✅ `units/points.py` - Aggiunto collision_layer
9. ✅ `rats.py` - Integrato CollisionSystem nel game loop
10. ✅ `test_collision_performance.py` - Benchmark suite
## Prossimi Passi (Opzionali)
1. **Rimozione backward compatibility**: Eliminare `unit_positions`/`unit_positions_before`
2. **Profiling avanzato**: Identificare ulteriori bottleneck
3. **Spatial grid gerarchico**: Per mappe molto grandi (>100x100)
4. **Caching bbox**: Se le unità non si muovono ogni frame
## Installazione
```bash
cd /home/enne2/Sviluppo/mice
source .venv/bin/activate
pip install numpy
```
## Testing
```bash
# Benchmark completo
python test_collision_performance.py
# Gioco normale
./mice.sh
```
## Note Tecniche
### Approccio Ibrido Spiegato
Il sistema usa un **threshold di 10 candidati** per decidere quando usare NumPy:
- **< 10 candidati**: Loop Python semplice (no overhead numpy)
- **≥ 10 candidati**: Operazioni vettorizzate NumPy
Questo è ottimale perché:
- Con pochi candidati, l'overhead di creare array NumPy supera i benefici
- Con molti candidati, la vettorizzazione compensa l'overhead iniziale
### Memory Layout
```
Arrays NumPy (pre-allocati):
- bboxes: (capacity, 4) float32 → ~1.6KB per 100 unità
- positions: (capacity, 2) int32 → ~800B per 100 unità
- layers: (capacity,) int8 → ~100B per 100 unità
Total: ~2.5KB per 100 unità (trascurabile)
```
## Conclusioni
L'ottimizzazione con NumPy è **altamente efficace** per il caso d'uso di Mice! con 200+ unità:
✅ Performance eccellenti (300+ FPS con 250 unità)
✅ Scalabilità lineare grazie a spatial hashing
✅ Backward compatible
✅ Approccio ibrido ottimale per tutti gli scenari
✅ Memory footprint minimo
Il sistema è **pronto per la produzione**.
NUMPY_TUTORIAL.md
-773
View File
@@ -1,773 +0,0 @@
# NumPy Tutorial: Dal Tuo Sistema di Collisioni al Codice Ottimizzato
Questo documento spiega NumPy usando come esempio reale il sistema di collisioni di Mice!, confrontando il tuo approccio originale con la versione ottimizzata.
## Indice
1. [Introduzione: Il Problema delle Performance](#1-introduzione-il-problema-delle-performance)
2. [Cos'è NumPy e Perché Serve](#2-cosè-numpy-e-perché-serve)
3. [Concetti Base di NumPy](#3-concetti-base-di-numpy)
4. [Dal Tuo Codice a NumPy: Caso Pratico](#4-dal-tuo-codice-a-numpy-caso-pratico)
5. [Spatial Hashing: L'Algoritmo Intelligente](#5-spatial-hashing-lalgoritmo-intelligente)
6. [Operazioni Vettoriali in NumPy](#6-operazioni-vettoriali-in-numpy)
7. [Best Practices e Pitfalls](#7-best-practices-e-pitfalls)
---
## 1. Introduzione: Il Problema delle Performance
### Il Tuo Sistema Originale (Funzionava Bene!)
```python
# rats.py - Il tuo approccio originale
def update_maze(self):
# Popolava dizionari con le posizioni delle unità
self.unit_positions = {}
self.unit_positions_before = {}
for unit in self.units.values():
unit.move()
# Raggruppa unità per posizione
self.unit_positions.setdefault(unit.position, []).append(unit)
self.unit_positions_before.setdefault(unit.position_before, []).append(unit)
for unit in self.units.values():
unit.collisions() # Ogni unità controlla le proprie collisioni
```
### Il Problema con 200+ Unità
Con 5-10 topi: **funziona perfetto** ✅
Con 200+ topi: **FPS crollano** ❌
**Perché?**
- Ogni topo controlla collisioni con TUTTI gli altri topi
- 200 topi = 200 × 200 = **40,000 controlli per frame!**
- Complessità: **O(n²)** - cresce in modo quadratico
---
## 2. Cos'è NumPy e Perché Serve
### NumPy in 3 Parole
**Array multidimensionali ottimizzati**
### Perché è Veloce?
```python
# Python puro (lento ❌)
distances = []
for i in range(1000):
for j in range(1000):
dx = x[i] - y[j]
dy = x[i] - y[j]
distances.append((dx**2 + dy**2)**0.5)
# Tempo: ~500ms con 1 milione di operazioni
# NumPy (veloce ✅)
import numpy as np
distances = np.sqrt((x[:, None] - y[None, :])**2 + (x[:, None] - y[None, :])**2)
# Tempo: ~5ms - 100 volte più veloce!
```
### Perché la Differenza?
1. **Codice C Compilato**: NumPy è scritto in C/C++, non Python interpretato
2. **Operazioni Vettoriali**: Calcola migliaia di valori in parallelo
3. **Memoria Contigua**: Dati organizzati efficientemente in RAM
4. **CPU SIMD**: Usa istruzioni speciali della CPU per parallelismo hardware
---
## 3. Concetti Base di NumPy
### Array vs Liste Python
```python
# Lista Python (flessibile ma lenta)
lista = [1, 2, 3, 4, 5]
lista.append("sei") # OK - tipi misti
lista[0] = "uno" # OK - cambio tipo
# Array NumPy (veloce ma rigido)
import numpy as np
array = np.array([1, 2, 3, 4, 5])
# array[0] = "uno" # ERRORE! Tipo fisso: int64
```
**Regola**: NumPy sacrifica flessibilità per velocità
### Operazioni Elemento per Elemento
```python
# Python puro
lista_a = [1, 2, 3]
lista_b = [4, 5, 6]
risultato = []
for a, b in zip(lista_a, lista_b):
risultato.append(a + b)
# risultato = [5, 7, 9]
# NumPy (broadcasting)
array_a = np.array([1, 2, 3])
array_b = np.array([4, 5, 6])
risultato = array_a + array_b # [5, 7, 9] - automatico!
```
### Broadcasting: Operazioni su Array di Dimensioni Diverse
```python
# Esempio reale dal tuo gioco: calcolare distanze
unit_positions = np.array([[10, 20], [30, 40], [50, 60]]) # 3 unità
target = np.array([25, 35]) # 1 bersaglio
# Vogliamo: distanza di ogni unità dal bersaglio
# Senza broadcasting (noioso):
distances = []
for pos in unit_positions:
dx = pos[0] - target[0]
dy = pos[1] - target[1]
distances.append(np.sqrt(dx**2 + dy**2))
# Con broadcasting (elegante):
diff = unit_positions - target # NumPy espande target automaticamente
distances = np.sqrt((diff**2).sum(axis=1))
# Output: [18.03, 7.07, 28.28]
```
**Come funziona?**
```
unit_positions: [[10, 20], target: [25, 35]
[30, 40],
[50, 60]] Broadcasting lo espande a:
[[25, 35],
[25, 35],
[25, 35]]
```
---
## 4. Dal Tuo Codice a NumPy: Caso Pratico
### Fase 1: Il Tuo Approccio con i Dizionari
```python
# units/rat.py - Il tuo codice originale
def collisions(self):
# Prende unità nella stessa cella
units_here = self.game.unit_positions.get(self.position, [])
units_before = self.game.unit_positions_before.get(self.position_before, [])
# Controlla ogni unità
for other_unit in units_here + units_before:
if other_unit.id == self.id:
continue
# Logica di collisione...
if self.sex == other_unit.sex and self.fight:
self.die(other_unit)
elif self.sex != other_unit.sex:
self.fuck(other_unit)
```
**Pro del Tuo Approccio:**
- ✅ Semplice e leggibile
- ✅ Usa dizionari Python nativi
- ✅ Funziona perfettamente con poche unità
**Problema con 200+ Unità:**
- ❌ Ogni topo itera su liste di Python
- ❌ Controlli ripetuti (topo A controlla B, poi B controlla A)
- ❌ Nessuna ottimizzazione per distanze
### Fase 2: Spatial Hashing (L'Idea Geniale)
Prima di NumPy, serve un algoritmo migliore: **Spatial Hashing**
```python
# Concetto: dividi il mondo in "celle" (griglia)
# Ogni cella contiene solo le unità al suo interno
# Mondo di gioco:
# 0 1 2 3
# 0 [ ] [ ] [ ] [ ]
# 1 [ ] [A] [B] [ ]
# 2 [ ] [ ] [C] [ ]
# 3 [ ] [ ] [ ] [ ]
# Dizionario spatial hash:
spatial_grid = {
(1, 1): [unit_A],
(2, 1): [unit_B],
(2, 2): [unit_C]
}
# Quando unit_A cerca collisioni:
# Controlla SOLO celle (1,1) e adiacenti (0,0), (0,1), (0,2), (1,0), (1,2), (2,0), (2,1), (2,2)
# Non controlla unit_C a (2,2) - troppo lontano!
```
**Vantaggio**: Da O(n²) a O(n)!
- 200 unità: da 40,000 controlli a ~1,800 controlli (celle adiacenti)
### Fase 3: NumPy per Calcoli Massivi
```python
# engine/collision_system.py - Il nuovo approccio
class CollisionSystem:
def __init__(self, cell_size=32):
# Pre-allocazione: prepara spazio per array NumPy
self.unit_ids = np.zeros(100, dtype=np.int64) # Array di ID
self.bboxes = np.zeros((100, 4), dtype=np.float32) # Array di bounding box
self.positions = np.zeros((100, 2), dtype=np.int32) # Array di posizioni
self.current_size = 0 # Quante unità registrate
self.capacity = 100 # Capacità massima prima di resize
```
**Perché Pre-allocazione?**
```python
# Cattivo: crescita lenta ❌
array = np.array([])
for i in range(1000):
array = np.append(array, i) # Crea NUOVO array ogni volta!
# Tempo: ~200ms
# Buono: pre-allocazione ✅
array = np.zeros(1000)
for i in range(1000):
array[i] = i # Modifica array esistente
# Tempo: ~2ms
```
### Fase 4: Registrazione Unità
```python
def register_unit(self, unit_id, bbox, position, position_before, collision_layer):
"""Registra un'unità nel sistema di collisione"""
# Se array pieno, raddoppia capacità
if self.current_size >= self.capacity:
self._resize_arrays(self.capacity * 2)
idx = self.current_size
# Inserisci dati negli array NumPy
self.unit_ids[idx] = unit_id
self.bboxes[idx] = bbox # [x1, y1, x2, y2]
self.positions[idx] = position
self.position_before[idx] = position_before
self.layers[idx] = collision_layer.value
# Spatial hashing: aggiungi a griglia
cell = (position[0], position[1])
self.spatial_grid[cell].append(idx) # Salva INDICE, non unità
self.current_size += 1
```
**Nota Importante**: Salviamo **indici** negli array, non oggetti Python!
- `spatial_grid[(5, 10)] = [0, 3, 7]` → Unità agli indici 0, 3, 7 degli array NumPy
- Accesso veloce: `self.bboxes[0]`, `self.bboxes[3]`, `self.bboxes[7]`
### Fase 5: Collisioni Vettoriali con NumPy
```python
def get_collisions_for_unit(self, unit_id, bbox, collision_layer):
"""Trova tutte le collisioni per un'unità"""
# 1. Trova celle da controllare (spatial hashing)
x, y = bbox[0] // self.cell_size, bbox[1] // self.cell_size
cells_to_check = [
(x-1, y-1), (x, y-1), (x+1, y-1),
(x-1, y), (x, y), (x+1, y),
(x-1, y+1), (x, y+1), (x+1, y+1)
]
# 2. Raccogli candidati da celle adiacenti
candidates = []
for cell in cells_to_check:
candidates.extend(self.spatial_grid.get(cell, []))
if len(candidates) < 10:
# POCHI candidati: usa Python normale
collisions = []
for idx in candidates:
if self.unit_ids[idx] == unit_id:
continue
if self._check_bbox_collision(bbox, self.bboxes[idx]):
collisions.append((self.layers[idx], self.unit_ids[idx]))
return collisions
else:
# MOLTI candidati: USA NUMPY! ✨
return self._vectorized_collision_check(unit_id, bbox, candidates)
```
### Fase 6: La Magia di NumPy - Vectorized Collision Check
```python
def _vectorized_collision_check(self, unit_id, bbox, candidate_indices):
"""Controlla collisioni usando NumPy per massima velocità"""
# Converti candidati in array NumPy
candidate_indices = np.array(candidate_indices, dtype=np.int32)
# Filtra l'unità stessa (non collidere con se stessi)
mask = self.unit_ids[candidate_indices] != unit_id
candidate_indices = candidate_indices[mask]
if len(candidate_indices) == 0:
return []
# Estrai bounding box di TUTTI i candidati in un colpo solo
candidate_bboxes = self.bboxes[candidate_indices] # Shape: (N, 4)
# candidate_bboxes = [[x1, y1, x2, y2], # candidato 0
# [x1, y1, x2, y2], # candidato 1
# ...]
# Controllo collisione AABB (Axis-Aligned Bounding Box)
# Due rettangoli collidono se:
# - bbox.x1 < other.x2 AND
# - bbox.x2 > other.x1 AND
# - bbox.y1 < other.y2 AND
# - bbox.y2 > other.y1
# NumPy calcola TUTTE le collisioni contemporaneamente! 🚀
colliding_mask = (
(bbox[0] < candidate_bboxes[:, 2]) & # bbox.x1 < others.x2
(bbox[2] > candidate_bboxes[:, 0]) & # bbox.x2 > others.x1
(bbox[1] < candidate_bboxes[:, 3]) & # bbox.y1 < others.y2
(bbox[3] > candidate_bboxes[:, 1]) # bbox.y2 > others.y1
)
# colliding_mask = [True, False, True, False, True, ...]
# Filtra solo unità che collidono
colliding_indices = candidate_indices[colliding_mask]
# Restituisci coppie (layer, unit_id)
return list(zip(
self.layers[colliding_indices],
self.unit_ids[colliding_indices]
))
```
**Spiegazione Dettagliata del Codice NumPy:**
```python
# Esempio concreto con 3 candidati
bbox = [10, 20, 30, 40] # Nostro topo: x1=10, y1=20, x2=30, y2=40
candidate_bboxes = np.array([
[5, 15, 25, 35], # Candidato 0
[50, 60, 70, 80], # Candidato 1 (lontano)
[15, 25, 35, 45] # Candidato 2
])
# Controllo bbox[0] < candidate_bboxes[:, 2]
# bbox[0] = 10
# candidate_bboxes[:, 2] = [25, 70, 35] # Colonna x2 di tutti i candidati
# 10 < [25, 70, 35] = [True, True, True]
# Controllo bbox[2] > candidate_bboxes[:, 0]
# bbox[2] = 30
# candidate_bboxes[:, 0] = [5, 50, 15] # Colonna x1
# 30 > [5, 50, 15] = [True, False, True]
# ... altri controlli ...
# Combinazione finale (AND logico):
colliding_mask = [True, False, True] # Solo 0 e 2 collidono!
```
---
## 5. Spatial Hashing: L'Algoritmo Intelligente
### Visualizzazione Pratica
```
Mondo di gioco 640x480, cell_size=32
Griglia spaziale:
0 1 2 3 4 5 ... 19
┌────┬────┬────┬────┬────┬────┬────┬────┐
0 │ │ │ │ │ │ │ │ │
├────┼────┼────┼────┼────┼────┼────┼────┤
1 │ │ R1 │ R2 │ │ │ │ │ │ R = Rat
├────┼────┼────┼────┼────┼────┼────┼────┤ B = Bomb
2 │ │ R3 │ B1 │ R4 │ │ │ │ │ M = Mine
├────┼────┼────┼────┼────┼────┼────┼────┤
3 │ │ │ M1 │ │ │ │ │ │
└────┴────┴────┴────┴────┴────┴────┴────┘
```
### Come Funziona il Lookup
```python
# R1 cerca collisioni da cella (1, 1)
def get_collisions_for_unit(self, unit_id, bbox):
x, y = 1, 1 # Posizione R1
# Controlla 9 celle (3x3 centrato su R1):
cells = [
(0,0), (1,0), (2,0), # Riga sopra
(0,1), (1,1), (2,1), # Riga centrale (include R1)
(0,2), (1,2), (2,2) # Riga sotto
]
# spatial_grid è un dizionario:
# {
# (1, 1): [idx_R1],
# (2, 1): [idx_R2],
# (1, 2): [idx_R3],
# (2, 2): [idx_B1, idx_R4],
# (2, 3): [idx_M1]
# }
candidates = []
for cell in cells:
candidates.extend(self.spatial_grid.get(cell, []))
# candidates = [idx_R1, idx_R2, idx_R3, idx_B1, idx_R4]
# NON include idx_M1 perché (2,3) è fuori dal range 3x3!
```
### Benefici Misurabili
```python
# SENZA spatial hashing (O(n²)):
# 200 unità → 200 × 200 = 40,000 controlli
# CON spatial hashing (O(n)):
# 200 unità, distribuite su 20×15=300 celle
# Media 0.67 unità per cella
# Ogni unità controlla 9 celle × 0.67 = ~6 candidati
# 200 unità × 6 candidati = 1,200 controlli
#
# Miglioramento: 40,000 → 1,200 = 33x più veloce! 🚀
```
---
## 6. Operazioni Vettoriali in NumPy
### Broadcasting Avanzato: Esplosioni
```python
def get_units_in_area(self, positions, layer_filter=None):
"""Trova unità in un'area (es. esplosione bomba)"""
# positions: lista di posizioni esplose
# es. [(10, 10), (10, 11), (11, 10), (11, 11)] # Esplosione 2x2
if self.current_size == 0:
return []
# Converti in array NumPy
area_positions = np.array(positions, dtype=np.int32) # Shape: (4, 2)
# Prendi posizioni di TUTTE le unità
all_positions = self.positions[:self.current_size] # Shape: (N, 2)
# es. all_positions = [[5, 5], [10, 10], [15, 15], [10, 11], ...]
# Broadcasting trick per confrontare OGNI posizione esplosione con OGNI unità
# area_positions[:, None, :] → Shape: (4, 1, 2)
# all_positions[None, :, :] → Shape: (1, N, 2)
# Risultato → Shape: (4, N, 2) - tutte le combinazioni!
matches = (area_positions[:, None, :] == all_positions[None, :, :]).all(axis=2)
# matches[i, j] = True se esplosione i colpisce unità j
# any(axis=0): almeno una posizione esplosione colpisce quella unità?
unit_hit_mask = matches.any(axis=0) # Shape: (N,)
# Filtra per layer se richiesto
if layer_filter:
valid_layers = self.layers[:self.current_size] == layer_filter.value
unit_hit_mask = unit_hit_mask & valid_layers
# Restituisci ID delle unità colpite
hit_indices = np.where(unit_hit_mask)[0]
return self.unit_ids[hit_indices].tolist()
```
**Spiegazione con Esempio Concreto:**
```python
# Bomba esplode creando 4 celle di fuoco
area_positions = np.array([[10, 10], [10, 11], [11, 10], [11, 11]])
# Ci sono 3 topi nel gioco
all_positions = np.array([[5, 5], [10, 10], [10, 11]])
# Broadcasting:
area_positions[:, None, :].shape # (4, 1, 2)
all_positions[None, :, :].shape # (1, 3, 2)
# Confronto elemento per elemento:
matches = (area_positions[:, None, :] == all_positions[None, :, :]).all(axis=2)
# matches = [
# [False, False, False], # Esplosione (10,10) vs [(5,5), (10,10), (10,11)]
# [False, True, False], # Esplosione (10,11) vs ...
# [False, False, True ], # Esplosione (11,10) vs ...
# [False, False, False] # Esplosione (11,11) vs ...
# ]
# Collassa su asse 0 (almeno UNA esplosione colpisce?)
unit_hit_mask = matches.any(axis=0) # [False, True, True]
# Topo 0 (5,5): NON colpito
# Topo 1 (10,10): COLPITO (da esplosione 0)
# Topo 2 (10,11): COLPITO (da esplosione 1)
```
### Calcolo Distanze Vettoriale
```python
# Esempio: trovare tutti i topi entro raggio 50 pixel da una bomba
bomb_position = np.array([100, 100]) # Posizione bomba
# Posizioni di tutti i topi (array NumPy)
rat_positions = self.positions[:self.current_size] # Shape: (N, 2)
# Calcolo distanze usando broadcasting
diff = rat_positions - bomb_position # Shape: (N, 2)
# diff[i] = [rat_x - bomb_x, rat_y - bomb_y]
distances = np.sqrt((diff ** 2).sum(axis=1)) # Shape: (N,)
# distances[i] = sqrt((dx)^2 + (dy)^2)
# Trova topi entro raggio
within_radius = distances < 50 # Boolean mask
hit_rat_indices = np.where(within_radius)[0]
# Esempio output:
# rat_positions = [[90, 90], [110, 110], [200, 200]]
# diff = [[-10, -10], [10, 10], [100, 100]]
# distances = [14.14, 14.14, 141.42]
# within_radius = [True, True, False]
# hit_rat_indices = [0, 1] # Primi due topi colpiti!
```
---
## 7. Best Practices e Pitfalls
### ✅ Quando Usare NumPy
```python
# BUONO: Operazioni su molti dati
positions = np.array([[...] for _ in range(1000)])
distances = np.sqrt(((positions - target)**2).sum(axis=1))
# CATTIVO: Operazioni su pochi dati (overhead NumPy!)
positions = np.array([[10, 20], [30, 40]]) # Solo 2 elementi
distances = np.sqrt(((positions - target)**2).sum(axis=1))
# Più lento di un semplice loop Python!
```
**Regola nel tuo codice:**
```python
if len(candidates) < 10:
# Usa Python normale
for idx in candidates:
...
else:
# Usa NumPy
self._vectorized_collision_check(...)
```
### ✅ Pre-allocazione vs Append
```python
# CATTIVO ❌ (lento con array grandi)
array = np.array([])
for i in range(10000):
array = np.append(array, i) # O(n) ad ogni append!
# BUONO ✅ (veloce)
array = np.zeros(10000)
for i in range(10000):
array[i] = i # O(1) ad ogni assegnazione
# MIGLIORE ✅ (senza loop!)
array = np.arange(10000) # Operazione vettoriale nativa
```
### ✅ Memory Layout e Performance
```python
# Row-major (C order) - default NumPy
array = np.zeros((1000, 3), order='C')
# Memoria: [x0, y0, z0, x1, y1, z1, ...]
# Veloce per accesso righe: array[i, :]
# Column-major (Fortran order)
array = np.zeros((1000, 3), order='F')
# Memoria: [x0, x1, ..., y0, y1, ..., z0, z1, ...]
# Veloce per accesso colonne: array[:, j]
# Nel tuo caso (posizioni):
self.positions = np.zeros((100, 2)) # Row-major è perfetto
# Accesso frequente: self.positions[idx] → [x, y] di un'unità
```
### ⚠️ Pitfall Comuni
#### 1. Copy vs View
```python
# View (condivide memoria)
a = np.array([1, 2, 3])
b = a[:] # b è una VIEW di a
b[0] = 999
print(a) # [999, 2, 3] - modificato anche a!
# Copy (memoria separata)
a = np.array([1, 2, 3])
b = a.copy()
b[0] = 999
print(a) # [1, 2, 3] - a è immutato
```
**Nel tuo codice:**
```python
def get_collisions_for_unit(self, ...):
# Filtriamo candidati
candidate_indices = candidate_indices[mask] # Crea VIEW
# Se modifichi candidate_indices dopo, potresti modificare l'originale!
# Soluzione: .copy() se necessario
```
#### 2. Broadcasting Inatteso
```python
a = np.array([1, 2, 3])
b = np.array([[1], [2], [3]])
# Cosa succede?
result = a + b
# Broadcasting espande a:
# [[1, 2, 3], [[1], [1], [1]] [[2, 3, 4],
# [1, 2, 3], + [2], [2], [2]] = [3, 4, 5],
# [1, 2, 3]] [3], [3], [3]] [4, 5, 6]]
```
**Verifica sempre le shape:**
```python
print(f"Shape: {array.shape}") # Sempre prima di operazioni complesse!
```
#### 3. Integer Overflow
```python
# ATTENZIONE con dtype piccoli!
a = np.array([250], dtype=np.uint8) # Max 255
b = a + 10 # 260, ma uint8 wrap: diventa 4!
# Soluzione: usa dtype appropriati
a = np.array([250], dtype=np.int32) # Max ~2 miliardi
b = a + 10 # 260 ✅
```
---
## Confronto Finale: Prima vs Dopo
### Codice Originale (Il Tuo)
```python
# rats.py
def update_maze(self):
self.unit_positions = {}
self.unit_positions_before = {}
for unit in self.units.values():
unit.move()
self.unit_positions.setdefault(unit.position, []).append(unit)
self.unit_positions_before.setdefault(unit.position_before, []).append(unit)
for unit in self.units.values():
unit.collisions()
# units/rat.py
def collisions(self):
for other_unit in self.game.unit_positions.get(self.position, []):
if other_unit.id == self.id:
continue
# Controlla collisione...
```
**Complessità**: O(n²) nel caso peggiore
**Performance**: ~50ms con 200 unità
**Memoria**: Dizionari Python + liste di oggetti
### Codice Ottimizzato (NumPy)
```python
# rats.py - 4-pass loop
def update_maze(self):
self.collision_system.clear()
# Pass 1: Pre-registra posizioni
for unit in self.units.values():
self.collision_system.register_unit(unit.id, unit.bbox, ...)
# Pass 2: Movimento
for unit in self.units.values():
unit.move()
# Pass 3: Ri-registra dopo movimento
self.collision_system.clear()
for unit in self.units.values():
self.collision_system.register_unit(unit.id, unit.bbox, ...)
# Pass 4: Collisioni
for unit in self.units.values():
unit.collisions()
# units/rat.py
def collisions(self):
collisions = self.game.collision_system.get_collisions_for_unit(
self.id, self.bbox, self.collision_layer
)
for _, other_id in collisions:
other_unit = self.game.get_unit_by_id(other_id)
if isinstance(other_unit, Rat):
# Controlla collisione...
```
**Complessità**: O(n) con spatial hashing + NumPy
**Performance**: ~3ms con 250 unità (16x più veloce!)
**Memoria**: Array NumPy pre-allocati (più efficiente)
---
## Conclusione
### Cosa Hai Imparato
1. **NumPy**: Array veloci per operazioni matematiche massive
2. **Broadcasting**: Operazioni automatiche su array di dimensioni diverse
3. **Spatial Hashing**: Ridurre O(n²) a O(n) con partizionamento spaziale
4. **Vectorization**: Sostituire loop Python con operazioni NumPy parallele
5. **Pre-allocazione**: Evitare allocazioni ripetute per velocità
### Quando Applicare Queste Tecniche
- ✅ **Usa NumPy quando**: Hai 50+ elementi da processare con operazioni matematiche
- ✅ **Usa Spatial Hashing quando**: Controlli collisioni/prossimità in spazio 2D/3D
- ✅ **Usa Vectorization quando**: Stesso calcolo ripetuto su molti dati
- ❌ **Non usare quando**: Pochi elementi (< 10) o logica complessa non matematica
### Risorse per Approfondire
- **NumPy Documentation**: https://numpy.org/doc/stable/
- **NumPy Quickstart**: https://numpy.org/doc/stable/user/quickstart.html
- **Broadcasting**: https://numpy.org/doc/stable/user/basics.broadcasting.html
- **Performance Tips**: https://numpy.org/doc/stable/user/c-info.performance.html
---
**Il tuo codice originale era ottimo per il caso d'uso iniziale.** L'ottimizzazione con NumPy è stata necessaria solo quando hai scalato a 200+ unità. Questo è un esempio perfetto di "ottimizza quando serve", non prematuramente! 🎯
README_PROFILE_MANAGER.md
-308
View File
@@ -1,308 +0,0 @@
# Game Profile Manager
A PySDL2-based user profile management system designed for gamepad-only control with virtual keyboard input. This system allows players to create, edit, delete, and select user profiles for games using only gamepad inputs or directional keys, with no need for physical keyboard text input.
## Features
- **640x480 Resolution**: Optimized for retro gaming systems and handheld devices
- **Create New Profiles**: Add new user profiles with custom names using virtual keyboard
- **Profile Selection**: Browse and select active profiles
- **Edit Settings**: Modify profile settings including difficulty, volume levels, and preferences
- **Delete Profiles**: Remove unwanted profiles
- **Gamepad/Directional Navigation**: Full control using only gamepad/joystick inputs or arrow keys
- **Virtual Keyboard**: Text input using directional controls - no physical keyboard typing required
- **JSON Storage**: Profiles stored in human-readable JSON format
- **Persistent Settings**: All changes automatically saved
## Installation
### Requirements
- Python 3.6+
- PySDL2
- SDL2 library
### Setup
```bash
# Install required Python packages
pip install pysdl2
# For Ubuntu/Debian users, you may also need:
sudo apt-get install libsdl2-dev libsdl2-ttf-dev
# Make launcher executable
chmod +x launch_profile_manager.sh
```
## Usage
### Running the Profile Manager
```bash
# Method 1: Use the launcher script
./launch_profile_manager.sh
# Method 2: Run directly with Python
python3 profile_manager.py
```
### Gamepad Controls
#### Standard Gamepad Layout (Xbox/PlayStation compatible)
- **D-Pad/Hat**: Navigate menus up/down/left/right, control virtual keyboard cursor
- **Button 0 (A/X)**: Confirm selection, enter menus, select virtual keyboard characters
- **Button 1 (B/Circle)**: Go back, cancel action
- **Button 2 (X/Square)**: Delete profile, backspace in virtual keyboard
- **Button 3 (Y/Triangle)**: Reserved for future features
#### Keyboard Controls (Alternative)
- **Arrow Keys**: Navigate menus and virtual keyboard cursor
- **Enter/Space**: Confirm selection, select virtual keyboard characters
- **Escape**: Go back, cancel action
- **Delete/Backspace**: Delete profile, backspace in virtual keyboard
- **Tab**: Reserved for future features
#### Virtual Keyboard Text Input
When creating or editing profile names:
1. **Navigate**: Use D-Pad/Arrow Keys to move cursor over virtual keyboard
2. **Select Character**: Press A/Enter to add character to profile name
3. **Backspace**: Press X/Delete to remove last character
4. **Complete**: Navigate to "DONE" and press A/Enter to finish input
5. **Cancel**: Navigate to "CANCEL" and press A/Enter to abort
#### Navigation Flow
1. **Main Menu**: Create Profile → Select Profile → Edit Settings → Exit
2. **Profile List**: Choose from existing profiles, or go back
3. **Create Profile**: Use virtual keyboard to enter name, confirm with directional controls
4. **Edit Profile**: Adjust settings using left/right navigation
### Display Specifications
- **Resolution**: 640x480 pixels (4:3 aspect ratio)
- **Optimized for**: Retro gaming systems, handheld devices, embedded systems
- **Font Scaling**: Adaptive font sizes for optimal readability at low resolution
### Profile Structure
Profiles are stored in `user_profiles.json` with the following structure:
```json
{
"profiles": {
"PlayerName": {
"name": "PlayerName",
"created_date": "2024-01-15T10:30:00",
"last_played": "2024-01-20T14:45:00",
"games_played": 25,
"total_score": 15420,
"best_score": 980,
"settings": {
"difficulty": "normal",
"sound_volume": 75,
"music_volume": 60,
"screen_shake": true,
"auto_save": true
},
"achievements": [
"first_win",
"score_500"
]
}
},
"active_profile": "PlayerName"
}
```
## Integration with Games
### Loading Active Profile
```python
import json
def load_active_profile():
try:
with open('user_profiles.json', 'r') as f:
data = json.load(f)
active_name = data.get('active_profile')
if active_name and active_name in data['profiles']:
return data['profiles'][active_name]
except (FileNotFoundError, json.JSONDecodeError):
pass
return None
# Usage in your game
profile = load_active_profile()
if profile:
difficulty = profile['settings']['difficulty']
sound_volume = profile['settings']['sound_volume']
```
### Updating Profile Stats
```python
def update_profile_stats(score, game_completed=True):
try:
with open('user_profiles.json', 'r') as f:
data = json.load(f)
active_name = data.get('active_profile')
if active_name and active_name in data['profiles']:
profile = data['profiles'][active_name]
if game_completed:
profile['games_played'] += 1
profile['total_score'] += score
profile['best_score'] = max(profile['best_score'], score)
profile['last_played'] = datetime.now().isoformat()
with open('user_profiles.json', 'w') as f:
json.dump(data, f, indent=2)
except Exception as e:
print(f"Error updating profile: {e}")
```
## Customization
### Adding New Settings
Edit the `UserProfile` dataclass and the settings adjustment methods:
```python
# In profile_manager.py, modify the UserProfile.__post_init__ method
def __post_init__(self):
if self.settings is None:
self.settings = {
"difficulty": "normal",
"sound_volume": 50,
"music_volume": 50,
"screen_shake": True,
"auto_save": True,
"your_new_setting": "default_value" # Add here
}
```
### Custom Font
Place your font file in the `assets/` directory and update the font path:
```python
font_path = "assets/your_font.ttf"
```
### Screen Resolution
The application is optimized for 640x480 resolution. To change resolution, modify the window size in the init_sdl method:
```python
self.window = sdl2.ext.Window(
title="Profile Manager",
size=(your_width, your_height) # Change from (640, 480)
)
```
### Virtual Keyboard Layout
Customize the virtual keyboard characters by modifying the keyboard_chars list:
```python
self.keyboard_chars = [
['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'],
['K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T'],
['U', 'V', 'W', 'X', 'Y', 'Z', '1', '2', '3', '4'],
['5', '6', '7', '8', '9', '0', '_', '-', ' ', '<'],
['DONE', 'CANCEL', '', '', '', '', '', '', '', '']
]
```
## Troubleshooting
### No Gamepad Detected
- Ensure your gamepad is connected before starting the application
- Try different USB ports
- Check if your gamepad is recognized by your system
- The application will show "No gamepad detected - using keyboard fallback"
- Virtual keyboard works with both gamepad and keyboard controls
### Font Issues
- Ensure the font file exists in the assets directory
- The system will fall back to default font if custom font is not found
- Supported font formats: TTF, OTF
- Font sizes are automatically scaled for 640x480 resolution
### Virtual Keyboard Not Responding
- Ensure you're in text input mode (creating/editing profile names)
- Use arrow keys or D-Pad to navigate the virtual keyboard cursor
- Press Enter/A button to select characters
- The virtual keyboard cursor should be visible as a highlighted character
### Profile Not Saving
- Check file permissions in the application directory
- Ensure sufficient disk space
- Verify JSON format is not corrupted
### Resolution Issues
- The application is designed for 640x480 resolution
- On higher resolution displays, the window may appear small
- This is intentional for compatibility with retro gaming systems
- Content is optimized and readable at this resolution
## File Structure
```
project_directory/
├── profile_manager.py # Main application (640x480, virtual keyboard)
├── launch_profile_manager.sh # Launcher script
├── user_profiles.json # Profile data storage
├── test_profile_manager.py # Test suite for core functions
├── game_profile_integration.py # Example game integration
├── assets/
│ └── decterm.ttf # Font file (optional)
└── README_PROFILE_MANAGER.md # This documentation
```
## Development Notes
### Virtual Keyboard Implementation
The virtual keyboard is implemented as a 2D grid of characters:
- Cursor position tracked with (keyboard_cursor_x, keyboard_cursor_y)
- Character selection adds to input_text string
- Special functions: DONE (confirm), CANCEL (abort), < (backspace)
- Fully navigable with directional controls only
### Screen Layout for 640x480
- Header area: 0-80px (titles, status)
- Content area: 80-400px (main UI elements)
- Controls area: 400-480px (help text, instructions)
- All elements scaled and positioned for optimal readability
### Adding New Screens
1. Add screen name to `current_screen` handling
2. Create render method (e.g., `render_new_screen()`)
3. Add navigation logic in input handlers
4. Update screen transitions in confirm/back handlers
### Gamepad Button Mapping
The application uses SDL2's joystick interface. Button numbers may vary by controller:
- Most modern controllers follow the Xbox layout
- PlayStation controllers map similarly but may have different button numbers
- Test with your specific controller and adjust mappings if needed
### Performance Considerations
- Rendering is capped at 60 FPS for smooth operation
- Input debouncing prevents accidental rapid inputs
- JSON operations are minimized and occur only when necessary
- Virtual keyboard rendering optimized for 640x480 resolution
- Font scaling automatically adjusted for readability
### Adding Support for Different Resolutions
To support different screen resolutions, modify these key areas:
1. Window initialization in `init_sdl()`
2. Panel and button positioning in render methods
3. Font size scaling factors
4. Virtual keyboard grid positioning
### Gamepad Integration Notes
- Uses SDL2's joystick interface for maximum compatibility
- Button mapping follows standard Xbox controller layout
- Hat/D-Pad input prioritized over analog sticks for precision
- Input timing designed for responsive but not accidental activation
## Target Platforms
This profile manager is specifically designed for:
- **Handheld Gaming Devices**: Steam Deck, ROG Ally, etc.
- **Retro Gaming Systems**: RetroPie, Batocera, etc.
- **Embedded Gaming Systems**: Custom arcade cabinets, portable devices
- **Low-Resolution Displays**: 640x480, 800x600, and similar resolutions
- **Gamepad-Only Environments**: Systems without keyboard access
## License
This profile manager is provided as-is for educational and personal use. Designed for integration with retro and handheld gaming systems.
REGENERATE_BACKGROUND_REFACTOR_PLAN.md
-419
View File
@@ -1,419 +0,0 @@
# regenerate_background() Analysis And Refactor Plan
## Scope
This document analyzes `Graphics.regenerate_background()` and proposes a staged refactor plan.
Relevant code paths:
- `engine/graphics.py#L146` `draw_maze()` lazily triggers background generation.
- `engine/graphics.py#L155` `draw_cave_foreground()` consumes cave overlay metadata produced during regeneration.
- `engine/graphics.py#L175` `regenerate_background()` builds the static background texture and cave overlay placements.
- `engine/graphics.py#L311` `add_blood_stain()` confirms that blood is intentionally excluded from the background texture and rendered as a separate overlay.
- `engine/sdl2.py#L98` `create_texture()` composites surface tiles into one SDL texture.
- `engine/sdl2.py#L118` `load_image()` explains why the code keeps both surfaces and textures for the same themed assets.
- `engine/maze.py#L13-L15` define `MAP_EMPTY`, `MAP_WALL`, and `MAP_TUNNEL`.
- `rats.py#L79`, `rats.py#L117-L121`, and `rats.py#L163-L165` show where background state is invalidated.
- `rats.py#L335` shows cave foreground rendering happens after the background draw and before units are drawn.
## What The Method Actually Does
`regenerate_background()` is doing more than the name suggests. It is not only “regenerating a background”; it is handling five separate concerns in one place:
1. It walks the logical map cell by cell.
2. It analyzes neighborhood topology around each wall or tunnel cell.
3. It chooses visual variants, including random grass and flower decoration.
4. It builds cave foreground overlay metadata for later explosion-aware rendering.
5. It commits the accumulated surfaces into a single SDL background texture.
That makes it both a planner and a renderer.
## Current Inputs, Outputs, And Side Effects
### Inputs read from `self`
- `self.map.tiles`, `self.map.width`, `self.map.height`
- `self.cell_size`
- `self.grasses`, `self.grass_textures`
- `self.flowers`, `self.flower_textures`
- `self.edges`, `self.corners`, `self.inner_corners`
- `self.caves`
- `self.render_engine`
### Derived helpers inside the method
- `occupied(x, y)` treats every non-empty cell as occupied, so both walls and tunnels count as solid neighbors for topology decisions.
- `is_tunnel(x, y)` is used only for the flower suppression logic in the bottom-right quadrant.
- `draw(...)` appends background surface tiles.
- `draw_cave(...)` appends cave overlay tuples in the format consumed later by `draw_cave_foreground()`.
- `random_wall()`, `random_wall_texture()`, `random_flower()`, `random_flower_texture()` embed random selection directly in the traversal logic.
### Outputs and side effects
- Resets `self.cave_foreground_tiles`
- Builds a local `texture_tiles` list
- Sets `self.background_texture`
- Does not return a value
This means the method is hard to test in isolation because the real output is split across mutable instance state and SDL object creation.
## Functional Walkthrough
### 1. Initialization
The method creates:
- `texture_tiles`: a list of `(surface, x, y)` tuples for the static background
- `self.cave_foreground_tiles`: a list of `(cell_x, cell_y, direction, surface, x, y)` tuples for overlay rendering
- `half_cell`: used to place quarter-cell tiles at 20 px offsets when `cell_size` is 40
This immediately shows a hidden design choice: one map cell can emit up to four quarter tiles rather than a single full-tile sprite.
### 2. Cell iteration
The outer loop traverses every cell of `self.map.tiles`.
- `MAP_EMPTY`: skipped completely
- `MAP_WALL`: potentially emits several quarter tiles
- `MAP_TUNNEL`: emits cave overlays and sometimes grass filler tiles
### 3. Wall rendering logic
For `MAP_WALL`, the method evaluates the four quadrants independently.
#### Top-left quadrant
If the north-west corner is exposed, it chooses among:
- `inner_corners["WN"]`
- `edges["W"]`
- `edges["N"]`
- `corners["NW"]`
based on whether the north and west neighbors are occupied.
#### Bottom-right quadrant
This is the densest branch. It checks south, east, and south-east occupancy.
- If all three are occupied, it usually draws a random grass tile.
- With a 10% chance, it draws a flower instead, but only if the cell is not near the border and none of the neighboring cells involved are tunnels.
- If only south or east are occupied, it chooses `inner_corners["ES"]`, `edges["E"]`, or `edges["S"]`.
- Otherwise it uses `corners["SE"]`.
This branch mixes topology, decoration policy, border constraints, and tunnel suppression all in one nested block.
#### Top-right quadrant
Mirrors the top-left logic using north and east occupancy:
- `inner_corners["EN"]`
- `edges["E"]`
- `edges["N"]`
- `corners["NE"]`
#### Bottom-left quadrant
Mirrors the same pattern using south and west occupancy:
- `inner_corners["WS"]`
- `edges["W"]`
- `edges["S"]`
- `corners["SW"]`
### 4. Tunnel rendering logic
For `MAP_TUNNEL`, the method checks `above`, `below`, `left`, and `right` occupancy and chooses cave overlay sprites.
Observed behavior:
- If there is no occupied tile above, it always draws a grass filler in the bottom-right quarter and uses the `UP` cave sprite.
- If there is an occupied tile above but not below, it uses the `DOWN` cave sprite.
- If both above and below are occupied and the left side is blocked, it may use a full-quarter wall/flower texture in the cave list.
- If both above and below are occupied and the left side is open, it draws a grass filler plus the `LEFT` cave sprite.
- If above and below are occupied, left is blocked, and right is open, it uses the `RIGHT` cave sprite.
This logic appears tuned to the current level topology and asset set rather than representing a complete, explicit rule system for all tunnel neighbor combinations.
### 5. Commit phase
After traversal, the method calls `render_engine.create_texture(texture_tiles, fill_color=(128, 128, 128))` to compose one static SDL texture for the entire maze background.
This is the correct optimization boundary for the current architecture, but it also means SDL concerns leak directly into the generation logic.
## Why The Method Feels Complex
The complexity is not only “too many lines”. It comes from multiple kinds of coupling.
### 1. Mixed responsibilities
The method mixes:
- map analysis
- rule selection
- random decoration
- cave overlay planning
- final rendering commit
Each of these changes for different reasons, so they should not live in the same function.
### 2. Repeated neighborhood queries
Neighbor checks like `occupied(x, y - 1)` and `occupied(x + 1, y)` are recomputed many times, often inside overlapping branches. That makes the code noisy and increases the chance of introducing asymmetric bugs during edits.
### 3. Hidden representation mismatch
Background composition uses SDL surfaces, while cave overlays use textures. That is why the code has parallel helpers like `random_wall()` and `random_wall_texture()`. The behavior is valid, but the representation split is leaking into every branch.
### 4. Randomness is embedded in rule logic
The function directly calls global `random` during traversal. That makes visual behavior hard to snapshot-test or compare before and after a refactor.
### 5. Side effects are scattered across the class lifecycle
Invalidation is controlled elsewhere in `rats.py`, where the code manually clears:
- `self.background_texture`
- `self.blood_layer_sprites`
- `self.cave_foreground_tiles`
This is correct today, but it creates a fragile contract between game flow code and rendering code.
### 6. Tunnel rules are implicit
The tunnel branch contains nested assumptions that are hard to verify by inspection. It is not obvious whether the logic is exhaustive, map-specific, or intentionally asymmetric.
## Important Invariants To Preserve
Any refactor must keep these behaviors unless you explicitly choose to change them:
1. Blood stains remain outside the static background texture.
2. `draw_cave_foreground()` must still be able to swap cave sprites for explosion sprites at runtime.
3. Quarter-tile placement and offsets must remain visually identical.
4. Random flower placement must preserve the current frequency and tunnel/border exclusions, or the change must be documented as a visual redesign.
5. Theme asset selection must keep using surfaces for background composition and textures for runtime overlays unless the render-engine API changes.
## Refactor Goals
The target should be:
- easier to read
- behaviorally stable
- testable without SDL
- explicit about map-topology rules
- easy to extend with new wall or tunnel tile rules
## Recommended Refactor Direction
The safest path is not a full rewrite. It is a staged extraction toward a pure planning layer.
### Stage 1: Name The Concepts
Extract small private helpers without changing data structures yet.
Suggested helpers:
- `_is_occupied(x, y)`
- `_is_tunnel(x, y)`
- `_make_cell_context(x, y)`
- `_append_background_tile(surface, x, y, texture_tiles)`
- `_append_cave_tile(surface, x, y, direction)`
- `_choose_wall_fill(x, y, allow_flower)`
This alone will remove repeated neighbor reads and make the current logic easier to reason about.
### Stage 2: Introduce A Pure Planning Model
Create lightweight data containers, for example:
```python
from dataclasses import dataclass
@dataclass(frozen=True)
class TilePlacement:
surface: object
x: int
y: int
@dataclass(frozen=True)
class CavePlacement:
cell_x: int
cell_y: int
direction: str | None
sprite: object
x: int
y: int
@dataclass(frozen=True)
class CellContext:
x: int
y: int
cell: int
north: bool
south: bool
east: bool
west: bool
north_west: bool
north_east: bool
south_west: bool
south_east: bool
```
Then split the method into:
- `_build_background_plan()`
- `_plan_wall_cell(context, plan)`
- `_plan_tunnel_cell(context, plan)`
- `_commit_background_plan(plan)`
The important shift is this: planning should produce plain Python data first, and SDL texture creation should happen only in the commit step.
### Stage 3: Replace Nested Branches With Rule Helpers
The wall logic is currently “four quadrants, each with a small rule tree”. Keep that structure, but make it explicit.
Suggested helpers:
- `_plan_wall_nw(context, px, py, plan)`
- `_plan_wall_ne(context, px, py, half_cell, plan)`
- `_plan_wall_sw(context, px, py, half_cell, plan)`
- `_plan_wall_se(context, px, py, half_cell, plan)`
This sounds verbose, but it is much easier to review because each helper owns one visual quadrant and one set of rules.
### Stage 4: Isolate Decoration Policy
The flower rule is currently buried inside the `SE` branch. Extract it into a dedicated function such as:
```python
def _should_place_flower(self, x, y, context) -> bool:
...
```
That function should own:
- the 10% probability
- border exclusions
- tunnel exclusions
This makes visual tuning possible without reopening the topology logic.
### Stage 5: Make Tunnel Rules Explicit
Tunnel behavior needs a named rule function with documented cases.
For example:
- `_classify_tunnel(context) -> TunnelPattern`
- `_plan_tunnel_pattern(pattern, px, py, plan)`
Even if the final logic stays the same, naming the tunnel patterns will expose whether the code is intentionally map-specific or accidentally incomplete.
### Stage 6: Centralize Invalidation
Introduce one method such as:
```python
def invalidate_background(self):
self.background_texture = None
self.cave_foreground_tiles.clear()
```
Then use that method from lifecycle points in `rats.py`.
This reduces the chance of future bugs where one part of the cached rendering state is reset and another is forgotten.
## Suggested Final Shape
The long-term shape can stay inside `Graphics` and still be much cleaner:
```python
def regenerate_background(self):
plan = self._build_background_plan()
self._commit_background_plan(plan)
def _build_background_plan(self):
...
def _plan_wall_cell(self, context, plan):
...
def _plan_tunnel_cell(self, context, plan):
...
def _commit_background_plan(self, plan):
self.cave_foreground_tiles = plan.cave_tiles
self.background_texture = self.render_engine.create_texture(
plan.background_tiles,
fill_color=(128, 128, 128),
)
```
This would preserve the current class boundaries while making the core algorithm testable.
## Test Strategy Before Refactoring
Because the function is visual and randomized, refactoring without a guardrail is risky.
Recommended safety steps:
1. Introduce a seeded RNG path so map generation can be deterministic during tests.
2. Add a small test map fixture that exercises walls, corners, borders, and tunnels.
3. Snapshot the produced tile plan, not the SDL texture object.
4. Verify cave overlay tuples are identical before and after the extraction.
5. Add a smoke test for `draw_cave_foreground()` with an explosion unit to ensure cave sprite replacement still works.
## Proposed Implementation Order
### Phase 0: Freeze Current Behavior
- Add a deterministic RNG entry point or injectable random source.
- Capture the current background plan for one or two representative maps.
### Phase 1: Extract Context And Emit Helpers
- Remove repeated `occupied(...)` calls.
- Keep current tuple outputs and current SDL commit behavior.
### Phase 2: Split Wall And Tunnel Planning
- Move wall rules into quadrant helpers.
- Move tunnel rules into a dedicated planner.
### Phase 3: Introduce A `BackgroundPlan`
- Return plain data from planning.
- Keep SDL texture creation in one place.
### Phase 4: Centralize Cache Invalidation
- Replace direct state resets with a single background invalidation method.
### Phase 5: Optional Optimization Pass
- Consider caching immutable plans by `(level_index, theme_index)` if needed.
- Consider precomputing per-cell contexts if profiling shows the planner is still hot.
## Refactor Risks And Questions
These should be clarified before implementation:
1. Are tunnel patterns guaranteed by the level data, or should the code become exhaustive for arbitrary maps?
2. Is `occupied()` intentionally treating tunnels as “solid” for wall topology, or is that only a rendering shortcut?
3. Is the flower placement rule part of the visual identity, or can it be simplified?
4. Do we want to keep both surfaces and textures in the theme cache, or would a render-engine API change be acceptable later?
## Recommended First Refactor PR
The lowest-risk first PR would do only this:
1. Extract `CellContext` creation.
2. Extract the four wall-quadrant planners.
3. Extract tunnel planning into one helper.
4. Leave the tuple formats and SDL commit step unchanged.
That PR would reduce complexity sharply while keeping the visual output almost certainly identical.
## Summary
`regenerate_background()` is complex because it is simultaneously a topology analyzer, decoration policy engine, cave overlay planner, and SDL background composer. The safest refactor is to separate planning from rendering, then isolate wall rules, tunnel rules, and decoration policy into named helpers with deterministic test coverage.
RENDERING_ANALYSIS.md
-466
View File
@@ -1,466 +0,0 @@
# Analisi Performance Rendering SDL2 - Mice!
## Sommario Esecutivo
Il sistema di rendering presenta **diverse criticità** che possono causare cali di FPS con molte unità (200+). Ho identificato 7 problemi principali e relative soluzioni.
---
## 🔴 CRITICITÀ IDENTIFICATE
### 1. **Controllo Visibilità Inefficiente** ⚠️ ALTA PRIORITÀ
**Problema:**
```python
def is_in_visible_area(self, x, y):
return (-self.w_offset - self.cell_size <= x <= self.width - self.w_offset and
-self.h_offset - self.cell_size <= y <= self.height - self.h_offset)
```
Ogni `draw_image()` chiama `is_in_visible_area()` che fa **4 confronti** per ogni sprite.
**Impatto con 250 unità:**
- 250 unità × 4 confronti = **1000 operazioni per frame**
- Molte unità potrebbero essere fuori schermo ma vengono controllate comunque
**Soluzione:**
```python
# Opzione A: Culling a livello di game loop (CONSIGLIATA)
# Filtra unità PRIMA del draw usando spatial grid
visible_cells = get_visible_cells(w_offset, h_offset, viewport_width, viewport_height)
for unit in units:
if unit.position in visible_cells or unit.position_before in visible_cells:
unit.draw()
# Opzione B: Cache dei bounds
class GameWindow:
def update_viewport_bounds(self):
self.visible_x_min = -self.w_offset - self.cell_size
self.visible_x_max = self.width - self.w_offset
self.visible_y_min = -self.h_offset - self.cell_size
self.visible_y_max = self.height - self.h_offset
def is_in_visible_area(self, x, y):
return (self.visible_x_min <= x <= self.visible_x_max and
self.visible_y_min <= y <= self.visible_y_max)
```
**Guadagno stimato:** 10-15% con 200+ unità
---
### 2. **Chiamate renderer.copy() Non Batch** ⚠️ ALTA PRIORITÀ
**Problema:**
```python
# Ogni unità chiama renderer.copy() individualmente
def draw_image(self, x, y, sprite, tag=None, anchor="nw"):
if not self.is_in_visible_area(x, y):
return
sprite.position = (x + self.w_offset, y + self.w_offset)
self.renderer.copy(sprite, dstrect=sprite.position) # ← Singola chiamata SDL
```
**Impatto:**
- 250 unità = **250 chiamate individuali a SDL2**
- Ogni chiamata ha overhead di context switch
- Non sfrutta batching hardware
**Soluzione - Sprite Batching:**
```python
class GameWindow:
def __init__(self, ...):
self.sprite_batch = [] # Accumula sprite da disegnare
def queue_sprite(self, x, y, sprite):
"""Accoda sprite invece di disegnarlo subito"""
if self.is_in_visible_area(x, y):
self.sprite_batch.append((sprite, x + self.w_offset, y + self.h_offset))
def flush_sprites(self):
"""Disegna tutti gli sprite in batch"""
for sprite, x, y in self.sprite_batch:
sprite.position = (x, y)
self.renderer.copy(sprite, dstrect=sprite.position)
self.sprite_batch.clear()
# Nel game loop
for unit in units:
unit.draw() # Ora usa queue_sprite invece di draw_image
renderer.flush_sprites() # Singolo flush alla fine
```
**Guadagno stimato:** 15-25% con 200+ unità
---
### 3. **Calcolo Posizioni Ridondante** ⚠️ MEDIA PRIORITÀ
**Problema in Rat.draw():**
```python
def draw(self):
start_perf = self.game.render_engine.get_perf_counter() # ← Non utilizzato!
direction = self.calculate_rat_direction() # ← Già calcolato in move()
# Calcolo partial_x/y ripetuto per ogni frame
if direction in ["UP", "DOWN"]:
partial_y = self.partial_move * self.game.cell_size * (1 if direction == "DOWN" else -1)
else:
partial_x = self.partial_move * self.game.cell_size * (1 if direction == "RIGHT" else -1)
x_pos = self.position_before[0] * self.game.cell_size + ...
y_pos = self.position_before[1] * self.game.cell_size + ...
# get_image_size() chiamato ogni frame
image_size = self.game.render_engine.get_image_size(image)
```
**Impatto:**
- `calculate_rat_direction()`: già calcolato in `move()` → **250 chiamate duplicate**
- `get_image_size()`: dimensioni statiche, non cambiano → **250 lookups inutili**
- Calcoli aritmetici ripetuti
**Soluzione - Cache in Unit:**
```python
class Rat(Unit):
def move(self):
# ... existing move logic ...
self.direction = self.calculate_rat_direction() # Cache direction
# Pre-calcola render_position durante move
self._update_render_position()
def _update_render_position(self):
"""Pre-calcola posizione di rendering"""
if self.direction in ["UP", "DOWN"]:
partial_y = self.partial_move * self.game.cell_size * (1 if self.direction == "DOWN" else -1)
partial_x = 0
else:
partial_x = self.partial_move * self.game.cell_size * (1 if self.direction == "RIGHT" else -1)
partial_y = 0
image_size = self.game.rat_image_sizes[self.sex if self.age > AGE_THRESHOLD else "BABY"][self.direction]
self.render_x = self.position_before[0] * self.game.cell_size + (self.game.cell_size - image_size[0]) // 2 + partial_x
self.render_y = self.position_before[1] * self.game.cell_size + (self.game.cell_size - image_size[1]) // 2 + partial_y
self.bbox = (self.render_x, self.render_y, self.render_x + image_size[0], self.render_y + image_size[1])
def draw(self):
sex = self.sex if self.age > AGE_THRESHOLD else "BABY"
image = self.game.rat_assets_textures[sex][self.direction]
self.game.render_engine.draw_image(self.render_x, self.render_y, image, tag="unit")
```
**Pre-cache dimensioni immagini in Graphics:**
```python
class Graphics:
def load_assets(self):
# ... existing code ...
# Pre-cache image sizes
self.rat_image_sizes = {}
for sex in ["MALE", "FEMALE", "BABY"]:
self.rat_image_sizes[sex] = {}
for direction in ["UP", "DOWN", "LEFT", "RIGHT"]:
texture = self.rat_assets_textures[sex][direction]
self.rat_image_sizes[sex][direction] = texture.size
```
**Guadagno stimato:** 5-10% con 200+ unità
---
### 4. **Tag System Inutilizzato** ⚠️ BASSA PRIORITÀ
**Problema:**
```python
def delete_tag(self, tag):
"""Placeholder for tag deletion (not implemented)"""
pass
# Ogni draw passa tag="unit" ma non viene mai usato
unit.draw() # → draw_image(..., tag="unit")
```
**Impatto:**
- Overhead minimo di passaggio parametro inutile
- 250 unità × parametro = spreco memoria call stack
**Soluzione:**
Rimuovere parametro `tag` da `draw_image()` e tutte le chiamate.
**Guadagno stimato:** 1-2%
---
### 5. **Generazione Blood Stains Costosa** ⚠️ MEDIA PRIORITÀ
**Problema:**
```python
def add_blood_stain(self, position):
# Genera nuova surface SDL con pixel manipulation
new_blood_surface = self.render_engine.generate_blood_surface() # LENTO
if position in self.blood_stains:
# Combina surfaces con pixel blending
combined_surface = self.render_engine.combine_blood_surfaces(...) # MOLTO LENTO
# WORST: Rigenera TUTTO il background
self.background_texture = None # ← Forza rigenerazione completa
```
**Impatto:**
- Ogni morte di ratto → rigenerazione background completo
- 200 morti = **200 rigenerazioni** di texture enorme
- `generate_blood_surface()`: loop pixel-by-pixel
- `combine_blood_surfaces()`: blending manuale RGBA
**Soluzione - Pre-generazione + Overlay Layer:**
```python
class Graphics:
def load_assets(self):
# Pre-genera 10 varianti di blood stains
self.blood_stain_pool = [
self.render_engine.generate_blood_surface()
for _ in range(10)
]
self.blood_stain_textures = [
self.render_engine.factory.from_surface(surface)
for surface in self.blood_stain_pool
]
# Layer separato per blood
self.blood_layer_sprites = []
def add_blood_stain(self, position):
"""Aggiunge blood come sprite invece che rigenerare background"""
import random
blood_texture = random.choice(self.blood_stain_textures)
x = position[0] * self.cell_size
y = position[1] * self.cell_size
self.blood_layer_sprites.append((blood_texture, x, y))
def draw_blood_layer(self):
"""Disegna tutti i blood stains come sprites"""
for texture, x, y in self.blood_layer_sprites:
self.render_engine.draw_image(x, y, texture, tag="blood")
# Nel game loop
self.draw_maze() # Background statico (UNA SOLA VOLTA)
self.draw_blood_layer() # Blood stains come sprites
# ... draw units ...
```
**Guadagno stimato:** 20-30% durante scenari con molte morti
---
### 6. **Font Manager Creazione Inefficiente** ⚠️ BASSA PRIORITÀ
**Problema:**
```python
def generate_fonts(self, font_file):
fonts = {}
for i in range(10, 70, 1): # 60 font managers!
fonts.update({i: sdl2.ext.FontManager(font_path=font_file, size=i)})
return fonts
```
**Impatto:**
- 60 FontManager creati all'avvio
- Usa solo 3-4 dimensioni durante il gioco
- Memoria sprecata: ~60 × FontManager overhead
**Soluzione - Lazy Loading:**
```python
def generate_fonts(self, font_file):
self.font_file = font_file
self.fonts = {}
# Pre-carica solo dimensioni comuni
common_sizes = [20, 35, 45]
for size in common_sizes:
self.fonts[size] = sdl2.ext.FontManager(font_path=font_file, size=size)
def get_font(self, size):
"""Lazy load font se non esiste"""
if size not in self.fonts:
self.fonts[size] = sdl2.ext.FontManager(font_path=self.font_file, size=size)
return self.fonts[size]
```
**Guadagno:** Startup time: -200ms, Memoria: -5MB
---
### 7. **Performance Counter Inutilizzato** ⚠️ MINIMA PRIORITÀ
**Problema in Rat.draw():**
```python
def draw(self):
start_perf = self.game.render_engine.get_perf_counter() # Mai usato!
# ... resto del codice ...
```
**Impatto:**
- 250 chiamate a `SDL_GetPerformanceCounter()` per niente
- Overhead chiamata: ~0.001ms × 250 = 0.25ms/frame
**Soluzione:**
Rimuovere la riga o usarla per profiling reale.
---
## 📊 IMPATTO TOTALE STIMATO
### Performance Attuali (Stimate)
Con 250 unità:
- Collision detection: ~3.3ms (✅ ottimizzato)
- Rendering: **~10-15ms** (🔴 collo di bottiglia)
- Game logic: ~2ms
- **TOTALE: ~15-20ms/frame** (50-65 FPS)
### Performance Post-Ottimizzazione
Con 250 unità:
- Collision detection: ~3.3ms
- Rendering: **~4-6ms** (✅ migliorato 2.5x)
- Game logic: ~2ms
- **TOTALE: ~9-11ms/frame** (90-110 FPS)
---
## 🎯 PIANO DI IMPLEMENTAZIONE CONSIGLIATO
### Priority 1 - Quick Wins (1-2 ore)
1. ✅ **Viewport culling** (soluzione A - spatial grid)
2. ✅ **Cache render positions** in Rat
3. ✅ **Pre-cache image sizes**
4. ✅ **Rimuovi tag parameter**
**Guadagno atteso: 20-30%**
### Priority 2 - Medium Effort (2-3 ore)
5. ✅ **Blood stain overlay layer** (invece di rigenerazione)
6. ✅ **Sprite batching** (queue + flush)
**Guadagno atteso: +30-40% cumulativo = 50-70% totale**
### Priority 3 - Optional (1 ora)
7. ✅ **Lazy font loading**
8. ✅ **Rimuovi performance counter inutilizzato**
**Guadagno atteso: marginale ma cleanup code**
---
## 🔧 OTTIMIZZAZIONI AVANZATE (Opzionali)
### A. Texture Atlas per Rat Sprites
**Problema:** 250 ratti = 250 texture bind per frame
**Soluzione:**
```python
# Combina tutti i rat sprites in una singola texture
# Usa source rectangles per selezionare sprite specifici
rat_atlas = create_texture_atlas(all_rat_sprites)
renderer.copy(rat_atlas, srcrect=sprite_rect, dstrect=screen_rect)
```
**Guadagno:** +10-20% con 200+ unità
### B. Dirty Rectangle Tracking
**Problema:** Ridisegna tutto il background ogni frame
**Soluzione:**
```python
# Traccia solo le aree che sono cambiate
dirty_rects = []
for unit in units:
if unit.moved:
dirty_rects.append(unit.previous_rect)
dirty_rects.append(unit.current_rect)
# Ridisegna solo dirty rects
for rect in dirty_rects:
redraw_region(rect)
```
**Guadagno:** +30-50% su mappe grandi
### C. Multi-threaded Rendering
**Problema:** Single-threaded rendering
**Soluzione:**
```python
# Thread 1: Game logic + collision
# Thread 2: Preparazione sprite (calcolo posizioni, culling)
# Main thread: Solo rendering SDL
```
**Guadagno:** +40-60% su CPU multi-core
---
## 📈 METRICHE DI SUCCESSO
Dopo le ottimizzazioni Priority 1 e 2:
| Unità | FPS Attuale | FPS Target | FPS Atteso |
|-------|-------------|------------|------------|
| 50 | ~60 | 60 | 60+ |
| 100 | ~55 | 60 | 60+ |
| 200 | ~45 | 50 | 70-80 |
| 250 | ~35-40 | 50 | 60-70 |
| 300 | ~30 | 50 | 50-60 |
---
## 🧪 STRUMENTI DI PROFILING
### Script di Benchmark Rendering
```python
# test_rendering_performance.py
import time
from rats import MiceMaze
def benchmark_rendering():
game = MiceMaze('maze.json')
# Spawna 250 ratti
for _ in range(250):
game.spawn_rat()
# Misura 100 frame
render_times = []
for _ in range(100):
start = time.perf_counter()
# Solo rendering (no game logic)
game.draw_maze()
for unit in game.units.values():
unit.draw()
game.renderer.present()
render_times.append((time.perf_counter() - start) * 1000)
print(f"Avg render time: {sum(render_times)/len(render_times):.2f}ms")
print(f"Min: {min(render_times):.2f}ms, Max: {max(render_times):.2f}ms")
```
---
## 💡 CONCLUSIONI
Il rendering è **il principale bottleneck** con 200+ unità, non le collisioni.
**Ottimizzazioni critiche:**
1. Viewport culling (15% gain)
2. Sprite batching (25% gain)
3. Blood stain overlay (30% gain in scenari con morti)
4. Cache render positions (10% gain)
**Implementando Priority 1 + 2 si ottiene ~2.5x speedup sul rendering**, portando il gioco da ~40 FPS a ~70-80 FPS con 250 unità.
Il sistema di collisioni NumPy è già ottimizzato (3.3ms), quindi il focus deve essere sul rendering SDL2.
RENDERING_OPTIMIZATIONS_DONE.md
-259
View File
@@ -1,259 +0,0 @@
# Ottimizzazioni Rendering Implementate
## ✅ Completato - 24 Ottobre 2025
### Modifiche Implementate
#### 1. **Cache Viewport Bounds** ✅ (+15% performance)
**File:** `engine/sdl2.py`
**Problema:** `is_in_visible_area()` ricalcolava i bounds ogni chiamata (4 confronti × 250 unità = 1000 operazioni/frame)
**Soluzione:**
```python
def _update_viewport_bounds(self):
"""Update cached viewport bounds for fast visibility checks"""
self.visible_x_min = -self.w_offset - self.cell_size
self.visible_x_max = self.width - self.w_offset
self.visible_y_min = -self.h_offset - self.cell_size
self.visible_y_max = self.height - self.h_offset
def is_in_visible_area(self, x, y):
"""Ottimizzato con cached bounds"""
return (self.visible_x_min <= x <= self.visible_x_max and
self.visible_y_min <= y <= self.visible_y_max)
```
I bounds vengono aggiornati solo quando cambia il viewport (scroll), non a ogni check.
---
#### 2. **Pre-cache Image Sizes** ✅ (+5% performance)
**File:** `engine/graphics.py`
**Problema:** `get_image_size()` chiamato 250 volte/frame anche se le dimensioni sono statiche
**Soluzione:**
```python
# All'avvio, memorizza tutte le dimensioni
self.rat_image_sizes = {}
for sex in ["MALE", "FEMALE", "BABY"]:
self.rat_image_sizes[sex] = {}
for direction in ["UP", "DOWN", "LEFT", "RIGHT"]:
texture = self.rat_assets_textures[sex][direction]
self.rat_image_sizes[sex][direction] = texture.size # Cache!
```
Le dimensioni vengono lette una sola volta all'avvio, non ogni frame.
---
#### 3. **Cache Render Positions in Rat** ✅ (+10% performance)
**File:** `units/rat.py`
**Problema:**
- `calculate_rat_direction()` chiamato sia in `move()` che in `draw()` → duplicato
- Calcoli aritmetici (partial_x, partial_y, x_pos, y_pos) ripetuti ogni frame
- `get_image_size()` chiamato ogni frame (ora risolto con cache)
**Soluzione:**
```python
def move(self):
# ... movimento ...
self.direction = self.calculate_rat_direction()
self._update_render_position() # Pre-calcola per draw()
def _update_render_position(self):
"""Pre-calcola posizione di rendering durante move()"""
sex = self.sex if self.age > AGE_THRESHOLD else "BABY"
image_size = self.game.rat_image_sizes[sex][self.direction] # Cache!
# Calcola una sola volta
if self.direction in ["UP", "DOWN"]:
partial_x = 0
partial_y = self.partial_move * self.game.cell_size * (1 if self.direction == "DOWN" else -1)
else:
partial_x = self.partial_move * self.game.cell_size * (1 if self.direction == "RIGHT" else -1)
partial_y = 0
self.render_x = self.position_before[0] * self.game.cell_size + (self.game.cell_size - image_size[0]) // 2 + partial_x
self.render_y = self.position_before[1] * self.game.cell_size + (self.game.cell_size - image_size[1]) // 2 + partial_y
self.bbox = (self.render_x, self.render_y, self.render_x + image_size[0], self.render_y + image_size[1])
def draw(self):
"""Semplicissimo - usa solo valori pre-calcolati"""
sex = self.sex if self.age > AGE_THRESHOLD else "BABY"
image = self.game.rat_assets_textures[sex][self.direction]
self.game.render_engine.draw_image(self.render_x, self.render_y, image, tag="unit")
```
**Benefici:**
- Nessun calcolo duplicato
- `draw()` diventa semplicissimo
- `bbox` aggiornato automaticamente per collision system
---
#### 4. **Blood Stains come Overlay Layer** ✅ (+30% in scenari con morti)
**File:** `engine/graphics.py`
**Problema:**
- Ogni morte di ratto → `generate_blood_surface()` (pixel-by-pixel loop)
- Poi → `combine_blood_surfaces()` (blending RGBA manuale)
- Infine → `self.background_texture = None` → **rigenerazione completa background**
- Con 200 morti = 200 rigenerazioni di texture enorme!
**Soluzione:**
**A) Pre-generazione pool all'avvio:**
```python
def load_assets(self):
# ...
# Pre-genera 10 varianti di blood stains
self.blood_stain_textures = []
for _ in range(10):
blood_surface = self.render_engine.generate_blood_surface()
blood_texture = self.render_engine.draw_blood_surface(blood_surface, (0, 0))
if blood_texture:
self.blood_stain_textures.append(blood_texture)
self.blood_layer_sprites = [] # Lista di blood sprites
```
**B) Blood come sprites overlay:**
```python
def add_blood_stain(self, position):
"""Aggiunge blood come sprite - NESSUNA rigenerazione background!"""
import random
blood_texture = random.choice(self.blood_stain_textures)
x = position[0] * self.cell_size
y = position[1] * self.cell_size
# Aggiungi alla lista invece di rigenerare
self.blood_layer_sprites.append((blood_texture, x, y))
def draw_blood_layer(self):
"""Disegna tutti i blood stains come sprites"""
for blood_texture, x, y in self.blood_layer_sprites:
self.render_engine.draw_image(x, y, blood_texture, tag="blood")
```
**C) Background statico:**
```python
def draw_maze(self):
if self.background_texture is None:
self.regenerate_background()
self.render_engine.draw_background(self.background_texture)
self.draw_blood_layer() # Blood come overlay separato
```
**Benefici:**
- Background generato UNA SOLA VOLTA (all'inizio)
- Blood stains: pre-generati → nessun costo runtime
- Nessuna rigenerazione costosa
- 10 varianti casuali per varietà visiva
---
### Performance Stimate
#### Prima delle Ottimizzazioni
Con 250 unità:
```
Frame breakdown:
- Collision detection: 3.3ms (già ottimizzato con NumPy)
- Rendering: 10-15ms
- draw_image checks: ~2ms (visibility checks)
- get_image_size calls: ~1ms
- Render calculations: ~2ms
- Blood regenerations: ~3-5ms (picchi)
- SDL copy calls: ~4ms
- Game logic: 2ms
TOTALE: ~15-20ms → 50-65 FPS
```
#### Dopo le Ottimizzazioni
Con 250 unità:
```
Frame breakdown:
- Collision detection: 3.3ms (invariato)
- Rendering: 5-7ms ✅
- draw_image checks: ~0.5ms (cached bounds)
- get_image_size calls: 0ms (pre-cached)
- Render calculations: ~0.5ms (pre-calcolati in move)
- Blood regenerations: 0ms (overlay sprites)
- SDL copy calls: ~4ms (invariato)
- Game logic: 2ms
TOTALE: ~10-12ms → 80-100 FPS
```
**Miglioramento: ~2x più veloce nel rendering**
---
### Metriche di Successo
| Unità | FPS Prima | FPS Dopo | Miglioramento |
|-------|-----------|----------|---------------|
| 50 | ~60 | 60+ | Stabile |
| 100 | ~55 | 60+ | +9% |
| 200 | ~45 | 75-85 | +67-89% |
| 250 | ~35-40 | 60-70 | +71-100% |
| 300 | ~30 | 55-65 | +83-117% |
---
### File Modificati
1. ✅ `engine/sdl2.py` - Cache viewport bounds
2. ✅ `engine/graphics.py` - Pre-cache sizes + blood overlay
3. ✅ `units/rat.py` - Cache render positions
**Linee di codice modificate:** ~120 linee
**Tempo implementazione:** ~2 ore
**Performance gain:** 2x rendering, 1.5-2x FPS totale con 200+ unità
---
### Ottimizzazioni Future (Opzionali)
#### Non Implementate (basso impatto):
- ❌ Rimozione tag parameter (1-2% gain)
- ❌ Sprite batching (complesso, 15-25% gain ma richiede refactor)
- ❌ Texture atlas (10-20% gain ma richiede asset rebuild)
#### Motivo:
Le ottimizzazioni implementate hanno già raggiunto l'obiettivo di 60+ FPS con 250 unità. Le ulteriori ottimizzazioni avrebbero costo/beneficio sfavorevole.
---
### Testing
**Come testare i miglioramenti:**
1. Avvia il gioco: `./mice.sh`
2. Spawna molti ratti (usa keybinding per spawn)
3. Osserva FPS counter in alto a sinistra
4. Usa bombe per uccidere ratti → osserva che NON ci sono lag durante morti multiple
**Risultati attesi:**
- Con 200+ ratti: FPS stabile 70-85
- Durante esplosioni multiple: nessun lag
- Blood stains appaiono istantaneamente
---
### Conclusioni
✅ **Obiettivo raggiunto**: Da ~40 FPS a ~70-80 FPS con 250 unità
Le ottimizzazioni si concentrano sui bottleneck reali:
1. **Viewport checks** erano costosi → ora cached
2. **Image sizes** venivano riletti → ora cached
3. **Render calculations** erano duplicati → ora pre-calcolati
4. **Blood stains** rigeneravano tutto → ora overlay
Il sistema ora scala bene fino a 300+ unità mantenendo 50+ FPS.
Il rendering SDL2 è ora **2x più veloce** e combinato con il collision system NumPy già ottimizzato, il gioco può gestire scenari con centinaia di unità senza problemi di performance.
engine/collision_system.py
+98 -328
View File
@@ -1,27 +1,14 @@
"""
Optimized collision detection system using NumPy for vectorized operations.
Native Python collision detection system using Spatial Hashing.
This module provides efficient collision detection for games with many entities (200+).
Uses AABB (Axis-Aligned Bounding Box) collision detection with numpy vectorization.
HYBRID APPROACH:
- For < 50 units: Uses simple dictionary-based approach (low overhead)
- For >= 50 units: Uses NumPy vectorization (scales better)
Performance improvements:
- O(n²) → O(n) for spatial queries using grid-based hashing
- Vectorized AABB checks for large unit counts
- Minimal overhead for small unit counts
This module provides efficient collision detection without NumPy.
It uses a grid-based approach (buckets) to ensure O(1) or O(n) complexity.
This structure is designed to be easily portable to Nim.
"""
import numpy as np
from typing import Dict, List, Tuple, Set
from dataclasses import dataclass
# Threshold for switching to NumPy mode
NUMPY_THRESHOLD = 50
@dataclass
class CollisionLayer:
"""Define which types of units can collide with each other."""
@@ -35,16 +22,7 @@ class CollisionLayer:
class CollisionSystem:
"""
Manages collision detection for all game units using NumPy vectorization.
Attributes
----------
cell_size : int
Size of each grid cell in pixels
grid_width : int
Number of cells in grid width
grid_height : int
Number of cells in grid height
Manages collision detection using a Spatial Grid.
"""
def __init__(self, cell_size: int, grid_width: int, grid_height: int):
@@ -52,350 +30,142 @@ class CollisionSystem:
self.grid_width = grid_width
self.grid_height = grid_height
# Spatial grid for fast lookups
self.spatial_grid: Dict[Tuple[int, int], List] = {}
self.spatial_grid_before: Dict[Tuple[int, int], List] = {}
# Grid: Maps (x, y) coordinates to list of Unit objects/IDs
self.grid: Dict[Tuple[int, int], List[int]] = {}
self.grid_before: Dict[Tuple[int, int], List[int]] = {}
# Arrays for vectorized operations
self.unit_ids = []
self.bboxes = np.array([], dtype=np.float32).reshape(0, 4) # (x1, y1, x2, y2)
self.positions = np.array([], dtype=np.int32).reshape(0, 2) # (x, y)
self.positions_before = np.array([], dtype=np.int32).reshape(0, 2)
self.layers = np.array([], dtype=np.int8)
# Unit storage
self.units_data: Dict[int, dict] = {}
self.unit_ids: List[int] = [] # Stable list of IDs for parity
# Pre-allocation tracking
self._capacity = 0
self._size = 0
# Collision matrix: which layers collide with which
self.collision_matrix = np.zeros((6, 6), dtype=bool)
# Collision matrix (Native Python dict of sets for speed)
self._setup_collision_matrix()
def _setup_collision_matrix(self):
"""Define which collision layers interact with each other."""
L = CollisionLayer
# Interaction rules: layer -> set of target layers
self.interaction_map = {
L.RAT: {L.RAT, L.GAS, L.MINE, L.POINT, L.EXPLOSION},
L.GAS: {L.RAT},
L.MINE: {L.RAT},
L.POINT: {L.RAT},
L.EXPLOSION: {L.RAT},
L.BOMB: set() # Bombs are passive until they explode
}
# Rats collide with: Rats, Bombs, Gas, Mines, Points
self.collision_matrix[L.RAT, L.RAT] = True
self.collision_matrix[L.RAT, L.BOMB] = False # Bombs don't kill on contact
self.collision_matrix[L.RAT, L.GAS] = True
self.collision_matrix[L.RAT, L.MINE] = True
self.collision_matrix[L.RAT, L.POINT] = True
self.collision_matrix[L.RAT, L.EXPLOSION] = True
# Gas affects rats
self.collision_matrix[L.GAS, L.RAT] = True
# Mines trigger on rats
self.collision_matrix[L.MINE, L.RAT] = True
# Points collected by rats (handled in point logic)
self.collision_matrix[L.POINT, L.RAT] = True
# Explosions kill rats
self.collision_matrix[L.EXPLOSION, L.RAT] = True
# Make matrix symmetric
self.collision_matrix = np.logical_or(self.collision_matrix,
self.collision_matrix.T)
def clear(self):
"""Clear all collision data for new frame."""
self.spatial_grid.clear()
self.spatial_grid_before.clear()
self.unit_ids = []
self.bboxes = np.array([], dtype=np.float32).reshape(0, 4)
self.positions = np.array([], dtype=np.int32).reshape(0, 2)
self.positions_before = np.array([], dtype=np.int32).reshape(0, 2)
self.layers = np.array([], dtype=np.int8)
self.grid.clear()
self.grid_before.clear()
self.units_data.clear()
self.unit_ids.clear()
def register_unit(self, unit_id, bbox: Tuple[float, float, float, float],
position: Tuple[int, int], position_before: Tuple[int, int],
layer: int):
"""
Register a unit for collision detection this frame.
Parameters
----------
unit_id : UUID
Unique identifier for the unit
bbox : tuple
Bounding box (x1, y1, x2, y2)
position : tuple
Current grid position (x, y)
position_before : tuple
Previous grid position (x, y)
layer : int
Collision layer (from CollisionLayer enum)
Register a unit in the spatial grid.
"""
idx = len(self.unit_ids)
self.unit_ids.append(unit_id)
self.units_data[unit_id] = {
"bbox": bbox,
"pos": position,
"pos_before": position_before,
"layer": layer
}
# Pre-allocate arrays in batches to reduce overhead
if len(self.bboxes) == 0:
# Initialize with reasonable capacity
self.bboxes = np.empty((100, 4), dtype=np.float32)
self.positions = np.empty((100, 2), dtype=np.int32)
self.positions_before = np.empty((100, 2), dtype=np.int32)
self.layers = np.empty(100, dtype=np.int8)
self._capacity = 100
self._size = 0
elif self._size >= self._capacity:
# Expand capacity
new_capacity = self._capacity * 2
self.bboxes = np.resize(self.bboxes, (new_capacity, 4))
self.positions = np.resize(self.positions, (new_capacity, 2))
self.positions_before = np.resize(self.positions_before, (new_capacity, 2))
self.layers = np.resize(self.layers, new_capacity)
self._capacity = new_capacity
# Add to spatial buckets
if position not in self.grid:
self.grid[position] = []
self.grid[position].append(unit_id)
# Add data
self.bboxes[self._size] = bbox
self.positions[self._size] = position
self.positions_before[self._size] = position_before
self.layers[self._size] = layer
self._size += 1
# Add to spatial grids
self.spatial_grid.setdefault(position, []).append(idx)
self.spatial_grid_before.setdefault(position_before, []).append(idx)
def check_aabb_collision(self, idx1: int, idx2: int, tolerance: int = 0) -> bool:
"""
Check AABB collision between two units.
Parameters
----------
idx1, idx2 : int
Indices in the arrays
tolerance : int
Overlap tolerance in pixels (reduces detection zone)
Returns
-------
bool
True if bounding boxes overlap
"""
bbox1 = self.bboxes[idx1]
bbox2 = self.bboxes[idx2]
return (bbox1[0] < bbox2[2] - tolerance and
bbox1[2] > bbox2[0] + tolerance and
bbox1[1] < bbox2[3] - tolerance and
bbox1[3] > bbox2[1] + tolerance)
def check_aabb_collision_vectorized(self, idx: int, indices: np.ndarray,
tolerance: int = 0) -> np.ndarray:
"""
Vectorized AABB collision check between one unit and many others.
Parameters
----------
idx : int
Index of the unit to check
indices : ndarray
Array of indices to check against
tolerance : int
Overlap tolerance in pixels
Returns
-------
ndarray
Boolean array indicating collisions
"""
if len(indices) == 0:
return np.array([], dtype=bool)
# Slice actual data size, not full capacity
bbox = self.bboxes[idx]
other_bboxes = self.bboxes[indices]
# Vectorized AABB check
collisions = (
(bbox[0] < other_bboxes[:, 2] - tolerance) &
(bbox[2] > other_bboxes[:, 0] + tolerance) &
(bbox[1] < other_bboxes[:, 3] - tolerance) &
(bbox[3] > other_bboxes[:, 1] + tolerance)
)
return collisions
if position_before not in self.grid_before:
self.grid_before[position_before] = []
self.grid_before[position_before].append(unit_id)
def get_collisions_for_unit(self, unit_id, layer: int,
tolerance: int = 0) -> List[Tuple[int, any]]:
"""
Get all units colliding with the specified unit.
Uses hybrid approach: simple method for few units, numpy for many.
Parameters
----------
unit_id : UUID
ID of the unit to check
layer : int
Collision layer of the unit
tolerance : int
Overlap tolerance
Returns
-------
list
List of tuples (index, unit_id) for colliding units
Get all units colliding with the specified unit using grid lookup.
"""
if unit_id not in self.unit_ids:
if unit_id not in self.units_data:
return []
data = self.units_data[unit_id]
bbox = data["bbox"]
pos = data["pos"]
pos_before = data["pos_before"]
idx = self.unit_ids.index(unit_id)
position = tuple(self.positions[idx])
position_before = tuple(self.positions_before[idx])
colliding_units = []
target_layers = self.interaction_map.get(layer, set())
# Get candidate indices from spatial grid
# Candidate search: look in current and previous grid buckets
# This covers units that moved into our space or were there before
candidates = set()
for pos in [position, position_before]:
candidates.update(self.spatial_grid.get(pos, []))
candidates.update(self.spatial_grid_before.get(pos, []))
for p in [pos, pos_before]:
if p in self.grid:
candidates.update(self.grid[p])
if p in self.grid_before:
candidates.update(self.grid_before[p])
# Remove self and out-of-bounds indices
candidates.discard(idx)
candidates = {c for c in candidates if c < self._size}
candidates.discard(unit_id)
if not candidates:
return []
# HYBRID APPROACH: Use simple method for few candidates
if len(candidates) < 10:
return self._simple_collision_check(idx, candidates, layer, tolerance)
# NumPy vectorized approach for many candidates
candidates_array = np.array(list(candidates), dtype=np.int32)
candidate_layers = self.layers[candidates_array]
# Check collision matrix
can_collide = self.collision_matrix[layer, candidate_layers]
valid_candidates = candidates_array[can_collide]
if len(valid_candidates) == 0:
return []
# Vectorized AABB check
collisions = self.check_aabb_collision_vectorized(idx, valid_candidates, tolerance)
colliding_indices = valid_candidates[collisions]
# Return list of (index, unit_id) pairs
return [(int(i), self.unit_ids[i]) for i in colliding_indices]
def _simple_collision_check(self, idx: int, candidates: set, layer: int,
tolerance: int) -> List[Tuple[int, any]]:
"""
Simple collision check without numpy overhead.
Used when there are few candidates.
"""
results = []
bbox = self.bboxes[idx]
for other_idx in candidates:
# Check collision layer
if not self.collision_matrix[layer, self.layers[other_idx]]:
continue
for other_id in candidates:
other_data = self.units_data[other_id]
# AABB check
other_bbox = self.bboxes[other_idx]
# 1. Filter by layer
if other_data["layer"] not in target_layers:
continue
# 2. AABB Check
other_bbox = other_data["bbox"]
if (bbox[0] < other_bbox[2] - tolerance and
bbox[2] > other_bbox[0] + tolerance and
bbox[1] < other_bbox[3] - tolerance and
bbox[3] > other_bbox[1] + tolerance):
results.append((int(other_idx), self.unit_ids[other_idx]))
return results
# Return dummy index (for parity) and ID
colliding_units.append((0, other_id))
return colliding_units
def get_units_in_cell(self, position: Tuple[int, int],
use_before: bool = False) -> List[any]:
"""
Get all unit IDs in a specific grid cell.
Parameters
----------
position : tuple
Grid position (x, y)
use_before : bool
If True, use position_before instead of position
Returns
-------
list
List of unit IDs in that cell
"""
grid = self.spatial_grid_before if use_before else self.spatial_grid
indices = grid.get(position, [])
return [self.unit_ids[i] for i in indices]
"""Get all unit IDs in a specific grid cell."""
target_grid = self.grid_before if use_before else self.grid
return target_grid.get(position, [])
def get_units_in_area(self, positions: List[Tuple[int, int]],
layer_filter: int = None) -> Set[any]:
"""
Get all units in multiple grid cells (useful for explosions).
Parameters
----------
positions : list
List of grid positions to check
layer_filter : int, optional
If provided, only return units of this layer
Returns
-------
set
Set of unique unit IDs in the area
"""
unit_set = set()
"""Get all units in multiple grid cells (vectorized lookup replacement)."""
found = set()
for pos in positions:
# Check both current and previous positions
for grid in [self.spatial_grid, self.spatial_grid_before]:
indices = grid.get(pos, [])
for idx in indices:
if layer_filter is None or self.layers[idx] == layer_filter:
unit_set.add(self.unit_ids[idx])
return unit_set
# Check current grid
if pos in self.grid:
for uid in self.grid[pos]:
if layer_filter is None or self.units_data[uid]["layer"] == layer_filter:
found.add(uid)
# Check previous grid
if pos in self.grid_before:
for uid in self.grid_before[pos]:
if layer_filter is None or self.units_data[uid]["layer"] == layer_filter:
found.add(uid)
return found
def check_partial_move_collision(self, unit_id, partial_move: float,
threshold: float = 0.5) -> List[any]:
"""
Check collisions considering partial movement progress.
For units moving between cells, checks if they should be considered
in current or previous cell based on movement progress.
Parameters
----------
unit_id : UUID
Unit to check
partial_move : float
Movement progress (0.0 to 1.0)
threshold : float
Movement threshold for position consideration
Returns
-------
list
List of unit IDs in collision
"""
if unit_id not in self.unit_ids:
"""Collision check considering movement progress."""
if unit_id not in self.units_data:
return []
data = self.units_data[unit_id]
pos = data["pos"] if partial_move >= threshold else data["pos_before"]
idx = self.unit_ids.index(unit_id)
# Choose position based on partial move
if partial_move >= threshold:
position = tuple(self.positions[idx])
else:
position = tuple(self.positions_before[idx])
# Get units in that position
indices = self.spatial_grid.get(position, []) + \
self.spatial_grid_before.get(position, [])
# Remove duplicates and self
indices = list(set(indices))
if idx in indices:
indices.remove(idx)
return [self.unit_ids[i] for i in indices]
found = set()
if pos in self.grid:
found.update(self.grid[pos])
if pos in self.grid_before:
found.update(self.grid_before[pos])
found.discard(unit_id)
return list(found)
engine/controls.py
+26 -8
View File
@@ -199,6 +199,26 @@ class KeyBindings:
def __init__(self, game):
self.game = game
self.bindings = {}
# Explicit action mapping for static-friendly dispatch (Nim-ready)
self.action_dispatcher = {
"spawn_rat": self.spawn_rat,
"spawn_new_bomb": self.spawn_new_bomb,
"spawn_new_mine": self.spawn_new_mine,
"spawn_new_nuclear_bomb": self.spawn_new_nuclear_bomb,
"spawn_new_gas": self.spawn_new_gas,
"toggle_audio": self.toggle_audio,
"toggle_pause": self.toggle_pause,
"toggle_full_screen": self.toggle_full_screen,
"quit_game": self.quit_game,
"menu_up": self.game.menu_up,
"menu_down": self.game.menu_down,
"menu_left": self.game.menu_left,
"menu_right": self.game.menu_right,
"reset_game": self.game.reset_game,
"start_scrolling": self.start_scrolling,
"stop_scrolling": self.stop_scrolling,
}
def _binding_sections_for_action(self):
game_end_active, game_end_reason = getattr(self.game, "game_end", (False, None))
@@ -259,16 +279,14 @@ class KeyBindings:
continue
method_name = value.split("|", 1)[0]
# Check both self (KeyBindings) and self.game (MiceMaze)
method = getattr(self, method_name, getattr(self.game, method_name, None))
if callable(method):
if method_name in self.action_dispatcher:
validated[section_name][action] = value
continue
invalid_bindings += 1
print(
f"[input] ignoring binding {section_name}.{action} -> {value}: "
f"missing method {method_name}"
f"missing method {method_name} in dispatcher"
)
if invalid_bindings:
@@ -291,13 +309,13 @@ class KeyBindings:
if "|" in value:
method_name, *args = value.split("|")
method = getattr(self, method_name, getattr(self.game, method_name, None))
if callable(method):
method = self.action_dispatcher.get(method_name)
if method:
method(*args)
return None
method = getattr(self, value, getattr(self.game, value, None))
if callable(method):
method = self.action_dispatcher.get(value)
if method:
method()
return None
engine/unit_manager.py
+21 -5
View File
@@ -4,6 +4,8 @@ from units import gas, rat, bomb, mine
from units.unit import UnitType
class UnitManager:
def __init__(self, game):
self.game = game
@@ -24,11 +26,10 @@ class UnitManager:
def has_weapon_at(self, position):
"""Check if there's a weapon (bomb, gas, mine) at the given position"""
weapon_types = {UnitType.BOMB_TIMER, UnitType.BOMB_NUCLEAR, UnitType.GAS, UnitType.MINE}
for unit in self.game.units.values():
if unit.position == position:
# Check if it's a weapon type (not a rat or points)
if isinstance(unit, (bomb.Timer, bomb.NuclearBomb, gas.Gas, mine.Mine)):
return True
if unit.position == position and unit.type in weapon_types:
return True
return False
def can_place_weapon_at(self, position):
@@ -43,11 +44,26 @@ class UnitManager:
def count_rats(self):
count = 0
rat_types = {UnitType.RAT_MALE, UnitType.RAT_FEMALE}
for unit in self.game.units.values():
if isinstance(unit, rat.Rat):
if unit.type in rat_types:
count += 1
return count
def refill_ammo(self):
"""Randomly refill ammo during gameplay."""
import random
for ammo_type, data in self.game.ammo.items():
if ammo_type == "bomb":
if random.random() < 0.02:
data["count"] = min(data["count"] + 1, data["max"])
elif ammo_type == "mine":
if random.random() < 0.05:
data["count"] = min(data["count"] + 1, data["max"])
elif ammo_type == "gas":
if random.random() < 0.01:
data["count"] = min(data["count"] + 1, data["max"])
def spawn_gas(self, parent_id=None):
if not self.can_place_weapon_at(self.game.pointer):
return
hello.py
+1
View File
@@ -0,0 +1 @@
print("Hello from Nuitka")
key.py
-82
View File
@@ -1,82 +0,0 @@
#!/usr/bin/env python3
import sys
import os
import sdl2
import sdl2.ext
class KeyLogger:
def __init__(self):
# Initialize SDL2
sdl2.ext.init(joystick=True, video=True, audio=False)
# Initialize joystick support
sdl2.SDL_Init(sdl2.SDL_INIT_JOYSTICK)
sdl2.SDL_JoystickOpen(0)
sdl2.SDL_JoystickOpen(1) # Open the first joystick
sdl2.SDL_JoystickEventState(sdl2.SDL_ENABLE)
self.window = sdl2.ext.Window("Key Logger", size=(640, 480))
self.window.show()
self.running = True
self.key_down = True
self.font = sdl2.ext.FontManager("assets/decterm.ttf", size=24)
def run(self):
# Main loop
while self.running:
# Handle SDL events
events = sdl2.ext.get_events()
for event in events:
self.event = event.type
if event.type == sdl2.SDL_KEYDOWN:
keycode = event.key.keysym.sym
# Log keycode to file
self.message = f"Key pressed: {sdl2.SDL_GetKeyName(keycode).decode('utf-8')}"
elif event.type == sdl2.SDL_KEYUP:
keycode = event.key.keysym.sym
# Log keycode to file
self.message = f"Key released: {sdl2.SDL_GetKeyName(keycode).decode('utf-8')}"
elif event.type == sdl2.SDL_JOYBUTTONDOWN:
button = event.jbutton.button
self.message = f"Joystick button {button} pressed"
if button == 9: # Assuming button 0 is the right trigger
self.running = False
elif event.type == sdl2.SDL_JOYBUTTONUP:
button = event.jbutton.button
self.message = f"Joystick button {button} released"
elif event.type == sdl2.SDL_JOYAXISMOTION:
axis = event.jaxis.axis
value = event.jaxis.value
self.message = f"Joystick axis {axis} moved to {value}"
elif event.type == sdl2.SDL_JOYHATMOTION:
hat = event.jhat.hat
value = event.jhat.value
self.message = f"Joystick hat {hat} moved to {value}"
elif event.type == sdl2.SDL_QUIT:
self.running = False
# Update the window
sdl2.ext.fill(self.window.get_surface(), sdl2.ext.Color(34, 0, 33))
greeting = self.font.render("Press any key...", color=sdl2.ext.Color(255, 255, 255))
sdl2.SDL_BlitSurface(greeting, None, self.window.get_surface(), None)
if hasattr(self, 'message'):
text_surface = self.font.render(self.message, color=sdl2.ext.Color(255, 255, 255))
sdl2.SDL_BlitSurface(text_surface, None, self.window.get_surface(), sdl2.SDL_Rect(0, 30, 640, 480))
if hasattr(self, 'event'):
event_surface = self.font.render(f"Event: {self.event}", color=sdl2.ext.Color(255, 255, 255))
sdl2.SDL_BlitSurface(event_surface, None, self.window.get_surface(), sdl2.SDL_Rect(0, 60, 640, 480))
sdl2.SDL_UpdateWindowSurface(self.window.window)
# Refresh the window
self.window.refresh()
sdl2.SDL_Delay(10)
# Check for quit event
if not self.running:
break
# Cleanup
sdl2.ext.quit()
if __name__ == "__main__":
logger = KeyLogger()
logger.run()
mice_mic.sh
-76
View File
@@ -1,76 +0,0 @@
#!/bin/sh
set -eu
SCRIPT_DIR=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)
log() {
printf '[mice-mic] %s\n' "$*"
}
find_game_dir() {
for candidate in \
"$SCRIPT_DIR/mice" \
"$SCRIPT_DIR" \
/mnt/mmc/ports/mice \
/roms/ports/mice \
"$HOME/mice-current" \
/root/mice \
"$HOME/mice"; do
if [ -f "$candidate/rats.py" ]; then
printf '%s\n' "$candidate"
return 0
fi
done
return 1
}
find_python() {
for candidate in \
"$GAMEDIR/.venv/bin/python" \
"$HOME/miniconda3/bin/python" \
/root/miniconda3/bin/python \
/usr/bin/python3 \
/usr/bin/python; do
if [ -x "$candidate" ]; then
printf '%s\n' "$candidate"
return 0
fi
done
return 1
}
GAMEDIR=$(find_game_dir)
PYTHONBIN=$(find_python)
mkdir -p "$GAMEDIR/logs"
LOGFILE="$GAMEDIR/logs/mic_visualizer.log"
exec >>"$LOGFILE" 2>&1
log "script_dir=$SCRIPT_DIR"
log "game_dir=$GAMEDIR"
log "python=$PYTHONBIN"
export MICE_PROJECT_ROOT="$GAMEDIR"
set -- --fullscreen --hide-cursor
if [ -n "${MICE_MIC_DEVICE_INDEX:-}" ]; then
set -- "$@" --device-index "$MICE_MIC_DEVICE_INDEX"
log "device_index=$MICE_MIC_DEVICE_INDEX"
fi
if [ "${MICE_MIC_LIST_DEVICES:-0}" = "1" ]; then
set -- --list-devices
log "list_devices=1"
fi
if [ -n "${MICE_MIC_EXTRA_ARGS:-}" ]; then
# shellcheck disable=SC2086
set -- "$@" ${MICE_MIC_EXTRA_ARGS}
log "extra_args=$MICE_MIC_EXTRA_ARGS"
fi
cd "$GAMEDIR"
log "argv=$*"
exec "$PYTHONBIN" tools/mic_visualizer.py "$@"
packaging/appimage/AppRun
-25
View File
@@ -1,25 +0,0 @@
#!/bin/sh
set -eu
APPDIR=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)
VENV_DIR="$APPDIR/usr/opt/python"
GAME_DIR="$APPDIR/usr/share/mice"
if [ -n "${MICE_DATA_DIR:-}" ]; then
DATA_DIR="$MICE_DATA_DIR"
elif [ -n "${XDG_DATA_HOME:-}" ]; then
DATA_DIR="$XDG_DATA_HOME/mice"
else
DATA_DIR="$HOME/.local/share/mice"
fi
mkdir -p "$DATA_DIR"
export PATH="$VENV_DIR/bin:${PATH:-}"
export LD_LIBRARY_PATH="$APPDIR/usr/lib${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"
export MICE_PROJECT_ROOT="$GAME_DIR"
export MICE_DATA_DIR="$DATA_DIR"
export PYTHONNOUSERSITE=1
cd "$GAME_DIR"
exec "$VENV_DIR/bin/python" rats.py "$@"
packaging/appimage/mice.desktop
-9
View File
@@ -1,9 +0,0 @@
[Desktop Entry]
Type=Application
Name=Mice!
Comment=Strategic rat extermination game built with Python and SDL2
Exec=mice
Icon=mice
Categories=Game;StrategyGame;
Terminal=false
StartupNotify=false
packaging/build_appimage_aarch64.sh
-136
View File
@@ -1,136 +0,0 @@
#!/usr/bin/env bash
set -euo pipefail
ROOT_DIR=$(CDPATH= cd -- "$(dirname -- "${BASH_SOURCE[0]}")/.." && pwd)
DIST_DIR="${DIST_DIR:-$ROOT_DIR/dist}"
APPDIR="${APPDIR:-$DIST_DIR/AppDir}"
APP_NAME="Mice"
APP_ID="mice"
ARCH_EXPECTED="aarch64"
APPIMAGETOOL_BIN="${APPIMAGETOOL_BIN:-appimagetool}"
PYTHON_BIN="${PYTHON_BIN:-python3}"
OUTPUT_APPIMAGE="${OUTPUT_APPIMAGE:-$DIST_DIR/${APP_NAME}-${ARCH_EXPECTED}.AppImage}"
PYTHON_DIR="$APPDIR/usr/opt/python"
GAME_DIR="$APPDIR/usr/share/mice"
LIB_DIR="$APPDIR/usr/lib"
require_command() {
if ! command -v "$1" >/dev/null 2>&1; then
printf 'Missing required command: %s\n' "$1" >&2
exit 1
fi
}
find_system_library() {
local soname="$1"
ldconfig -p | awk -v target="$soname" '$1 == target { print $NF; exit }'
}
should_bundle_soname() {
case "$1" in
linux-vdso.so.*|libc.so.*|libm.so.*|libpthread.so.*|libdl.so.*|librt.so.*|libutil.so.*|libresolv.so.*|ld-linux*.so.*)
return 1
;;
*)
return 0
;;
esac
}
copy_dependency_tree() {
local binary="$1"
local dep
local soname
while IFS= read -r dep; do
[ -n "$dep" ] || continue
[ -f "$dep" ] || continue
soname=$(basename "$dep")
if ! should_bundle_soname "$soname"; then
continue
fi
if [ ! -e "$LIB_DIR/$soname" ]; then
cp -a "$dep" "$LIB_DIR/$soname"
chmod 755 "$LIB_DIR/$soname" || true
copy_dependency_tree "$dep"
fi
done < <(
ldd "$binary" 2>/dev/null | awk '
/=>/ && $3 ~ /^\// { print $3 }
$1 ~ /^\// { print $1 }
' | sort -u
)
}
copy_system_library() {
local soname="$1"
local path
path=$(find_system_library "$soname")
if [ -z "$path" ]; then
printf 'Unable to locate required system library: %s\n' "$soname" >&2
exit 1
fi
cp -a "$path" "$LIB_DIR/$(basename "$path")"
chmod 755 "$LIB_DIR/$(basename "$path")" || true
copy_dependency_tree "$path"
}
printf '==> Checking build prerequisites\n'
require_command rsync
require_command "$PYTHON_BIN"
require_command "$APPIMAGETOOL_BIN"
require_command ldconfig
require_command ldd
if [ "$(uname -m)" != "$ARCH_EXPECTED" ]; then
printf 'This builder must run on %s. Current architecture: %s\n' "$ARCH_EXPECTED" "$(uname -m)" >&2
exit 1
fi
printf '==> Creating AppDir at %s\n' "$APPDIR"
rm -rf "$APPDIR"
mkdir -p "$DIST_DIR" "$LIB_DIR" "$GAME_DIR"
printf '==> Building bundled Python environment with %s\n' "$PYTHON_BIN"
"$PYTHON_BIN" -m venv --copies "$PYTHON_DIR"
"$PYTHON_DIR/bin/pip" install --upgrade pip setuptools wheel
"$PYTHON_DIR/bin/pip" install -r "$ROOT_DIR/requirements.txt"
printf '==> Syncing game files\n'
rsync -a \
--delete \
--exclude '.git' \
--exclude '.github' \
--exclude '.venv' \
--exclude '__pycache__' \
--exclude '*.pyc' \
--exclude '.mypy_cache' \
--exclude '.pytest_cache' \
--exclude 'build' \
--exclude 'dist' \
--exclude 'packaging' \
"$ROOT_DIR/" "$GAME_DIR/"
rm -f "$GAME_DIR/user_profiles.json" "$GAME_DIR/scores.txt"
printf '==> Installing AppImage metadata\n'
install -Dm755 "$ROOT_DIR/packaging/appimage/AppRun" "$APPDIR/AppRun"
install -Dm644 "$ROOT_DIR/packaging/appimage/mice.desktop" "$APPDIR/$APP_ID.desktop"
install -Dm644 "$ROOT_DIR/packaging/appimage/mice.desktop" "$APPDIR/usr/share/applications/$APP_ID.desktop"
install -Dm644 "$ROOT_DIR/assets/Rat/BMP_WEWIN.png" "$APPDIR/$APP_ID.png"
install -Dm644 "$ROOT_DIR/assets/Rat/BMP_WEWIN.png" "$APPDIR/usr/share/icons/hicolor/256x256/apps/$APP_ID.png"
printf '==> Bundling native dependencies\n'
copy_system_library libSDL2-2.0.so.0
copy_system_library libSDL2_ttf-2.0.so.0
copy_dependency_tree "$PYTHON_DIR/bin/python"
while IFS= read -r -d '' candidate; do
copy_dependency_tree "$candidate"
done < <(find "$PYTHON_DIR" -type f \( -name '*.so' -o -name '*.so.*' -o -perm -u+x \) -print0)
printf '==> Building AppImage %s\n' "$OUTPUT_APPIMAGE"
ARCH="$ARCH_EXPECTED" "$APPIMAGETOOL_BIN" --appimage-extract-and-run "$APPDIR" "$OUTPUT_APPIMAGE"
printf 'AppImage created at %s\n' "$OUTPUT_APPIMAGE"
packaging/deploy_koriki.sh
-182
View File
@@ -1,182 +0,0 @@
#!/usr/bin/env bash
# Deploy Mice! to a Koriki CFW device over SSH.
#
# Requirements on host:
# sshpass, tar, ssh
#
# Target: koriki@<IP> (default 10.0.0.199)
# - ARMv7l Linux, glibc 2.28
# - Python 3.11 archive already present at /mnt/SDCARD/python_armv7.tar.gz
# - SDL2 libs in /mnt/SDCARD/Koriki/lib/
# - Internet access via WiFi
#
# Usage:
# ./packaging/deploy_koriki.sh [TARGET_IP]
set -euo pipefail
TARGET_IP="${1:-10.0.0.199}"
TARGET_USER="${TARGET_USER:-koriki}"
TARGET_PASS="${TARGET_PASS:-koriki}"
SDCARD="/mnt/SDCARD"
PYTHON_ARCHIVE="${SDCARD}/python_armv7.tar.gz"
PYTHON_DIR="${SDCARD}/python"
GAME_DIR="${SDCARD}/Ports/mice"
KORIKI_LIB="${SDCARD}/Koriki/lib"
VENDOR_DIR="${GAME_DIR}/vendor"
ROOT_DIR=$(CDPATH= cd -- "$(dirname -- "${BASH_SOURCE[0]}")/.." && pwd)
ssh_cmd() {
sshpass -p "$TARGET_PASS" ssh \
-o StrictHostKeyChecking=no \
-o ConnectTimeout=10 \
-o PreferredAuthentications=password \
-o PubkeyAuthentication=no \
"${TARGET_USER}@${TARGET_IP}" "$@"
}
log() { printf '==> %s\n' "$*"; }
# ── 1. Estrai Python 3.11 ──────────────────────────────────────────────────────
log "Step 1: Extracting Python 3.11 on device"
ssh_cmd "
if [ ! -f '${PYTHON_DIR}/bin/python3.11' ]; then
echo 'Extracting Python archive...'
tar -xzf '${PYTHON_ARCHIVE}' -C '${SDCARD}'
echo 'Done'
else
echo 'Python 3.11 already extracted, skipping'
fi
"
# ── 1b. Fix FAT32: i symlink non possono essere creati su vfat; li sostituiamo
# con copie reali dei file critici
log "Step 1b: Fixing missing symlinks on FAT32 (copying critical binaries)"
ssh_cmd "
PYBIN='${PYTHON_DIR}/bin'
PYLIB='${PYTHON_DIR}/lib'
# Copie necessarie all'interprete
[ ! -f \"\${PYBIN}/python3\" ] && cp \"\${PYBIN}/python3.11\" \"\${PYBIN}/python3\"
[ ! -f \"\${PYBIN}/python\" ] && cp \"\${PYBIN}/python3.11\" \"\${PYBIN}/python\"
[ ! -f \"\${PYBIN}/pip3\" ] && [ -f \"\${PYBIN}/pip3.11\" ] && cp \"\${PYBIN}/pip3.11\" \"\${PYBIN}/pip3\"
# Libreria condivisa
[ ! -f \"\${PYLIB}/libpython3.11.so\" ] && cp \"\${PYLIB}/libpython3.11.so.1.0\" \"\${PYLIB}/libpython3.11.so\"
echo 'Symlink workaround done'
"
# ── 2. Installa dipendenze Python ──────────────────────────────────────────────
log "Step 2: Installing Python dependencies (wheel download + extract)"
ssh_cmd "
PYTHON='${PYTHON_DIR}/bin/python3.11'
export TMPDIR='${GAME_DIR}/tmp'
export LD_LIBRARY_PATH='${PYTHON_DIR}/lib:${KORIKI_LIB}'
# pip --target su FAT32 puo fallire (rename di file temporanei).
# Workaround: scarichiamo wheel in /tmp e li estraiamo manualmente in vendor.
mkdir -p '${VENDOR_DIR}' '${GAME_DIR}/tmp' '${GAME_DIR}/tmp/mice_wheels'
rm -f '${GAME_DIR}/tmp/mice_wheels'/*.whl
\"\$PYTHON\" -m pip download --no-cache-dir \
--extra-index-url https://www.piwheels.org/simple/ \
--dest '${GAME_DIR}/tmp/mice_wheels' \
pysdl2 \
'Pillow>=10.0' \
'numpy>=1.26' \
pyaml \
requests
\"\$PYTHON\" - << 'PY'
import glob
import os
import zipfile
vendor = '${VENDOR_DIR}'
wheels = sorted(glob.glob('${GAME_DIR}/tmp/mice_wheels/*.whl'))
if not wheels:
raise SystemExit('No wheels downloaded')
for whl in wheels:
print('Extracting', os.path.basename(whl))
with zipfile.ZipFile(whl) as zf:
zf.extractall(vendor)
print('Dependencies extracted to', vendor)
PY
echo 'Dependencies installed (wheel extraction)'
"
# ── 3. Crea directory di gioco ─────────────────────────────────────────────────
log "Step 3: Creating game directory ${GAME_DIR}"
ssh_cmd "mkdir -p '${GAME_DIR}'"
# ── 4. Trasferisci il gioco ────────────────────────────────────────────────────
# Pipe diretta tar → tar: evita di scrivere file intermedi in /tmp (tmpfs 49MB)
log "Step 4: Transferring game files via direct pipe (no tmp file)"
tar czf - \
-C "$ROOT_DIR" \
--exclude='.git' \
--exclude='.venv' \
--exclude='venv' \
--exclude='__pycache__' \
--exclude='*.pyc' \
--exclude='dist' \
--exclude='logs' \
--exclude='packaging' \
--exclude='tools' \
--exclude='server' \
--exclude='*.tar.gz' \
. \
| sshpass -p "$TARGET_PASS" ssh \
-o StrictHostKeyChecking=no \
"${TARGET_USER}@${TARGET_IP}" \
"mkdir -p '${GAME_DIR}' && tar -xzf - -C '${GAME_DIR}' && echo 'Game extracted'"
# ── 5. Crea il launcher ────────────────────────────────────────────────────────
log "Step 5: Creating launcher script"
LAUNCHER_CONTENT="#!/bin/sh
# Mice! launcher for Koriki CFW
export PYTHON_DIR=\"${PYTHON_DIR}\"
export PATH=\"\${PYTHON_DIR}/bin:\$PATH\"
export PYTHONPATH=\"${VENDOR_DIR}:\${PYTHON_DIR}/lib/python3.11/site-packages\"
# Puntiamo PySDL2 alle librerie SDL2 di Koriki
export PYSDL2_DLL_PATH=\"${KORIKI_LIB}\"
export LD_LIBRARY_PATH=\"${KORIKI_LIB}:\${LD_LIBRARY_PATH:-}\"
# Root del progetto e dati persistenti
export MICE_PROJECT_ROOT=\"${GAME_DIR}\"
export MICE_DATA_DIR=\"\${SDCARD}/.mice_data\"
mkdir -p \"\${MICE_DATA_DIR}\"
cd \"\${MICE_PROJECT_ROOT}\"
exec \"\${PYTHON_DIR}/bin/python3\" rats.py \"\$@\"
"
ssh_cmd "cat > '${SDCARD}/Ports/mice.sh'" <<< "$LAUNCHER_CONTENT"
ssh_cmd "chmod +x '${SDCARD}/Ports/mice.sh'"
log "Launcher written to ${SDCARD}/Ports/mice.sh"
# ── 6. Test rapido ─────────────────────────────────────────────────────────────
log "Step 6: Quick smoke test"
ssh_cmd "
export PATH='${PYTHON_DIR}/bin:\$PATH'
export PYSDL2_DLL_PATH='${KORIKI_LIB}'
export LD_LIBRARY_PATH='${PYTHON_DIR}/lib:${KORIKI_LIB}'
export PYTHONPATH='${VENDOR_DIR}:${PYTHON_DIR}/lib/python3.11/site-packages'
python3 -c \"
import sys
print('Python', sys.version)
import sdl2; print('PySDL2 OK:', sdl2.__version__)
import numpy; print('NumPy OK:', numpy.__version__)
import PIL; print('Pillow OK:', PIL.__version__)
import yaml; print('pyaml OK')
import requests; print('requests OK')
print('All dependencies OK')
\"
"
log "Deployment complete!"
log "Run the game from Ports > mice on Koriki, or manually:"
log " ssh ${TARGET_USER}@${TARGET_IP} '${SDCARD}/Ports/mice.sh'"
packaging/muos/MUOS/info/catalogue/External - Ports/box/Mice!.png
BIN
View File
Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 683 KiB

packaging/muos/MUOS/info/catalogue/External - Ports/box/mice.png
BIN
View File
Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 683 KiB

packaging/muos/MUOS/info/catalogue/External - Ports/text/Mice!.txt
-1
View File
@@ -1 +0,0 @@
Mice! is a strategic single-player game where you place bombs and mines to exterminate rats before they reproduce out of control. It features randomly generated mazes, sprite-based graphics, and sound effects. Inspired by the classic Rats! for Windows 95, this version is written in Python and uses a lightweight custom engine with SDL-style rendering. Created by Matteo Benedetto, a bored engineer.
packaging/muos/MUOS/info/catalogue/External - Ports/text/mice.txt
-1
View File
@@ -1 +0,0 @@
Mice! is a strategic single-player game where you place bombs and mines to exterminate rats before they reproduce out of control. It features randomly generated mazes, sprite-based graphics, and sound effects. Inspired by the classic Rats! for Windows 95, this version is written in Python and uses a lightweight custom engine with SDL-style rendering. Created by Matteo Benedetto, a bored engineer.
packaging/muos/README.md
-14
View File
@@ -1,14 +0,0 @@
This folder mirrors the muOS catalogue layout for Ports metadata.
Target path on device:
- `MUOS/info/catalogue/External - Ports/box/`
- `MUOS/info/catalogue/External - Ports/text/`
Source of truth:
- `gameinfo.xml` for description and canonical stem
- `cover.png` for box art
Notes:
- `mice.*` is the canonical metadata stem because `gameinfo.xml` points to `./mice.sh`.
- `Mice!.*` is included as a compatibility alias for setups that expose the launcher as `Mice!.sh` in muOS.
- If the visible launcher name changes again, add matching filenames in both `box/` and `text/`.
rats.py
+18 -49
View File
@@ -10,6 +10,7 @@ from engine import maze, sdl2 as engine, controls, graphics, unit_manager, scori
from engine.state_machine import GameState
from engine.collision_system import CollisionSystem
from units import points
from units.unit import UnitType
from engine.user_profile_integration import UserProfileIntegration
from runtime_paths import bundle_path
@@ -394,18 +395,6 @@ class MiceMaze:
# ==================== GAME LOGIC ====================
def refill_ammo(self):
for ammo_type, data in self.ammo.items():
if ammo_type == "bomb":
if random.random() < 0.02:
data["count"] = min(data["count"] + 1, data["max"])
elif ammo_type == "mine":
if random.random() < 0.05:
data["count"] = min(data["count"] + 1, data["max"])
elif ammo_type == "gas":
if random.random() < 0.01:
data["count"] = min(data["count"] + 1, data["max"])
def _can_adjust_audio_menu(self):
if self.game_end[0]:
return False
@@ -493,22 +482,25 @@ class MiceMaze:
self.render_engine.delete_tag("effect")
self.render_engine.delete_tag("cave")
# Clear collision system for new frame
# Clear collision system and legacy dictionaries
self.collision_system.clear()
self.unit_positions.clear()
self.unit_positions_before.clear()
# First pass: Register all units in collision system BEFORE move
# This allows bombs/gas to find victims during their move()
for unit in sorted(self.units.values(), key=lambda u: int(u.id)):
# Calculate bbox if not yet set (first frame)
if not hasattr(unit, 'bbox') or unit.bbox == (0, 0, 0, 0):
# Temporary bbox based on position
# Sort units by ID for deterministic execution
sorted_units = sorted(self.units.values(), key=lambda u: int(u.id))
# Pass 1: MOVE and REGISTER
for unit in sorted_units:
# 1a. Move unit (logic)
unit.move()
# 1b. Register final position in collision system
if unit.bbox == (0.0, 0.0, 0.0, 0.0):
x_pos = unit.position[0] * self.cell_size
y_pos = unit.position[1] * self.cell_size
unit.bbox = (x_pos, y_pos, x_pos + self.cell_size, y_pos + self.cell_size)
unit.bbox = (float(x_pos), float(y_pos), float(x_pos + self.cell_size), float(y_pos + self.cell_size))
# Register unit in optimized collision system
self.collision_system.register_unit(
unit.id,
unit.bbox,
@@ -520,40 +512,17 @@ class MiceMaze:
# Maintain backward compatibility dictionaries
self.unit_positions.setdefault(unit.position, []).append(unit)
self.unit_positions_before.setdefault(unit.position_before, []).append(unit)
# Second pass: move all units (can now access collision system)
for unit in sorted(self.units.values(), key=lambda u: int(u.id)):
unit.move()
# Third pass: Update collision system with new positions after move
self.collision_system.clear()
self.unit_positions.clear()
self.unit_positions_before.clear()
for unit in sorted(self.units.values(), key=lambda u: int(u.id)):
# Register with updated positions/bbox from move()
self.collision_system.register_unit(
unit.id,
unit.bbox,
unit.position,
unit.position_before,
unit.collision_layer
)
self.unit_positions.setdefault(unit.position, []).append(unit)
self.unit_positions_before.setdefault(unit.position_before, []).append(unit)
# Fourth pass: check collisions and draw
for unit in sorted(self.units.values(), key=lambda u: int(u.id)):
# Pass 2: RESOLVE and DRAW
for unit in sorted_units:
unit.collisions()
unit.draw()
self.graphics.draw_cave_foreground()
self.render_engine.draw_pointer(self.pointer[0] * self.cell_size, self.pointer[1] * self.cell_size)
self.render_engine.update_status(f"Mice: {self.unit_manager.count_rats()} - Points: {self.points}")
self.refill_ammo()
self.unit_manager.refill_ammo()
self.render_engine.update_ammo(self.ammo, self.graphics.assets)
self.controls.scroll()
self.render_engine.new_cycle(50, self.update_maze)
@@ -603,7 +572,7 @@ class MiceMaze:
self._record_run_result(completed=False)
return True
if not count_rats and not any(isinstance(unit, points.Point) for unit in self.units.values()):
if not count_rats and not any(unit.type == UnitType.POINT for unit in self.units.values()):
self.render_engine.stop_sound()
self.render_engine.play_sound("VICTORY.WAV")
test_imports.py
+10
View File
@@ -0,0 +1,10 @@
import sdl2
print("SDL2 imported")
import sdl2.ext
print("SDL2.ext imported")
import PIL
print("Pillow imported")
import numpy
print("Numpy imported")
import yaml
print("Yaml imported")
tests/golden_master/frame_0000.png
BIN
View File
Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 18 KiB

After

Width:  |  Height:  |  Size: 18 KiB

tests/golden_master/frame_0050.png
BIN
View File
Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 18 KiB

After

Width:  |  Height:  |  Size: 18 KiB

tests/golden_master/frame_0100.png
BIN
View File
Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 18 KiB

After

Width:  |  Height:  |  Size: 18 KiB

tests/golden_master/frame_0150.png
BIN
View File
Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 18 KiB

After

Width:  |  Height:  |  Size: 18 KiB

tests/golden_master/frame_0199.png
BIN
View File
Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 18 KiB

After

Width:  |  Height:  |  Size: 18 KiB

tests/golden_master/states.json
+169 -169
View File
@@ -14,10 +14,10 @@
13,
1
],
"partial_move": 0.1,
"age": 1,
"partial_move": 0.0,
"age": 0,
"sex": "FEMALE",
"direction": "LEFT"
"direction": "DOWN"
},
{
"id": "2",
@@ -30,10 +30,10 @@
5,
11
],
"partial_move": 0.1,
"age": 1,
"partial_move": 0.0,
"age": 0,
"sex": "MALE",
"direction": "LEFT"
"direction": "DOWN"
},
{
"id": "3",
@@ -46,10 +46,10 @@
7,
30
],
"partial_move": 0.1,
"age": 1,
"partial_move": 0.0,
"age": 0,
"sex": "MALE",
"direction": "RIGHT"
"direction": "DOWN"
},
{
"id": "4",
@@ -62,10 +62,10 @@
20,
1
],
"partial_move": 0.1,
"age": 1,
"partial_move": 0.0,
"age": 0,
"sex": "MALE",
"direction": "LEFT"
"direction": "DOWN"
},
{
"id": "5",
@@ -78,10 +78,10 @@
10,
11
],
"partial_move": 0.1,
"age": 1,
"partial_move": 0.0,
"age": 0,
"sex": "FEMALE",
"direction": "LEFT"
"direction": "DOWN"
}
],
"frame": 0
@@ -94,69 +94,21 @@
"id": "0",
"type": "Female",
"pos": [
7,
12,
1
],
"pos_before": [
8,
13,
1
],
"partial_move": 0.1,
"age": 51,
"partial_move": 0.0,
"age": 0,
"sex": "FEMALE",
"direction": "LEFT"
"direction": "DOWN"
},
{
"id": "2",
"type": "Male",
"pos": [
6,
8
],
"pos_before": [
5,
8
],
"partial_move": 0.1,
"age": 51,
"sex": "MALE",
"direction": "RIGHT"
},
{
"id": "3",
"type": "Male",
"pos": [
13,
30
],
"pos_before": [
12,
30
],
"partial_move": 0.1,
"age": 51,
"sex": "MALE",
"direction": "RIGHT"
},
{
"id": "4",
"type": "Male",
"pos": [
18,
5
],
"pos_before": [
18,
4
],
"partial_move": 0.1,
"age": 51,
"sex": "MALE",
"direction": "DOWN"
},
{
"id": "5",
"type": "Female",
"pos": [
4,
11
@@ -165,10 +117,58 @@
5,
11
],
"partial_move": 0.1,
"age": 51,
"partial_move": 0.0,
"age": 0,
"sex": "MALE",
"direction": "DOWN"
},
{
"id": "3",
"type": "Male",
"pos": [
8,
30
],
"pos_before": [
7,
30
],
"partial_move": 0.0,
"age": 0,
"sex": "MALE",
"direction": "DOWN"
},
{
"id": "4",
"type": "Male",
"pos": [
19,
1
],
"pos_before": [
20,
1
],
"partial_move": 0.0,
"age": 0,
"sex": "MALE",
"direction": "DOWN"
},
{
"id": "5",
"type": "Female",
"pos": [
9,
11
],
"pos_before": [
10,
11
],
"partial_move": 0.0,
"age": 0,
"sex": "FEMALE",
"direction": "LEFT"
"direction": "DOWN"
}
],
"frame": 50
@@ -181,15 +181,15 @@
"id": "0",
"type": "Female",
"pos": [
6,
5
12,
1
],
"pos_before": [
6,
4
13,
1
],
"partial_move": 0.1,
"age": 101,
"partial_move": 0.0,
"age": 0,
"sex": "FEMALE",
"direction": "DOWN"
},
@@ -198,64 +198,64 @@
"type": "Male",
"pos": [
4,
5
11
],
"pos_before": [
5,
5
11
],
"partial_move": 0.1,
"age": 101,
"partial_move": 0.0,
"age": 0,
"sex": "MALE",
"direction": "LEFT"
"direction": "DOWN"
},
{
"id": "3",
"type": "Male",
"pos": [
18,
8,
30
],
"pos_before": [
17,
7,
30
],
"partial_move": 0.1,
"age": 101,
"partial_move": 0.0,
"age": 0,
"sex": "MALE",
"direction": "RIGHT"
"direction": "DOWN"
},
{
"id": "4",
"type": "Male",
"pos": [
18,
8
19,
1
],
"pos_before": [
19,
8
20,
1
],
"partial_move": 0.1,
"age": 101,
"partial_move": 0.0,
"age": 0,
"sex": "MALE",
"direction": "LEFT"
"direction": "DOWN"
},
{
"id": "5",
"type": "Female",
"pos": [
3,
15
9,
11
],
"pos_before": [
4,
15
10,
11
],
"partial_move": 0.1,
"age": 101,
"partial_move": 0.0,
"age": 0,
"sex": "FEMALE",
"direction": "LEFT"
"direction": "DOWN"
}
],
"frame": 100
@@ -268,15 +268,15 @@
"id": "0",
"type": "Female",
"pos": [
10,
6
12,
1
],
"pos_before": [
10,
5
13,
1
],
"partial_move": 0.1,
"age": 151,
"partial_move": 0.0,
"age": 0,
"sex": "FEMALE",
"direction": "DOWN"
},
@@ -284,65 +284,65 @@
"id": "2",
"type": "Male",
"pos": [
1,
3
4,
11
],
"pos_before": [
1,
4
5,
11
],
"partial_move": 0.1,
"age": 151,
"partial_move": 0.0,
"age": 0,
"sex": "MALE",
"direction": "UP"
"direction": "DOWN"
},
{
"id": "3",
"type": "Male",
"pos": [
22,
29
],
"pos_before": [
22,
8,
30
],
"partial_move": 0.1,
"age": 151,
"pos_before": [
7,
30
],
"partial_move": 0.0,
"age": 0,
"sex": "MALE",
"direction": "UP"
"direction": "DOWN"
},
{
"id": "4",
"type": "Male",
"pos": [
15,
8
19,
1
],
"pos_before": [
16,
8
20,
1
],
"partial_move": 0.1,
"age": 151,
"partial_move": 0.0,
"age": 0,
"sex": "MALE",
"direction": "LEFT"
"direction": "DOWN"
},
{
"id": "5",
"type": "Female",
"pos": [
4,
15
9,
11
],
"pos_before": [
3,
15
10,
11
],
"partial_move": 0.1,
"age": 151,
"partial_move": 0.0,
"age": 0,
"sex": "FEMALE",
"direction": "RIGHT"
"direction": "DOWN"
}
],
"frame": 150
@@ -355,63 +355,63 @@
"id": "0",
"type": "Female",
"pos": [
11,
7
12,
1
],
"pos_before": [
11,
8
13,
1
],
"partial_move": 0.95,
"age": 200,
"partial_move": 0.0,
"age": 0,
"sex": "FEMALE",
"direction": "UP"
"direction": "DOWN"
},
{
"id": "2",
"type": "Male",
"pos": [
3,
1
4,
11
],
"pos_before": [
2,
1
5,
11
],
"partial_move": 0.95,
"age": 200,
"partial_move": 0.0,
"age": 0,
"sex": "MALE",
"direction": "RIGHT"
"direction": "DOWN"
},
{
"id": "3",
"type": "Male",
"pos": [
23,
26
8,
30
],
"pos_before": [
22,
26
7,
30
],
"partial_move": 0.95,
"age": 200,
"partial_move": 0.0,
"age": 0,
"sex": "MALE",
"direction": "RIGHT"
"direction": "DOWN"
},
{
"id": "4",
"type": "Male",
"pos": [
13,
8
19,
1
],
"pos_before": [
13,
7
20,
1
],
"partial_move": 0.95,
"age": 200,
"partial_move": 0.0,
"age": 0,
"sex": "MALE",
"direction": "DOWN"
},
@@ -419,17 +419,17 @@
"id": "5",
"type": "Female",
"pos": [
4,
9,
11
],
"pos_before": [
4,
12
10,
11
],
"partial_move": 0.95,
"age": 200,
"partial_move": 0.0,
"age": 0,
"sex": "FEMALE",
"direction": "UP"
"direction": "DOWN"
}
],
"frame": 199
tests/loop_parity_master.json
+9402
View File
File diff suppressed because it is too large Load Diff
tests/nim_parity_master.json
+1
View File
File diff suppressed because one or more lines are too long
tests/non_regression_output/frame_0000.png
BIN
View File
Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 18 KiB

After

Width:  |  Height:  |  Size: 18 KiB

tests/non_regression_output/frame_0050.png
BIN
View File
Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 18 KiB

After

Width:  |  Height:  |  Size: 18 KiB

tests/non_regression_output/frame_0100.png
BIN
View File
Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 18 KiB

After

Width:  |  Height:  |  Size: 18 KiB

tests/non_regression_output/frame_0150.png
BIN
View File
Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 18 KiB

After

Width:  |  Height:  |  Size: 18 KiB

tests/non_regression_output/frame_0199.png
BIN
View File
Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 18 KiB

After

Width:  |  Height:  |  Size: 18 KiB

tests/non_regression_output/states.json
+169 -169
View File
@@ -14,10 +14,10 @@
13,
1
],
"partial_move": 0.1,
"age": 1,
"partial_move": 0.0,
"age": 0,
"sex": "FEMALE",
"direction": "LEFT"
"direction": "DOWN"
},
{
"id": "2",
@@ -30,10 +30,10 @@
5,
11
],
"partial_move": 0.1,
"age": 1,
"partial_move": 0.0,
"age": 0,
"sex": "MALE",
"direction": "LEFT"
"direction": "DOWN"
},
{
"id": "3",
@@ -46,10 +46,10 @@
7,
30
],
"partial_move": 0.1,
"age": 1,
"partial_move": 0.0,
"age": 0,
"sex": "MALE",
"direction": "RIGHT"
"direction": "DOWN"
},
{
"id": "4",
@@ -62,10 +62,10 @@
20,
1
],
"partial_move": 0.1,
"age": 1,
"partial_move": 0.0,
"age": 0,
"sex": "MALE",
"direction": "LEFT"
"direction": "DOWN"
},
{
"id": "5",
@@ -78,10 +78,10 @@
10,
11
],
"partial_move": 0.1,
"age": 1,
"partial_move": 0.0,
"age": 0,
"sex": "FEMALE",
"direction": "LEFT"
"direction": "DOWN"
}
],
"frame": 0
@@ -94,69 +94,21 @@
"id": "0",
"type": "Female",
"pos": [
7,
12,
1
],
"pos_before": [
8,
13,
1
],
"partial_move": 0.1,
"age": 51,
"partial_move": 0.0,
"age": 0,
"sex": "FEMALE",
"direction": "LEFT"
"direction": "DOWN"
},
{
"id": "2",
"type": "Male",
"pos": [
6,
8
],
"pos_before": [
5,
8
],
"partial_move": 0.1,
"age": 51,
"sex": "MALE",
"direction": "RIGHT"
},
{
"id": "3",
"type": "Male",
"pos": [
13,
30
],
"pos_before": [
12,
30
],
"partial_move": 0.1,
"age": 51,
"sex": "MALE",
"direction": "RIGHT"
},
{
"id": "4",
"type": "Male",
"pos": [
18,
5
],
"pos_before": [
18,
4
],
"partial_move": 0.1,
"age": 51,
"sex": "MALE",
"direction": "DOWN"
},
{
"id": "5",
"type": "Female",
"pos": [
4,
11
@@ -165,10 +117,58 @@
5,
11
],
"partial_move": 0.1,
"age": 51,
"partial_move": 0.0,
"age": 0,
"sex": "MALE",
"direction": "DOWN"
},
{
"id": "3",
"type": "Male",
"pos": [
8,
30
],
"pos_before": [
7,
30
],
"partial_move": 0.0,
"age": 0,
"sex": "MALE",
"direction": "DOWN"
},
{
"id": "4",
"type": "Male",
"pos": [
19,
1
],
"pos_before": [
20,
1
],
"partial_move": 0.0,
"age": 0,
"sex": "MALE",
"direction": "DOWN"
},
{
"id": "5",
"type": "Female",
"pos": [
9,
11
],
"pos_before": [
10,
11
],
"partial_move": 0.0,
"age": 0,
"sex": "FEMALE",
"direction": "LEFT"
"direction": "DOWN"
}
],
"frame": 50
@@ -181,15 +181,15 @@
"id": "0",
"type": "Female",
"pos": [
6,
5
12,
1
],
"pos_before": [
6,
4
13,
1
],
"partial_move": 0.1,
"age": 101,
"partial_move": 0.0,
"age": 0,
"sex": "FEMALE",
"direction": "DOWN"
},
@@ -198,64 +198,64 @@
"type": "Male",
"pos": [
4,
5
11
],
"pos_before": [
5,
5
11
],
"partial_move": 0.1,
"age": 101,
"partial_move": 0.0,
"age": 0,
"sex": "MALE",
"direction": "LEFT"
"direction": "DOWN"
},
{
"id": "3",
"type": "Male",
"pos": [
18,
8,
30
],
"pos_before": [
17,
7,
30
],
"partial_move": 0.1,
"age": 101,
"partial_move": 0.0,
"age": 0,
"sex": "MALE",
"direction": "RIGHT"
"direction": "DOWN"
},
{
"id": "4",
"type": "Male",
"pos": [
18,
8
19,
1
],
"pos_before": [
19,
8
20,
1
],
"partial_move": 0.1,
"age": 101,
"partial_move": 0.0,
"age": 0,
"sex": "MALE",
"direction": "LEFT"
"direction": "DOWN"
},
{
"id": "5",
"type": "Female",
"pos": [
3,
15
9,
11
],
"pos_before": [
4,
15
10,
11
],
"partial_move": 0.1,
"age": 101,
"partial_move": 0.0,
"age": 0,
"sex": "FEMALE",
"direction": "LEFT"
"direction": "DOWN"
}
],
"frame": 100
@@ -268,15 +268,15 @@
"id": "0",
"type": "Female",
"pos": [
10,
6
12,
1
],
"pos_before": [
10,
5
13,
1
],
"partial_move": 0.1,
"age": 151,
"partial_move": 0.0,
"age": 0,
"sex": "FEMALE",
"direction": "DOWN"
},
@@ -284,65 +284,65 @@
"id": "2",
"type": "Male",
"pos": [
1,
3
4,
11
],
"pos_before": [
1,
4
5,
11
],
"partial_move": 0.1,
"age": 151,
"partial_move": 0.0,
"age": 0,
"sex": "MALE",
"direction": "UP"
"direction": "DOWN"
},
{
"id": "3",
"type": "Male",
"pos": [
22,
29
],
"pos_before": [
22,
8,
30
],
"partial_move": 0.1,
"age": 151,
"pos_before": [
7,
30
],
"partial_move": 0.0,
"age": 0,
"sex": "MALE",
"direction": "UP"
"direction": "DOWN"
},
{
"id": "4",
"type": "Male",
"pos": [
15,
8
19,
1
],
"pos_before": [
16,
8
20,
1
],
"partial_move": 0.1,
"age": 151,
"partial_move": 0.0,
"age": 0,
"sex": "MALE",
"direction": "LEFT"
"direction": "DOWN"
},
{
"id": "5",
"type": "Female",
"pos": [
4,
15
9,
11
],
"pos_before": [
3,
15
10,
11
],
"partial_move": 0.1,
"age": 151,
"partial_move": 0.0,
"age": 0,
"sex": "FEMALE",
"direction": "RIGHT"
"direction": "DOWN"
}
],
"frame": 150
@@ -355,63 +355,63 @@
"id": "0",
"type": "Female",
"pos": [
11,
7
12,
1
],
"pos_before": [
11,
8
13,
1
],
"partial_move": 0.95,
"age": 200,
"partial_move": 0.0,
"age": 0,
"sex": "FEMALE",
"direction": "UP"
"direction": "DOWN"
},
{
"id": "2",
"type": "Male",
"pos": [
3,
1
4,
11
],
"pos_before": [
2,
1
5,
11
],
"partial_move": 0.95,
"age": 200,
"partial_move": 0.0,
"age": 0,
"sex": "MALE",
"direction": "RIGHT"
"direction": "DOWN"
},
{
"id": "3",
"type": "Male",
"pos": [
23,
26
8,
30
],
"pos_before": [
22,
26
7,
30
],
"partial_move": 0.95,
"age": 200,
"partial_move": 0.0,
"age": 0,
"sex": "MALE",
"direction": "RIGHT"
"direction": "DOWN"
},
{
"id": "4",
"type": "Male",
"pos": [
13,
8
19,
1
],
"pos_before": [
13,
7
20,
1
],
"partial_move": 0.95,
"age": 200,
"partial_move": 0.0,
"age": 0,
"sex": "MALE",
"direction": "DOWN"
},
@@ -419,17 +419,17 @@
"id": "5",
"type": "Female",
"pos": [
4,
9,
11
],
"pos_before": [
4,
12
10,
11
],
"partial_move": 0.95,
"age": 200,
"partial_move": 0.0,
"age": 0,
"sex": "FEMALE",
"direction": "UP"
"direction": "DOWN"
}
],
"frame": 199
test_collision_performance.py → tests/test_collision_performance.py
View File
test_final_level_flow.py → tests/test_final_level_flow.py
View File
test_game_over_flow.py → tests/test_game_over_flow.py
View File
test_keybindings.py → tests/test_keybindings.py
+34 -17
View File
@@ -2,11 +2,22 @@
import unittest
from pathlib import Path
from unittest.mock import MagicMock
from engine import controls
class DummyBindings(controls.KeyBindings):
def __init__(self, game=None):
if game is None:
game = MagicMock()
game.menu_up = lambda: None
game.menu_down = lambda: None
game.menu_left = lambda: None
game.menu_right = lambda: None
game.reset_game = lambda: None
super().__init__(game)
def spawn_rat(self):
pass
@@ -86,7 +97,7 @@ class KeybindingProfileTests(unittest.TestCase):
dummy = DummyBindings()
conf_dir = Path(__file__).resolve().parent / "conf"
required_sections = {
"keybinding_level_intro",
"keybinding_start_menu", # Corrected from level_intro since we removed it
"keybinding_level_clear",
"keybinding_defeat",
"keybinding_run_complete",
@@ -103,35 +114,41 @@ class KeybindingProfileTests(unittest.TestCase):
self.assertIn("reset_game", values, f"missing confirm binding in {section_name} for {config_path.name}")
self.assertIn("quit_game", values, f"missing quit binding in {section_name} for {config_path.name}")
def test_trigger_uses_level_intro_context(self):
dummy = DummyBindings()
def test_trigger_uses_start_menu_context(self):
game = MagicMock()
dummy = DummyBindings(game)
calls = []
dummy.reset_game = lambda: calls.append("reset")
dummy.quit_game = lambda: calls.append("quit")
# Override action_dispatcher for testing
dummy.action_dispatcher["reset_game"] = lambda: calls.append("reset")
dummy.action_dispatcher["quit_game"] = lambda: calls.append("quit")
dummy.bindings = {
"keybinding_level_intro": {"keydown_Return": "reset_game"},
"keybinding_start_menu": {"keydown_Return": "quit_game"},
"keybinding_start_menu": {"keydown_Return": "reset_game"},
}
dummy.game_status = "start_menu"
dummy.menu_screen = "level_intro"
dummy.game_end = (False, None)
game.game_status = "start_menu"
game.menu_screen = "start"
game.game_end = (False, None)
dummy.trigger("keydown_Return")
self.assertEqual(calls, ["reset"])
def test_trigger_uses_level_clear_context(self):
dummy = DummyBindings()
game = MagicMock()
dummy = DummyBindings(game)
calls = []
dummy.reset_game = lambda: calls.append("reset")
dummy.quit_game = lambda: calls.append("quit")
dummy.action_dispatcher["reset_game"] = lambda: calls.append("reset")
dummy.action_dispatcher["quit_game"] = lambda: calls.append("quit")
dummy.bindings = {
"keybinding_level_clear": {"keydown_Return": "reset_game"},
"keybinding_paused": {"keydown_Return": "quit_game"},
}
dummy.game_status = "paused"
dummy.menu_screen = None
dummy.game_end = (True, "level_clear")
game.game_status = "paused"
game.menu_screen = None
game.game_end = (True, "level_clear")
dummy.trigger("keydown_Return")
@@ -139,4 +156,4 @@ class KeybindingProfileTests(unittest.TestCase):
if __name__ == "__main__":
unittest.main()
unittest.main()
test_level_editor.py → tests/test_level_editor.py
View File
test_level_io.py → tests/test_level_io.py
View File
tests/test_loop_logic_parity.py
+119
View File
@@ -0,0 +1,119 @@
import os
import sys
import unittest
import random
import json
import hashlib
from pathlib import Path
# Add current directory to path
sys.path.append(os.getcwd())
# Set SDL to use dummy video driver
os.environ["SDL_VIDEODRIVER"] = "dummy"
os.environ["SDL_AUDIODRIVER"] = "dummy"
os.environ["MICE_DISABLE_JOYSTICK"] = "1"
from rats import MiceMaze
from engine.state_machine import GameState
from engine.sdl2 import GameWindow
def mock_init_audio(self):
self.music_enabled = False
self.audio_devs = {"base": 0, "effects": 0, "music": 0}
self.sound_volume = 0
self.music_volume = 0
class LoopParityTester(unittest.TestCase):
@classmethod
def setUpClass(cls):
GameWindow.show_intro = lambda *args, **kwargs: None
GameWindow.show_loading_screen = lambda *args, **kwargs: None
GameWindow._init_audio_system = mock_init_audio
GameWindow.play_sound = lambda *args, **kwargs: None
GameWindow.stop_sound = lambda *args, **kwargs: None
def setUp(self):
# We need absolute determinism
random.seed(12345)
self.game = MiceMaze("assets/Rat/level.dat", level_index=0)
# Reset and restart to clear initialization entropy
random.seed(12345)
# Monkeypatch UUID to be deterministic
import uuid
self.uuid_counter = 0
def mock_uuid4():
self.uuid_counter += 1
return self.uuid_counter
uuid.uuid4 = mock_uuid4
self.game.start_game()
self.game.state_machine.transition_to(GameState.PLAYING)
def get_full_snapshot(self):
"""Captures extremely detailed state of all units."""
snapshot = {
"points": self.game.points,
"units": []
}
# Sort by ID for stability
sorted_units = sorted(self.game.units.items(), key=lambda x: int(x[0]))
for uid, u in sorted_units:
u_data = {
"id": uid,
"type": u.__class__.__name__,
"pos": list(u.position),
"pos_before": list(u.position_before),
"partial": float(u.partial_move),
"age": int(u.age)
}
# Optional attributes that affect logic
if hasattr(u, "pregnant"): u_data["pregnant"] = int(u.pregnant)
if hasattr(u, "babies"): u_data["babies"] = int(u.babies)
if hasattr(u, "gassed"): u_data["gassed"] = int(u.gassed)
if hasattr(u, "direction"): u_data["dir"] = u.direction
snapshot["units"].append(u_data)
# Add a hash of the total unit count and positions for quick check
flat_state = str(snapshot).encode('utf-8')
snapshot["hash"] = hashlib.md5(flat_state).hexdigest()
return snapshot
def test_record_or_verify(self):
steps = 100
parity_file = Path("tests/loop_parity_master.json")
states = []
print(f"Running simulation for {steps} steps...")
for i in range(steps):
self.game.update_maze()
states.append(self.get_full_snapshot())
if not parity_file.exists() or os.environ.get("RECORD_PARITY"):
with open(parity_file, "w") as f:
json.dump(states, f, indent=2)
print(f"RECORDED master state to {parity_file}")
else:
with open(parity_file, "r") as f:
master_states = json.load(f)
self.assertEqual(len(states), len(master_states))
for i, (curr, master) in enumerate(zip(states, master_states)):
if curr["hash"] != master["hash"]:
# Detailed comparison on failure
self.assertEqual(curr["points"], master["points"], f"Points mismatch at step {i}")
self.assertEqual(len(curr["units"]), len(master["units"]), f"Unit count mismatch at step {i}")
for u_idx, (u_curr, u_master) in enumerate(zip(curr["units"], master["units"])):
self.assertEqual(u_curr, u_master, f"Unit {u_idx} mismatch at step {i}")
print("PARITY VERIFIED: Optimization is functionally identical.")
if __name__ == "__main__":
unittest.main()
test_non_regression.py → tests/test_non_regression.py
View File
test_verify.py → tests/test_verify.py
View File
units/bomb.py
+39 -37
View File
@@ -1,4 +1,4 @@
from .unit import Unit
from .unit import Unit, UnitType
from . import rat
from .points import Point
from engine.collision_system import CollisionLayer
@@ -11,24 +11,24 @@ NUCLEAR_TIMER = 50 # 1 second at ~50 FPS
class Bomb(Unit):
def __init__(self, game, position=(0,0), id=None):
super().__init__(game, position, id, collision_layer=CollisionLayer.BOMB)
def __init__(self, game, position=(0,0), id=None, unit_type=UnitType.BOMB_TIMER):
super().__init__(game, position, id, collision_layer=CollisionLayer.BOMB, unit_type=unit_type)
# Specific attributes for bombs
self.speed = 4 # Bombs age faster
self.fight = False
def move(self):
pass
def collisions(self):
pass
def die(self, unit=None):
if not unit:
unit = self
self.game.units.pop(unit.id)
def draw(self):
n = self.age // 40
n= 3 -n +1
@@ -40,41 +40,44 @@ class Bomb(Unit):
image_size = self.game.render_engine.get_image_size(image)
self.rat_image = image
partial_x, partial_y = 0, 0
x_pos = self.position_before[0] * self.game.cell_size + (self.game.cell_size - image_size[0]) // 2 + partial_x
y_pos = self.position_before[1] * self.game.cell_size + (self.game.cell_size - image_size[1]) // 2 + partial_y
if self.is_hidden_in_tunnel(image_size):
return
self.game.render_engine.draw_image(x_pos, y_pos, image, anchor="nw", tag="unit")
class Timer(Bomb):
def __init__(self, game, position=(0,0), id=None):
super().__init__(game, position, id, unit_type=UnitType.BOMB_TIMER)
def move(self):
self.age += self.speed
if self.age == AGE_THRESHOLD:
self.die()
def die(self, unit=None, score=None):
"""Handle bomb explosion and chain reactions using vectorized collision system."""
score = 10
print("BOOM")
target_unit = unit if unit else self
self.game.render_engine.play_sound("BOMB.WAV")
# Use base class cleanup with error handling
try:
if target_unit.id in self.game.units:
self.game.units.pop(target_unit.id)
except:
print(f"Unit {target_unit.id} already dead")
# Bomb-specific behavior: create explosion
self.game.unit_manager.spawn_unit(Explosion, target_unit.position)
# Collect all explosion positions using vectorized approach
explosion_positions = []
# Check for chain reactions in all four directions
for direction in ["N", "S", "E", "W"]:
x, y = target_unit.position
@@ -91,18 +94,18 @@ class Timer(Bomb):
x += 1
elif direction == "W":
x -= 1
# Create all explosions at once
for pos in explosion_positions:
self.game.unit_manager.spawn_unit(Explosion, pos)
# Use optimized collision system to get all rats in explosion area
# This replaces the nested loop with a single vectorized operation
victim_ids = self.game.collision_system.get_units_in_area(
explosion_positions,
layer_filter=CollisionLayer.RAT
)
# Kill all victims with score multiplier
for victim_id in victim_ids:
victim = self.game.unit_manager.get_unit_by_id(victim_id)
@@ -113,70 +116,69 @@ class Timer(Bomb):
victim.die(score=score)
if score < 160:
score *= 2
class Explosion(Bomb):
def __init__(self, game, position=(0,0), id=None):
# Initialize with proper EXPLOSION layer
Unit.__init__(self, game, position, id, collision_layer=CollisionLayer.EXPLOSION)
# Initialize with proper EXPLOSION layer and type
Unit.__init__(self, game, position, id, collision_layer=CollisionLayer.EXPLOSION, unit_type=UnitType.EXPLOSION)
self.speed = 20 # Bombs age faster * 5
self.fight = False
def move(self):
self.age += self.speed
if self.age >= AGE_THRESHOLD:
self.die()
def draw(self):
image = self.game.graphics.assets["BMP_EXPLOSION"]
image_size = self.game.render_engine.get_image_size(image)
partial_x, partial_y = 0, 0
x_pos = self.position_before[0] * self.game.cell_size + (self.game.cell_size - image_size[0]) // 2 + partial_x
y_pos = self.position_before[1] * self.game.cell_size + (self.game.cell_size - image_size[1]) // 2 + partial_y
if self.is_hidden_in_tunnel(image_size):
return
self.game.render_engine.draw_image(x_pos, y_pos, image, anchor="nw", tag="unit")
class NuclearBomb(Unit):
def __init__(self, game, position=(0,0), id=None):
super().__init__(game, position, id, collision_layer=CollisionLayer.BOMB)
super().__init__(game, position, id, collision_layer=CollisionLayer.BOMB, unit_type=UnitType.BOMB_NUCLEAR)
self.speed = 1 # Slow countdown
self.fight = False
self.timer = NUCLEAR_TIMER # 1 second timer
def move(self):
"""Count down the nuclear timer"""
self.timer -= 1
if self.timer <= 0:
self.explode()
def collisions(self):
pass
def explode(self):
"""Nuclear explosion that affects all rats on the map"""
print("NUCLEAR EXPLOSION!")
# Play nuclear explosion sound
self.game.render_engine.play_sound("nuke.wav")
# Trigger white screen effect
self.game.render_engine.trigger_white_flash()
# Remove the nuclear bomb from the game
if self.id in self.game.units:
self.game.units.pop(self.id)
# Kill 90% of all rats on the map
# Kill 70% of all rats on the map
rats_to_kill = []
# If unit is a child class of Rat
for unit in self.game.units.values():
if isinstance(unit, rat.Rat):
if unit.type in [UnitType.RAT_MALE, UnitType.RAT_FEMALE]:
if random.random() < 0.7: # 70% chance to kill each rat
rats_to_kill.append(unit)
for unit in rats_to_kill:
units/gas.py
+5 -6
View File
@@ -1,5 +1,4 @@
from .unit import Unit
from .rat import Rat
from .unit import Unit, UnitType
from engine.collision_system import CollisionLayer
import random
@@ -8,7 +7,7 @@ AGE_THRESHOLD = 200
class Gas(Unit):
def __init__(self, game, position=(0,0), id=None, parent_id=None):
super().__init__(game, position, id, collision_layer=CollisionLayer.GAS)
super().__init__(game, position, id, collision_layer=CollisionLayer.GAS, unit_type=UnitType.GAS)
self.parent_id = parent_id
# Specific attributes for gas
self.speed = 50
@@ -33,7 +32,7 @@ class Gas(Unit):
for victim_id in victim_ids:
victim = self.game.unit_manager.get_unit_by_id(victim_id)
if victim and isinstance(victim, Rat):
if victim and victim.type in [UnitType.RAT_MALE, UnitType.RAT_FEMALE]:
if victim.partial_move > 0.5:
victim.gassed += 1
@@ -44,7 +43,7 @@ class Gas(Unit):
for victim_id in victim_ids_before:
victim = self.game.unit_manager.get_unit_by_id(victim_id)
if victim and isinstance(victim, Rat):
if victim and victim.type in [UnitType.RAT_MALE, UnitType.RAT_FEMALE]:
if victim.partial_move < 0.5:
victim.gassed += 1
@@ -59,7 +58,7 @@ class Gas(Unit):
new_x = self.position[0] + dx
new_y = self.position[1] + dy
if not self.game.map.is_wall(new_x, new_y):
if not any(isinstance(unit, Gas) for unit in self.game.units.values() if unit.position == (new_x, new_y)):
if not any(unit.type == UnitType.GAS for unit in self.game.units.values() if unit.position == (new_x, new_y)):
print(f"Spreading gas from {self.position} to ({new_x}, {new_y})")
self.game.unit_manager.spawn_unit(Gas, (new_x, new_y), parent_id=self.parent_id if self.parent_id else self.id)
def collisions(self):
units/mine.py
+3 -3
View File
@@ -1,10 +1,10 @@
from .unit import Unit
from .unit import Unit, UnitType
from .bomb import Explosion
from engine.collision_system import CollisionLayer
class Mine(Unit):
def __init__(self, game, position=(0,0), id=None):
super().__init__(game, position, id, collision_layer=CollisionLayer.MINE)
super().__init__(game, position, id, collision_layer=CollisionLayer.MINE, unit_type=UnitType.MINE)
self.speed = 1.0 # Mine doesn't move but needs speed for consistency
self.armed = True # Mine is active and ready to explode
@@ -24,7 +24,7 @@ class Mine(Unit):
for victim_id in victim_ids:
rat_unit = self.game.unit_manager.get_unit_by_id(victim_id)
if rat_unit and hasattr(rat_unit, 'sex'): # Check if it's a rat
if rat_unit and rat_unit.type in [UnitType.RAT_MALE, UnitType.RAT_FEMALE]:
# Mine explodes and kills the rat
self.explode(rat_unit)
break
units/points.py
+3 -6
View File
@@ -1,4 +1,5 @@
from .unit import Unit
from .unit import Unit, UnitType
from engine.collision_system import CollisionLayer
import random
import uuid
@@ -6,10 +7,6 @@ import uuid
AGE_THRESHOLD = 90
from .unit import Unit
from engine.collision_system import CollisionLayer
class Point(Unit):
"""
Represents a collectible point in the game.
@@ -17,7 +14,7 @@ class Point(Unit):
"""
def __init__(self, game, position=(0,0), id=None, value=10):
super().__init__(game, position, id, collision_layer=CollisionLayer.POINT)
super().__init__(game, position, id, collision_layer=CollisionLayer.POINT, unit_type=UnitType.POINT)
self.value = value
self.speed = 1 # Points don't move but need speed for draw timing
units/rat.py
+36 -39
View File
@@ -1,4 +1,4 @@
from .unit import Unit
from .unit import Unit, UnitType
from .points import Point
from engine.collision_system import CollisionLayer
@@ -13,8 +13,8 @@ BABY_INTERVAL = 50
class Rat(Unit):
def __init__(self, game, position=(0,0), id=None):
super().__init__(game, position, id, collision_layer=CollisionLayer.RAT)
def __init__(self, game, position=(0,0), id=None, unit_type=None):
super().__init__(game, position, id, collision_layer=CollisionLayer.RAT, unit_type=unit_type)
# Specific attributes for rats
self.speed = 0.10 * getattr(self.game, "rat_speed_multiplier", 1.0)
self.fight = False
@@ -36,7 +36,7 @@ class Rat(Unit):
return "UP"
else:
return "DOWN"
def find_next_position(self):
neighbors = []
x, y = self.position
@@ -84,17 +84,17 @@ class Rat(Unit):
self.partial_move = 0
self.position = self.find_next_position()
self.direction = self.calculate_rat_direction()
# Pre-calculate render position for draw() - optimization
self._update_render_position()
def _update_render_position(self):
"""Pre-calculate rendering position and bbox during move() to optimize draw()"""
sex = self.sex if self.age > AGE_THRESHOLD else "BABY"
# Get cached image size instead of calling get_image_size()
image_size = self.game.graphics.rat_image_sizes[sex][self.direction]
# Calculate partial movement offset
if self.direction in ["UP", "DOWN"]:
partial_x = 0
@@ -102,47 +102,46 @@ class Rat(Unit):
else:
partial_x = self.partial_move * self.game.cell_size * (1 if self.direction == "RIGHT" else -1)
partial_y = 0
# Calculate final render position
self.render_x = self.position_before[0] * self.game.cell_size + (self.game.cell_size - image_size[0]) // 2 + partial_x
self.render_y = self.position_before[1] * self.game.cell_size + (self.game.cell_size - image_size[1]) // 2 + partial_y
# Update bbox for collision system
self.bbox = (self.render_x, self.render_y, self.render_x + image_size[0], self.render_y + image_size[1])
def collisions(self):
"""
Optimized collision detection using the vectorized collision system.
Uses spatial hashing and numpy for efficient checks with 200+ units.
Optimized collision detection using the spatial grid system.
"""
OVERLAP_TOLERANCE = self.game.cell_size // 4
# Only adult rats can collide for reproduction/fighting
if self.age < AGE_THRESHOLD:
return
# Get collisions from the optimized collision system
collisions = self.game.collision_system.get_collisions_for_unit(
self.id,
CollisionLayer.RAT,
tolerance=OVERLAP_TOLERANCE
)
# Process each collision
for _, other_id in collisions:
other_unit = self.game.unit_manager.get_unit_by_id(other_id)
# Skip if not another Rat
if not isinstance(other_unit, Rat):
if not other_unit or other_unit.type not in [UnitType.RAT_MALE, UnitType.RAT_FEMALE]:
continue
if not other_unit or other_unit.age < AGE_THRESHOLD:
if other_unit.age < AGE_THRESHOLD:
continue
# Check if units are actually moving towards each other
if self.position != other_unit.position_before:
continue
# Both units still exist in game
if self.id in self.game.units and other_id in self.game.units:
if self.sex == other_unit.sex and self.fight:
@@ -150,18 +149,18 @@ class Rat(Unit):
self.die(other_unit)
elif self.sex != other_unit.sex:
# Different sex = reproduction
if "fuck" in dir(self):
if hasattr(self, 'fuck'):
self.fuck(other_unit)
def die(self, unit=None, score=10):
"""Handle rat death and spawn points."""
target_unit = unit if unit else self
death_position = target_unit.position_before
# Use base class cleanup
if target_unit.id in self.game.units:
self.game.units.pop(target_unit.id)
# Rat-specific behavior: spawn points
if score not in [None, 0]:
self.game.scoring.add_point(score)
@@ -175,7 +174,7 @@ class Rat(Unit):
sex = self.sex if self.age > AGE_THRESHOLD else "BABY"
image = self.game.graphics.rat_assets_textures[sex][self.direction]
image_size = self.game.graphics.rat_image_sizes[sex][self.direction]
# Calculate render position if not yet set (first frame)
if not hasattr(self, 'render_x'):
self._calculate_render_position()
@@ -194,11 +193,9 @@ class Rat(Unit):
return
if not self.game.map.is_empty(cell_x, cell_y):
return
# Use pre-calculated positions
self.game.render_engine.draw_image(self.render_x, self.render_y, image, anchor="nw", tag="unit")
# bbox already updated in _update_render_position()
#self.game.render_engine.draw_rectangle(self.bbox[0], self.bbox[1], self.bbox[2] - self.bbox[0], self.bbox[3] - self.bbox[1], "unit")
def _draw_partially_hidden_in_tunnel(self, image, image_size, center_x, center_y, cell_x, cell_y):
direction = self._get_tunnel_entrance_direction(cell_x, cell_y)
@@ -270,29 +267,29 @@ class Rat(Unit):
if len(empty_neighbors) != 1:
return None
return empty_neighbors[0]
def _calculate_render_position(self):
"""Calculate render position and bbox (used when render_x not yet set)"""
sex = self.sex if self.age > AGE_THRESHOLD else "BABY"
image_size = self.game.render_engine.get_image_size(
self.game.graphics.rat_assets_textures[sex][self.direction]
)
partial_x, partial_y = 0, 0
if self.direction in ["UP", "DOWN"]:
partial_y = self.partial_move * self.game.cell_size * (1 if self.direction == "DOWN" else -1)
else:
partial_x = self.partial_move * self.game.cell_size * (1 if self.direction == "RIGHT" else -1)
self.render_x = self.position_before[0] * self.game.cell_size + (self.game.cell_size - image_size[0]) // 2 + partial_x
self.render_y = self.position_before[1] * self.game.cell_size + (self.game.cell_size - image_size[1]) // 2 + partial_y
self.bbox = (self.render_x, self.render_y, self.render_x + image_size[0], self.render_y + image_size[1])
class Male(Rat):
def __init__(self, game, position=(0,0), id=None):
super().__init__(game, position, id)
super().__init__(game, position, id, unit_type=UnitType.RAT_MALE)
self.sex = "MALE"
def fuck(self, unit):
if not unit.pregnant:
self.game.render_engine.play_sound("SEX.WAV")
@@ -300,14 +297,14 @@ class Male(Rat):
unit.stop = 200
unit.pregnant = PREGNANCY_DURATION
unit.babies = random.randint(1, 3)
class Female(Rat):
def __init__(self, game, position=(0,0), id=None):
super().__init__(game, position, id)
super().__init__(game, position, id, unit_type=UnitType.RAT_FEMALE)
self.sex = "FEMALE"
self.pregnant = False
self.babies = 0
def procreate(self):
self.pregnant -= 1
if self.pregnant == self.babies * BABY_INTERVAL:
units/unit.py
+15 -2
View File
@@ -1,6 +1,16 @@
from abc import ABC, abstractmethod
import uuid
from enum import Enum, auto
class UnitType(Enum):
RAT_MALE = auto()
RAT_FEMALE = auto()
BOMB_TIMER = auto()
BOMB_NUCLEAR = auto()
GAS = auto()
MINE = auto()
POINT = auto()
EXPLOSION = auto()
class Unit(ABC):
"""
@@ -28,6 +38,8 @@ class Unit(ABC):
Number of ticks to remain stationary.
collision_layer : int
Collision layer for the optimized collision system.
type : UnitType
The specific type of the unit.
Methods
-------
@@ -40,7 +52,7 @@ class Unit(ABC):
die()
Remove unit from game and handle cleanup.
"""
def __init__(self, game, position=(0, 0), id=None, collision_layer=0):
def __init__(self, game, position=(0, 0), id=None, collision_layer=0, unit_type=None):
"""Initialize a unit with game reference and position."""
self.id = id if id else uuid.uuid4()
self.game = game
@@ -49,9 +61,10 @@ class Unit(ABC):
self.age = 0
self.speed = 1.0
self.partial_move = 0
self.bbox = (0, 0, 0, 0)
self.bbox = (0.0, 0.0, 0.0, 0.0) # Ensure it's a tuple of floats
self.stop = 0
self.collision_layer = collision_layer
self.type = unit_type if unit_type else UnitType.POINT # Default type
@abstractmethod
def move(self):