Game.cpp

#pragma once
#include <iostream>
#include "Game.hpp"
#include "Enums.hpp"
#include "ResourceManager.hpp"
#include "Consts.hpp"
#include "Blinky.hpp"
#include "Inky.hpp"
#include "Pinky.hpp"
#include "Clyde.hpp"
#include "Zlatko.hpp"

Game::Game()
    :window(sf::VideoMode({ RESOLUTION_X, RESOLUTION_Y }), "Pac-Man"), 
    grid(std::vector<std::string>{
        "XXXXXXXXXXXXXXXXXXXXXXXXXXXX",
        "X............XX............X",
        "X.XXXX.XXXXX.XX.XXXXX.XXXX.X",
        "X@XXXX.XXXXX.XX.XXXXX.XXXX@X",
        "X.XXXX.XXXXX.XX.XXXXX.XXXX.X",
        "X..........................X",
        "X.XXXX.XX.XXXXXXXX.XX.XXXX.X",
        "X.XXXX.XX.XXXXXXXX.XX.XXXX.X",
        "X......XX....XX....XX......X",
        "XXXXXX.XXXXX XX XXXXX.XXXXXX",
        "XXXXXX.XXXXX XX XXXXX.XXXXXX",
        "XXXXXX.XX          XX.XXXXXX",
        "XXXXXX.XX XXX  XXX XX.XXXXXX",
        "XXXXXX.XX X      X XX.XXXXXX",
        "      .   X      X   .      ",
        "XXXXXX.XX X      X XX.XXXXXX",
        "XXXXXX.XX XXXXXXXX XX.XXXXXX",
        "XXXXXX.XX          XX.XXXXXX",
        "XXXXXX.XX XXXXXXXX XX.XXXXXX",
        "XXXXXX.XX XXXXXXXX XX.XXXXXX",
        "X............XX............X",
        "X.XXXX.XXXXX.XX.XXXXX.XXXX.X",
        "X.XXXX.XXXXX.XX.XXXXX.XXXX.X",
        "X@..XX.......  .......XX..@X",
        "XXX.XX.XX.XXXXXXXX.XX.XX.XXX",
        "XXX.XX.XX.XXXXXXXX.XX.XX.XXX",
        "X......XX....XX....XX......X",
        "X.XXXXXXXXXX.XX.XXXXXXXXXX.X",
        "X.XXXXXXXXXX.XX.XXXXXXXXXX.X",
        "X..........................X",
        "XXXXXXXXXXXXXXXXXXXXXXXXXXXX",
        }),
    pacman(&grid)
{

    window.setFramerateLimit(60);
    
    // Init times for switcing ghost modes
    // Reverse order
    float values[] = { 1000000, 5, 20, 5, 20, 7, 20, 7 };
    
    for (auto x : values)
        this->timeForStateSwitch.push(x);

    // Init ghosts , order is really important to match GhostArray enum
    ghosts.push_back(new Blinky(&grid));    // Blinky(RED) == 0
    ghosts.push_back(new Pinky(&grid));     // Pinky(PINK) == 1
    ghosts.push_back(new Clyde(&grid));     // Cylde(ORANGE) == 2
    ghosts.push_back(new Inky(&grid));      // Inky(Blue) == 3
    ghosts.push_back(new Zlatko(&grid));      // Zlatko(Green) == 4

}

void Game::run()
{
    
    sf::Clock clock;
    this->pause();
    while (window.isOpen())
    {
        float dt = clock.restart().asSeconds();

        handleEvents();
        if (running) {
            update(dt);
        }
        render();

        std::cout << globalGhostState << std::endl;
        //std::cout << "Direction: " << direction << " Queued: " << queuedDirection << std::endl;
        //std::cout << "Blinky: " << ghosts[0]->getState() << std::endl;
        //std::cout << "Pacman: " << pacman.getState() << std::endl;
    }

}

void Game::handleEvents()
{
    while (const std::optional event = window.pollEvent())
    {
        if (event->is<sf::Event::Closed>())
            window.close();
        
        // KEYBOARD 
        if (const auto* keyPressed = event->getIf<sf::Event::KeyPressed>()) {
            // GRID TOGGLE
            if (keyPressed->scancode == sf::Keyboard::Scancode::G) {
                showGrid = !showGrid;
                continue;
            }
            // PAUSE TOGGLE
            if (keyPressed->scancode == sf::Keyboard::Scancode::Space) {
                togglePause();
                continue;
            }
            // MOVEMENT
            DirectionEnum newDirection = DirectionEnum::NONE;
            if (keyPressed->scancode == sf::Keyboard::Scancode::A) {
                newDirection = DirectionEnum::LEFT;
            }
            if (keyPressed->scancode == sf::Keyboard::Scancode::D) {
                newDirection = DirectionEnum::RIGHT;
            }
            if (keyPressed->scancode == sf::Keyboard::Scancode::S) {
                newDirection = DirectionEnum::DOWN;
            }
            if (keyPressed->scancode == sf::Keyboard::Scancode::W) {
                newDirection = DirectionEnum::UP;
            }
            
            // Ignore multiple clicks in same direction
            if (newDirection == pacman.getDirection()) {
                pacman.setQueuedDirection(DirectionEnum::NONE);
            }
            else {
                pacman.setQueuedDirection(newDirection);
            }
            
        }
    }
}

