main.cpp

#include <iostream>
#include <map>
#include <vector>
#include <chrono>
#include <thread>
#include <random>

#include "src/cenarios/tela.h"
#include "src/cenarios/telafinal.h"
#include "src/cenarios/telainicial.h"

#include "src/coletaveis/coletavel.h"
#include "src/coletaveis/banana.h"
#include "src/coletaveis/camera.h"
#include "src/coletaveis/rosa.h"

#include "src/personagens/gisele.h"

#include "src/gerenciadorinputs.h"

int main(){
    // Iniciar gerador de números aleatório
    std::random_device rd; 
    std::mt19937 gen(rd());
    std::uniform_int_distribution<> distr(1, 100); 

    // Configurações do jogo
    const int largura = 60;
    const int altura = 15;
    const int FPS_ALVO = 30;
    const std::chrono::milliseconds DURACAO_DO_QUADRO(1000 / FPS_ALVO);
    const int pixels_por_metro = 20;
    const int meta_metros = 700;
    const int tempo_flash_max = 50;
    const int tempo_gerador_max = 40;

    // Objetos iniciais
    Tela tela(largura, altura);
    TelaInicial tela_inicial(largura, altura);
    Gisele gisele(3, 5, 13); 

    // Variáveis iniciais
    std::map<string, int> contador = {
        {"banana", 0},
        {"camera", 0},
        {"rosa", 0}
    };
    int distancia_pixels = 0;
    int distancia_metros = 0;
    int tempo_flash = 0;
    int tempo_gerador = 0;
    bool efeito_flash = false;
    bool finalizando = false;
    
    std::vector<Coletavel*> coletaveis;
    std::vector<int> xs_ocupados;
    std::vector<int> ys_ocupados;

    // Tela de início
    // Mostra as opções
    std::cout << "\033[2J\033[H"; // Limpa a tela
    bool run = tela_inicial.init();


    // Início do game
    while (run) {
        std::cout << "\033[2J\033[H"; // Limpa a tela

        // Marca o início do frame
        auto inicio_do_frame = std::chrono::high_resolution_clock::now();

        // ----------------------------------------------------
        // LÓGICA DO JOGO
        // ----------------------------------------------------
        tempo_gerador++;
        if (efeito_flash) tempo_flash++;

        if (tempo_flash >= tempo_flash_max) {
            efeito_flash = false;
            tempo_flash = 0;
        }

        char input = GerenciadorInputs::checarInput();
        switch (input) {
            case 'w': case 'W': gisele.pular(); break;
            case 'q': case 'Q': run = false; break;
            case 'e': case 'E': run = false; finalizando = true; break; // apenas para teste
        }

        gisele.atualizar_fisica();
        int gisele_altura = gisele.get_altura_hitbox();
        int gisele_largura = gisele.get_largura_hitbox();
        
        distancia_pixels += 7;
        distancia_metros = distancia_pixels / pixels_por_metro;

        // Colisão
        std::vector<Coletavel*> coletaveis_vivos;
        std::vector<int> xs_vivos, ys_vivos;
        for (size_t i = 0; i < coletaveis.size(); ++i) {
            Coletavel* item = coletaveis[i];
            item->mover();
            
            if(item->colidiu(gisele.get_x(), gisele.get_y(), gisele_altura, gisele_largura)) {
                item->aplicarEfeito(contador);
                if (dynamic_cast<Camera*>(item) && !efeito_flash){
                    efeito_flash = true;
                    tempo_flash = 0;
                }
                delete item;
            } else if (item->getX() < 0) { // Apaga o item da borda, sem aplicar efeito
                delete item;
            } else {
                coletaveis_vivos.push_back(item);
                xs_vivos.push_back(item->getX());
                ys_vivos.push_back(item->getY());
            }
        }
        coletaveis = coletaveis_vivos;
        xs_ocupados = xs_vivos;
        ys_ocupados = ys_vivos;

        // Gerador aleatório
        if (!finalizando) {
            if (tempo_gerador % tempo_gerador_max == 0) {
                Coletavel* novo_coletavel;

                try {
                    novo_coletavel = Coletavel::geradorColetavel(distr(gen), ys_ocupados, xs_ocupados, largura);
                    coletaveis.push_back(novo_coletavel);
                    xs_ocupados.push_back(novo_coletavel->getX());
                    ys_ocupados.push_back(novo_coletavel->getY());
                }
                catch (const ErroPosicaoIndisponivel& e) {
                    cout << "Item ignorado: " << e.what() << endl;
                }
                catch (const logic_error& e){
                    cout << "Bug crítico" << e.what() << endl;
                    exit(1);
                }
                
            }
        }

        // Limpar e desenhar a tela
        tela.clear_window();
        if (!efeito_flash) {
            for (auto item : coletaveis) {
                tela.draw(item->getSimbolo(), item->getX(), item->getY(), item->getTamanhoColetavel(), item->getTamanhoColetavel());
            }
            tela.draw(gisele.simbolo, gisele.get_x(), gisele.get_y(), gisele_largura, gisele_altura);
            tela.draw('X', 0, altura-2, largura, 2); // Chão
            tela.update();
        } else {
            tela.clear_window('#');
        }

        std::cout << "B: " << contador["banana"] << " *: " << contador["camera"] << " @: " << contador["rosa"] << "\n" << distancia_metros  << "m" << std::endl;

        // Fim de jogo 
        if (contador["banana"] >= 3 || contador["camera"] >= 3) {
            run = false;
        } else if (distancia_metros >= meta_metros) {
            run = false;
        } else if (distancia_metros >= meta_metros - 50) {
            finalizando = true;
        }

        if (!run) {
            TelaFinal tela_final(largura, altura, contador, distancia_metros, meta_metros);
            if (tela_final.init()) {
                // Recomeçar
                contador["banana"] = 0;
                contador["camera"] = 0;
                contador["rosa"] = 0;
                distancia_pixels = 0;
                distancia_metros = 0;
                tempo_flash = 0;
                tempo_gerador = 0;
                efeito_flash = false;
                run = true;
                finalizando = false;
                for (auto item : coletaveis) {
                    delete item;
                }
                coletaveis.clear();
                xs_ocupados.clear();
                ys_ocupados.clear();
            }
        }

        // Marca o fim do processamento do frame
        auto fim_do_frame = std::chrono::high_resolution_clock::now();
        auto tempo_decorrido = std::chrono::duration_cast<std::chrono::milliseconds>(fim_do_frame - inicio_do_frame);

        // Se terminou antes do tempo alvo (30 FPS), espera o restante
        if (tempo_decorrido < DURACAO_DO_QUADRO) {
            std::this_thread::sleep_for(DURACAO_DO_QUADRO - tempo_decorrido);
        }
    }

    return 0;
}