kgameio.cpp

/*
    This file is part of the KDE games library
    SPDX-FileCopyrightText: 2001 Martin Heni <kde at heni-online.de>
    SPDX-FileCopyrightText: 2001 Andreas Beckermann <[email protected]>
 
    SPDX-License-Identifier: LGPL-2.0-only
*/
 
#include "kgameio.h"
 
// own
#include "kgame.h"
#include "kgamemessage.h"
#include "kmessageio.h"
#include "kplayer.h"
// Qt
#include <QBuffer>
#include <QEvent>
#include <QGraphicsScene>
#include <QKeyEvent>
#include <QMouseEvent>
#include <QTimer>
#include <QWidget>
// Std
#include <cstdlib>
 
class KGameIOPrivate
{
public:
    KGameIOPrivate()
        : mPlayer(nullptr)
    {
    }
 
    KPlayer *mPlayer;
};
 
// ----------------------- Generic IO -------------------------
KGameIO::KGameIO()
    : KGameIO(*new KGameIOPrivate)
{
}
 
KGameIO::KGameIO(KPlayer *player)
    : KGameIO(*new KGameIOPrivate, player)
{
}
 
KGameIO::KGameIO(KGameIOPrivate &dd, KPlayer *player)
    : d(&dd)
{
    qCDebug(GAMES_PRIVATE_KGAME) << ": this=" << this << ", sizeof(this)" << sizeof(KGameIO);
    if (player) {
        player->addGameIO(this);
    }
}
 
KGameIO::~KGameIO()
{
    qCDebug(GAMES_PRIVATE_KGAME) << ": this=" << this;
    // unregister ourselves
    if (player()) {
        player()->removeGameIO(this, false);
    }
}
 
KPlayer *KGameIO::player() const
{
    return d->mPlayer;
}
 
void KGameIO::setPlayer(KPlayer *p)
{
    d->mPlayer = p;
}
 
void KGameIO::initIO(KPlayer *p)
{
    setPlayer(p);
}
 
void KGameIO::notifyTurn(bool b)
{
    if (!player()) {
        qCWarning(GAMES_PRIVATE_KGAME) << ": player() is NULL";
        return;
    }
    bool sendit = false;
    QByteArray buffer;
    QDataStream stream(&buffer, QIODevice::WriteOnly);
    Q_EMIT signalPrepareTurn(stream, b, this, &sendit);
    if (sendit) {
        QDataStream ostream(buffer);
        quint32 sender = player()->id(); // force correct sender
        qCDebug(GAMES_PRIVATE_KGAME) << "Prepare turn sendInput";
        sendInput(ostream, true, sender);
    }
}
 
KGame *KGameIO::game() const
{
    if (!player()) {
        return nullptr;
    }
    return player()->game();
}
 
bool KGameIO::sendInput(QDataStream &s, bool transmit, quint32 sender)
{
    if (!player()) {
        return false;
    }
    return player()->forwardInput(s, transmit, sender);
}
 
void KGameIO::Debug()
{
    qCDebug(GAMES_PRIVATE_KGAME) << "------------------- KGAMEINPUT --------------------";
    qCDebug(GAMES_PRIVATE_KGAME) << "this:    " << this;
    qCDebug(GAMES_PRIVATE_KGAME) << "rtti :   " << rtti();
    qCDebug(GAMES_PRIVATE_KGAME) << "Player:  " << player();
    qCDebug(GAMES_PRIVATE_KGAME) << "---------------------------------------------------";
}
 
// ----------------------- Key IO ---------------------------
class KGameKeyIOPrivate : public KGameIOPrivate
{
};
 
KGameKeyIO::KGameKeyIO(QWidget *parent)
    : KGameIO(*new KGameKeyIOPrivate)
{
    if (parent) {
        qCDebug(GAMES_PRIVATE_KGAME) << "Key Event filter installed";
        parent->installEventFilter(this);
    }
}
 
KGameKeyIO::~KGameKeyIO()
{
    if (parent()) {
        parent()->removeEventFilter(this);
    }
}
 
int KGameKeyIO::rtti() const
{
    return KeyIO;
}
 
bool KGameKeyIO::eventFilter(QObject *o, QEvent *e)
{
    if (!player()) {
        return false;
    }
 
    // key press/release
    if (e->type() == QEvent::KeyPress || e->type() == QEvent::KeyRelease) {
        QKeyEvent *k = (QKeyEvent *)e;
        //   qCDebug(GAMES_PRIVATE_KGAME) << "KGameKeyIO" << this << "key press/release" <<  k->key();
        QByteArray buffer;
        QDataStream stream(&buffer, QIODevice::WriteOnly);
        bool eatevent = false;
        Q_EMIT signalKeyEvent(this, stream, k, &eatevent);
        QDataStream msg(buffer);
 
        if (eatevent && sendInput(msg)) {
            return eatevent;
        }
        return false; // do not eat otherwise
    }
    return QObject::eventFilter(o, e); // standard event processing
}
 
