Minesweeper/mines.c

//
// mines.c - this file is a part of Minesweeper, a computer game
//
// Copyright (C) 2020 The Minesweeper contributors
//
// This program is free software: you can redistribute it and/or modify 
// it under the terms of the GNU General Public License as published by 
// the Free Software Foundation, either version 3 of the License, 
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful, 
// but WITHOUT ANY WARRANTY; without even the implied warranty of 
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License 
// along with this program. If not, see <http://www.gnu.org/licenses/>
//
// @author Andrew Tokarskiy <tokarskiy.a@keemail.me>
//

#include "mines.h"
#include <stdlib.h>

#define ALLOCATE(type, amount) (type*)malloc(sizeof(type) * amount)

inline const size_t sqr(const size_t a); 
void randomizeMines(Game* game, const size_t firstMoveI, const size_t firstMoveJ, const int minesAmount); 

Game* initGame(const size_t height, const size_t width, const int minesAmount) {
    int** map = ALLOCATE(int*, height);
    int** statuses = ALLOCATE(int*, height); 
    for (size_t i = 0; i < height; i++) {
        map[i] = ALLOCATE(int, width);
        statuses[i] = ALLOCATE(int, width); 
        for (size_t j = 0; j < width; j++) {
            map[i][j] = 0; 
            statuses[i][j] = STATUS_NULL; 
        }
    }

    Game* game = ALLOCATE(Game, 1); 
    game->map = map;
    game->statuses = statuses; 
    game->width = width; 
    game->height = height; 
    game->minesAmount = minesAmount; 
    game->initialized = 0; 

    return game; 
}

inline const size_t sqr(const size_t a) {
    return a * a; 
}

inline const size_t dif(const size_t a, const size_t b) {
    return a > b ? a - b : b - a;
}

void shuffle(size_t* array, const size_t count) {
    if (count > 1) {
        for (size_t i = 0; i < count - 1; i++) {
            const size_t j = i + rand() / (RAND_MAX / (count - i) + 1);
            const int t = array[j];
            array[j] = array[i];
            array[i] = t;
        }
    }
}

const int calculateMinesAround(Game* game, const size_t i, const size_t j) {
    int amount = 0; 
    const size_t iFrom = i == 0                ? 0                : i - 1;
    const size_t   iTo = i == game->height - 1 ? game->height - 1 : i + 1;
    const size_t jFrom = j == 0                ? 0                : j - 1; 
    const size_t   jTo = j == game->width - 1  ? game->width - 1  : j + 1;   


    for (size_t ii = iFrom; ii <= iTo; ii++) {
        for (size_t jj = jFrom; jj <= jTo; jj++) {
            if (ii == i && jj == j) {
                continue;
            }

            if (game->map[ii][jj] == MINE_INDEX) {
                amount++; 
            }
        }
    }

    return amount; 
}

void randomizeMines(Game* game, const size_t firstMoveI, const size_t firstMoveJ, const int minesAmount) {
    int** map = game->map; 

    const size_t size = game->width * game->height;
    size_t* possiblePlaces = ALLOCATE(size_t, size); 
    size_t pos = 0; 
    for (size_t i = 0; i < size; i++) {
        const size_t posI = i / game->width; 
        const size_t posJ = i % game->width; 

        int sqDistance = sqr(dif(firstMoveI, posI)) + sqr(dif(firstMoveJ, posJ)); 
        if (sqDistance >= 4) { // 2 - distance between points (0, 0) & (2, 0). sqrt(2) - distance between points (0, 0) & (1, 1)
            possiblePlaces[pos] = i; 
            pos++;
        } 
    }

    const size_t possiblePlacesSize = pos; 
    shuffle(possiblePlaces, possiblePlacesSize); 
    for (size_t i = 0; i < minesAmount; i++) {
        const size_t place = possiblePlaces[i]; 
        const size_t posI = place / game->width;
        const size_t posJ = place % game->width; 
        
        map[posI][posJ] = MINE_INDEX; 
    }

    free(possiblePlaces); 

    for (size_t i = 0; i < game->height; i++) {
        for (size_t j = 0; j < game->width; j++) {
            if (map[i][j] != MINE_INDEX) {
                map[i][j] = calculateMinesAround(game, i, j); 
            }
        }
    }
}

void freeGame(Game* game) {
	for (size_t i = 0; i < game->height; i++) {
		int* mapLine = game->map[i]; 
		free(mapLine);
		
		int* statLine = game->statuses[i]; 
		free(statLine);  
	}
	
    free(game->map);
    free(game->statuses); 
    free(game); 
}

// call only when map[i][j] >= 0
void fill(Game* game, const size_t i, const size_t j) {
    if (i < 0 || i >= game->height || j < 0 || j >= game->width) {
        return;
    }
    
    if (game->statuses[i][j] >= 0) {
        return; 
    } 
    
    const size_t iFrom = i == 0                ? 0                : i - 1;
    const size_t   iTo = i == game->height - 1 ? game->height - 1 : i + 1;
    const size_t jFrom = j == 0                ? 0                : j - 1; 
    const size_t   jTo = j == game->width - 1  ? game->width - 1  : j + 1;

    game->statuses[i][j] = game->map[i][j];
    if (game->map[i][j] == 0) {
        for (size_t ii = iFrom; ii <= iTo; ii++) {
            for (size_t jj = jFrom; jj <= jTo; jj++) {
                if (ii == i && jj == j) {
                    continue;
                }

                fill(game, ii, jj); 
            }
        }
    } 
}

const ActionResult checkWinStatus(Game* game) {
    int** statuses = game->statuses; 
    int nullCount = 0; 
    
    for (size_t i = 0; i < game->height; i++) {
        for (size_t j = 0; j < game->width; j++) {
            if (statuses[i][j] == STATUS_FLAG || statuses[i][j] == STATUS_NULL) {
                nullCount++; 
            }
        }
    }

    return nullCount == game->minesAmount ? Win : Continue; 
}

// return 0 -> continue, return 1 -> lose, 2 -> win 
const ActionResult action(Game* game, const size_t i, const size_t j, const ActionType actionType) {
    int** statuses = game->statuses;
    int** map = game->map; 
    if (statuses[i][j] >= 0) { // if cell is opened
        return Continue; 
    }

    if (actionType == MarkMine && statuses[i][j] == STATUS_NULL) {
        statuses[i][j] = STATUS_FLAG; 
        return Continue; 
    }

    if (actionType == MarkMine && statuses[i][j] == STATUS_FLAG) {
        statuses[i][j] = STATUS_NULL; 
        return Continue; 
    }

    if (game->initialized == 0) {
        randomizeMines(game, i, j, game->minesAmount);
        game->initialized = 1;  
    }

    if (game->map[i][j] == MINE_INDEX) {
        for (size_t ii = 0; ii < game->height; ii++) {
            for (size_t jj = 0; jj < game->width; jj++) {
                if (map[ii][jj] == MINE_INDEX) {
                    statuses[ii][jj] = STATUS_MINE; 
                }
            }
        }

        return Lose;
    }

    fill(game, i, j);
 
    return checkWinStatus(game); 
}