Table.h

Go to the documentation of this file.

//   ____   __                  __  __
// /\__  _\/\ \                /\ \/\ \
// \/_/\ \/\ \ \___      __    \ \ \_\ \    ___   __  __    ____     __
//    \ \ \ \ \  _ `\  /'__`\   \ \  _  \  / __`\/\ \/\ \  /',__\  /'__`\
//     \ \ \ \ \ \ \ \/\  __/    \ \ \ \ \/\ \L\ \ \ \_\ \/\__, `\/\  __/
//      \ \_\ \ \_\ \_\ \____\    \ \_\ \_\ \____/\ \____/\/\____/\ \____\
//       \/_/  \/_/\/_/\/____/     \/_/\/_/\/___/  \/___/  \/___/  \/____/
 
 
#pragma once
 
 
#include "Scoring.h"
#include "Component/Board.h"
#include "Component/Player.h"
#include "Framework/System.h"
#include "Gameplay/Systems/PlayerTurn.h"
 
namespace sys
{
 
class PlayerTurn;
class Table : public System
{
public:
#pragma region static_functions
    static auto getEnum() -> Type
    {
        return Type::Table;
    }
#pragma endregion
 
    Table();
 
    Table(const Table&);
    Table(Table&& other) noexcept;
    auto operator=(const Table&) -> Table&           = default;
    auto operator=(Table&& other) noexcept -> Table& = default;
    ~Table() override                                = default;
 
#pragma region overriden_functions
 
    auto clone() const -> std::unique_ptr<GameObject> override
    {
        return std::make_unique<Table>(*this);
    }
 
    auto systemShowMenu() -> void override;
    // for debug ImGUI
    auto onUpdate(float dt) -> void override;
 
    auto endWindow() -> void override
    {
    } // for debug ImGUI
    auto onRender() -> void override;
    auto onSceneStart(const std::string& sceneName) -> void override;
    auto onSceneExit(const std::string& sceneName) -> void override;
 
    auto load(const Stream& stream) -> void override;
    auto save(Stream& stream) const -> void override;
 
 
#pragma endregion
 
#pragma region Table_functions

    auto reloadCache() -> void;

    auto dealCardToPlayer(int playerNumber) -> void;

    auto dealCardToPlayer(Player* player) -> void;

    auto fillPlayerHand(Player* player) -> void;

    auto fillAllPlayerHands() -> void;
    
    auto movePlayerCardsUp(float cardDelay, Player* currentPlayer) const -> void;
    
    auto movePlayerCardsDown(float cardDelay, Player* currentPlayer) const -> void;
    
    auto moveAllPlayersToNormalPosition(float delayAmount) const -> void;
    
    auto moveAllPlayerCardsDown(float delayAmount) const -> void;
    
    auto moveAllPlayersOffscreen(float delayAmount) const -> void;
    
    auto moveSelectorToCurrentPlayer() -> void;
    
    auto getInBoard() -> bool;
    
    auto setInBoard(bool setInBoard) -> void;
    
    auto setInputID(int id) const -> void;
    
    auto disableFilteredSelector() -> void;
    
    auto updateScoreText(int newScore) -> void;
    
    auto getSelector() const -> Entity*;

    auto undoLastPlayedCard() const -> void;

    auto playerScoreEffects() -> void;
    
    auto handPopUpPushBack(HandRating::HandType typeOfHand) -> void;
    
    auto updateHandPopText(HandRating::HandType typeOfHand, int amount) -> void;
    
    auto destroyHandPopUp() -> void;

    auto unHighlightPlayedCards() const -> void;
    
    
    auto getDisabledFilter() -> bool;

    auto getDisabledInput() const -> bool;

    auto enableGameplayInput() -> void;
    
    auto enableHelpPopUp() -> void;

    auto disableGameplayInput() -> void;

    auto pauseCurrentPlayerTimer() const -> void;
    
    auto unpauseCurrentPlayerTimer() const -> void;

    auto grayCurrentTimer() const -> void;

    auto hideDeckCount() const -> void;

    auto completelyHideSelector() const -> void;
    
#pragma endregion
 
private:
#pragma region member_variables

    PlayerTurn* playerTurn = nullptr;
    Scoring* scoring = nullptr;

    std::vector<Player*> players;
    Board* board;
    Deck* deck;
    Entity* selector;
    Entity* lastSelectedTile;

    GameRules* gameRules;
    
    bool inBoard = false;

    bool filterDisabled = false;
 
    
    bool inputDisabled = false;
    
#pragma endregion
 
#pragma region helper_functions

    auto checkValidInputID(int id) const -> bool;
    
    auto moveSelectorToBoard() -> void;

    auto moveSelectorToPlayer(int playerNumber) -> void;
    auto moveSelectorToPlayer(Player* player) -> void;
    auto moveSelectorToLastSelectedCard() -> void;

    auto moveSelectorToLastSelectedTile() -> void;

    auto getCurrentlyHoveredCard() const -> Card*;
    
    auto updatePlayerScoreText(int playerNumber) -> void;    

    auto updateCardsPlayedText() -> void;

    auto updateCardsInDeckText() const -> void;
    
    auto adjustPlayers() -> void;

    auto reloadPlayers() -> void;

    auto reloadBoard() -> void;

    auto reloadDeck() -> void;

    auto reloadSelector() -> void;

    auto resetTable() -> void;

    auto playCardOnBoard(Card* cardToPlay, const std::pair<int, int>& positionOnBoard) -> void;
    
#pragma endregion
 
#pragma region messaging_functions

    auto receiveResetTable(const Message* message) -> Message;
    auto receiveCardSelected(const Message* message) -> Message;
    auto receiveDeselect(const Message* message) -> Message;
    auto receiveUndo(const Message* message) -> Message;
    auto receiveRedo(const Message* message) -> Message;
    auto receiveCardPlayedOnBoard(const Message* message) -> Message;
    auto receiveEndTurn(const Message* message) -> Message;
    auto receiveScoreCalculator(const Message* message) -> Message;
    auto receivePlayerTimerRanOut(const Message* message) -> Message;
    auto receiveHelp(const Message* message) -> Message;
 
    auto receiveLeftKeyPressed(const Message* message) -> Message;
    auto receiveRightKeyPressed(const Message* message) -> Message;
    auto receiveUpKeyPressed(const Message* message) -> Message;
    auto receiveDownKeyPressed(const Message* message) -> Message;
 
    /* ----------- Cheat codes ----------- */

    auto receiveAddScore(const Message* message) -> Message;
    auto receiveDrawCard(const Message* message) -> Message;
    auto receiveGoToWinScreen(const Message* message) -> Message;
    auto disableFilteredSelector(const Message* message) -> Message;
 
    auto linkMessages() -> void;
 
 
#pragma endregion
 
#pragma region static_variables
 
#pragma endregion
    friend class PlayerTurn;
};
 
}