// ----------------------- Mouse IO ---------------------------
class KGameMouseIOPrivate : public KGameIOPrivate
{
};
 
KGameMouseIO::KGameMouseIO(QWidget *parent, bool trackmouse)
    : KGameIO(*new KGameMouseIOPrivate)
{
    if (parent) {
        qCDebug(GAMES_PRIVATE_KGAME) << "Mouse Event filter installed tracking=" << trackmouse;
        parent->installEventFilter(this);
        parent->setMouseTracking(trackmouse);
    }
}
 
KGameMouseIO::KGameMouseIO(QGraphicsScene *parent, bool /*trackmouse*/)
    : KGameIO(*new KGameMouseIOPrivate)
{
    if (parent) {
        // qCDebug(GAMES_PRIVATE_KGAME) << "Mouse Event filter installed tracking=" << trackmouse;
        parent->installEventFilter(this);
        //     parent->setMouseTracking(trackmouse);
    }
}
 
KGameMouseIO::~KGameMouseIO()
{
    if (parent()) {
        parent()->removeEventFilter(this);
    }
}
 
int KGameMouseIO::rtti() const
{
    return MouseIO;
}
 
void KGameMouseIO::setMouseTracking(bool b)
{
    if (parent()) {
        ((QWidget *)parent())->setMouseTracking(b);
    }
}
 
bool KGameMouseIO::eventFilter(QObject *o, QEvent *e)
{
    if (!player()) {
        return false;
    }
    // qCDebug(GAMES_PRIVATE_KGAME) << "KGameMouseIO" << this << QLatin1String( " " ) << e->type();
 
    // mouse action
    if (e->type() == QEvent::MouseButtonPress || e->type() == QEvent::MouseButtonRelease || e->type() == QEvent::MouseButtonDblClick
        || e->type() == QEvent::Wheel || e->type() == QEvent::MouseMove || e->type() == QEvent::GraphicsSceneMousePress
        || e->type() == QEvent::GraphicsSceneMouseRelease || e->type() == QEvent::GraphicsSceneMouseDoubleClick || e->type() == QEvent::GraphicsSceneWheel
        || e->type() == QEvent::GraphicsSceneMouseMove) {
        QMouseEvent *k = (QMouseEvent *)e;
        // qCDebug(GAMES_PRIVATE_KGAME) << "KGameMouseIO" << this;
        QByteArray buffer;
        QDataStream stream(&buffer, QIODevice::WriteOnly);
        bool eatevent = false;
        Q_EMIT signalMouseEvent(this, stream, k, &eatevent);
        // qCDebug(GAMES_PRIVATE_KGAME) << "################# eatevent=" << eatevent;
        QDataStream msg(buffer);
        if (eatevent && sendInput(msg)) {
            return eatevent;
        }
        return false; // do not eat otherwise
    }
    return QObject::eventFilter(o, e); // standard event processing
}
 
// ----------------------- KGameProcesPrivate ---------------------------
class KGameProcessIOPrivate : public KGameIOPrivate
{
public:
    KGameProcessIOPrivate()
    {
        // mMessageServer = 0;
        // mMessageClient = 0;
        mProcessIO = nullptr;
    }
    // KMessageServer *mMessageServer;
    // KMessageClient *mMessageClient;
    KMessageProcess *mProcessIO;
};
 
