room.cpp - master - tytyshka/Typing_Race_Game

room.cpp
152 строки3 KB
tytyshka
Client
16 дек 2025, 21:37
16 дек 2025, 21:37f770ab5
#include "room.h"
#include <iostream>
#include <random>
#include "utils.h"


Room::Room(const std::string& id, const std::string& name, int max_players, bool auto_start, ms_t duration_ms)
    : id_(id), name_(name), max_players_(max_players), auto_start_(auto_start), duration_ms_(duration_ms) {
}

Room::~Room() {}

bool Room::add_player(std::shared_ptr<PlayerSession> session) {
    std::lock_guard<std::mutex> lk(mtx_);

    // ���� ���� ��� ��� � ���� ��������
    if (game_) {
        std::cout << "[Room] join rejected: game already running\n";
        return false;
    }

    // ��� � �������
    for (auto& it : players_) {
        auto& existing = it.second;
        if (existing->get_info().player_id ==
            session->get_info().player_id) {
            return false;
        }
    }

    // ����� �������
    if ((int)players_.size() >= max_players_) {
        return false;
    }

    std::string pid = session->get_info().player_id;
    players_.emplace(pid, session);

    std::cout << "[Room] player added: " << pid
        << " to room " << id_ << "\n";

    return true;
}

void Room::remove_player(const std::string& player_id) {
    std::lock_guard<std::mutex> lk(mtx_);
    players_.erase(player_id);
}

void Room::broadcast(const json& msg) {
    std::lock_guard<std::mutex> lk(mtx_);

    for (auto it = players_.begin(); it != players_.end(); ) {
        if (!it->second->send_json(msg)) {
            std::cout << "[Room] removing disconnected player " << it->first << "\n";
            it = players_.erase(it);
        }
        else {
            ++it;
        }
    }
}
std::vector<std::shared_ptr<PlayerSession>> Room::get_players() const {
    std::lock_guard<std::mutex> lk(mtx_);

    std::vector<std::shared_ptr<PlayerSession>> result;
    for (const auto& kv : players_) {
        result.push_back(kv.second);
    }
    return result;
}


size_t Room::player_count() {
    std::lock_guard<std::mutex> lk(mtx_);
    return players_.size();
}
int Room::max_players() { return max_players_; }
std::string Room::name() { return name_; }
std::string Room::room_id() { return id_; }
std::string Room::state_str() {
    std::lock_guard<std::mutex> lk(mtx_);
    if (game_) return "RUNNING";
    return "WAITING";
}

bool Room::start_game() {
    std::lock_guard<std::mutex> lk(mtx_);

    if (game_)
        return false;

    game_ = std::make_unique<GameInstance>(duration_ms_);
    for (auto& kv : players_) {
        game_->add_player(kv.second.get());
    }

    game_->start();

    broadcast({
        {"type","GAME_STARTED"},
        {"payload", {{"room_id", id_}}}
        });

    // game_->start();

    std::cout << "[Room] game started in room " << id_ << "\n";
    return true;
}


bool Room::is_game_running() const {
    return game_ != nullptr;
}

void Room::handle_keypress(PlayerSession* player, char key) {
    std::lock_guard<std::mutex> lk(mtx_);
    if (game_) {
        game_->handle_keypress(player, key);
    }
}


void Room::finish_game() {
    std::lock_guard<std::mutex> lk(mtx_);

    if (!game_)
        return;

    game_.reset();

    // game_running_ = false;

    json results = json::array();
    for (auto& kv : players_) {
        auto& p = kv.second;

        results.push_back({
            {"player", p->get_info().username},
            {"score", p->score()}
            });
    }

    broadcast({
        {"type","GAME_FINISHED"},
        {"payload", {{"results", results}}}
        });



    std::cout << "[Room] game finished in room " << id_ << "\n";
}