141 lines
4.5 KiB
C++
141 lines
4.5 KiB
C++
#pragma once
|
|
|
|
#include <cstdint>
|
|
#include <functional>
|
|
#include <string>
|
|
#include <utility>
|
|
|
|
// Clase dedicada para manejar el sistema de pausa
|
|
class PauseManager {
|
|
public:
|
|
// Enum encapsulado dentro de la clase
|
|
enum class Source : uint8_t {
|
|
NONE = 0,
|
|
PLAYER = 1 << 0, // 0001
|
|
SERVICE_MENU = 1 << 1, // 0010
|
|
FOCUS_LOST = 1 << 2 // 0100
|
|
};
|
|
|
|
// Operadores para trabajar con las banderas (funciones friend)
|
|
friend auto operator|(Source a, Source b) -> Source {
|
|
return static_cast<Source>(static_cast<uint8_t>(a) | static_cast<uint8_t>(b));
|
|
}
|
|
|
|
friend auto operator&(Source a, Source b) -> Source {
|
|
return static_cast<Source>(static_cast<uint8_t>(a) & static_cast<uint8_t>(b));
|
|
}
|
|
|
|
friend auto operator~(Source a) -> uint8_t {
|
|
return ~static_cast<uint8_t>(a);
|
|
}
|
|
|
|
friend auto operator&=(Source& a, uint8_t b) -> Source& {
|
|
a = static_cast<Source>(static_cast<uint8_t>(a) & b);
|
|
return a;
|
|
}
|
|
|
|
friend auto operator|=(Source& a, Source b) -> Source& {
|
|
return a = a | b;
|
|
}
|
|
|
|
friend auto operator&=(Source& a, Source b) -> Source& {
|
|
return a = a & b;
|
|
}
|
|
|
|
private:
|
|
Source flags_ = Source::NONE;
|
|
std::function<void(bool)> on_pause_changed_callback_;
|
|
|
|
[[nodiscard]] auto hasFlag(Source flag) const -> bool {
|
|
return (flags_ & flag) != Source::NONE;
|
|
}
|
|
|
|
void notifyPauseChanged() {
|
|
if (on_pause_changed_callback_) {
|
|
on_pause_changed_callback_(isPaused());
|
|
}
|
|
}
|
|
|
|
public:
|
|
// Constructor con callback opcional
|
|
explicit PauseManager(std::function<void(bool)> callback = nullptr)
|
|
: on_pause_changed_callback_(std::move(callback)) {}
|
|
|
|
// Establece/quita una fuente de pausa específica
|
|
void setFlag(Source source, bool enable) {
|
|
bool was_paused = isPaused();
|
|
|
|
if (enable) {
|
|
flags_ |= source;
|
|
} else {
|
|
flags_ &= ~source; // Ahora funciona: Source &= uint8_t
|
|
}
|
|
|
|
if (was_paused != isPaused()) {
|
|
notifyPauseChanged();
|
|
}
|
|
}
|
|
|
|
// Métodos específicos para cada fuente
|
|
void setPlayerPause(bool enable) { setFlag(Source::PLAYER, enable); }
|
|
void setServiceMenuPause(bool enable) { setFlag(Source::SERVICE_MENU, enable); }
|
|
void setFocusLossPause(bool enable) { setFlag(Source::FOCUS_LOST, enable); }
|
|
|
|
// Toggle para el jugador (más común)
|
|
void togglePlayerPause() { setPlayerPause(!isPlayerPaused()); }
|
|
|
|
// Getters
|
|
[[nodiscard]] auto isPaused() const -> bool { return flags_ != Source::NONE; }
|
|
[[nodiscard]] auto isPlayerPaused() const -> bool { return hasFlag(Source::PLAYER); }
|
|
[[nodiscard]] auto isServiceMenuPaused() const -> bool { return hasFlag(Source::SERVICE_MENU); }
|
|
[[nodiscard]] auto isFocusLossPaused() const -> bool { return hasFlag(Source::FOCUS_LOST); }
|
|
|
|
// Obtiene las banderas actuales
|
|
[[nodiscard]] auto getFlags() const -> Source { return flags_; }
|
|
|
|
// Limpia todas las pausas (útil para reset)
|
|
void clearAll() {
|
|
if (isPaused()) {
|
|
flags_ = Source::NONE;
|
|
notifyPauseChanged();
|
|
}
|
|
}
|
|
|
|
// Método para debug
|
|
[[nodiscard]] auto getStatusString() const -> std::string {
|
|
if (flags_ == Source::NONE) {
|
|
return "Active";
|
|
}
|
|
|
|
std::string result = "Paused by: ";
|
|
bool first = true;
|
|
|
|
if (hasFlag(Source::PLAYER)) {
|
|
if (!first) {
|
|
result += ", ";
|
|
}
|
|
result += "Player";
|
|
first = false;
|
|
}
|
|
if (hasFlag(Source::SERVICE_MENU)) {
|
|
if (!first) {
|
|
result += ", ";
|
|
}
|
|
result += "ServiceMenu";
|
|
first = false;
|
|
}
|
|
if (hasFlag(Source::FOCUS_LOST)) {
|
|
if (!first) {
|
|
result += ", ";
|
|
}
|
|
result += "FocusLoss";
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
// Permite cambiar el callback en runtime
|
|
void setCallback(std::function<void(bool)> callback) {
|
|
on_pause_changed_callback_ = callback;
|
|
}
|
|
}; |