# Enne2Engine
![Enne2Engine Logo](logo.png)

Un semplice motore di gioco 2D isometrico sviluppato in Python con supporto per SDL2.

## Caratteristiche

- Supporto per più backend grafici
- Sistema di rendering di sprite e tilesheet
- Gestione delle animazioni tramite file JSON
- Sistema di controllo utente e gestione eventi
- Trasformazioni di coordinate isometriche
- Sistema di selezione singola e multipla di entità
- Gestione degli asset semplificata
- Supporto per mappe basate su tile con ombreggiatura
- Pathfinding per le unità di gioco

## Prerequisiti

- Python 3.7+
- SDL2 (per l'utilizzo del backend SDL2)
- Pyglet (per l'utilizzo del backend Pyglet)

## Installazione

1. Clona il repository:
```bash
git clone https://git.enne2.net/enne2/enne2engine
cd enne2engine
```

2. Installa le dipendenze con Python 3.13
```bash
pip install -r requirements.txt
```

## Utilizzo

### Avvio della demo

Per avviare la demo con il backend SDL2:
```bash
python engine_demo.py
```

### Sistema di Entità

L'engine supporta un sistema di entità per la creazione di unità di gioco:

```python
from Entities.Units.marine import Marine

# Creazione di un'unità Marine
marine = Marine("knight", x=5, y=10, animation="idle", speed=1, health=100, game_engine=engine)

# Aggiunta dell'unità al gioco
game.entities.append(marine)

# Selezionare e muovere l'unità
marine.select_unit()
marine.set_target_cell((10, 8))  # L'unità inizierà a muoversi verso questo punto
```

### Sistema Isometrico

Il motore supporta trasformazioni isometriche per la visualizzazione 2.5D:

```python
# Trasformazione da coordinate di mappa a coordinate schermo
screen_x, screen_y = graphics.iso_transform(map_x, map_y)

# Trasformazione da coordinate schermo a coordinate di mappa
map_x, map_y = graphics.inv_iso_transform(screen_x, screen_y)
```

### Gestione delle Mappe

Le mappe sono definite tramite file JSON:

```json
[
  [0, 1, 2, 3],
  [4, 5, 6, 7],
  [8, 9, 10, 11]
]
```

Dove ogni numero rappresenta un indice di tile nel tilesheet.

## Creazione di un nuovo progetto

```python
from enne2engine.sdl2_wrapper import SDL2Wrapper
from enne2engine.controls import UserControls

class MioGioco(UserControls):
    def __init__(self):
        super().__init__()
        self.graphics = SDL2Wrapper(self)
        # Inizializzazione delle risorse e della logica di gioco
        self.load_assets()
        
    def run(self):
        running = True
        while running:
            event = self.graphics.handle_events()
            if event == "QUIT":
                running = False
            
            self.graphics.clear_screen()
            # Logica di rendering
            self.graphics.present_renderer()
        
        self.graphics.quit()
        
    def load_assets(self):
        # Caricamento delle risorse
        self.graphics.load_tilesheet("tiles", "assets/tiles/my_tiles.png")
        self.graphics.load_spritesheet("player", "assets/player/player_animations.json")

if __name__ == "__main__":
    gioco = MioGioco()
    gioco.run()
```

## Struttura del Progetto

- `enne2engine/`: Moduli principali del motore
  - `sdl2_wrapper.py`: Wrapper per SDL2
  - `pyglet_wrapper.py`: Wrapper per Pyglet
  - `controls.py`: Sistema di gestione degli input utente
- `assets/`: Contiene gli asset di esempio
  - `KnightBasic/`: Animazioni del cavaliere (Idle, Run, Walk, Die, Attack)
  - `tiles/`: Tileset di esempio
  - `maps/`: Mappe di esempio in formato JSON
- `Entities/`: Definizioni delle entità di gioco
  - `Units/`: Unità di gioco come Marines
- `engine_demo.py`: Demo del motore

## Formato delle Animazioni

Le animazioni sono definite in file JSON con il seguente formato:

```json
{
  "frames": [
    {
      "frame": {"x": 0, "y": 0, "w": 256, "h": 256},
      "duration": 100
    },
    {
      "frame": {"x": 256, "y": 0, "w": 256, "h": 256},
      "duration": 100
    }
  ],
  "meta": {
    "app": "https://pixelover.io",
    "frameAnimations": [
      {
        "name": "Walk",
        "fps": 10,
        "from": 0,
        "to": 10
      }
    ],
    "direction": 0
  }
}
```

## Rendering e Performance

Il motore include funzionalità per ottimizzare le performance:
- Rendering di background in texture separate
- Texture targeting per operazioni di disegno efficiente
- Conteggio FPS e regolazione del frame timing

## Licenza

Questo progetto è rilasciato sotto la licenza [MIT](LICENSE).