PlayingScene.cpp

Go to the documentation of this file.

 
#include "Scenes/PlayingScene.hpp"
#include "RType/ECS/Components/Audio/AudioSource.hpp"
#include "Game/SpriteCustomizer.hpp"
#include "RType/ECS/Components/UI/Button.hpp"
#include "RType/ECS/Components/UI/Slider.hpp"
#include "RType/ECS/Components/UI/Text.hpp"
#include "RType/ECS/Components/UI/TextInput.hpp"
#include <SFML/Window/Joystick.hpp>
 
#include <algorithm>
 
namespace rtp::client {
    namespace scenes {
 
        // Public API
 
        PlayingScene::PlayingScene(ecs::Registry& worldRegistry,
                                    ecs::Registry& uiRegistry,
                                    Settings& settings,
                                    TranslationManager& translationManager,
                                    NetworkSyncSystem& network,
                                    graphics::UiFactory& uiFactory,
                                    EntityBuilder& worldBuilder,
                                    std::function<void(GameState)> changeState)
            : _uiRegistry(uiRegistry),
              _settings(settings),
              _translationManager(translationManager),
              _network(network),
              _uiFactory(uiFactory),
              _changeState(changeState),
              _worldRegistry(worldRegistry),
              _worldBuilder(worldBuilder)
        {
        }
 
        void PlayingScene::onEnter()
        {
            log::info("Entering PlayingScene");
 
            _uiScore = 0;
 
            spawnParallax();
 
            {
                auto musicEntity = _worldRegistry.spawn();
                if (musicEntity) {
                    ecs::components::audio::AudioSource levelMusic;
                    levelMusic.audioPath = "assets/musics/lvl1.mp3";
                    levelMusic.volume = 80.0f;
                    levelMusic.loop = true;
                    levelMusic.isPlaying = true;
                    levelMusic.dirty = true;
                    _worldRegistry.add<ecs::components::audio::AudioSource>(musicEntity.value(), levelMusic);
                    log::info("Playing Level 1 music");
                } else {
                    log::warning("Failed to spawn entity for Level 1 music");
                }
            }
 
            _chatCompactPanel = _uiFactory.createButton(
                _uiRegistry,
                {30.0f, 15.0f},
                {715.0f, 40.0f},
                "",
                nullptr
            );
            if (auto buttonsOpt = _uiRegistry.get<ecs::components::ui::Button>()) {
                auto &buttons = buttonsOpt.value().get();
                if (buttons.has(_chatCompactPanel)) {
                    auto &panel = buttons[_chatCompactPanel];
                    panel.idleColor[0] = 20; panel.idleColor[1] = 20; panel.idleColor[2] = 20;
                    panel.hoverColor[0] = 20; panel.hoverColor[1] = 20; panel.hoverColor[2] = 20;
                    panel.pressedColor[0] = 20; panel.pressedColor[1] = 20; panel.pressedColor[2] = 20;
                }
            }
 
            _chatCompactText = _uiFactory.createText(
                _uiRegistry,
                {45.0f, 22.0f},
                "",
                "assets/fonts/main.ttf",
                18,
                10,
                {220, 220, 220}
            );
 
            auto makeHudText = [&](const Vec2f& pos, unsigned size, const graphics::color& color) -> ecs::Entity {
                auto eRes = _uiRegistry.spawn();
                if (!eRes) return {};
 
                auto e = eRes.value();
                ecs::components::ui::Text t;
                t.content = "";
                t.position = pos;
                t.fontPath = "assets/fonts/main.ttf";
                t.fontSize = size;
                t.red = color.r; t.green = color.g; t.blue = color.b;
                t.alpha = 220;
                t.zIndex = 999;
                _uiRegistry.add<ecs::components::ui::Text>(e, t);
                return e;
            };
 
            _hudHealth   = makeHudText({980.0f, 18.0f}, 18, {110, 220, 170});
            _hudScore    = makeHudText({980.0f, 42.0f}, 18, {120, 190, 230});
            _hudAmmo     = makeHudText({980.0f, 66.0f}, 16, {230, 190, 120});
            _hudFps      = makeHudText({980.0f, 90.0f}, 14, {180, 180, 190});
 
            _hudPing     = makeHudText({1020.0f, 660.0f}, 12, {140, 140, 150});
            _hudEntities = makeHudText({1020.0f, 678.0f}, 12, {140, 140, 150});
 
            _hudChargeBar = _uiFactory.createSlider(
                _uiRegistry,
                {520.0f, 700.0f},
                {240.0f, 6.0f},
                0.0f,
                1.0f,
                0.0f,
                nullptr
            );
            if (auto slidersOpt = _uiRegistry.get<ecs::components::ui::Slider>()) {
                auto &sliders = slidersOpt.value().get();
                if (sliders.has(_hudChargeBar)) {
                    auto &slider = sliders[_hudChargeBar];
                    slider.trackColor[0] = 25; slider.trackColor[1] = 25; slider.trackColor[2] = 25;
                    slider.fillColor[0] = 180; slider.fillColor[1] = 120; slider.fillColor[2] = 60;
                    slider.handleColor[0] = 25; slider.handleColor[1] = 25; slider.handleColor[2] = 25;
                    slider.zIndex = 999;
                }
            }
 
            _hudInit = true;
            _chargeTime = 0.0f;
        }
 
