jminos/src/TextUI/main.cpp

#include "../Core/Menu.h"
#include "../Pieces/Generator.h"
#include "../Pieces/PiecesFiles.h"

#include <chrono>


void testGeneratorForAllSizes(int amount);
void testGeneratorForOneSize(int size);
void testGeneratorByprintingAllNminos(int n);
void testStoringAndRetrievingPieces(int size);
void generateFilesForAllSizes(int amount);
void generateFilesForOneSize(int size);
void loadFromFilesForOneSize(int size);
void readStatsFromFilesForAllSizes(int amount);


int main(int argc, char** argv) {
    std::srand(std::time(NULL));

    Menu menu;
    menu.getPiecesList().loadPieces(4);
    menu.getPiecesList().selectAllPieces(4);
    Game game = menu.startGame(SPRINT);
    game.start();

    loadFromFilesForOneSize(13);

    return 0;
}


void testGeneratorForAllSizes(int amount) {
    using std::chrono::high_resolution_clock;
    using std::chrono::duration_cast;
    using std::chrono::duration;
    using std::chrono::milliseconds;
    Generator generator;

    for (int i = 1; i <= amount; i++) {
        auto t1 = high_resolution_clock::now();
        std::vector<Polyomino> n_minos = generator.generatePolyominos(i);
        auto t2 = high_resolution_clock::now();
    
        duration<double, std::milli> ms_double = t2 - t1;
        std::cout << "generated " << n_minos.size() << " polyominos of size " << i << " in " << ms_double.count() << "ms" << std::endl;
    }
}

void testGeneratorForOneSize(int size) {
    using std::chrono::high_resolution_clock;
    using std::chrono::duration_cast;
    using std::chrono::duration;
    using std::chrono::milliseconds;
    Generator generator;

    std::cout << "Generating " << size << "-minos" << std::endl;
    for (int i = 0; i < 10; i++) {
        auto t1 = high_resolution_clock::now();
        std::vector<Polyomino> n_minos = generator.generatePolyominos(size);
        auto t2 = high_resolution_clock::now();
    
        duration<double, std::milli> ms_double = t2 - t1;
        std::cout << ms_double.count() << "ms" << std::endl;
    }
}

void testGeneratorByprintingAllNminos(int n) {
    Generator generator;
    std::vector<Polyomino> n_minos = generator.generatePolyominos(n);

    for (Polyomino& n_mino : n_minos) {
        n_mino.goToSpawnPosition();
    }
    std::sort(n_minos.begin(), n_minos.end());

    for (Polyomino& n_mino : n_minos) {
        
        std::cout << n_mino << std::endl;
    }
}

void testStoringAndRetrievingPieces(int size) {
    PiecesFiles piecesFiles;
    piecesFiles.savePieces(size);

    std::vector<Piece> pieces;
    std::vector<int> convexPieces;
    std::vector<int> holelessPieces;
    std::vector<int> otherPieces;
    piecesFiles.loadPieces(size, pieces, convexPieces, holelessPieces, otherPieces);

    std::cout << "Convex " << size << "-minos:" << std::endl;
    for (int index : convexPieces) {
        std::cout << pieces.at(index);
    }

    std::cout << "Holeless " << size << "-minos:" << std::endl;
    for (int index : holelessPieces) {
        std::cout << pieces.at(index);
    }

    std::cout << "Others " << size << "-minos:" << std::endl;
    for (int index : otherPieces) {
        std::cout << pieces.at(index);
    }
}

void generateFilesForAllSizes(int amount) {
    using std::chrono::high_resolution_clock;
    using std::chrono::duration_cast;
    using std::chrono::duration;
    using std::chrono::milliseconds;
    PiecesFiles piecesFiles;

    for (int i = 1; i <= amount; i++) {
        auto t1 = high_resolution_clock::now();
        piecesFiles.savePieces(i);
        auto t2 = high_resolution_clock::now();

        duration<double, std::milli> ms_double = t2 - t1;
        std::cout << "Generated pieces files for size " << i << " in " << ms_double.count() << "ms" << std::endl;
    }

    std::vector<Piece> pieces;
    std::vector<int> convexPieces;
    std::vector<int> holelessPieces;
    std::vector<int> otherPieces;
    for (int i = 1; i <= amount; i++) {
        auto t1 = high_resolution_clock::now();
        piecesFiles.loadPieces(i, pieces, convexPieces, holelessPieces, otherPieces);
        auto t2 = high_resolution_clock::now();

        duration<double, std::milli> ms_double = t2 - t1;
        std::cout << "Read pieces from files for size " << i << " in " << ms_double.count() << "ms" << std::endl;
    }
}

void generateFilesForOneSize(int size) {
    using std::chrono::high_resolution_clock;
    using std::chrono::duration_cast;
    using std::chrono::duration;
    using std::chrono::milliseconds;
    PiecesFiles piecesFiles;

    std::cout << "Generating " << size << "-minos files" << std::endl;
    for (int i = 0; i < 10; i++) {
        auto t1 = high_resolution_clock::now();
        piecesFiles.savePieces(size);
        auto t2 = high_resolution_clock::now();

        duration<double, std::milli> ms_double = t2 - t1;
        std::cout << ms_double.count() << "ms" << std::endl;
    }
}

void loadFromFilesForOneSize(int size) {
    using std::chrono::high_resolution_clock;
    using std::chrono::duration_cast;
    using std::chrono::duration;
    using std::chrono::milliseconds;
    PiecesFiles piecesFiles;

    std::vector<Piece> pieces;
    std::vector<int> convexPieces;
    std::vector<int> holelessPieces;
    std::vector<int> otherPieces;
    std::cout << "Loading " << size << "-minos from files" << std::endl;
    for (int i = 0; i < 10; i++) {
        auto t1 = high_resolution_clock::now();
        piecesFiles.loadPieces(size, pieces, convexPieces, holelessPieces, otherPieces);
        auto t2 = high_resolution_clock::now();

        duration<double, std::milli> ms_double = t2 - t1;
        std::cout << ms_double.count() << "ms" << std::endl;
    }
}

void readStatsFromFilesForAllSizes(int amount) {
    PiecesFiles piecesFiles;
    for (int i = 1; i <= amount; i++) {
        std::vector<Piece> pieces;
        std::vector<int> convexPieces;
        std::vector<int> holelessPieces;
        std::vector<int> otherPieces;
        piecesFiles.loadPieces(i, pieces, convexPieces, holelessPieces, otherPieces);

        std::cout << i << "-minos : " << pieces.size() << std::endl;
        std::cout << "Convex " << i << "-minos : " << convexPieces.size() << std::endl;
        std::cout << "Holeless " << i << "-minos : " << holelessPieces.size() << std::endl;
        std::cout << "Others " << i << "-minos : " << otherPieces.size() << std::endl;
    }
}