// ----------------------- Process IO ---------------------------
KGameProcessIO::KGameProcessIO(const QString &name)
    : KGameIO(*new KGameProcessIOPrivate)
{
    Q_D(KGameProcessIO);
 
    qCDebug(GAMES_PRIVATE_KGAME) << ": this=" << this << ", sizeof(this)=" << sizeof(KGameProcessIO);
 
    // qCDebug(GAMES_PRIVATE_KGAME) << "================= KMEssageServer ====================";
    // d->mMessageServer=new KMessageServer(0,this);
    // qCDebug(GAMES_PRIVATE_KGAME) << "================= KMEssageClient ====================";
    // d->mMessageClient=new KMessageClient(this);
    qCDebug(GAMES_PRIVATE_KGAME) << "================= KMEssageProcessIO ====================";
    d->mProcessIO = new KMessageProcess(this, name);
    qCDebug(GAMES_PRIVATE_KGAME) << "================= KMEssage Add client ====================";
    // d->mMessageServer->addClient(d->mProcessIO);
    // qCDebug(GAMES_PRIVATE_KGAME) << "================= KMEssage SetSErver ====================";
    // d->mMessageClient->setServer(d->mMessageServer);
    qCDebug(GAMES_PRIVATE_KGAME) << "================= KMEssage: Connect ====================";
    // connect(d->mMessageClient, SIGNAL(broadcastReceived(QByteArray,quint32)),
    //         this, SLOT(clientMessage(QByteArray,quint32)));
    // connect(d->mMessageClient, SIGNAL(forwardReceived(QByteArray,quint32,QValueList<quint32>)),
    //         this, SLOT(clientMessage(QByteArray,quint32,QValueList<quint32>)));
    connect(d->mProcessIO, &KMessageProcess::received, this, &KGameProcessIO::receivedMessage);
    // Relay signal
    connect(d->mProcessIO, &KMessageProcess::signalReceivedStderr, this, &KGameProcessIO::signalReceivedStderr);
    // qCDebug(GAMES_PRIVATE_KGAME) << "Our client is id="<<d->mMessageClient->id();
}
 
KGameProcessIO::~KGameProcessIO()
{
    Q_D(KGameProcessIO);
 
    qCDebug(GAMES_PRIVATE_KGAME) << ": this=" << this;
    qCDebug(GAMES_PRIVATE_KGAME) << "player=" << player();
    if (player()) {
        player()->removeGameIO(this, false);
    }
    if (d->mProcessIO) {
        delete d->mProcessIO;
        d->mProcessIO = nullptr;
    }
}
 
int KGameProcessIO::rtti() const
{
    return ProcessIO;
}
 
void KGameProcessIO::initIO(KPlayer *p)
{
    KGameIO::initIO(p);
    // Send 'hello' to process
    QByteArray buffer;
    QDataStream stream(&buffer, QIODevice::WriteOnly);
 
    bool sendit = true;
    if (p) {
        qint16 id = p->userId();
        stream << id;
        Q_EMIT signalIOAdded(this, stream, p, &sendit);
        if (sendit) {
            quint32 sender = p->id();
            qCDebug(GAMES_PRIVATE_KGAME) << "Sending IOAdded to process player !!!!!!!!!!!!!! ";
            sendSystemMessage(stream, KGameMessage::IdIOAdded, 0, sender);
        }
    }
}
 
void KGameProcessIO::notifyTurn(bool b)
{
    if (!player()) {
        qCWarning(GAMES_PRIVATE_KGAME) << ": player() is NULL";
        return;
    }
    bool sendit = true;
    QByteArray buffer;
    QDataStream stream(&buffer, QIODevice::WriteOnly);
    stream << (qint8)b;
    Q_EMIT signalPrepareTurn(stream, b, this, &sendit);
    if (sendit) {
        quint32 sender = player()->id();
        qCDebug(GAMES_PRIVATE_KGAME) << "Sending Turn to process player !!!!!!!!!!!!!! ";
        sendSystemMessage(stream, KGameMessage::IdTurn, 0, sender);
    }
}
 
void KGameProcessIO::sendSystemMessage(QDataStream &stream, int msgid, quint32 receiver, quint32 sender)
{
    sendAllMessages(stream, msgid, receiver, sender, false);
}
 
void KGameProcessIO::sendMessage(QDataStream &stream, int msgid, quint32 receiver, quint32 sender)
{
    sendAllMessages(stream, msgid, receiver, sender, true);
}
 
void KGameProcessIO::sendAllMessages(QDataStream &stream, int msgid, quint32 receiver, quint32 sender, bool usermsg)
{
    Q_D(KGameProcessIO);
 
    qCDebug(GAMES_PRIVATE_KGAME) << "==============>  KGameProcessIO::sendMessage (usermsg=" << usermsg << ")";
    // if (!player()) return ;
    // if (!player()->isActive()) return ;
 
    if (usermsg) {
        msgid += KGameMessage::IdUser;
    }
 
    qCDebug(GAMES_PRIVATE_KGAME) << "=============* ProcessIO (" << msgid << "," << receiver << "," << sender << ") ===========";
 
    QByteArray buffer;
    QDataStream ostream(&buffer, QIODevice::WriteOnly);
    QBuffer *device = (QBuffer *)stream.device();
    QByteArray data = device->buffer();
    ;
 
    KGameMessage::createHeader(ostream, sender, receiver, msgid);
    // ostream.writeRawBytes(data.data()+device->at(),data.size()-device->at());
    ostream.writeRawData(data.data(), data.size());
    qCDebug(GAMES_PRIVATE_KGAME) << "   Adding user data from pos=" << device->pos() << " amount=" << data.size() << "byte";
    // if (d->mMessageClient) d->mMessageClient->sendBroadcast(buffer);
    if (d->mProcessIO) {
        d->mProcessIO->send(buffer);
    }
}
 
