Nell'ultimo articolo (
Tempo di giocare) ho introdotto il concetto di timing nei giochi, in questo articolo voglio introdurre i concetti base del disegno e del movimento di oggetti sullo schermo utilizzando le librerie
SDL.
Iniziamo definendo alcune costanti, la larghezza e l'altezza di un nostro ipotetico personaggio sullo schermo:
#define PLAYER_W 10 //Larghezza
#define PLAYER_H 10 //Altezza
In questo caso il nostro personaggio avra' una forma prettamente quadrata, possiamo passare ora alla definizione di una struttura atta a contenere altre informazioni utili.
Creiamo il tipo di dato "
Player" ad esempio, nel modo che segue:
struct _Player
{
int x, y; //Coordinate del giocatore
} Player;
Due semplici variabili di tipo integer per gestire separatamente le coordinate del nostro giocatore nella finestra di gioco, queste coordinate saranno incrementate e decrementate dalla pressione dei tasti sulla tastiera.
Sulle coordinate del nostro personaggio verra' disegnata la sua immagine, io per comodita' ho racchiuso il tutto in una funzione:
void DrawRect(int x, int y, int width, int height, int color)
{
rect.x = x;
rect.y = y;
rect.w = width;
rect.h = height;
SDL_FillRect(screen, &rect, color);
}
Questa funzione sfrutta delle strutture gia' dichiarate all'interno delle libreria SDL, tra cui
SDL_Surface ed
SDL_Rect.
Possiamo dichiarare come globali delle variabili di questo tipo in cima al nostro sorgente:
SDL_Surface *screen; //L'intera area di gioco
SDL_Rect rect; //Un area per il disegno
All'interno della superfice "
screen" verranno piazzate come in un collage le varie immagini rappresentate da "
rect", il tutto viene effettuato dalla funzione "
SDL_FillRect()".
Ora ci bastera' richiamare la funzione DrawRect in modo analogo per disegnare il nostro personaggio sullo schermo:
DrawRect(Player.x, Player.y, PLAYER_W, PLAYER_H, 0xffffff);
L'argomento color e' un semplice valore esadecimale come quelli che si usano nelle pagine html proprio per i colori, in questo caso il nostro personaggio sara' bianco.
Questa funzione verra' richiamata nel main game loop ad ogni ciclo disegnando un rettangolo colorato delle dimensioni specificate alle coordinate "attuali" del giocatore.
Per incrementare e decrementare le coordinate del nostor giocatore scriviamo quindi passo passo la nostra funzione
getInput()" che verra' anch'essa usata successivamente nel main game loop:
int getInput()
{
while(SDL_PollEvent(&event))
{
if (event.type == SDL_QUIT ||
(event.type == SDL_KEYDOWN &&
event.key.keysym.sym == SDLK_ESCAPE)) quit = 1; /* Window closed */
}
Questo ciclo esegue un "polling" su una struttura contenente una lista di eventi, ovvero controlla la presenza di un qualunque evento in questa lista, lo esegue e lo toglie dalla coda.
In questo caso controlla se vi e' la volonta' di uscire dal programma controllando l'eventuale pressione del tasto ESC, in caso di positivita' assegna ad una variabile
quit il valore di
1, ritroveremo questa variabile piu' avanti nel corso del sorgente.
// Controlla lo stato della tastiera
keystate = SDL_GetKeyState( NULL );
/* Gestisce la pressione dei tasti */
if (keystate[SDLK_LEFT])
Player.x = -1;
if (keystate[SDLK_RIGHT])
Player.x = 1;
if (keystate[SDLK_UP])
Player.y = -1;
if (keystate[SDLK_DOWN])
Player.y = 1;
}
Qui troviamo la variabile "keystate" associata alla funzione
SDL_GetKeyState(), questa funzione ci ritorna lo stato di un dato tasto passatogli come argomento.
I valori "
SDLK_" sono delle costanti numeriche definite all'interno della libreria SDL riferiti ai valori ASCII dei tasti.
In questo caso viene controllato se un determinato tasto e' premuto, in caso positivo viene incrementata una coordinata del giocatore.
Se gli input qui elencati fossero gestiti nel ciclo di polling come per il tasto ESC, si dovrebbe continuamente ripremere il tasto per incrementare o decrementare le coordinate del giocatore.
Questo metodo di gestire gli input ci permette di avere un controllo "continuo" sulla pressione di un eventuale tasto ad ogni ciclo.
Si noti bene che le variabili keystate, quit ed event non sono definite nella funzione, andranno definita in maniera globale nel modo seguente:
SDL_Event event; // Struttura per eventi
Uint8 *keystate; // Stato della tastiera
int quit=0, repeat;
Ora che abbiamo sia la funzione di disegno che quella per la gestione dei movimenti del nostro giocatore, possiamo assemblare il tutto, inseriamo la nostra funzione di gestione del timing come nel precedente
articolo:
int fps_sync ()
{
t = SDL_GetTicks ();
if (t - tl >= frequency)
{
temp = (t - tl) / frequency;
tl += temp * frequency;
return temp;
}
else
{
SDL_Delay (frequency - (t - tl));
tl += frequency;
return 1;
}
}
Ora implementiamo il nostro main game loop in una funzione apposita, successivamente lo richiameremo all'interno di un ciclo.
int mainLoop()
{
//main game loop
while(!quit)
{
repeat = fps_sync ();
for (i = 0; i < repeat ; i++){
getInput();
}
Come gia' visto nell'articolo "
Tempo di giocare", limitiamo il numero di azioni di gioco eseguite al secondo. Si nota anche la presenza di un
!quit come argomento nel
while, finche' quit sara' uguale a 0 il ciclo continuera'.
// Cancella tutto lo schermo di gioco
SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0));
// Disegna il personaggio
DrawRect(Player.x, Player.y, PLAYER_W, PLAYER_H, 0xffffff);
// Aggiorna lo schermo di gioco
SDL_Flip(screen);
}
}
Qui ho usato la funzione SDL_FillRect() per riempire lo schermo di nero, se non si facesse cio' si continuerebbero a vedere i disegni del giocatore nelle varie posizioni passate. Diamo come un colpo di gomma e ridisegniamo successivamente con la funzione
DrawRect() il nostro personaggio.
Con
SDL_Flip() aggiorniamo interamente lo schermo e lo rendiamo pronto per la visualizzazione, su superfici software in alternativa viene richiamato SDL_UpdateRect().
Ora non ci rimane che popolare la nostra funzione principale e testare il nostro prodotto.
int main()
{
// Inizializziamo la libreria SDL
screen = SDL_SetVideoMode(SCREEN_WIDTH, SCREEN_HEIGHT, 32, SDL_SWSURFACE);
if(screen == NULL)
{
fprintf(stderr, "Can't initialize SDL: %s\n", SDL_GetError());
exit(-1);
}
SDL_WM_SetCaption("Esempio", "Esempio");
// Posizione di partenza del nostro giocatore
Player.x = 64;
Player.y = 64;
//main game loop
mainLoop();
SDL_Quit(); // Terminiamo l'utilizzo della libreria in modo corretto
return 0;
}
Il nostro gioco di base e' pronto, al momento non fa molto a parte muovere un quadrato bianco sullo schermo ma come base per capire i concetti di un videogame va piu' che bene.
Salvate il tutto come
game.c e compilate il vostro gioco con
gcc -o game game.c -lSDL, oppure
impostate il vostro IDE preferito e divertitevi!
Questo mese invece del classico articolo sul game programming, affrontiamo un tema leggermente piu' soft e alla portata di tutti, il Game Design.
Lo abbiamo visto ovunque, sui cellulari, in regalo con i detersivi, persino nei decoder per digitale terrestre!
Una caratteristica fondamentale di un buon gioco, e' quella di presentare livelli esplorabili in lungo e in largo, senza costringere il giocatore ad una schermata fissa.
Abbiamo imparato come caricare e mostrare porzioni di un immagine su schermo, per i nostri giochi, grazie all'articolo precedente sui font bmp.
Lo scorso mese ho introdotto l'utilizzo delle matrici in un semplice gioco di campo minato, in questo articolo estenderemo quel concetto realizzando un completo clone del tetris.
Campo minato e' uno dei piu' semplici ed interessanti che ci sia a mio parere.
Ho gia' avuto modo di parlare di questo fantastico gingillo e di come farlo funzionare su un sistema Linux molto grossolanamente, ironia della sorte vuole che abbia dovuto fare pulizia sul computer e di conseguenza rimboccarmi le maniche.
In un precedente articolo, abbiamo realizzato un semplice clone del Pong, sfruttando le tecniche apprese.
Retropong, un semplice remake realizzato da Pix3l.Nel precedente articolo, abbiamo trattato l'argomento collisioni semplici ed implementato una sorta di mini gioco che le sfruttasse.
Il metodo piu' semplice da utilizzare per gestire delle collisioni e' sicuramente il Rectangular Collision (Collisione rettangolare), conosciuto anche come Box Collision. Il presupposto e' che un qualunque oggetto sullo schermo occupa un'area quadrata o rettangolare nel campo di gioco, a discapito dello sprite (l'immagine dell'oggetto).
Tenendo conto delle loro rispettive posizioni sul piano, si puo' fare un confronto fra le loro coordinate, larghezze e altezze.
Ad ogni pagina, corrispondeva un campo completamente vuoto e pulito, l'immagine disegnata era una trasposizione di circa una capocchia di spillo rispetto alla precedente.