diff --git a/README.md b/README.md index c3c091b..672c830 100644 --- a/README.md +++ b/README.md @@ -13,7 +13,7 @@ Un survival-horror procedurale in prospettiva isometrica per Game Boy (DMG/CGB), - **Delayed Auto-Shift (DAS)**: controlli alla Tetris — delay iniziale di 12 frame e ripetizione ogni 6 frame per il movimento continuo tenendo premuto il D-Pad. - **Salto evasivo con Stamina**: A+direzione scavalca il blocco adiacente atterrando 2 tile più in là (la cella intermedia deve essere un muro). Costa 60 punti stamina; la barra si ricarica di 1 punto al secondo. - **Corsa con Stamina**: B+direzione fa correre il protagonista: il passo dura 8 frame invece di 16 e consuma 10 stamina per tile, con DAS più rapido per incatenare i tile fluidamente. Se la stamina scende sotto 10 ripiega automaticamente sulla camminata normale. -- **Progressione livelli**: si parte dal livello 1; raggiungere la botola fa sprofondare nel livello successivo (livello +1). L'indicatore `L` in alto a sinistra (sprite HUD, come la barra stamina in alto a destra) mostra il livello corrente e si aggiorna ad ogni livello superato. In caso di sconfitta si ricomincia dall'**ultimo livello raggiunto** (il contatore non si azzera). +- **Progressione livelli**: si parte dal livello 1; raggiungere la botola fa sprofondare nel livello successivo (livello +1). L'indicatore `L` in alto a sinistra (sprite HUD, come la barra stamina in alto a destra) mostra il livello corrente e si aggiorna ad ogni livello superato. In caso di sconfitta si ricomincia dall'**ultimo livello raggiunto** (il contatore non si azzera). **La dimensione del labirinto cresce col livello**: +2 tile per lato ad ogni livello (7→9→11→13→15→17), capped a 17x17, così la difficoltà aumenta progressivamente. - **AI del fantasma**: pathfinding greedy con distanza al quadrato (niente sqrt, niente A*), cooldown di 1 secondo tra i passi, hitbox pixel-perfect (12×6 px) per una morte "giusta". - **Audio procedurale**: colonna sonora sintetizzata manipolando direttamente i registri APU via VBL interrupt (nessun campione). - **Schermate a tutto schermo**: copertina 2-bit nativa per il titolo, immagine "Going Deeper" per la vittoria, metasprite "GAME OVER" per la sconfitta. diff --git a/doc/AScreamFromTheDark_report.md b/doc/AScreamFromTheDark_report.md index dcd9367..bfaf4cb 100644 --- a/doc/AScreamFromTheDark_report.md +++ b/doc/AScreamFromTheDark_report.md @@ -56,9 +56,10 @@ py = (lx + ly) * 8 + 16 Camera centrata: `scroll_x = px - 64`, `scroll_y = py - 72` (160×144 display → centro 80×72, con offset hardware). ### 3.2 Generazione del labirinto (`maze.c`) -- **DFS iterativo con stack in WRAM** (`stack_x[49]/stack_y[49]`): evita l'overflow dello stack hardware del LR35902 ricorrendo a un array in RAM. Celle dispari = stanze, celle pari = muri divisori; scava il muro di mezzo con la media aritmetica delle coordinate. -- **Fase 2 — loop**: riapre muri residui che collegano due corridoi opposti con probabilità 15%. Vitale per il gameplay d'inseguimento (permette di aggirare il fantasma). -- **Fase 3 — botola**: sceglie una cella calpestabile **a sufficiente distanza** dalla partenza `(1,1)` (distanza di Chebyshev ≥ `MIN_GOAL_DIST` = 3) tra **tutte** le celle del labirinto, non più vincolata al bordo sud. Fallback estremo sulla cella calpestabile più lontana in assoluto da `(1,1)` se nessuna cella fosse a sufficienza distante (teoricamente impossibile in un perfect maze 7x7). +- **DFS iterativo con stack in WRAM** (`stack_x/y` statici, sized `(MAX_MAP_SIZE/2)^2`): evita l'overflow dello stack hardware del LR35902. Celle dispari = stanze, celle pari = muri divisori; scava il muro di mezzo con la media aritmetica delle coordinate. +- **Dimensione crescente col livello**: `map_size = MAP_SIZE + 2*(level-1)`, capped a `MAX_MAP_SIZE`=17 (sempre dispari). L'array `maze` è allocato `[MAX_MAP_SIZE][MAX_MAP_SIZE]` (289 byte) e i moduli usano `map_size` come bound runtime. +- **Fase 2 — loop**: riapre muri residui che collegano due corridoi opposti con probabilità 15%. Vitale per il gameplay d'inseguimento. +- **Fase 3 — botola**: sceglie una cella calpestabile a distanza di Chebyshev ≥ `map_size/2` dalla partenza `(1,1)` (soglia scalata: 3 per 7x7, 8 per 17x17), tra **tutte** le celle del labirinto. Fallback sulla cella più lontana in assoluto. ### 3.3 Movimento & DAS (`player_logic.c`) - **State machine rigida**: durante `is_moving` (16 frame di LERP, o 8 in corsa) ogni input è ignorato → movimento strettamente grid-based stile Zelda/Pokémon. @@ -87,7 +88,7 @@ Distanza di **Chebyshev** `max(|dx|,|dy|)` invece di euclidea (no sqrt, no looku - Questo evita l'uso di sprite hardware per la botola (che causerebbero flickering per il limite di 10 sprite/scanline) e contiene il consumo di VRAM (limite 256 tile). ### 3.6 Ottimizzazione rendering -Trasferisce solo le 16 righe visibili invece di tutte le 32: `set_bkg_tiles(0, 2, 32, 16, &map_buffer[2*32])`. Aggiornamento a `move_progress==8` (metà passo) per fluidità del fog of war. `map_buffer` usato con wrap `& 31` per gestire lo scroll modulare. +`memset` azzera `map_buffer` (32x32) ad ogni `draw_map`, poi disegna solo la finestra fog 5x5 (~25 tile). Trasferisce l'intera mappa 32x32 al background hardware (`set_bkg_tiles(0,0,32,32,map_buffer)`): necessario perché con labirinti grandi (`map_size` > 7) la finestra fog, proiettata in coordinate iso assolute, può cadere fuori dal range di righe che la vecchia ottimizzazione (righe 2-17) flussava, a causa del wrapping `& 31`. `draw_map` è chiamato solo ai passi del movimento (frame 8 e completamento, non ogni frame), quindi il flush completo è sostenibile. Aggiornamento a `move_progress==8` (metà passo) per fluidità del fog of war. `map_buffer` usato con wrap `& 31` per gestire lo scroll modulare. ### 3.7 AI del fantasma (`enemy_logic.c`) - **Greedy invece di A***: confronta la distanza al quadrato `dx²+dy²` delle 4 celle adiacenti calpestabili e sceglie la minima. No sqrt (pesante su 4 MHz), no heap/nodi (frame drops inammissibili). Difetto voluto: si incastra in vicoli a U → diventa una dinamica di gameplay (seminarlo col level design). diff --git a/doc/gameplay.md b/doc/gameplay.md index 914b545..ca69afd 100644 --- a/doc/gameplay.md +++ b/doc/gameplay.md @@ -39,4 +39,10 @@ Se la Stamina scende sotto 10, B+direzione **ripiega silenziosamente su camminat Il gioco parte dal **livello 1**. Raggiungere la botola (casella traguardo) significa "sprofondare più giù" (*Going Deeper*): alla pressione di START il livello viene **incrementato** e viene generato un nuovo labirinto. In caso di sconfitta (cattura da parte del fantasma) si **ricomincia dallo stesso livello raggiunto**: il contatore non si azzera, solo il passaggio per il titolo (nuova partita) riparte da 1. +## Dimensione crescente del labirinto + +Ad ogni livello la **dimensione del labirinto cresce di 2 tile per lato**: si parte da 7x7 (livello 1) e si arriva a 9x9, 11x11, 13x13, 15x15, fino al cap di **17x17**. La dimensione corrente è la variabile globale `map_size` (l'array `maze` è allocato con bound `MAX_MAP_SIZE` = 17 in modo da contenere qualunque dimensione). Il DFS in `maze.c` genera un perfect maze su `map_size`x`map_size` (le celle dispari sono le stanze, per questo `map_size` è sempre dispari), poi lo rompe con i loop al 15% e posiziona la botola a distanza di Chebyshev ≥ `map_size/2` dalla partenza. Anche lo spawn del fantasma scala: parte a distanza ≥ `map_size/2`, così nelle mappe grandi non si attiva subito (il suo cono visivo resta comunque 5x5, fissato dal fog of war). + +Poiché con labirinti grandi la finestra fog-of-war 5x5, proiettata in coordinate isometriche assolute, può cadere fuori dal vecchio range di righe flussato (2-17) a causa del wrapping della mappa 32x32, `draw_map` ora flussa l'intera mappa 32x32 al hardware background. `draw_map` è chiamato solo ai passi del movimento (non ogni frame), quindi il costo è sostenibile. + L'indicatore `L` è mostrato in **alto a sinistra** tramite tre sprite hardware (OAM ID 23–25), disegnati dall'asset `level.png` (11 glifi 8x16: 'L', '0'–'9'). Le decine vengono mostrate solo dal livello 10 in poi (sotto, lo sprite decine è spostato fuori schermo). Come la barra stamina (in alto a destra), l'indicatore è a coordinate-schermo fisse e indipendente dallo scroll isometrico, e viene nascosto durante il game over e sul titolo. La base VRAM dei glifi è allineata a un indice **pari** perché in modalità sprite 8x16 l'hardware ignora il bit meno significativo dell'indice tile. diff --git a/doc/generation.md b/doc/generation.md index 038151f..bd5c9cd 100644 --- a/doc/generation.md +++ b/doc/generation.md @@ -2,7 +2,7 @@ ## Algoritmo Depth-First Search (DFS) -Per garantire che ogni sessione di gioco sia unica, il labirinto viene generato proceduralmente ad ogni avvio (usando `DIV_REG` hardware del Game Boy come seed pseudo-casuale). +Per garantire che ogni sessione di gioco sia unica, il labirinto viene generato proceduralmente ad ogni avvio (usando `DIV_REG` hardware del Game Boy come seed pseudo-casuale). La **dimensione del labirinto cresce col livello**: la variabile globale `map_size` parte da `MAP_SIZE` (7) al livello 1 e aumenta di 2 per livello fino al cap `MAX_MAP_SIZE` (17) — quindi 7x7, 9x9, 11x11, 13x13, 15x15, 17x17. `map_size` è sempre dispari perchè il DFS usa le celle dispari come stanze e le pari come muri divisori. L'algoritmo utilizzato in `maze.c` è un **Depth-First Search (DFS)** con Backtracking, modellato per creare un "Perfect Maze" (labirinto perfetto in cui ogni cella è raggiungibile tramite un unico percorso possibile e senza cicli). La mappa è concettualmente divisa in: diff --git a/src/enemy_logic.c b/src/enemy_logic.c index d3fd9bc..f6d9343 100644 --- a/src/enemy_logic.c +++ b/src/enemy_logic.c @@ -65,14 +65,14 @@ void update_enemy_logic(void) { int16_t min_dist_sq = (int16_t)dx * dx + (int16_t)dy * dy; // Controllo 1: Direzione Down-Right (+1 X) - if (enemy_lx + 1 < MAP_SIZE && maze[enemy_ly][enemy_lx + 1] != 0) { + if (enemy_lx + 1 < map_size && maze[enemy_ly][enemy_lx + 1] != 0) { int8_t ndx = (int8_t)player_lx - (int8_t)(enemy_lx + 1); int8_t ndy = (int8_t)player_ly - (int8_t)enemy_ly; int16_t d_sq = (int16_t)ndx * ndx + (int16_t)ndy * ndy; if (d_sq < min_dist_sq) { min_dist_sq = d_sq; best_nx = enemy_lx + 1; best_ny = enemy_ly; } } // Controllo 2: Direzione Down-Left (+1 Y) - if (enemy_ly + 1 < MAP_SIZE && maze[enemy_ly + 1][enemy_lx] != 0) { + if (enemy_ly + 1 < map_size && maze[enemy_ly + 1][enemy_lx] != 0) { int8_t ndx = (int8_t)player_lx - (int8_t)enemy_lx; int8_t ndy = (int8_t)player_ly - (int8_t)(enemy_ly + 1); int16_t d_sq = (int16_t)ndx * ndx + (int16_t)ndy * ndy; diff --git a/src/engine.c b/src/engine.c index b5ca4f3..b751917 100644 --- a/src/engine.c +++ b/src/engine.c @@ -81,7 +81,12 @@ void engine_init(void) { // Usa il registro divisore hardware (DIV_REG) per seedare l'RNG. Garantisce labirinti diversi ogni volta. initrand(DIV_REG); - + + // Dimensione del labirinto crescente col livello: +2 tile per livello a partire da 7, + // capped a MAX_MAP_SIZE (17). Sempre dispari (per il pattern stanza/muro del DFS). + map_size = MAP_SIZE + 2 * (level - 1); + if (map_size > MAX_MAP_SIZE) map_size = MAX_MAP_SIZE; + // DELEGA LA GENERAZIONE: Chiede al modulo maze.c di creare l'array della mappa generate_maze(); @@ -106,8 +111,8 @@ void engine_init(void) { // Fallback di sicurezza: Cerca la prima casella libera se 1,1 è occupato (teoricamente impossibile col DFS) if (maze[player_ly][player_lx] == 0) { uint8_t found = 0; - for (uint8_t y = 1; y < MAP_SIZE - 1; y++) { - for (uint8_t x = 1; x < MAP_SIZE - 1; x++) { + for (uint8_t y = 1; y < map_size - 1; y++) { + for (uint8_t x = 1; x < map_size - 1; x++) { if (maze[y][x] == 1) { player_lx = x; player_ly = y; @@ -120,17 +125,21 @@ void engine_init(void) { } // SPAWN DEL NEMICO - // Cerca randomicamente un punto lontano almeno 3 celle dal giocatore + // Cerca randomicamente un punto lontano almeno map_size/2 celle dal giocatore + // (scala con la dimensione del labirinto: in una mappa grande il fantasma parte + // lontano e non si attiva finché non entra nel cono visivo 5x5 del fog of war). + uint8_t enemy_min_dist = map_size / 2; + if (enemy_min_dist < 3) enemy_min_dist = 3; while (1) { - uint8_t rx = rand() % MAP_SIZE; - uint8_t ry = rand() % MAP_SIZE; + uint8_t rx = rand() % map_size; + uint8_t ry = rand() % map_size; if (maze[ry][rx] == 1) { int8_t dx = (int8_t)rx - (int8_t)player_lx; int8_t dy = (int8_t)ry - (int8_t)player_ly; if (dx < 0) dx = -dx; if (dy < 0) dy = -dy; int8_t dist = (dx > dy) ? dx : dy; - if (dist >= 3) { + if (dist >= (int8_t)enemy_min_dist) { enemy_lx = rx; enemy_ly = ry; break; diff --git a/src/globals.c b/src/globals.c index ebb4a2b..26da86b 100644 --- a/src/globals.c +++ b/src/globals.c @@ -4,7 +4,8 @@ volatile uint8_t game_over = 0; volatile uint8_t game_over_timer = 0; -uint8_t maze[MAP_SIZE][MAP_SIZE]; +uint8_t map_size = MAP_SIZE; +uint8_t maze[MAX_MAP_SIZE][MAX_MAP_SIZE]; uint8_t map_buffer[32 * 32]; uint8_t player_lx = 1; diff --git a/src/globals.h b/src/globals.h index 47d137f..3f07020 100644 --- a/src/globals.h +++ b/src/globals.h @@ -22,9 +22,11 @@ extern volatile uint8_t game_over; extern volatile uint8_t game_over_timer; // --- Map Data --- -#define MAP_SIZE 7 -// The generated maze: 0 = Wall, 1 = Floor, 2 = Victory Tile -extern uint8_t maze[MAP_SIZE][MAP_SIZE]; +#define MAP_SIZE 7 // initial maze size (level 1); must be odd +#define MAX_MAP_SIZE 17 // hard cap for maze growth (odd); used as the array bound +// The generated maze: 0 = Wall, 1 = Floor, 2 = Victory Tile (hatch) +extern uint8_t map_size; // current maze side length (grows with level, MAP_SIZE..MAX_MAP_SIZE) +extern uint8_t maze[MAX_MAP_SIZE][MAX_MAP_SIZE]; // --- Camera & Rendering --- // Map buffer used to draw the isometric tiles into the Game Boy Background map @@ -36,9 +38,7 @@ extern int8_t scroll_y; extern uint8_t stairs_lx; extern uint8_t stairs_ly; -// --- Mappa e Entità --- -// The generated maze: 0 = Wall, 1 = Floor, 2 = Victory Tile -extern uint8_t maze[MAP_SIZE][MAP_SIZE]; +// --- Mappa e Entita --- extern uint8_t player_lx; extern uint8_t player_ly; extern uint8_t player_dir; // 0=DR, 1=DL, 2=UL, 3=UR @@ -74,4 +74,4 @@ extern int16_t enemy_start_px, enemy_start_py; extern int16_t enemy_target_px, enemy_target_py; extern uint8_t enemy_cooldown; -#endif +#endif \ No newline at end of file diff --git a/src/maze.c b/src/maze.c index 878c4ad..4407175 100644 --- a/src/maze.c +++ b/src/maze.c @@ -3,49 +3,56 @@ #include #include +// Capacita' massima degli array di appoggio (in WRAM, statici per non saturare +// lo stack hardware del LR35902). Le stanze del DFS sono le celle dispari: +// al massimo (MAX_MAP_SIZE/2)^2 = 8*8 = 64 per un labirinto 17x17. +#define MAX_ROOMS ((MAX_MAP_SIZE / 2) * (MAX_MAP_SIZE / 2)) +#define MAX_CELLS (MAX_MAP_SIZE * MAX_MAP_SIZE) + +// Array di appoggio statici (in WRAM, non sullo stack hardware). +static uint8_t stack_x[MAX_ROOMS]; +static uint8_t stack_y[MAX_ROOMS]; +static uint8_t valid_x[MAX_CELLS]; +static uint8_t valid_y[MAX_CELLS]; + /** * Generates a randomized maze using a Depth-First Search (DFS) algorithm with backtracking. - * + * * Sviluppo & Scelte Architetturali: - * 1. Perché DFS? Questo algoritmo è perfetto per labirinti garantendo che ogni cella sia - * raggiungibile partendo dall'inizio (nessuna isola irraggiungibile). - * 2. Il labirinto è una griglia MAP_SIZE x MAP_SIZE in cui le celle dispari (es. 1,1 o 3,3) - * sono le stanze, mentre le celle pari sono i muri divisori. Il DFS scava i muri saltando - * di 2 in 2 e abbattendo il muro in mezzo. - * 3. Abbiamo aggiunto una fase post-DFS che rimuove casualmente qualche muro rimasto (con - * il 15% di probabilità). Questo spezza la struttura "perfetta" del labirinto creando - * dei percorsi ciclici (loop). I loop sono vitali in un gioco con un nemico che ti insegue, - * permettendo al giocatore di aggirare il nemico scappando in cerchio. - * 4. La casella della VITTORIA viene piazzata alla fine. Usiamo la "Distanza di Manhattan" - * (somma della distanza X e Y) dalla partenza (1,1) per assicurarci che il traguardo - * sia la casella più lontana in assoluto. + * 1. Perché DFS? Garantisce che ogni cella sia raggiungibile dalla partenza (nessuna isola). + * 2. Il labirinto è una griglia map_size x map_size (cresce col livello, da MAP_SIZE a + * MAX_MAP_SIZE) in cui le celle dispari (1,1 o 3,3) sono le stanze e le pari sono i muri + * divisori. Il DFS scava i muri saltando di 2 in 2 e abbattendo il muro in mezzo. + * 3. Fase post-DFS: riapre casualmente il 15% dei muri per creare loop (vitali per + * aggirare l'inseguitore). + * 4. La BOTOLA (traguardo) viene piazzata su una cella a sufficiente distanza (Chebyshev + * >= map_size/2) dalla partenza (1,1), in modo che sia sempre lontana ma su qualunque tile. */ void generate_maze(void) { - // 1. Inizializziamo l'intera mappa a 0 (che rappresenta un Muro / Spazio Vuoto) + uint8_t sz = map_size; + + // 1. Inizializziamo l'intera mappa a 0 (Muro / Spazio Vuoto) memset(maze, 0, sizeof(maze)); - - // Stack array per il backtracking. La griglia 7x7 ha al massimo 49 celle dispari (stanze). - uint8_t stack_x[49]; - uint8_t stack_y[49]; + uint8_t stack_ptr = 0; - + // Partiamo sempre dalle coordinate (1, 1) in alto a sinistra uint8_t cx = 1; uint8_t cy = 1; maze[cy][cx] = 1; // 1 = Pavimento calpestabile - + while (1) { // Cerchiamo i vicini non visitati a distanza 2 (saltando il muro divisorio) uint8_t nx[4]; uint8_t ny[4]; uint8_t count = 0; - + // Su if (cy >= 3 && maze[cy - 2][cx] == 0) { nx[count] = cx; ny[count] = cy - 2; count++; } // Giù - if (cy <= MAP_SIZE - 4 && maze[cy + 2][cx] == 0) { + if (cy <= sz - 4 && maze[cy + 2][cx] == 0) { nx[count] = cx; ny[count] = cy + 2; count++; } // Sinistra @@ -53,49 +60,48 @@ void generate_maze(void) { nx[count] = cx - 2; ny[count] = cy; count++; } // Destra - if (cx <= MAP_SIZE - 4 && maze[cy][cx + 2] == 0) { + if (cx <= sz - 4 && maze[cy][cx + 2] == 0) { nx[count] = cx + 2; ny[count] = cy; count++; } - + // Se ci sono vicini validi if (count > 0) { // Scegli una direzione a caso tra quelle disponibili uint8_t dir = rand() % count; - + // Salviamo la cella corrente nello stack per poterci tornare stack_x[stack_ptr] = cx; stack_y[stack_ptr] = cy; stack_ptr++; - - // Abbattiamo il muro nel mezzo (calcolato facendo la media aritmetica delle coordinate) + + // Abbattiamo il muro nel mezzo (media aritmetica delle coordinate) maze[(cy + ny[dir]) / 2][(cx + nx[dir]) / 2] = 1; - + // Spostiamo la posizione corrente sul vicino scelto cx = nx[dir]; cy = ny[dir]; maze[cy][cx] = 1; - } - // Se non ci sono vicini, torna indietro prendendo l'ultima cella salvata dallo stack + } + // Se non ci sono vicini, torna indietro prendendo l'ultima cella dallo stack else if (stack_ptr > 0) { stack_ptr--; cx = stack_x[stack_ptr]; cy = stack_y[stack_ptr]; - } + } // Se lo stack è vuoto, abbiamo visitato tutte le celle: il labirinto è completo! else { break; } } - - // FASE 2: Riapriamo casualmente dei muri per creare percorsi alternativi e loop (15% chance). - // Questo è cruciale per la giocabilità: permette al giocatore di aggirare l'inseguitore! - for (uint8_t y = 1; y < MAP_SIZE - 1; y++) { - for (uint8_t x = 1; x < MAP_SIZE - 1; x++) { + + // FASE 2: Riapriamo casualmente dei muri per creare percorsi alternativi e loop (15%). + // Cruciale per la giocabilità: permette al giocatore di aggirare l'inseguitore! + for (uint8_t y = 1; y < sz - 1; y++) { + for (uint8_t x = 1; x < sz - 1; x++) { if (maze[y][x] == 0) { - // Se la casella è un muro che connette orizzontalmente o verticalmente due corridoi + // Muro che connette orizzontalmente o verticalmente due corridoi if ((maze[y][x - 1] == 1 && maze[y][x + 1] == 1) || (maze[y - 1][x] == 1 && maze[y + 1][x] == 1)) { - // Genera numero casuale tra 0 e 99. Se < 15, trasforma in pavimento. if ((rand() % 100) < 15) { maze[y][x] = 1; } @@ -103,27 +109,24 @@ void generate_maze(void) { } } } - + // FASE 3: Posizionamento della Botola (Traguardo). - // La botola viene piazzata su una cella calpestabile a "sufficiente distanza" - // dalla casella di partenza del giocatore (1,1), cosi' che il traguardo sia - // sempre lontano ma possa trovarsi su una qualunque tile del labirinto, - // non piu' vincolato al bordo sud. Usiamo la distanza di Chebyshev - // (consistente con il resto dell'engine: fog of war, attivazione nemico). -#define MIN_GOAL_DIST 3 - uint8_t valid_x[MAP_SIZE * MAP_SIZE]; - uint8_t valid_y[MAP_SIZE * MAP_SIZE]; + // La botola viene piazzata su una cella calpestabile a "sufficiente distanza" (Chebyshev + // >= map_size/2) dalla partenza (1,1): sempre lontana, ma su una qualunque tile. + // La soglia scala con la dimensione del labirinto (3 per 7x7, 8 per 17x17). + uint8_t min_goal = sz / 2; + if (min_goal < 3) min_goal = 3; uint8_t num_valid = 0; - for (uint8_t y = 1; y < MAP_SIZE - 1; y++) { - for (uint8_t x = 1; x < MAP_SIZE - 1; x++) { + for (uint8_t y = 1; y < sz - 1; y++) { + for (uint8_t x = 1; x < sz - 1; x++) { if (maze[y][x] == 1) { int8_t dx = (int8_t)x - 1; int8_t dy = (int8_t)y - 1; if (dx < 0) dx = -dx; if (dy < 0) dy = -dy; int8_t dist = (dx > dy) ? dx : dy; - if (dist >= MIN_GOAL_DIST) { + if (dist >= (int8_t)min_goal) { valid_x[num_valid] = x; valid_y[num_valid] = y; num_valid++; @@ -140,14 +143,13 @@ void generate_maze(void) { stairs_lx = target_x; stairs_ly = target_y; } else { - // Fallback estremo: nessuna cella a sufficienza distante (teoricamente - // impossibile in un perfect maze 7x7 con partenza 1,1, ma difensivo). - // Sceglie la cella calpestabile piu' lontana in assoluto da (1,1). - uint8_t best_x = MAP_SIZE - 2; - uint8_t best_y = MAP_SIZE - 2; + // Fallback estremo: nessuna cella a sufficienza distante. Sceglie la cella + // calpestabile piu' lontana in assoluto da (1,1). + uint8_t best_x = sz - 2; + uint8_t best_y = sz - 2; int8_t best_dist = -1; - for (uint8_t y = 1; y < MAP_SIZE - 1; y++) { - for (uint8_t x = 1; x < MAP_SIZE - 1; x++) { + for (uint8_t y = 1; y < sz - 1; y++) { + for (uint8_t x = 1; x < sz - 1; x++) { if (maze[y][x] == 1) { int8_t dx = (int8_t)x - 1; int8_t dy = (int8_t)y - 1; @@ -166,4 +168,4 @@ void generate_maze(void) { stairs_lx = best_x; stairs_ly = best_y; } -} +} \ No newline at end of file diff --git a/src/player_logic.c b/src/player_logic.c index 0ffa7d9..c781354 100644 --- a/src/player_logic.c +++ b/src/player_logic.c @@ -144,7 +144,7 @@ void update_player_movement(uint8_t keys, uint8_t prev_keys) { int8_t land_ly = player_ly + move_ly * 2; // Verifica che il salto cada all'interno del labirinto - if (land_lx >= 0 && land_lx < MAP_SIZE && land_ly >= 0 && land_ly < MAP_SIZE) { + if (land_lx >= 0 && (uint8_t)land_lx < map_size && land_ly >= 0 && (uint8_t)land_ly < map_size) { // Condizioni del salto: // a) La cella intermedia DEVE essere un muro (maze == 0) // b) La cella di arrivo DEVE essere un pavimento o vittoria (maze == 1 o 2) @@ -185,7 +185,7 @@ void update_player_movement(uint8_t keys, uint8_t prev_keys) { int8_t new_lx = player_lx + move_lx; int8_t new_ly = player_ly + move_ly; - if (new_lx >= 0 && new_lx < MAP_SIZE && new_ly >= 0 && new_ly < MAP_SIZE) { + if (new_lx >= 0 && (uint8_t)new_lx < map_size && new_ly >= 0 && (uint8_t)new_ly < map_size) { // Se la destinazione è pavimento normale o casella di vittoria if (maze[new_ly][new_lx] == 1 || maze[new_ly][new_lx] == 2) { is_moving = 1; diff --git a/src/render.c b/src/render.c index 903fc1d..c8f9d10 100644 --- a/src/render.c +++ b/src/render.c @@ -11,7 +11,7 @@ #include "maze.h" uint8_t get_tile_state(int8_t cx, int8_t cy, int8_t lx, int8_t ly) { - if (lx < 0 || lx >= MAP_SIZE || ly < 0 || ly >= MAP_SIZE) return 0; + if (lx < 0 || (uint8_t)lx >= map_size || ly < 0 || (uint8_t)ly >= map_size) return 0; if (maze[ly][lx] == 0) return 0; int8_t dx = lx - cx; int8_t dy = ly - cy; @@ -150,12 +150,12 @@ void draw_map(uint8_t center_x, uint8_t center_y) { int8_t start_x = center_x - 2; if (start_x < 0) start_x = 0; int8_t end_x = center_x + 2; - if (end_x >= MAP_SIZE) end_x = MAP_SIZE - 1; + if ((uint8_t)end_x >= map_size) end_x = map_size - 1; int8_t start_y = center_y - 2; if (start_y < 0) start_y = 0; int8_t end_y = center_y + 2; - if (end_y >= MAP_SIZE) end_y = MAP_SIZE - 1; + if ((uint8_t)end_y >= map_size) end_y = map_size - 1; // Processiamo la mappa in DUE passate per risolvere il problema dell'overlapping isometrico. // L'engine disegna da Nord a Sud. I tile a Sud sovrascrivono la metà inferiore dei tile a Nord. @@ -248,10 +248,13 @@ void draw_map(uint8_t center_x, uint8_t center_y) { update_stamina_display(); - // Ottimizzazione hardware critica: trasferire tutta la mappa (1024 bytes) via set_bkg_tiles - // causa lag e sfarfallii (VRAM access). Trasferiamo solo le righe da 2 a 17 (16 righe totali), - // che è la porzione visibile del Game Boy (160x144 px) in cui si svolge l'azione. - set_bkg_tiles(0, 2, 32, 16, &map_buffer[2 * 32]); + // Trasferiamo l'intera mappa 32x32 (1024 byte) al Background hardware. + // Con labirinti grandi (map_size > 7) la finestra fog-of-war 5x5, proiettata in + // coordinate isometriche assolute, puo' cadere in righe OLTRE il vecchio range + // 2-17 (a causa del wrapping & 31), quindi non basta piu' flussare solo 16 righe. + // draw_map e' chiamato solo ai passi del movimento (non ogni frame), quindi il + // costo del flush completo e' sostenibile. + set_bkg_tiles(0, 0, 32, 32, map_buffer); } /**