        void PlayingScene::onExit(void)
        {
            _hudInit = false;
            closeChat();
            _chargeTime = 0.0f;
        }
 
 
        void PlayingScene::handleEvent(const sf::Event& e)
        {
            // Check gamepad pause button
            if (_settings.getGamepadEnabled() && sf::Joystick::isConnected(0)) {
                static bool wasPausePressed = false;
                bool isPausePressed = sf::Joystick::isButtonPressed(0, _settings.getGamepadPauseButton());
                
                if (isPausePressed && !wasPausePressed) {
                    if (_chatOpen) {
                        closeChat();
                        wasPausePressed = true;
                        return;
                    }
                    _changeState(GameState::Paused);
                    wasPausePressed = true;
                    return;
                }
                wasPausePressed = isPausePressed;
            }
            
            if (const auto* kp = e.getIf<sf::Event::KeyPressed>()) {
                if (kp->code == sf::Keyboard::Key::Enter) {
                    if (!_chatOpen) {
                        openChat();
                    } else {
                        auto inputsOpt = _uiRegistry.get<ecs::components::ui::TextInput>();
                        bool focused = false;
                        if (inputsOpt) {
                            auto &inputs = inputsOpt.value().get();
                            if (inputs.has(_chatInput)) {
                                focused = inputs[_chatInput].isFocused;
                            }
                        }
                        if (!focused) {
                            closeChat();
                        }
                    }
                } else if (kp->code == sf::Keyboard::Key::Escape) {
                    if (_chatOpen) {
                        closeChat();
                        return;
                    }
                    _changeState(GameState::Paused);
                }
            }
        }
 
