summaryrefslogtreecommitdiffstats
path: root/libkdegames/kgame/kgameio.cpp
diff options
context:
space:
mode:
authortoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
committertoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
commitc90c389a8a8d9d8661e9772ec4144c5cf2039f23 (patch)
tree6d8391395bce9eaea4ad78958617edb20c6a7573 /libkdegames/kgame/kgameio.cpp
downloadtdegames-c90c389a8a8d9d8661e9772ec4144c5cf2039f23.tar.gz
tdegames-c90c389a8a8d9d8661e9772ec4144c5cf2039f23.zip
Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.
BUG:215923 git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdegames@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da
Diffstat (limited to 'libkdegames/kgame/kgameio.cpp')
-rw-r--r--libkdegames/kgame/kgameio.cpp539
1 files changed, 539 insertions, 0 deletions
diff --git a/libkdegames/kgame/kgameio.cpp b/libkdegames/kgame/kgameio.cpp
new file mode 100644
index 00000000..9b3a55e8
--- /dev/null
+++ b/libkdegames/kgame/kgameio.cpp
@@ -0,0 +1,539 @@
+/*
+ This file is part of the KDE games library
+ Copyright (C) 2001 Martin Heni (martin@heni-online.de)
+ Copyright (C) 2001 Andreas Beckermann (b_mann@gmx.de)
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public
+ License version 2 as published by the Free Software Foundation.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public License
+ along with this library; see the file COPYING.LIB. If not, write to
+ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
+*/
+/*
+ $Id$
+*/
+
+#include "kgameio.h"
+#include "kgameio.moc"
+#include "kgame.h"
+#include "kplayer.h"
+#include "kgamemessage.h"
+#include "kmessageio.h"
+
+#include <kdebug.h>
+
+#include <qwidget.h>
+#include <qbuffer.h>
+#include <qtimer.h>
+
+#include <stdlib.h>
+
+// ----------------------- Generic IO -------------------------
+KGameIO::KGameIO() : QObject(0,0)
+{
+ kdDebug(11001) << k_funcinfo << ": this=" << this << ", sizeof(this)" << sizeof(KGameIO) << endl;
+ mPlayer = 0;
+}
+
+KGameIO::KGameIO(KPlayer* player) : QObject(0,0)
+{
+ kdDebug(11001) << k_funcinfo << ": this=" << this << ", sizeof(this)" << sizeof(KGameIO) << endl;
+ mPlayer = 0;
+ if (player)
+ {
+ player->addGameIO(this);
+ }
+}
+
+KGameIO::~KGameIO()
+{
+ kdDebug(11001) << k_funcinfo << ": this=" << this << endl;
+ // unregister ourselves
+ if (player())
+ {
+ player()->removeGameIO(this, false);
+ }
+}
+
+void KGameIO::initIO(KPlayer *p)
+{
+ setPlayer(p);
+}
+
+void KGameIO::notifyTurn(bool b)
+{
+ if (!player())
+ {
+ kdWarning(11001) << k_funcinfo << ": player() is NULL" << endl;
+ return;
+ }
+ bool sendit=false;
+ QByteArray buffer;
+ QDataStream stream(buffer, IO_WriteOnly);
+ emit signalPrepareTurn(stream, b, this, &sendit);
+ if (sendit)
+ {
+ QDataStream ostream(buffer,IO_ReadOnly);
+ Q_UINT32 sender = player()->id(); // force correct sender
+ kdDebug(11001) << "Prepare turn sendInput" << endl;
+ sendInput(ostream, true, sender);
+ }
+}
+
+KGame* KGameIO::game() const
+{
+ if (!player())
+ {
+ return 0;
+ }
+ return player()->game();
+}
+
+bool KGameIO::sendInput(QDataStream& s, bool transmit, Q_UINT32 sender)
+{
+ if (!player())
+ {
+ return false;
+ }
+ return player()->forwardInput(s, transmit, sender);
+}
+
+void KGameIO::Debug()
+{
+ kdDebug(11001) << "------------------- KGAMEINPUT --------------------" << endl;
+ kdDebug(11001) << "this: " << this << endl;
+ kdDebug(11001) << "rtti : " << rtti() << endl;
+ kdDebug(11001) << "Player: " << player() << endl;
+ kdDebug(11001) << "---------------------------------------------------" << endl;
+}
+
+
+// ----------------------- Key IO ---------------------------
+KGameKeyIO::KGameKeyIO(QWidget *parent)
+ : KGameIO()
+{
+ if (parent)
+ {
+ kdDebug(11001) << "Key Event filter installed" << endl;
+ 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;
+ // kdDebug(11001) << "KGameKeyIO " << this << " key press/release " << k->key() << endl ;
+ QByteArray buffer;
+ QDataStream stream(buffer,IO_WriteOnly);
+ bool eatevent=false;
+ emit signalKeyEvent(this,stream,k,&eatevent);
+ QDataStream msg(buffer,IO_ReadOnly);
+
+ if (eatevent && sendInput(msg))
+ {
+ return eatevent;
+ }
+ return false; // do not eat otherwise
+ }
+ return QObject::eventFilter( o, e ); // standard event processing
+}
+
+
+// ----------------------- Mouse IO ---------------------------
+KGameMouseIO::KGameMouseIO(QWidget *parent,bool trackmouse)
+ : KGameIO()
+{
+ if (parent)
+ {
+ kdDebug(11001) << "Mouse Event filter installed tracking=" << trackmouse << endl;
+ 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;
+ }
+// kdDebug(11001) << "KGameMouseIO " << this << endl ;
+
+ // mouse action
+ if ( e->type() == QEvent::MouseButtonPress ||
+ e->type() == QEvent::MouseButtonRelease ||
+ e->type() == QEvent::MouseButtonDblClick ||
+ e->type() == QEvent::Wheel ||
+ e->type() == QEvent::MouseMove
+ )
+ {
+ QMouseEvent *k = (QMouseEvent*)e;
+ // kdDebug(11001) << "KGameMouseIO " << this << endl ;
+ QByteArray buffer;
+ QDataStream stream(buffer,IO_WriteOnly);
+ bool eatevent=false;
+ emit signalMouseEvent(this,stream,k,&eatevent);
+// kdDebug(11001) << "################# eatevent=" << eatevent << endl;
+ QDataStream msg(buffer,IO_ReadOnly);
+ if (eatevent && sendInput(msg))
+ {
+ return eatevent;
+ }
+ return false; // do not eat otherwise
+ }
+ return QObject::eventFilter( o, e ); // standard event processing
+}
+
+
+// ----------------------- KGameProcesPrivate ---------------------------
+class KGameProcessIO::KGameProcessIOPrivate
+{
+public:
+ KGameProcessIOPrivate()
+ {
+ //mMessageServer = 0;
+ //mMessageClient = 0;
+ mProcessIO=0;
+ }
+ //KMessageServer *mMessageServer;
+ //KMessageClient *mMessageClient;
+ KMessageProcess *mProcessIO;
+};
+
+// ----------------------- Process IO ---------------------------
+KGameProcessIO::KGameProcessIO(const QString& name)
+ : KGameIO()
+{
+ kdDebug(11001) << k_funcinfo << ": this=" << this << ", sizeof(this)=" << sizeof(KGameProcessIO) << endl;
+ d = new KGameProcessIOPrivate;
+
+ //kdDebug(11001) << "================= KMEssageServer ==================== " << endl;
+ //d->mMessageServer=new KMessageServer(0,this);
+ //kdDebug(11001) << "================= KMEssageClient ==================== " << endl;
+ //d->mMessageClient=new KMessageClient(this);
+ kdDebug(11001) << "================= KMEssageProcessIO ==================== " << endl;
+ d->mProcessIO=new KMessageProcess(this,name);
+ kdDebug(11001) << "================= KMEssage Add client ==================== " << endl;
+ //d->mMessageServer->addClient(d->mProcessIO);
+ //kdDebug(11001) << "================= KMEssage SetSErver ==================== " << endl;
+ //d->mMessageClient->setServer(d->mMessageServer);
+ kdDebug(11001) << "================= KMEssage: Connect ==================== " << endl;
+ //connect(d->mMessageClient, SIGNAL(broadcastReceived(const QByteArray&, Q_UINT32)),
+ // this, SLOT(clientMessage(const QByteArray&, Q_UINT32)));
+ //connect(d->mMessageClient, SIGNAL(forwardReceived(const QByteArray&, Q_UINT32, const QValueList <Q_UINT32> &)),
+ // this, SLOT(clientMessage(const QByteArray&, Q_UINT32, const QValueList <Q_UINT32> &)));
+ connect(d->mProcessIO, SIGNAL(received(const QByteArray&)),
+ this, SLOT(receivedMessage(const QByteArray&)));
+ //kdDebug(11001) << "Our client is id="<<d->mMessageClient->id() << endl;
+}
+
+KGameProcessIO::~KGameProcessIO()
+{
+ kdDebug(11001) << k_funcinfo << ": this=" << this << endl;
+ kdDebug(11001) << "player="<<player() << endl;
+ if (player())
+ {
+ player()->removeGameIO(this,false);
+ }
+ if (d->mProcessIO)
+ {
+ delete d->mProcessIO;
+ d->mProcessIO=0;
+ }
+ delete d;
+}
+
+int KGameProcessIO::rtti() const
+{
+ return ProcessIO;
+}
+
+void KGameProcessIO::initIO(KPlayer *p)
+{
+ KGameIO::initIO(p);
+ // Send 'hello' to process
+ QByteArray buffer;
+ QDataStream stream(buffer, IO_WriteOnly);
+ Q_INT16 id = p->userId();
+ stream << id;
+
+ bool sendit=true;
+ if (p)
+ {
+ emit signalIOAdded(this,stream,p,&sendit);
+ if (sendit )
+ {
+ Q_UINT32 sender = p->id();
+ kdDebug(11001) << "Sending IOAdded to process player !!!!!!!!!!!!!! " << endl;
+ sendSystemMessage(stream, KGameMessage::IdIOAdded, 0, sender);
+ }
+ }
+}
+
+void KGameProcessIO::notifyTurn(bool b)
+{
+ if (!player())
+ {
+ kdWarning(11001) << k_funcinfo << ": player() is NULL" << endl;
+ return;
+ }
+ bool sendit=true;
+ QByteArray buffer;
+ QDataStream stream(buffer,IO_WriteOnly);
+ stream << (Q_INT8)b;
+ emit signalPrepareTurn(stream,b,this,&sendit);
+ if (sendit)
+ {
+ Q_UINT32 sender=player()->id();
+ kdDebug(11001) << "Sending Turn to process player !!!!!!!!!!!!!! " << endl;
+ sendSystemMessage(stream, KGameMessage::IdTurn, 0, sender);
+ }
+}
+
+void KGameProcessIO::sendSystemMessage(QDataStream &stream,int msgid, Q_UINT32 receiver, Q_UINT32 sender)
+{
+ sendAllMessages(stream, msgid, receiver, sender, false);
+}
+
+void KGameProcessIO::sendMessage(QDataStream &stream,int msgid, Q_UINT32 receiver, Q_UINT32 sender)
+{
+ sendAllMessages(stream, msgid, receiver, sender, true);
+}
+
+void KGameProcessIO::sendAllMessages(QDataStream &stream,int msgid, Q_UINT32 receiver, Q_UINT32 sender, bool usermsg)
+{
+ kdDebug(11001) << "==============> KGameProcessIO::sendMessage (usermsg="<<usermsg<<")" << endl;
+ // if (!player()) return ;
+ //if (!player()->isActive()) return ;
+
+ if (usermsg)
+ {
+ msgid+=KGameMessage::IdUser;
+ }
+
+ kdDebug(11001) << "=============* ProcessIO (" << msgid << "," << receiver << "," << sender << ") ===========" << endl;
+
+ QByteArray buffer;
+ QDataStream ostream(buffer,IO_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.writeRawBytes(data.data(),data.size());
+ kdDebug(11001) << " Adding user data from pos="<< device->at() <<" amount= " << data.size() << " byte " << endl;
+ //if (d->mMessageClient) d->mMessageClient->sendBroadcast(buffer);
+ if (d->mProcessIO)
+ {
+ d->mProcessIO->send(buffer);
+ }
+}
+
+//void KGameProcessIO::clientMessage(const QByteArray& receiveBuffer, Q_UINT32 clientID, const QValueList <Q_UINT32> &recv)
+void KGameProcessIO::receivedMessage(const QByteArray& receiveBuffer)
+{
+ QDataStream stream(receiveBuffer,IO_ReadOnly);
+ int msgid;
+ Q_UINT32 sender;
+ Q_UINT32 receiver;
+ KGameMessage::extractHeader(stream,sender,receiver,msgid);
+
+ kdDebug(11001) << "************* Got process message sender =" << sender
+ << " receiver=" << receiver << " msgid=" << msgid << endl;
+
+
+ // Cut out the header part...to not confuse network code
+ QBuffer *buf=(QBuffer *)stream.device();
+ QByteArray newbuffer;
+ newbuffer.setRawData(buf->buffer().data()+buf->at(),buf->size()-buf->at());
+ QDataStream ostream(newbuffer,IO_ReadOnly);
+ kdDebug(11001) << "Newbuffer size=" << newbuffer.size() << endl;
+
+
+
+// This is a dummy message which allows us the process to talk with its owner
+ if (msgid==KGameMessage::IdProcessQuery)
+ {
+ 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
+ {
+ kdDebug(11001) << k_funcinfo << ": Got message from process but no player defined!" << endl;
+ }
+ newbuffer.resetRawData(buf->buffer().data()+buf->at(),buf->size()-buf->at());
+}
+
+
+// ----------------------- Computer IO --------------------------
+class KGameComputerIO::KGameComputerIOPrivate
+{
+//TODO: maybe these should be KGameProperties!!
+public:
+ KGameComputerIOPrivate()
+ {
+ mAdvanceCounter = 0;
+ mReactionPeriod = 0;
+
+ mPauseCounter = 0;
+
+ mAdvanceTimer = 0;
+ }
+ int mAdvanceCounter;
+ int mReactionPeriod;
+
+ int mPauseCounter;
+
+ QTimer* mAdvanceTimer;
+};
+
+KGameComputerIO::KGameComputerIO() : KGameIO()
+{
+ init();
+}
+
+KGameComputerIO::KGameComputerIO(KPlayer* p) : KGameIO(p)
+{
+ init();
+}
+
+void KGameComputerIO::init()
+{
+ d = new KGameComputerIOPrivate;
+}
+
+KGameComputerIO::~KGameComputerIO()
+{
+ if (d->mAdvanceTimer)
+ {
+ delete d->mAdvanceTimer;
+ }
+ delete d;
+}
+
+int KGameComputerIO::rtti() const
+{
+ return ComputerIO;
+}
+
+void KGameComputerIO::setReactionPeriod(int calls)
+{
+ d->mReactionPeriod = calls;
+}
+
+int KGameComputerIO::reactionPeriod() const
+{
+ return d->mReactionPeriod;
+}
+
+void KGameComputerIO::setAdvancePeriod(int ms)
+{
+ stopAdvancePeriod();
+ d->mAdvanceTimer = new QTimer(this);
+ connect(d->mAdvanceTimer, SIGNAL(timeout()), this, SLOT(advance()));
+ d->mAdvanceTimer->start(ms);
+}
+
+void KGameComputerIO::stopAdvancePeriod()
+{
+ if (d->mAdvanceTimer)
+ {
+ d->mAdvanceTimer->stop();
+ delete d->mAdvanceTimer;
+ }
+}
+
+void KGameComputerIO::pause(int calls)
+{
+ d->mPauseCounter = calls;
+}
+
+void KGameComputerIO::unpause()
+{
+ pause(0);
+}
+
+void KGameComputerIO::advance()
+{
+ 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()
+{
+ emit signalReaction();
+}
+
+