// void KGameProcessIO::clientMessage(const QByteArray& receiveBuffer, quint32 clientID, const QValueList <quint32> &recv)
void KGameProcessIO::receivedMessage(const QByteArray &receiveBuffer)
{
    QDataStream stream(receiveBuffer);
    int msgid;
    quint32 sender;
    quint32 receiver;
    KGameMessage::extractHeader(stream, sender, receiver, msgid);
 
    qCDebug(GAMES_PRIVATE_KGAME) << "************* Got process message sender =" << sender << "receiver=" << receiver << "   msgid=" << msgid;
 
    // Cut out the header part...to not confuse network code
    QBuffer *buf = (QBuffer *)stream.device();
    QByteArray newbuffer;
    newbuffer = QByteArray::fromRawData(buf->buffer().data() + buf->pos(), buf->size() - buf->pos());
    QDataStream ostream(newbuffer);
    qCDebug(GAMES_PRIVATE_KGAME) << "Newbuffer size=" << newbuffer.size();
 
    // This is a dummy message which allows us the process to talk with its owner
    if (msgid == KGameMessage::IdProcessQuery) {
        Q_EMIT signalProcessQuery(ostream, this);
    } else if (player()) {
        sender = player()->id(); // force correct sender
        if (msgid == KGameMessage::IdPlayerInput) {
            sendInput(ostream, true, sender);
        } else {
            player()->forwardMessage(ostream, msgid, receiver, sender);
        }
    } else {
        qCDebug(GAMES_PRIVATE_KGAME) << ": Got message from process but no player defined!";
    }
    newbuffer.clear();
}
 
// ----------------------- Computer IO --------------------------
class KGameComputerIOPrivate : public KGameIOPrivate
{
    // TODO: maybe these should be KGameProperties!!
public:
    KGameComputerIOPrivate()
    {
        mAdvanceCounter = 0;
        mReactionPeriod = 0;
 
        mPauseCounter = 0;
 
        mAdvanceTimer = nullptr;
    }
    int mAdvanceCounter;
    int mReactionPeriod;
 
    int mPauseCounter;
 
    QTimer *mAdvanceTimer;
};
 
KGameComputerIO::KGameComputerIO()
    : KGameIO(*new KGameComputerIOPrivate)
{
}
 
KGameComputerIO::KGameComputerIO(KPlayer *p)
    : KGameIO(*new KGameComputerIOPrivate, p)
{
}
 
KGameComputerIO::~KGameComputerIO()
{
    Q_D(KGameComputerIO);
 
    if (d->mAdvanceTimer) {
        delete d->mAdvanceTimer;
    }
}
 
int KGameComputerIO::rtti() const
{
    return ComputerIO;
}
 
void KGameComputerIO::setReactionPeriod(int calls)
{
    Q_D(KGameComputerIO);
 
    d->mReactionPeriod = calls;
}
 
int KGameComputerIO::reactionPeriod() const
{
    Q_D(const KGameComputerIO);
 
    return d->mReactionPeriod;
}
 
void KGameComputerIO::setAdvancePeriod(int ms)
{
    Q_D(KGameComputerIO);
 
    stopAdvancePeriod();
    d->mAdvanceTimer = new QTimer(this);
    connect(d->mAdvanceTimer, &QTimer::timeout, this, &KGameComputerIO::advance);
    d->mAdvanceTimer->start(ms);
}
 
void KGameComputerIO::stopAdvancePeriod()
{
    Q_D(KGameComputerIO);
 
    if (d->mAdvanceTimer) {
        d->mAdvanceTimer->stop();
        delete d->mAdvanceTimer;
    }
}
 
void KGameComputerIO::pause(int calls)
{
    Q_D(KGameComputerIO);
 
    d->mPauseCounter = calls;
}
 
void KGameComputerIO::unpause()
{
    pause(0);
}
 
void KGameComputerIO::advance()
{
    Q_D(KGameComputerIO);
 
    if (d->mPauseCounter > 0) {
        d->mPauseCounter--;
        return;
    } else if (d->mPauseCounter < 0) {
        return;
    }
    d->mAdvanceCounter++;
    if (d->mAdvanceCounter >= d->mReactionPeriod) {
        d->mAdvanceCounter = 0;
        reaction();
    }
}
 
void KGameComputerIO::reaction()
{
    Q_EMIT signalReaction();
}