controller/MainController.cpp - master - Kotopeska/RiseUpGame

controller/MainController.cpp
202 строки6 KB
Kotopeska
init
18 май 2025, 19:03
18 май 2025, 19:03668dfef
#include "MainController.h"
#include <FL/Fl.H>

namespace Controller
{

    MainController *MainController::m_instance = nullptr;

    MainController::MainController(int width, int height)
        : m_window(std::make_unique<Fl_Double_Window>(width, height, "Rise Up")),
          m_model(width, height),
          m_normalWidth(width),
          m_normalHeight(height)
    {

        m_instance = this;

        m_window->color(FL_BLACK);

        m_gameView = std::make_unique<View::GameView>(0, 0, width, height, m_model);
        m_menuView = std::make_unique<View::MenuView>(0, 0, width, height, m_model);
        m_aboutView = std::make_unique<View::AboutView>(0, 0, width, height, m_model);

        m_menuController = std::make_unique<MenuController>(m_model, *m_menuView);
        m_gamePlayController = std::make_unique<GamePlayController>(m_model, *m_gameView);
        m_gameOverController = std::make_unique<GameOverController>(m_model, *m_gameView);
        m_aboutController = std::make_unique<AboutController>(m_model, *m_aboutView);

        updateViewVisibility();

        m_window->callback(windowCallback, this);

        Fl::add_handler(eventHandler);

        m_window->end();

        m_model.showMenu();
    }

    MainController::~MainController()
    {
        Fl::remove_timeout(timerCallback, this);

        if (m_instance == this)
        {
            m_instance = nullptr;
        }
    }

    void MainController::run()
    {
        m_window->show();

        Fl::add_timeout(1.0 / 60.0, timerCallback, this);

        Fl::run();
    }

    void MainController::updateViewVisibility()
    {
        Model::GameState currentState = m_model.getState();

        switch (currentState)
        {
        case Model::GameState::MENU:
            m_menuView->show();
            m_gameView->hide();
            m_aboutView->hide();
            m_menuView->take_focus();
            break;

        case Model::GameState::PLAYING:
            m_menuView->hide();
            m_gameView->show();
            m_aboutView->hide();
            m_gameView->take_focus();
            break;

        case Model::GameState::GAME_OVER:
            m_menuView->hide();
            m_gameView->show();
            m_aboutView->hide();
            m_gameView->take_focus();
            break;

        case Model::GameState::ABOUT:
            m_menuView->hide();
            m_gameView->hide();
            m_aboutView->show();
            m_aboutView->take_focus();
            break;
        }
    }

    void MainController::timerCallback(void *userData)
    {
        MainController *controller = static_cast<MainController *>(userData);

        Model::GameState currentState = controller->m_model.getState();

        if (currentState == Model::GameState::PLAYING)
        {
            controller->m_gamePlayController->update();
        }
        else
        {
            controller->m_model.update();
        }

        controller->updateViewVisibility();

        Fl::repeat_timeout(1.0 / 60.0, timerCallback, userData);
    }

    void MainController::windowCallback(Fl_Widget *widget, void *data)
    {
        MainController *controller = static_cast<MainController *>(data);
        Fl_Window *window = static_cast<Fl_Window *>(widget);

        if (Fl::event() == FL_CLOSE)
        {
            exit(0);
        }

        static int last_w = 0, last_h = 0;
        if (window->w() != last_w || window->h() != last_h)
        {

            controller->m_gameView->size(window->w(), window->h());
            controller->m_menuView->size(window->w(), window->h());
            controller->m_aboutView->size(window->w(), window->h());

            controller->m_model.resize(window->w(), window->h());

            last_w = window->w();
            last_h = window->h();
        }
    }

    int MainController::eventHandler(int event)
    {
        if (m_instance)
        {
            return m_instance->handleEvent(event) ? 1 : 0;
        }
        return 0;
    }

    bool MainController::handleEvent(int event)
    {

        Model::GameState currentState = m_model.getState();

        switch (event)
        {
        case FL_KEYDOWN:
            switch (currentState)
            {
            case Model::GameState::MENU:
                return m_menuController->handleKeyPress(Fl::event_key());
            case Model::GameState::PLAYING:
                return m_gamePlayController->handleKeyPress(Fl::event_key());
            case Model::GameState::GAME_OVER:
                return m_gameOverController->handleKeyPress(Fl::event_key());
            case Model::GameState::ABOUT:
                return m_aboutController->handleKeyPress(Fl::event_key());
            }
            break;

        case FL_PUSH:
        case FL_RELEASE:
        case FL_DRAG:
            switch (currentState)
            {
            case Model::GameState::MENU:
                if (event == FL_PUSH)
                {
                    return m_menuController->handleMouseClick(Fl::event_x(), Fl::event_y());
                }
                break;
            case Model::GameState::PLAYING:
                return m_gamePlayController->handleMouseEvent(event, Fl::event_x(), Fl::event_y());
            case Model::GameState::GAME_OVER:
                if (event == FL_PUSH)
                {
                    return m_gameOverController->handleMouseClick(Fl::event_x(), Fl::event_y());
                }
                break;
            case Model::GameState::ABOUT:
                if (event == FL_PUSH)
                {
                    return m_aboutController->handleMouseClick(Fl::event_x(), Fl::event_y());
                }
                break;
            }
            break;
        }

        return false;
    }

} // namespace Controller