gameserver.cpp

#include "gameserver.h"

#include <QHostAddress>
#include <QJsonDocument>
#include <QJsonObject>
#include <QTcpServer>
#include <QTcpSocket>

namespace {
QByteArray toLine(const QJsonObject& o)
{
    return QJsonDocument(o).toJson(QJsonDocument::Compact) + '\n';
}
} // namespace

// ---------------------------------------------------------------------------
// Room
// ---------------------------------------------------------------------------

Room::Room(int id, QTcpSocket* a, QTcpSocket* b, QObject* parent)
    : QObject(parent), m_id(id), m_a(a), m_b(b)
{
    m_model.newGame(); // 权威布局（种子由系统熵决定，随 matched 下发）
}

void Room::sendTo(QTcpSocket* s, const QJsonObject& o)
{
    if (s && s->state() == QAbstractSocket::ConnectedState)
        s->write(toLine(o));
}

void Room::sendError(QTcpSocket* s, const QString& msg)
{
    QJsonObject o;
    o[QStringLiteral("type")] = QStringLiteral("error");
    o[QStringLiteral("message")] = msg;
    sendTo(s, o);
}

void Room::start()
{
    for (int p = 0; p < 2; p++) {
        QJsonObject o;
        o[QStringLiteral("type")] = QStringLiteral("matched");
        o[QStringLiteral("seed")] = qint64(m_model.seedUsed());
        o[QStringLiteral("you")] = p;
        o[QStringLiteral("state")] = m_model.buildFilteredState(p);
        sendTo(socket(p), o);
    }
}

void Room::sendState()
{
    for (int p = 0; p < 2; p++) {
        QJsonObject o;
        o[QStringLiteral("type")] = QStringLiteral("state");
        o[QStringLiteral("state")] = m_model.buildFilteredState(p);
        sendTo(socket(p), o);
    }
}

void Room::handleAction(QTcpSocket* from, const QString& action)
{
    if (m_finished)
        return;
    const int p = playerNo(from);
    if (p != m_model.currentPlayer()) {
        sendError(from, QStringLiteral("not your turn"));
        return;
    }
    if (!m_model.executeAction(action)) {
        sendError(from, QStringLiteral("illegal action"));
        return;
    }

    QJsonObject ar;
    ar[QStringLiteral("type")] = QStringLiteral("action_result");
    ar[QStringLiteral("ok")] = true;
    ar[QStringLiteral("result")] = int(m_model.lastResult());
    ar[QStringLiteral("yourTurn")] = (m_model.currentPlayer() != p);
    sendTo(from, ar);

    sendState();

    const int w = m_model.winner();
    if (w != -1)
        finishGame(w, QStringLiteral("sink"));
}

void Room::handleSurrender(QTcpSocket* from)
{
    if (m_finished)
        return;
    const int p = playerNo(from);
    if (p != m_model.currentPlayer()) {
        sendError(from, QStringLiteral("not your turn"));
        return;
    }
    m_model.surrender();
    finishGame(m_model.winner(), QStringLiteral("surrender"));
}

void Room::finishGame(int winner, const QString& reason)
{
    m_finished = true;
    for (int p = 0; p < 2; p++) {
        QJsonObject o;
        o[QStringLiteral("type")] = QStringLiteral("game_over");
        o[QStringLiteral("winner")] = winner;
        o[QStringLiteral("reason")] = reason;
        sendTo(socket(p), o);
    }
    emit over(m_id);
}

// ---------------------------------------------------------------------------
// GameServer
// ---------------------------------------------------------------------------

GameServer::GameServer(QObject* parent)
    : QObject(parent)
{
    m_server = new QTcpServer(this);
    connect(m_server, &QTcpServer::newConnection, this, &GameServer::onNewConnection);
}

bool GameServer::listen(quint16 port)
{
    return m_server->listen(QHostAddress::Any, port);
}

quint16 GameServer::port() const
{
    return m_server->serverPort();
}

void GameServer::onNewConnection()
{
    while (QTcpSocket* s = m_server->nextPendingConnection()) {
        m_buf.insert(s, QByteArray());
        connect(s, &QTcpSocket::readyRead, this, [this, s]() { onReadyRead(s); });
        connect(s, &QTcpSocket::disconnected, this, [this, s]() { onDisconnected(s); });
    }
}

void GameServer::onReadyRead(QTcpSocket* s)
{
    m_buf[s].append(s->readAll());
    int idx;
    while ((idx = m_buf[s].indexOf('\n')) >= 0) {
        const QByteArray line = m_buf[s].left(idx).trimmed();
        m_buf[s].remove(0, idx + 1);
        if (!line.isEmpty())
            processLine(s, line);
    }
}

void GameServer::processLine(QTcpSocket* s, const QByteArray& line)
{
    const QJsonObject msg = QJsonDocument::fromJson(line).object();
    const QString type = msg[QStringLiteral("type")].toString();

    if (type == QLatin1String("queue")) {
        if (!m_pending.contains(s))
            m_pending.append(s);
        tryMatch();
    } else if (Room* r = m_roomOf.value(s, nullptr)) {
        if (type == QLatin1String("action")) {
            const QString action = msg[QStringLiteral("payload")].toObject()[QStringLiteral("action")].toString();
            r->handleAction(s, action);
        } else if (type == QLatin1String("surrender")) {
            r->handleSurrender(s);
        } else if (type == QLatin1String("request_state")) {
            r->sendState();
        }
    }
}

void GameServer::tryMatch()
{
    while (m_pending.size() >= 2) {
        QTcpSocket* a = m_pending.takeFirst();
        QTcpSocket* b = m_pending.takeFirst();
        Room* r = new Room(m_nextRoomId++, a, b, this);
        connect(r, &Room::over, this, [this, r](int) { removeRoom(r); });
        m_rooms.insert(r->id(), r);
        m_roomOf.insert(a, r);
        m_roomOf.insert(b, r);
        r->start();
    }
}

void GameServer::removeRoom(Room* r)
{
    m_rooms.remove(r->id());
    m_roomOf.remove(r->socket(0));
    m_roomOf.remove(r->socket(1));
    r->deleteLater();
}

void GameServer::onDisconnected(QTcpSocket* s)
{
    m_pending.removeAll(s);
    if (Room* r = m_roomOf.value(s, nullptr)) {
        if (!r->finished()) {
            const int winner = (s == r->socket(0)) ? 1 : 0; // 掉线者的对手获胜
            QJsonObject o;
            o[QStringLiteral("type")] = QStringLiteral("game_over");
            o[QStringLiteral("winner")] = winner;
            o[QStringLiteral("reason")] = QStringLiteral("opponent_left");
            QTcpSocket* other = (s == r->socket(0)) ? r->socket(1) : r->socket(0);
            if (other && other->state() == QAbstractSocket::ConnectedState)
                other->write(toLine(o));
        }
        removeRoom(r);
    }
    m_roomOf.remove(s);
    m_buf.remove(s);
    s->deleteLater();
}