Problème destructeur C++

Bonjour,

Je réalise un petit jeu de belote en C++.
J'ai plutôt l'habitude du C donc j'ai peut être (suremment) raté un truc.

Le programme compile sans problème. (Pas de warning bizzares).
Mais plante lorsque je tente de quitter le progamme.
Plus exactement après debugage, c'est à la sortie du destructeur ~Game() que je reçoit une erreur de segmentation.

Si quelqu'un a une suggestion, c'est avec plaisir.

Merci

Note : J'utilise la SDL et pas de problème de ce coté là.

/*
*     main.cpp
*/
#include <iostream>
#include <stdlib.h>
#include <SDL.h>

#include "Game.h"

#include "const.h"

using namespace std;

int main(int argc, char** argv)
{

    //Initialisation
    if(SDL_Init(SDL_INIT_VIDEO) < 0){
        cout << "Unable to init SDL: " << SDL_GetError() << endl;
        return EXIT_FAILURE;
    }

    //Nouvelle fenêtre
    SDL_Surface* screen = SDL_SetVideoMode(SCREEN_WIDTH, SCREEN_HEIGHT, 32, SDL_HWSURFACE|SDL_DOUBLEBUF);
    if (screen == NULL){
        cout << "Unable to set 500x430 video: " << SDL_GetError() << endl;
        return EXIT_FAILURE;
    }

    //Chargement des sprites
    SDL_Surface* sprites[SPRITES_COUNT];
    unsigned int i;
    for(i = 0; i < SPRITES_COUNT; i++){
        sprites[i] = NULL;
    }
    sprites[BG] = SDL_LoadBMP("gfx/bg.bmp");
    sprites[CARDS] = SDL_LoadBMP("gfx/cards.bmp");
    for(i = 0; i < SPRITES_COUNT; i++){
        if(sprites[i] == NULL){
            cout << "Unable to load graphics : " << SDL_GetError() << endl;
        }
    }

    //Jeu
    Game* current_game = new Game();

    bool done = false;
    while(!done){

        //Gestion des events
        SDL_Event event;
        while (SDL_PollEvent(&event)){
            switch (event.type){
                case SDL_QUIT:
                    done = true;
                    break;
            }
        }

        //Effacer
        SDL_FillRect(screen, 0, SDL_MapRGB(screen->format, 0, 0, 0));

        //Blit
        current_game->draw(screen, sprites);

        //MAJ de l'écran
        SDL_Flip(screen);
    }

    //Free
    delete current_game;
    SDL_Quit();

    return EXIT_SUCCESS;
}

/**
*        Game.h
*/
#ifndef GAME_H_INCLUDED
#define GAME_H_INCLUDED

#include "Card.h"
//#include "Round.h"

#include "const.h"

class Game{

    private :
        unsigned int scores[2];     //Scores
        unsigned short int dealer;  //Donneur
        Card* deck[32];             //Paquet
        //Round* current_round;       //Manche

    public :
        Game();
        ~Game();
        /*
        *   Jeu
        */
        //Marquer des points
        void add_score(team t, unsigned int s);
        //Couper le jeu
        //void cut();
        //Nouvelle manche
        //void new_round(unsigned short int dealer, Card* deck[32]);
        //Vérifier si une équipe est victorieuse
        bool victory(team t);
        /*
        *   Dessin
        */
        void draw(SDL_Surface* s, SDL_Surface* spr[SPRITES_COUNT]);

};

#endif // GAME_H_INCLUDED


/*
*     Game.cpp
*/

#include <iostream>
#include <SDL.h>
#include <stdlib.h>
#include <time.h>


//#include "Card.h"
#include "Game.h"
//#include "Round.h"

#include "const.h"

//Constructeur
Game::Game(){
    this->scores[NS] = 0;
    this->scores[EW] = 0;

    //Premier donneur
    srand(time(NULL));
    this->dealer = (unsigned short int)rand()%4;

    //Initialisation du jeu
    unsigned short int i,j;
    for(i = 0; i < 4; i++){
        for(j = 7; j < 7+8; j++){
            this->deck[i*8+j] = new Card(i,j);
        }
    }
    //Mélange
    for(i = 0; i < 100; i++){
        unsigned short int c_1,c_2;
        c_1 = rand()%32;
        c_2 = rand()%32;
        Card* tmp_c = this->deck[c_1];
        this->deck[c_1] = this->deck[c_2];
        this->deck[c_2] = tmp_c;
    }

    //Nouvelle manche
    //this->new_round(this->dealer, this->deck);
}

//Destructeur
Game::~Game(){
    //deck
    unsigned short int i;
    for(i = 0; i < 32; i++){
        delete this->deck[i];
    }
    //current_round
    //delete current_round;
}

/*
*   Jeu
*/
//Marquer des points
void Game::add_score(team t, unsigned int s){
    this->scores[t] += s;
}

//Couper le jeu
/*
void Game::cut(){

    Card* tmp_deck[32];

    srand(time(NULL));

    unsigned short int i,j,cut_i;
    j = 0;
    cut_i = rand()%32;

    for(i = cut_i; i < 32; i++){
        tmp_deck[j++] = this->deck[i];
    }
    for(i = 0; i < cut_i; i++){
        tmp_deck[j++] = this->deck[i];
    }
}

//Nouvelle manche
void Game::new_round(unsigned short int dealer, Card* deck[32]){
    this->cut();
    if(this->current_round != NULL){
        delete this->current_round;
    }
    this->current_round = new Round(dealer,deck);
    this->dealer = (this->dealer+1)%4;
}
*/

//Victoire?
bool Game::victory(team t){
    if(this->scores[t] >= MAX_SCORE){
        return true;
    }
    else{
        return false;
    }
}


/*
*   Dessin
*/
void Game::draw(SDL_Surface* s, SDL_Surface* spr[SPRITES_COUNT]){
    SDL_Rect src,des;
    //Le tapis
    src.x = 0;
    src.y = 0;
    src.w = SCREEN_WIDTH;
    src.h = SCREEN_HEIGHT;
    des.x = 0;
    des.y = 0;
    des.w = SCREEN_WIDTH;
    des.h = SCREEN_HEIGHT;
    SDL_BlitSurface(spr[BG],&src,s,&des);
}