        void PlayingScene::update(float dt)
        {
            if (_network.consumeKicked()) {
                _changeState(GameState::Menu);
                return;
            }
            if (_network.consumeGameOver()) {
                _changeState(GameState::GameOver);
                return;
            }
            if (!_hudInit) return;
 
            _fpsTimer += dt;
            _fpsFrames += 1;
            if (_fpsTimer >= 0.5f) {
                _uiFps = static_cast<uint32_t>(_fpsFrames / _fpsTimer);
                _fpsFrames = 0;
                _fpsTimer = 0.0f;
            }
            _uiPing = _network.getPingMs();
            _uiScore = static_cast<uint32_t>(std::max(0, _network.getScore()));
 
            auto textsOpt = _uiRegistry.get<ecs::components::ui::Text>();
            if (!textsOpt) return;
            auto& texts = textsOpt.value().get();
 
            if (texts.has(_hudPing))     texts[_hudPing].content = "Ping " + std::to_string(_uiPing) + " ms";
            if (texts.has(_hudFps))      texts[_hudFps].content  = "FPS "  + std::to_string(_uiFps);
            if (texts.has(_hudScore))    texts[_hudScore].content = "SCORE " + std::to_string(_uiScore);
            if (texts.has(_hudHealth)) {
                const int current = _network.getHealthCurrent();
                const int max = _network.getHealthMax();
                if (max > 0) {
                    texts[_hudHealth].content = "HP " + std::to_string(current) + " / " + std::to_string(max);
                } else {
                    texts[_hudHealth].content = "HP --";
                }
            }
 
            auto spritesOpt = _worldRegistry.get<ecs::components::Sprite>();
            if (spritesOpt && texts.has(_hudEntities)) {
                const std::size_t count = spritesOpt.value().get().size();
                texts[_hudEntities].content = "Entities " + std::to_string(count + 2);
            }
 
            if (texts.has(_hudAmmo)) {
                const uint16_t current = _network.getAmmoCurrent();
                const uint16_t max = _network.getAmmoMax();
                std::string ammoText = "AMMO " + std::to_string(current) + " / " + std::to_string(max);
                if (_network.isReloading()) {
                    const float remaining = _network.getReloadCooldownRemaining();
                    ammoText += " (Reloading " + std::to_string(remaining).substr(0, 4) + "s)";
                }
                texts[_hudAmmo].content = ammoText;
            }
 
            if (texts.has(_chatCompactText)) {
                texts[_chatCompactText].content = _network.getLastChatMessage();
            }
 
            if (_chatOpen) {
                updateChatHistoryText();
            }
 
            auto slidersOpt = _uiRegistry.get<ecs::components::ui::Slider>();
            if (slidersOpt && slidersOpt->get().has(_hudChargeBar)) {
                constexpr float kChargeMax = 2.0f;
                bool canCharge = !_network.isReloading() && _network.getAmmoCurrent() > 0;
 
                if (canCharge) {
                    auto inputsOpt = _uiRegistry.get<ecs::components::ui::TextInput>();
                    if (inputsOpt) {
                        auto &inputs = inputsOpt.value().get();
                        for (const auto &e : inputs.entities()) {
                            if (inputs[e].isFocused) {
                                canCharge = false;
                                break;
                            }
                        }
                    }
                }
 
                if (canCharge && sf::Keyboard::isKeyPressed(_settings.getKey(KeyAction::Shoot))) {
                    _chargeTime = std::min(_chargeTime + dt, kChargeMax);
                } else {
                    _chargeTime = 0.0f;
                }
 
                auto &slider = slidersOpt->get()[_hudChargeBar];
                slider.currentValue = (_chargeTime > 0.0f) ? (_chargeTime / kChargeMax) : 0.0f;
            }
        }
 
        // Private API
 
        void PlayingScene::spawnParallax()
        {
            constexpr float baseTextureWidth = 1280.0f;
 
            auto spawnLayer = [&](EntityTemplate t) {
                const float scaledW = baseTextureWidth * t.scale.x;
 
                t.position.x = 0.0f;
                auto a = _worldBuilder.spawn(t);
                if (!a) {
                    log::error("Failed to spawn parallax A");
                    return;
                }
 
                t.position.x = scaledW;
                auto b = _worldBuilder.spawn(t);
                if (!b) {
                    log::error("Failed to spawn parallax B");
                    return;
                }
            };
 
            const uint32_t levelId = _network.getCurrentLevelId();
            switch (levelId) {
                case 1:
                    spawnLayer(EntityTemplate::createParrallaxLvl1_1());
                    spawnLayer(EntityTemplate::createParrallaxLvl1_2());
                    break;
                case 2:
                    spawnLayer(EntityTemplate::createParallaxLvl2_1());
                    //spawnLayer(EntityTemplate::createParallaxLvl2_2());
                    //spawnLayer(EntityTemplate::createParallaxLvl2_3());
                    //spawnLayer(EntityTemplate::createParallaxLvl2_4());
                    //spawnLayer(EntityTemplate::createParallaxLvl2_5());
                    //spawnLayer(EntityTemplate::createParallaxLvl2_6());
                    break;
                case 3:
                    spawnLayer(EntityTemplate::createParallaxLvl3_1());
                    spawnLayer(EntityTemplate::createParallaxLvl3_5());
                    spawnLayer(EntityTemplate::createParallaxLvl3_3());
                    spawnLayer(EntityTemplate::createParallaxLvl3_2());
                    spawnLayer(EntityTemplate::createParallaxLvl3_4());
                    spawnLayer(EntityTemplate::createParallaxLvl3_6());
                    spawnLayer(EntityTemplate::createParallaxLvl3_7());
                    spawnLayer(EntityTemplate::createParallaxLvl3_8());
                    spawnLayer(EntityTemplate::createParallaxLvl3_9());
                    break;
                case 4:
                    spawnLayer(EntityTemplate::createParallaxLvl4_1());
                    spawnLayer(EntityTemplate::createParallaxLvl4_2());
                    spawnLayer(EntityTemplate::createParallaxLvl4_3());
                    spawnLayer(EntityTemplate::createParallaxLvl4_4());
                    spawnLayer(EntityTemplate::createParallaxLvl4_5());
                    spawnLayer(EntityTemplate::createParallaxLvl4_6());
                    break;
            }
        }
 
