Trouts War

In questo tutorial costruiremo passo dopo passo un videogame 2D in cui un'astronave naviga nello spazio cercando di ammazzare i suoi nemici. Il videogame verrà implementato utilizzando la libreria SDL che è una libreria grafica disponibile sia su Linux che su Windows. Personalmente i miei test sono stati eseguiti su Gentoo con Linux 2.6.10, comunque non dovrebbe essere difficile farne il porting su Windows.

Il presente videogame è stato pubblicato sulla rivista Linux Pro e Linux Format e poichè ha suscitato in me e in altri lettori molto interesse ho pensato di chiedere l'autorizzazione per pubblicarlo sul mio wiki.

Da bravo programmatore mi sono preso la libertà di modificare il codice a mio piacimento soprattutto per quel che riguarda l'organizzazione dei files.

Il videogame verrà realizzato utilizzando il linguaggio C++.

Trouts War step 0

Iniziamo a costruire il nostro videogame costruendo la finestra che ospiterà il nostro videogico . Creiamo il file TroutsWar.h e inseriamo in esso il seguente codice.

#ifndef TROUTS_H
#define TROUTS_H

#include
#include

#define SCREEN_WIDTH 800
#define SCREEN_HEIGHT 600

#endif

Creiamo poi il file TroutsWar.cpp ed inseriamo il seguente codice.

#include "TroutsWars.h"

int main() {

    SDL_Init(SDL_INIT_VIDEO);
    atexit(SDL_Quit);
    SDL_SetVideoMode(SCREEN_WIDTH,SCREEN_HEIGHT,32,SDL_HWSURFACE|SDL_DOUBLEBUF);
    return 0;
}

La funzione SDL_Init inizializza la libreria SDL, si osservi la creazione dell'hook sulla funzione SDL_Quit necessaria per liberare le risorse SDL non appena si esce dal videogioco.

L'istruzione SDL_SetVideoMode definisce la modalità video che utilizzeremo (800x600 con double buffering). Per ulteriori dettagli sulle funzioni SDL si consultino [1] e [2]

A questo punto, per compilare il nostro codice sorgente, creiamo un file dal nome Makefile ed inseriamo il seguente codice.

GCC=g++
EXE=TroutsWars
RM=rm -rf

OBJS= TroutsWars.o

all: $(OBJS)

    @echo "linking"
    @$(GCC) -O3 -Wall -o $(EXE) $(OBJS) -lSDL
%.o: %.cpp

    @echo "compile: " $<
    @$(GCC) -O3 -Wall -c $< -o $@
clean:

    @echo "clean"
    @$(RM) $(EXE) *.o

Ricordatevi di usare i TAB nel Makefile e non gli spazi. Ulteriori dettagli su come scrivere un Makefile li trovate in [3].

A questo punto è possibile utilizzare il comando make per compilare il codice sorgente ed eseguirlo attraverso l'esecuzione dell'eseguibile TroutsWar . L'esecuzione di questo piccolo programmino visualizza una finestra che immediatamente scompare. Non preoccupatevi, nei successivi step vedremo come renderla permanentemente visibile. Nel frattempo, se lo desiderate, potete evitare il problema aggiungendo nel main l'istruzione while(1); prima dell'istruzione return 0. Questa aggiunta, però, richiede un kill brutale dell'appliczione per stopparla.

Trouts War step 1

In questo step non aggiungeremo alcuna funzionalità, creeremo solo la classe principale del videogame che ci consentirà di scrivere meglio le cose abbozzate nello step precedente. La classe contiene alcuni metodi fondamentali come: play, disegno della scena e pulizia della finestra.

Nel file TroutsWar.h aggiungiamo la definizione della classe CTWGame.

class CTWGame {
public:

    SDL_Surface* sfcScreen;

    CTWGame();
    void ClearScreen();
    void DrawScene();
    void Play();
};

Il codice di inizializzazione di SDL che nello step 0 avevamo messo nel main lo spostiamo nel costruttore della classe CTWGame.

CTWGame::CTWGame() {

    srand((unsigned) time(NULL));

    if (SDL_Init(SDL_INIT_VIDEO) < 0) {

      printf("troutswars error: impossibile inizializzare SDL - %s.\n", SDL_GetError());
      exit(1);
    }

    atexit(SDL_Quit);

    CTWGame::sfcScreen = SDL_SetVideoMode(SCREEN_WIDTH, SCREEN_HEIGHT, 32, SDL_HWSURFACE|SDL_DOUBLEBUF);

    if (sfcScreen == NULL) {

      printf("troutswars error: impossibile inizializzare SDL - %s.\n", SDL_GetError());
      exit(1);
    }
}

Implementiamo poi la funzionalità di pulizia della finestra utilizando la funzione SDL_FillRect di SDL.

void CTWGame::ClearScreen() {

    SDL_FillRect(sfcScreen, NULL, 0);
}

Nel nostro videogame utilizzeremo la funzionalità double buffering di SDL, ossia ci sono due aree di uguali dimensioni, una visibile e l'altra no. Quando disegnamo lo facciamo sempre su quella non visibile. Terminata la fase di disegno si effettua lo swap dei due buffer con la funzione SDL_Flip. Ecco l'implementazione della funzionalità di disegno (che per ora non disegna nulla).

void CTWGame::DrawScene() {

    ClearScreen();
    SDL_Flip(sfcScreen);
}

Infine c'è l'implementazione del metodo Play che effettua il polling sugli eventi e quando viene rilevata la chiusura della finestra il programma termina.

void CTWGame::Play() {

    int done = 0;
    SDL_Event event;

    while(done == 0) {

      while(SDL_PollEvent(&event)) {

        if (event.type == SDL_QUIT) {

          done = 1;
        }
      }
      DrawScene();
    }
}

Infine riscriviamo il nostro main in base al nuovo codice.

int main() {

    CTWGame *game = new CTWGame;
    game->Play();
    return 0;
}

Continua nel prossimo post ...

Codice Sorgente

Scarica il codice sorgente

Bibliografia

[1] SDL Tutorial parte 1
[2] SDL Tutorial parte 2
[3] How to write a Makefile


Page Information

  • 2 years ago [history]
  • View page source
  • You're not logged in
  • No tags yet learn more

Wiki Information

Recent PBwiki Blog Posts