void Game::render()
{
    window.clear();

    // Grid
    grid.render(window , showGrid);

    // Pacman 
    pacman.render(window);

    // Ghosts should dissapear in ending sequence
    if (!endingSequence) {
        for (auto& ghost : ghosts) {
            ghost->render(window);
        }
    }
    

    //Score
    sf::Text score_text(ResourceManager::instance().getFont("resources/Emulogic-zrEw.ttf"));
    score_text.setString("Score:" + std::to_string(pacman.getScore()));
    score_text.setCharacterSize(24);
    score_text.setPosition({ 15.f, 15.f });
    window.draw(score_text);

    window.display();
}

void Game::update(float delta)
{
    // Stop everything , do ending animation, then stop everything
    if (endingSequence) {
        static float lastAnimationDuration = 2.4;
        lastAnimationDuration -= delta;
        if (lastAnimationDuration < 0) {
            this->pause();
        }
        pacman.updateAnimation(delta);
        return;
    }

    cycleGlobalGhostState(delta);

    // Update tile
    pacman.updateActorTile(grid);
    for (auto& ghost : ghosts) {
        ghost->updateActorTile(grid);
    }


    // Update Animation
    pacman.updateAnimation(delta);
    for (auto& ghost : ghosts) {
        ghost->updateAnimation(delta);
    }

    // Update Ghost pathfinding
    for (auto& ghost : ghosts) {
        ghost->updateTarget(pacman, ghosts);
        ghost->updateNextDirection();
    }

    static float pinkyTimer = 5, inkyTimer = 10, clydeTimer = 15;
    pinkyTimer -= delta; inkyTimer -= delta; clydeTimer -= delta;
    // Update Movement
    pacman.updateMovement(this);

    ghosts[int(GhostArray::BLINKY)]->updateMovement(this);
    ghosts[int(GhostArray::ZLATKO)]->updateMovement(this);
    if (pinkyTimer < 0) {
        ghosts[int(GhostArray::PINKY)]->updateMovement(this);
    }
    if (inkyTimer < 0) {
        ghosts[int(GhostArray::INKY)]->updateMovement(this);
    }
    if (clydeTimer < 0) {
        ghosts[int(GhostArray::CLYDE)]->updateMovement(this);
    }




}

void Game::triggerFright()
{
    // If already in fright state, just reset timer
    if (globalGhostState == GhostState::FRIGHTENED) {
        frightTimeRemaining = FRIGHT_TIME;
        return;
    }
    frightTimeRemaining = FRIGHT_TIME;
    globalGhostStateBeforeFright = globalGhostState;
    globalGhostState = GhostState::FRIGHTENED;
    pacman.setState(PacmanState::FRIGHTENED);
}

void Game::cycleGlobalGhostState(float delta)
{
    // Fright state overpowers other states
    // Make sure fright state lasts FRIGHT_TIME
    if (globalGhostState == GhostState::FRIGHTENED) {
        frightTimeRemaining -= delta;
        if (frightTimeRemaining < 0) {
            globalGhostState = globalGhostStateBeforeFright;
            pacman.setState(PacmanState::ALIVE);
        }
    }

    // Update global state
    if (!timeForStateSwitch.empty() && globalGhostState != GhostState::FRIGHTENED) {
        float time = timeForStateSwitch.top(); timeForStateSwitch.pop();
        time -= delta;
        if (time < 0) {
            if (globalGhostState == GhostState::CHASE)
                globalGhostState = GhostState::SCATTER;
            else if (globalGhostState == GhostState::SCATTER)
                globalGhostState = GhostState::CHASE;
        }
        else {
            timeForStateSwitch.push(time);
        }
        
    }
    
    for (auto& ghost : ghosts) {
        // Unless dead ghosts should follow global state
        if (ghost->getState() != GhostState::DEAD) {
            // Reverse directions when flipping states
            if (ghost->getState() != globalGhostState) {
                ghost->setState(globalGhostState);
                ghost->setQueuedDirection(getReverse(ghost->getDirection()));
            }

        }
    }

       
}