00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024 #include "kgameio.h"
00025 #include "kgameio.moc"
00026 #include "kgame.h"
00027 #include "kplayer.h"
00028 #include "kgamemessage.h"
00029 #include "kmessageio.h"
00030
00031 #include <kdebug.h>
00032
00033 #include <qwidget.h>
00034 #include <qbuffer.h>
00035 #include <qtimer.h>
00036
00037 #include <stdlib.h>
00038
00039
00040 KGameIO::KGameIO() : QObject(0,0)
00041 {
00042 kdDebug(11001) << k_funcinfo << ": this=" << this << ", sizeof(this)" << sizeof(KGameIO) << endl;
00043 mPlayer = 0;
00044 }
00045
00046 KGameIO::KGameIO(KPlayer* player) : QObject(0,0)
00047 {
00048 kdDebug(11001) << k_funcinfo << ": this=" << this << ", sizeof(this)" << sizeof(KGameIO) << endl;
00049 mPlayer = 0;
00050 if (player)
00051 {
00052 player->addGameIO(this);
00053 }
00054 }
00055
00056 KGameIO::~KGameIO()
00057 {
00058 kdDebug(11001) << k_funcinfo << ": this=" << this << endl;
00059
00060 if (player())
00061 {
00062 player()->removeGameIO(this, false);
00063 }
00064 }
00065
00066 void KGameIO::initIO(KPlayer *p)
00067 {
00068 setPlayer(p);
00069 }
00070
00071 void KGameIO::notifyTurn(bool b)
00072 {
00073 if (!player())
00074 {
00075 kdWarning(11001) << k_funcinfo << ": player() is NULL" << endl;
00076 return;
00077 }
00078 bool sendit=false;
00079 QByteArray buffer;
00080 QDataStream stream(buffer, IO_WriteOnly);
00081 emit signalPrepareTurn(stream, b, this, &sendit);
00082 if (sendit)
00083 {
00084 QDataStream ostream(buffer,IO_ReadOnly);
00085 Q_UINT32 sender = player()->id();
00086 kdDebug(11001) << "Prepare turn sendInput" << endl;
00087 sendInput(ostream, true, sender);
00088 }
00089 }
00090
00091 KGame* KGameIO::game() const
00092 {
00093 if (!player())
00094 {
00095 return 0;
00096 }
00097 return player()->game();
00098 }
00099
00100 bool KGameIO::sendInput(QDataStream& s, bool transmit, Q_UINT32 sender)
00101 {
00102 if (!player())
00103 {
00104 return false;
00105 }
00106 return player()->forwardInput(s, transmit, sender);
00107 }
00108
00109 void KGameIO::Debug()
00110 {
00111 kdDebug(11001) << "------------------- KGAMEINPUT --------------------" << endl;
00112 kdDebug(11001) << "this: " << this << endl;
00113 kdDebug(11001) << "rtti : " << rtti() << endl;
00114 kdDebug(11001) << "Player: " << player() << endl;
00115 kdDebug(11001) << "---------------------------------------------------" << endl;
00116 }
00117
00118
00119
00120 KGameKeyIO::KGameKeyIO(QWidget *parent)
00121 : KGameIO()
00122 {
00123 if (parent)
00124 {
00125 kdDebug(11001) << "Key Event filter installed" << endl;
00126 parent->installEventFilter(this);
00127 }
00128 }
00129
00130 KGameKeyIO::~KGameKeyIO()
00131 {
00132 if (parent())
00133 {
00134 parent()->removeEventFilter(this);
00135 }
00136 }
00137
00138 int KGameKeyIO::rtti() const { return KeyIO; }
00139
00140 bool KGameKeyIO::eventFilter( QObject *o, QEvent *e )
00141 {
00142 if (!player())
00143 {
00144 return false;
00145 }
00146
00147
00148 if ( e->type() == QEvent::KeyPress ||
00149 e->type() == QEvent::KeyRelease )
00150 {
00151 QKeyEvent *k = (QKeyEvent*)e;
00152
00153 QByteArray buffer;
00154 QDataStream stream(buffer,IO_WriteOnly);
00155 bool eatevent=false;
00156 emit signalKeyEvent(this,stream,k,&eatevent);
00157 QDataStream msg(buffer,IO_ReadOnly);
00158
00159 if (eatevent && sendInput(msg))
00160 {
00161 return eatevent;
00162 }
00163 return false;
00164 }
00165 return QObject::eventFilter( o, e );
00166 }
00167
00168
00169
00170 KGameMouseIO::KGameMouseIO(QWidget *parent,bool trackmouse)
00171 : KGameIO()
00172 {
00173 if (parent)
00174 {
00175 kdDebug(11001) << "Mouse Event filter installed tracking=" << trackmouse << endl;
00176 parent->installEventFilter(this);
00177 parent->setMouseTracking(trackmouse);
00178 }
00179 }
00180
00181 KGameMouseIO::~KGameMouseIO()
00182 {
00183 if (parent())
00184 {
00185 parent()->removeEventFilter(this);
00186 }
00187 }
00188
00189 int KGameMouseIO::rtti() const
00190 {
00191 return MouseIO;
00192 }
00193
00194 void KGameMouseIO::setMouseTracking(bool b)
00195 {
00196 if (parent())
00197 {
00198 ((QWidget*)parent())->setMouseTracking(b);
00199 }
00200 }
00201
00202 bool KGameMouseIO::eventFilter( QObject *o, QEvent *e )
00203 {
00204 if (!player())
00205 {
00206 return false;
00207 }
00208
00209
00210
00211 if ( e->type() == QEvent::MouseButtonPress ||
00212 e->type() == QEvent::MouseButtonRelease ||
00213 e->type() == QEvent::MouseButtonDblClick ||
00214 e->type() == QEvent::Wheel ||
00215 e->type() == QEvent::MouseMove
00216 )
00217 {
00218 QMouseEvent *k = (QMouseEvent*)e;
00219
00220 QByteArray buffer;
00221 QDataStream stream(buffer,IO_WriteOnly);
00222 bool eatevent=false;
00223 emit signalMouseEvent(this,stream,k,&eatevent);
00224
00225 QDataStream msg(buffer,IO_ReadOnly);
00226 if (eatevent && sendInput(msg))
00227 {
00228 return eatevent;
00229 }
00230 return false;
00231 }
00232 return QObject::eventFilter( o, e );
00233 }
00234
00235
00236
00237 class KGameProcessIO::KGameProcessIOPrivate
00238 {
00239 public:
00240 KGameProcessIOPrivate()
00241 {
00242
00243
00244 mProcessIO=0;
00245 }
00246
00247
00248 KMessageProcess *mProcessIO;
00249 };
00250
00251
00252 KGameProcessIO::KGameProcessIO(const QString& name)
00253 : KGameIO()
00254 {
00255 kdDebug(11001) << k_funcinfo << ": this=" << this << ", sizeof(this)=" << sizeof(KGameProcessIO) << endl;
00256 d = new KGameProcessIOPrivate;
00257
00258
00259
00260
00261
00262 kdDebug(11001) << "================= KMEssageProcessIO ==================== " << endl;
00263 d->mProcessIO=new KMessageProcess(this,name);
00264 kdDebug(11001) << "================= KMEssage Add client ==================== " << endl;
00265
00266
00267
00268 kdDebug(11001) << "================= KMEssage: Connect ==================== " << endl;
00269
00270
00271
00272
00273 connect(d->mProcessIO, SIGNAL(received(const QByteArray&)),
00274 this, SLOT(receivedMessage(const QByteArray&)));
00275
00276 }
00277
00278 KGameProcessIO::~KGameProcessIO()
00279 {
00280 kdDebug(11001) << k_funcinfo << ": this=" << this << endl;
00281 kdDebug(11001) << "player="<<player() << endl;
00282 if (player())
00283 {
00284 player()->removeGameIO(this,false);
00285 }
00286 if (d->mProcessIO)
00287 {
00288 delete d->mProcessIO;
00289 d->mProcessIO=0;
00290 }
00291 delete d;
00292 }
00293
00294 int KGameProcessIO::rtti() const
00295 {
00296 return ProcessIO;
00297 }
00298
00299 void KGameProcessIO::initIO(KPlayer *p)
00300 {
00301 KGameIO::initIO(p);
00302
00303 QByteArray buffer;
00304 QDataStream stream(buffer, IO_WriteOnly);
00305 Q_INT16 id = p->userId();
00306 stream << id;
00307
00308 bool sendit=true;
00309 if (p)
00310 {
00311 emit signalIOAdded(this,stream,p,&sendit);
00312 if (sendit )
00313 {
00314 Q_UINT32 sender = p->id();
00315 kdDebug(11001) << "Sending IOAdded to process player !!!!!!!!!!!!!! " << endl;
00316 sendSystemMessage(stream, KGameMessage::IdIOAdded, 0, sender);
00317 }
00318 }
00319 }
00320
00321 void KGameProcessIO::notifyTurn(bool b)
00322 {
00323 if (!player())
00324 {
00325 kdWarning(11001) << k_funcinfo << ": player() is NULL" << endl;
00326 return;
00327 }
00328 bool sendit=true;
00329 QByteArray buffer;
00330 QDataStream stream(buffer,IO_WriteOnly);
00331 stream << (Q_INT8)b;
00332 emit signalPrepareTurn(stream,b,this,&sendit);
00333 if (sendit)
00334 {
00335 Q_UINT32 sender=player()->id();
00336 kdDebug(11001) << "Sending Turn to process player !!!!!!!!!!!!!! " << endl;
00337 sendSystemMessage(stream, KGameMessage::IdTurn, 0, sender);
00338 }
00339 }
00340
00341 void KGameProcessIO::sendSystemMessage(QDataStream &stream,int msgid, Q_UINT32 receiver, Q_UINT32 sender)
00342 {
00343 sendAllMessages(stream, msgid, receiver, sender, false);
00344 }
00345
00346 void KGameProcessIO::sendMessage(QDataStream &stream,int msgid, Q_UINT32 receiver, Q_UINT32 sender)
00347 {
00348 sendAllMessages(stream, msgid, receiver, sender, true);
00349 }
00350
00351 void KGameProcessIO::sendAllMessages(QDataStream &stream,int msgid, Q_UINT32 receiver, Q_UINT32 sender, bool usermsg)
00352 {
00353 kdDebug(11001) << "==============> KGameProcessIO::sendMessage (usermsg="<<usermsg<<")" << endl;
00354
00355
00356
00357 if (usermsg)
00358 {
00359 msgid+=KGameMessage::IdUser;
00360 }
00361
00362 kdDebug(11001) << "=============* ProcessIO (" << msgid << "," << receiver << "," << sender << ") ===========" << endl;
00363
00364 QByteArray buffer;
00365 QDataStream ostream(buffer,IO_WriteOnly);
00366 QBuffer *device=(QBuffer *)stream.device();
00367 QByteArray data=device->buffer();;
00368
00369 KGameMessage::createHeader(ostream,sender,receiver,msgid);
00370
00371 ostream.writeRawBytes(data.data(),data.size());
00372 kdDebug(11001) << " Adding user data from pos="<< device->at() <<" amount= " << data.size() << " byte " << endl;
00373
00374 if (d->mProcessIO)
00375 {
00376 d->mProcessIO->send(buffer);
00377 }
00378 }
00379
00380
00381 void KGameProcessIO::receivedMessage(const QByteArray& receiveBuffer)
00382 {
00383 QDataStream stream(receiveBuffer,IO_ReadOnly);
00384 int msgid;
00385 Q_UINT32 sender;
00386 Q_UINT32 receiver;
00387 KGameMessage::extractHeader(stream,sender,receiver,msgid);
00388
00389 kdDebug(11001) << "************* Got process message sender =" << sender
00390 << " receiver=" << receiver << " msgid=" << msgid << endl;
00391
00392
00393
00394 QBuffer *buf=(QBuffer *)stream.device();
00395 QByteArray newbuffer;
00396 newbuffer.setRawData(buf->buffer().data()+buf->at(),buf->size()-buf->at());
00397 QDataStream ostream(newbuffer,IO_ReadOnly);
00398 kdDebug(11001) << "Newbuffer size=" << newbuffer.size() << endl;
00399
00400
00401
00402
00403 if (msgid==KGameMessage::IdProcessQuery)
00404 {
00405 emit signalProcessQuery(ostream,this);
00406 }
00407 else if (player())
00408 {
00409 sender = player()->id();
00410 if (msgid==KGameMessage::IdPlayerInput)
00411 {
00412 sendInput(ostream,true,sender);
00413 }
00414 else
00415 {
00416 player()->forwardMessage(ostream,msgid,receiver,sender);
00417 }
00418 }
00419 else
00420 {
00421 kdDebug(11001) << k_funcinfo << ": Got message from process but no player defined!" << endl;
00422 }
00423 newbuffer.resetRawData(buf->buffer().data()+buf->at(),buf->size()-buf->at());
00424 }
00425
00426
00427
00428 class KGameComputerIO::KGameComputerIOPrivate
00429 {
00430
00431 public:
00432 KGameComputerIOPrivate()
00433 {
00434 mAdvanceCounter = 0;
00435 mReactionPeriod = 0;
00436
00437 mPauseCounter = 0;
00438
00439 mAdvanceTimer = 0;
00440 }
00441 int mAdvanceCounter;
00442 int mReactionPeriod;
00443
00444 int mPauseCounter;
00445
00446 QTimer* mAdvanceTimer;
00447 };
00448
00449 KGameComputerIO::KGameComputerIO() : KGameIO()
00450 {
00451 init();
00452 }
00453
00454 KGameComputerIO::KGameComputerIO(KPlayer* p) : KGameIO(p)
00455 {
00456 init();
00457 }
00458
00459 void KGameComputerIO::init()
00460 {
00461 d = new KGameComputerIOPrivate;
00462 }
00463
00464 KGameComputerIO::~KGameComputerIO()
00465 {
00466 if (d->mAdvanceTimer)
00467 {
00468 delete d->mAdvanceTimer;
00469 }
00470 delete d;
00471 }
00472
00473 int KGameComputerIO::rtti() const
00474 {
00475 return ComputerIO;
00476 }
00477
00478 void KGameComputerIO::setReactionPeriod(int calls)
00479 {
00480 d->mReactionPeriod = calls;
00481 }
00482
00483 int KGameComputerIO::reactionPeriod() const
00484 {
00485 return d->mReactionPeriod;
00486 }
00487
00488 void KGameComputerIO::setAdvancePeriod(int ms)
00489 {
00490 stopAdvancePeriod();
00491 d->mAdvanceTimer = new QTimer(this);
00492 connect(d->mAdvanceTimer, SIGNAL(timeout()), this, SLOT(advance()));
00493 d->mAdvanceTimer->start(ms);
00494 }
00495
00496 void KGameComputerIO::stopAdvancePeriod()
00497 {
00498 if (d->mAdvanceTimer)
00499 {
00500 d->mAdvanceTimer->stop();
00501 delete d->mAdvanceTimer;
00502 }
00503 }
00504
00505 void KGameComputerIO::pause(int calls)
00506 {
00507 d->mPauseCounter = calls;
00508 }
00509
00510 void KGameComputerIO::unpause()
00511 {
00512 pause(0);
00513 }
00514
00515 void KGameComputerIO::advance()
00516 {
00517 if (d->mPauseCounter > 0)
00518 {
00519 d->mPauseCounter--;
00520 return;
00521 }
00522 else if (d->mPauseCounter < 0)
00523 {
00524 return;
00525 }
00526 d->mAdvanceCounter++;
00527 if (d->mAdvanceCounter >= d->mReactionPeriod)
00528 {
00529 d->mAdvanceCounter = 0;
00530 reaction();
00531 }
00532 }
00533
00534 void KGameComputerIO::reaction()
00535 {
00536 emit signalReaction();
00537 }
00538
00539