Concetti Chiave
- Il codice rappresenta un semplice gioco in console in cui un eroe può muoversi su una mappa definita da un array di caratteri.
- La mappa è costituita da muri e spazi vuoti, con la possibilità di utilizzare una ricerca in ampiezza (BFS) per trovare un percorso.
- Il personaggio può muoversi in quattro direzioni, e i movimenti sono gestiti attraverso funzioni dedicate.
- Il gioco prevede un sistema di punteggio basato sull'interazione con elementi presenti sulla mappa.
- Le difficoltà del gioco possono essere selezionate dall'utente, influenzando la velocità del personaggio.
#include
#include
#include
#include
#include
using namespace std;
char tmp_map[18][32];
char map[18][32] = {
"+#############################+",
"| |",
"| |",
"|## ########### ## #########|",
"| | |",
"| | |### | | | |",
"| | | | |### | | | |",
"| | #####| | | ## | |",
"| | |### | | |",
"| |##### ### ## |",
"| ###### ####### ###|",
"| |",
"|# ### #### ### #######|",
"| |",
"| |",
"| |",
"| |",
"+#############################+"
};
void ShowMap()
{
for(int i = 0; i
printf("%s\n",map );
}
}
void gotoxy( short x, short y )
{
HANDLE hStdout = GetStdHandle(STD_OUTPUT_HANDLE) ;
COORD position = { x, y } ;
SetConsoleCursorPosition( hStdout, position ) ;
}
class entity {
public:
entity( int x, int y ){
this ->x = x;
this ->y = y;
}
void move_x( int p ){
if( map[y][x+p] == ' ' ) x += p;
}
void move_y( int p ){
if( map[y+p][x] == ' ' ) y += p;
}
void move( int p, int q ){
x += p;
y += q;
}
int get_x(){ return x; }
int get_y(){ return y; }
void draw( char p ){
map[x][y] = p;
gotoxy( x, y ); printf( "%c", p );
}
private:
int x;
int y;
};
struct walk {
short walk_count;
short x;
short y;
short back;
};
struct target {
short x;
short y;
};
vector
vector
void AddArray( int x, int y, int wc , int back ){
if( tmp_map[y][x] == ' ' || tmp_map[y][x] == '.' ){
tmp_map[y][x] = '#';
walk tmp;
tmp.x = x;
tmp.y = y;
tmp.walk_count = wc;
tmp.back = back;
BFSArray.push_back( tmp );
}
}
Funzione FindPath
void FindPath( int sx, int sy, int x, int y ){
memcpy( tmp_map, map, sizeof(map) );
BFSArray.clear();
walk tmp;
tmp.x = sx;
tmp.y = sy;
tmp.walk_count = 0;
tmp.back = -1;
BFSArray.push_back( tmp );
int i = 0;
while( i
if( BFSArray.x == x && BFSArray.y == y ){
walk_queue.clear();
target tmp2;
while( BFSArray.walk_count != 0 ){
tmp2.x = BFSArray.x;
tmp2.y = BFSArray.y;
walk_queue.push_back( tmp2 );
i = BFSArray.back;
}
break;
}
AddArray( BFSArray.x+1, BFSArray.y, BFSArray.walk_count+1, i );
AddArray( BFSArray.x-1, BFSArray.y, BFSArray.walk_count+1, i );
AddArray( BFSArray.x, BFSArray.y+1, BFSArray.walk_count+1, i );
AddArray( BFSArray.x, BFSArray.y-1, BFSArray.walk_count+1, i );
/*
AddArray( BFSArray.x+1, BFSArray.y+1, BFSArray.walk_count+1, i );
AddArray( BFSArray.x-1, BFSArray.y+1, BFSArray.walk_count+1, i );
AddArray( BFSArray.x+1, BFSArray.y+1, BFSArray.walk_count+1, i );
AddArray( BFSArray.x+1, BFSArray.y-1, BFSArray.walk_count+1, i );
AddArray( BFSArray.x+1, BFSArray.y-1, BFSArray.walk_count+1, i );
AddArray( BFSArray.x-1, BFSArray.y-1, BFSArray.walk_count+1, i );
AddArray( BFSArray.x-1, BFSArray.y+1, BFSArray.walk_count+1, i );
AddArray( BFSArray.x-1, BFSArray.y-1, BFSArray.walk_count+1, i );
*/
i++;
}
BFSArray.clear();
}
int main()
{
bool running = true;
int x = 15; // hero x
int y = 16; // hero y
int old_x;
int old_y;
int ex = 1;
int ey = 1;
int pts = 0;
printf("Instruzione:\n1. Usare le freccette per muovere il tuo eroe\n2. Mangia i pallini prodotti dal tuo nemico per ottenere punti\n3. Non farti prendere dal tuo nemico\n\n");
printf("H -> Difficile\nN -> Normale\nE -> Facile\n\nInput : ");
char diffi;
int speedmod = 3;
cin >> diffi;
if( diffi == 'N' ){
speedmod = 2;
}else if( diffi == 'H' ){
speedmod = 1;
}
system("cls");
ShowMap();
gotoxy( x, y ); cout
int frame = 0;
FindPath( ex,ey,x,y );
while( running ){
gotoxy( x, y ); cout
old_x = x;
old_y = y;
if ( GetAsyncKeyState( VK_UP ) ){
if( map[y-1][x] == '.' ){ y--; pts++; } else
if( map[y-1][x] == ' ' ) y--;
}
if ( GetAsyncKeyState( VK_DOWN ) ){
if( map[y+1][x] == '.' ){ y++; pts++; } else
if( map[y+1][x] == ' ' ) y++;
}
if ( GetAsyncKeyState( VK_LEFT ) ){
if( map[y][x-1] == '.' ){ x--; pts++; } else
if( map[y][x-1] == ' ' ) x--;
}
if ( GetAsyncKeyState( VK_RIGHT ) ){
if( map[y][x+1] == '.' ){ x++; pts++; } else
if( map[y][x+1] == ' ' ) x++;
}
if( old_x != x || old_y != y ){
FindPath( ex,ey,x,y );
}
gotoxy( x,y ); cout
map[ey][ex] = '.';
gotoxy( ex, ey ); cout
if( frame%speedmod == 0 && walk_queue.size() != 0 ){
ex = walk_queue.back().x;
ey = walk_queue.back().y;
walk_queue.pop_back();
}
gotoxy( ex, ey ); cout
if( ex == x && ey == y ){
break;
}
gotoxy( 32, 18 );
gotoxy( 32, 1 ); cout
Sleep( 100 );
frame++;
}
system("cls");
printf("Hai perso...Il tuo punteggio e' : %i", pts );
cin.get();
cin.get();
cin.get();
cin.get();
cin.get();
cin.get();
cin.get();
cin.get();
return 0;
}
Domande da interrogazione
- Qual è la funzione principale del codice fornito?
- Come viene gestito il movimento dell'entità nel gioco?
- Qual è il ruolo della funzione `FindPath`?
- Come viene visualizzata la mappa nel gioco?
- Quali sono le istruzioni fornite all'inizio del gioco?
Il codice implementa un gioco in cui un eroe si muove su una mappa, mangiando pallini e evitando nemici, utilizzando le frecce direzionali per il movimento.
Il movimento dell'entità è gestito tramite la classe `entity`, che permette di spostare l'eroe in orizzontale e verticale, controllando se la nuova posizione è valida (cioè se non è un muro).
La funzione `FindPath` cerca di trovare un percorso dalla posizione iniziale a una posizione obiettivo sulla mappa, utilizzando un algoritmo di ricerca in ampiezza (BFS) per esplorare le possibili mosse.
La mappa viene visualizzata tramite la funzione `ShowMap`, che stampa ogni riga della mappa su console, permettendo al giocatore di vedere il layout del gioco.
Le istruzioni indicano di usare le frecce per muovere l'eroe, mangiare i pallini per guadagnare punti e di non farsi prendere dal nemico.
Accedi a tutti gli appunti
Tutor AI: studia meglio e in meno tempo