        void PlayingScene::sendChatMessage(void)
        {
            auto inputsOpt = _uiRegistry.get<ecs::components::ui::TextInput>();
            if (!inputsOpt)
                return;
 
            auto &inputs = inputsOpt.value().get();
            if (!inputs.has(_chatInput))
                return;
 
            auto &input = inputs[_chatInput];
            const std::string message = input.value;
            if (message.empty())
                return;
 
            _network.trySendMessage(message);
            input.value.clear();
            closeChat();
        }
 
        void PlayingScene::openChat(void)
        {
            if (_chatOpen)
                return;
 
            _chatOpen = true;
 
            _chatPanel = _uiFactory.createButton(
                _uiRegistry,
                {30.0f, 60.0f},
                {715.0f, 220.0f},
                "",
                nullptr
            );
            if (auto buttonsOpt = _uiRegistry.get<ecs::components::ui::Button>()) {
                auto &buttons = buttonsOpt.value().get();
                if (buttons.has(_chatPanel)) {
                    auto &panel = buttons[_chatPanel];
                    panel.idleColor[0] = 20; panel.idleColor[1] = 20; panel.idleColor[2] = 20;
                    panel.hoverColor[0] = 20; panel.hoverColor[1] = 20; panel.hoverColor[2] = 20;
                    panel.pressedColor[0] = 20; panel.pressedColor[1] = 20; panel.pressedColor[2] = 20;
                }
            }
 
            _chatHistoryText = _uiFactory.createText(
                _uiRegistry,
                {45.0f, 70.0f},
                "",
                "assets/fonts/main.ttf",
                18,
                10,
                {230, 230, 230}
            );
 
            _chatInput = _uiFactory.createTextInput(
                _uiRegistry,
                {45.0f, 235.0f},
                {685.0f, 30.0f},
                "assets/fonts/main.ttf",
                18,
                120,
                "Type message...",
                nullptr,
                nullptr
            );
            if (auto inputsOpt = _uiRegistry.get<ecs::components::ui::TextInput>()) {
                auto &inputs = inputsOpt.value().get();
                if (inputs.has(_chatInput)) {
                    inputs[_chatInput].onSubmit = [this](const std::string&) {
                        sendChatMessage();
                    };
                    inputs[_chatInput].isFocused = true;
                    inputs[_chatInput].showCursor = true;
                }
            }
 
            updateChatHistoryText();
        }
 
        void PlayingScene::closeChat(void)
        {
            if (!_chatOpen)
                return;
 
            _chatOpen = false;
            if (!_chatPanel.isNull()) _uiRegistry.kill(_chatPanel);
            if (!_chatHistoryText.isNull()) _uiRegistry.kill(_chatHistoryText);
            if (!_chatInput.isNull()) _uiRegistry.kill(_chatInput);
            _chatPanel = {};
            _chatHistoryText = {};
            _chatInput = {};
        }
 
        void PlayingScene::updateChatHistoryText(void)
        {
            auto textsOpt = _uiRegistry.get<ecs::components::ui::Text>();
            if (!textsOpt)
                return;
            auto &texts = textsOpt.value().get();
            if (!texts.has(_chatHistoryText))
                return;
 
            const auto &history = _network.getChatHistory();
            std::string combined;
            for (const auto &line : history) {
                if (!combined.empty())
                    combined += "\n";
                combined += line;
            }
            texts[_chatHistoryText].content = combined;
        }
 
    } // namespace scenes
} // namespace rtp::client