SDL with C - Blocks remains after being played

Question

I have been working on a game that is a Stacker. Everything works fine, but after you have played and started over the blocks from the previous game still remain there.

Could anyone help me with this problem?

#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
#include <SDL/SDL_mixer.h>
#include <stdio.h>
#include <stdlib.h>

#define BASE_TIME_INTERVAL 80
#define SPEED_INCREASE 1.03
#define GAME_ROWS 15
#define GAME_COLUMNS 7

#define MIN(a, b) ((a < b) ? a : b)
#define MAX(a, b) ((a > b) ? a : b)

int array_matrix[GAME_ROWS][GAME_COLUMNS];

//void save();

int credit = 0;
int in = 0;
int out = 0;

int inGame = 0;

static SDL_Surface *screen;

//Sprites
static SDL_Surface *square;
static SDL_Surface *background;
static SDL_Surface *grid;
static SDL_Surface *main_ui;
static SDL_Surface *award;

//Text Credits Sprites
static SDL_Surface *credits;
static SDL_Surface *number;

//Sounds
Mix_Chunk *soundPlace = NULL;
Mix_Chunk *soundGameOver = NULL;
Mix_Chunk *soundCredit = NULL;

FILE * fptr;

void print_board() {
    int i, j;
    SDL_Rect src, dest;     

        for (i = 0; i < 15; i++) {
            for (j = 0; j < 7 ; j++) {
                if (array_matrix[i][j] == 1) {

                    src.x = 0;
                    src.y = 0;
                    src.w = 65; 
                    src.h = 65;

                    dest.x = j * 67 + 227;
                    dest.y = i * 67 + 240;
                    dest.w = 65;
                    dest.h = 65;        

                    SDL_BlitSurface(square, &src, screen, &dest);
                
                }
            }
        }
    }

void update_board(int x_pos, int length, int level) {
    int underflow_ammt = length - 1;
    int j;

    if (x_pos < underflow_ammt)
        length = length - (underflow_ammt - x_pos);

    x_pos = MAX(0, x_pos-underflow_ammt);

    for (j = 0; j < GAME_COLUMNS; j++) 
        array_matrix[GAME_ROWS - level][j] = 0;
    
    for (j = x_pos; j < x_pos + length; j++) {
        array_matrix[GAME_ROWS - level][MIN(j, GAME_COLUMNS-1)] = 1;
    }
}

int get_new_length(int level) {
    int i;
    int length = 0;

    for (i = 0; i < GAME_COLUMNS; i++) {
        if (array_matrix[GAME_ROWS - level][i] == 1) {
            length++;
            if (level != 1) {
                if (array_matrix[GAME_ROWS - (level - 1)][i] != 1) {
                    array_matrix[GAME_ROWS - level][i] = 0;
                    length--;
                }
            }
        } 
        if ((level == 4 && length == 3) || (level == 10 && length == 2)) {
            length--;
        }
    }
    return length;
}

void draw_background(){
    SDL_BlitSurface(background, NULL, screen, NULL);
    SDL_BlitSurface(main_ui, NULL, screen, NULL);
    SDL_BlitSurface(award, NULL, screen, NULL);
    SDL_BlitSurface(grid, NULL, screen, NULL);
}

void draw_credits(){
    SDL_Rect destCredits;
    SDL_Rect destNumber;

    switch (credit)
    {
        case 0:
            number = IMG_Load("assets/0.png");
        break;

        case 1:
            number = IMG_Load("assets/1.png");
        break;

        case 2:
            number = IMG_Load("assets/2.png");
        break;

        case 3:
            number = IMG_Load("assets/3.png");
        break;

        case 4:
            number = IMG_Load("assets/4.png");
        break;

        case 5:
            number = IMG_Load("assets/5.png");
        break;

        case 6:
            number = IMG_Load("assets/6.png");
        break;

        case 7:
            number = IMG_Load("assets/7.png");
        break;

        case 8:
            number = IMG_Load("assets/8.png");
        break;

        case 9:
            number = IMG_Load("assets/9.png");
        break;
    }

    if (number == NULL) {
        printf("Unable to load number png.\n");
    }

    destCredits.x = 300;
    destCredits.y = 1300;

    destNumber.x = 550;
    destNumber.y = 1305;

    SDL_BlitSurface(credits, NULL, screen, &destCredits);
    SDL_BlitSurface(number, NULL, screen, &destNumber);
}

void game_loop() {
    int time_delay = BASE_TIME_INTERVAL;
    int left_or_right = 1;
    int current_level = 1;
    int length = 3;
    int x_pos = 0;
    int quit = 0;
    int underflow_ammt = length - 1;
    SDL_Event event;

    while (!quit) {
        while (SDL_PollEvent(&event)) {
            switch(event.type) {
                case SDL_KEYDOWN: 
                    if (event.key.keysym.sym == SDLK_SPACE && inGame == 1) {
                        length = get_new_length(current_level);
                        underflow_ammt = length - 1;
                        if (current_level >= 15 || length == 0) {
                            Mix_PlayChannel( -1, soundGameOver, 0 );
                            inGame = 0;
                            time_delay = BASE_TIME_INTERVAL;
                            left_or_right = 1;
                            current_level = 1;
                            length = 3;
                            x_pos = 0;
                            underflow_ammt = length - 1;
                        }
                        else{
                            Mix_PlayChannel( -1, soundPlace, 0 );
                            current_level++;
                            time_delay = time_delay/SPEED_INCREASE;
                        }
                    }

                    if (event.key.keysym.sym == SDLK_2 && credit < 9){
                        credit++;
                        in++;
                        save();
                        Mix_PlayChannel( -1, soundCredit, 0 );
                    }
                    if (event.key.keysym.sym == SDLK_1 && credit > 0 && inGame == 0){
                        credit--;
                        out++;
                        save();
                        Mix_PlayChannel( -1, soundCredit, 0 );
                        inGame = 1;
                    }

                    if (event.key.keysym.sym == SDLK_ESCAPE){
                        quit = 1;
                        exit(0);
                    }

                break;
                case SDL_QUIT:
                    quit = 1;
                    exit(0);
                break;
            }
        }
        if (!quit) {    
            SDL_FillRect(screen, NULL, 0x000000);
            if (x_pos >= GAME_COLUMNS + (underflow_ammt - 1))
                left_or_right = -1;
            if (x_pos <= 0) 
                left_or_right = 1;  
            update_board(x_pos, length, current_level); 
            draw_background();
            if (inGame == 1)
                print_board();
            draw_credits();
            SDL_Flip(screen);
            x_pos = x_pos + left_or_right;
            SDL_Delay(time_delay);
        }
    }
}

/*
void save(){
    fptr = fopen("data.xml", "w"); 
    fprintf(fptr,"<?xml version=\"1.0\" encoding=\"utf-8\"?>\n");
    fprintf(fptr,"<Data>\n");
    fprintf(fptr,"  <credits>%d</credits>\n",credit);
    fprintf(fptr,"  <IN>%d</IN>\n",in);
    fprintf(fptr,"  <OUT>%d</OUT>\n",out);
    fprintf(fptr,"</Data>\n");
    fclose(fptr);
}
*/

void init(){
    if (SDL_Init(SDL_INIT_VIDEO) != 0) {
    printf("Unable to initialize SDL: %s\n", SDL_GetError());
    }

    screen = SDL_SetVideoMode(768, 1366, 16, SDL_DOUBLEBUF | SDL_HWSURFACE | SDL_FULLSCREEN);
    if (screen == NULL) {
        printf("Unable to set video mode: %s\n", SDL_GetError());
    }

    int imgFlags = IMG_INIT_PNG;
    if( !( IMG_Init( imgFlags ) & imgFlags ) )
    {
        printf( "SDL_image could not initialize! SDL_image Error: %s\n", IMG_GetError() );
    }

    if (SDL_Init(SDL_INIT_AUDIO) < 0){
        printf("Unable to set audio mode: %s\n", SDL_GetError());
    }

     //Initialize SDL_mixer
    if( Mix_OpenAudio( 44100, MIX_DEFAULT_FORMAT, 2, 2048 ) < 0 )
        printf( "SDL_mixer could not initialize! SDL_mixer Error: %s\n", Mix_GetError());

}

void loadMedia(){
    background = IMG_Load("assets/background.png");
    if (background == NULL)
        printf("Unable to load background png.\n");

    square = IMG_Load("assets/square.png");
    if (square == NULL)
        printf("Unable to load square png.\n");

    credits = IMG_Load("assets/credits.png");
    if (credits == NULL)
        printf("Unable to load credits png.\n");

    grid = IMG_Load("assets/grid.png");
    if (grid == NULL)
        printf("Unable to load grid png.\n");

    main_ui = IMG_Load("assets/main_ui.png");
    if (main_ui == NULL)
        printf("Unable to load main_ui png.\n");

    soundPlace = Mix_LoadWAV("assets/place.wav");
    if(soundPlace == NULL)
        printf( "Failed to load place sound effect! SDL_mixer Error: %s\n", Mix_GetError() );

    soundGameOver = Mix_LoadWAV("assets/gameover.wav");
    if(soundGameOver == NULL)
        printf( "Failed to load gameover sound effect! SDL_mixer Error: %s\n", Mix_GetError() );

    soundCredit = Mix_LoadWAV("assets/credit.wav");
    if( soundCredit == NULL )
        printf( "Failed to load credit sound effect! SDL_mixer Error: %s\n", Mix_GetError() );
}

void close(){
    SDL_FreeSurface(square);
    SDL_FreeSurface(background);
    SDL_FreeSurface(credits);
    SDL_FreeSurface(grid);
    SDL_FreeSurface(main_ui);
    SDL_FreeSurface(number);

    Mix_FreeChunk(soundPlace);
    Mix_FreeChunk(soundGameOver);
    Mix_FreeChunk(soundCredit);

    Mix_Quit();
    IMG_Quit();
    SDL_Quit();
}

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

    init();
    loadMedia();

    game_loop();

    close();

    return 0;
}

I using:

• SDL 1.2.15
• SDL_image 1.2.12
• SDL_mixer 1.2.12