• Skip to content
  • Skip to link menu
Trinity API Reference
  • Trinity API Reference
  • libtdegames
 

libtdegames

  • libtdegames
  • kgame
kgamenetwork.cpp
1 /*
2  This file is part of the TDE games library
3  Copyright (C) 2001 Martin Heni (martin@heni-online.de)
4  Copyright (C) 2001 Andreas Beckermann (b_mann@gmx.de)
5 
6  This library is free software; you can redistribute it and/or
7  modify it under the terms of the GNU Library General Public
8  License version 2 as published by the Free Software Foundation.
9 
10  This library is distributed in the hope that it will be useful,
11  but WITHOUT ANY WARRANTY; without even the implied warranty of
12  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13  Library General Public License for more details.
14 
15  You should have received a copy of the GNU Library General Public License
16  along with this library; see the file COPYING.LIB. If not, write to
17  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18  Boston, MA 02110-1301, USA.
19 */
20 /*
21  $Id$
22 */
23 
24 #include "kgamenetwork.h"
25 #include "kgamenetwork.moc"
26 #include "kgamemessage.h"
27 #include "kgameerror.h"
28 
29 #include "kmessageserver.h"
30 #include "kmessageclient.h"
31 #include "kmessageio.h"
32 #include <dnssd/publicservice.h>
33 
34 #include <kdebug.h>
35 
36 #include <tqbuffer.h>
37 
38 
39 class KGameNetworkPrivate
40 {
41 public:
42  KGameNetworkPrivate()
43  {
44  mMessageClient = 0;
45  mMessageServer = 0;
46  mDisconnectId = 0;
47  mService = 0;
48  }
49 
50 public:
51  KMessageClient* mMessageClient;
52  KMessageServer* mMessageServer;
53  TQ_UINT32 mDisconnectId; // Stores gameId() over a disconnect process
54  DNSSD::PublicService* mService;
55  TQString mType;
56  TQString mName;
57 
58  int mCookie;
59 };
60 
61 // ------------------- NETWORK GAME ------------------------
62 KGameNetwork::KGameNetwork(int c, TQObject* parent) : TQObject(parent, 0)
63 {
64  d = new KGameNetworkPrivate;
65  d->mCookie = (TQ_INT16)c;
66 
67  // Init the game as a local game, i.e.
68  // create your own KMessageServer and a KMessageClient connected to it.
69  setMaster();
70 
71  kdDebug(11001) << k_funcinfo << "this=" << this <<", cookie=" << cookie() << " sizeof(this)="<<sizeof(KGameNetwork) << endl;
72 }
73 
74 KGameNetwork::~KGameNetwork()
75 {
76  kdDebug(11001) << k_funcinfo << "this=" << this << endl;
77 // Debug();
78  delete d->mService;
79  delete d;
80 }
81 
82 // ----------------------------- status methods
83 bool KGameNetwork::isNetwork() const
84 { return isOfferingConnections() || d->mMessageClient->isNetwork();}
85 
86 TQ_UINT32 KGameNetwork::gameId() const
87 {
88  //return d->mMessageClient->id() ;
89  // Return stored id in the case of disconnect. In any other
90  // case the disconnect id is 0
91  if (d->mMessageClient->id()!=0 ) {
92  return d->mMessageClient->id() ;
93  } else {
94  return d->mDisconnectId;
95  }
96 }
97 
98 int KGameNetwork::cookie() const
99 { return d->mCookie; }
100 
101 bool KGameNetwork::isMaster() const
102 { return (d->mMessageServer != 0); }
103 
104 bool KGameNetwork::isAdmin() const
105 { return (d->mMessageClient->isAdmin()); }
106 
107 KMessageClient* KGameNetwork::messageClient() const
108 { return d->mMessageClient; }
109 
110 KMessageServer* KGameNetwork::messageServer() const
111 { return d->mMessageServer; }
112 
113 // ----------------------- network init
114 void KGameNetwork::setMaster()
115 {
116  if (!d->mMessageServer) {
117  d->mMessageServer = new KMessageServer (cookie(), this);
118  } else {
119  kdWarning(11001) << k_funcinfo << "Server already running!!" << endl;
120  }
121  if (!d->mMessageClient) {
122  d->mMessageClient = new KMessageClient (this);
123  connect (d->mMessageClient, TQ_SIGNAL(broadcastReceived(const TQByteArray&, TQ_UINT32)),
124  this, TQ_SLOT(receiveNetworkTransmission(const TQByteArray&, TQ_UINT32)));
125  connect (d->mMessageClient, TQ_SIGNAL(connectionBroken()),
126  this, TQ_SIGNAL(signalConnectionBroken()));
127  connect (d->mMessageClient, TQ_SIGNAL(aboutToDisconnect(TQ_UINT32)),
128  this, TQ_SLOT(aboutToLoseConnection(TQ_UINT32)));
129  connect (d->mMessageClient, TQ_SIGNAL(connectionBroken()),
130  this, TQ_SLOT(slotResetConnection()));
131 
132  connect (d->mMessageClient, TQ_SIGNAL(adminStatusChanged(bool)),
133  this, TQ_SLOT(slotAdminStatusChanged(bool)));
134  connect (d->mMessageClient, TQ_SIGNAL(eventClientConnected(TQ_UINT32)),
135  this, TQ_SIGNAL(signalClientConnected(TQ_UINT32)));
136  connect (d->mMessageClient, TQ_SIGNAL(eventClientDisconnected(TQ_UINT32, bool)),
137  this, TQ_SIGNAL(signalClientDisconnected(TQ_UINT32, bool)));
138 
139  // broacast and direct messages are treated equally on receive.
140  connect (d->mMessageClient, TQ_SIGNAL(forwardReceived(const TQByteArray&, TQ_UINT32, const TQValueList<TQ_UINT32>&)),
141  d->mMessageClient, TQ_SIGNAL(broadcastReceived(const TQByteArray&, TQ_UINT32)));
142 
143  } else {
144  // should be no problem but still has to be tested
145  kdDebug(11001) << k_funcinfo << "Client already exists!" << endl;
146  }
147  d->mMessageClient->setServer(d->mMessageServer);
148 }
149 
150 void KGameNetwork::setDiscoveryInfo(const TQString& type, const TQString& name)
151 {
152  kdDebug() << k_funcinfo << type << ":" << name << endl;
153  d->mType = type;
154  d->mName = name;
155  tryPublish();
156 }
157 
158 void KGameNetwork::tryPublish()
159 {
160  if (d->mType.isNull() || !isOfferingConnections()) return;
161  if (!d->mService) d->mService = new DNSSD::PublicService(d->mName,d->mType,port());
162  else {
163  if (d->mType!=d->mService->type()) d->mService->setType(d->mType);
164  if (d->mName!=d->mService->serviceName()) d->mService->setServiceName(d->mName);
165  }
166  if (!d->mService->isPublished()) d->mService->publishAsync();
167 }
168 
169 void KGameNetwork::tryStopPublishing()
170 {
171  if (d->mService) d->mService->stop();
172 }
173 
174 bool KGameNetwork::offerConnections(TQ_UINT16 port)
175 {
176  kdDebug (11001) << k_funcinfo << "on port " << port << endl;
177  if (!isMaster()) {
178  setMaster();
179  }
180 
181  // Make sure this is 0
182  d->mDisconnectId = 0;
183 
184  // FIXME: This debug message can be removed when the program is working correct.
185  if (d->mMessageServer && d->mMessageServer->isOfferingConnections()) {
186  kdDebug (11001) << k_funcinfo << "Already running as server! Changing the port now!" << endl;
187  }
188 
189  tryStopPublishing();
190  kdDebug (11001) << k_funcinfo << "before Server->initNetwork" << endl;
191  if (!d->mMessageServer->initNetwork (port)) {
192  kdError (11001) << k_funcinfo << "Unable to bind to port " << port << "!" << endl;
193  // no need to delete - we just cannot listen to the port
194 // delete d->mMessageServer;
195 // d->mMessageServer = 0;
196 // d->mMessageClient->setServer((KMessageServer*)0);
197  return false;
198  }
199  kdDebug (11001) << k_funcinfo << "after Server->initNetwork" << endl;
200  tryPublish();
201  return true;
202 }
203 
204 bool KGameNetwork::connectToServer (const TQString& host, TQ_UINT16 port)
205 {
206  if (host.isEmpty()) {
207  kdError(11001) << k_funcinfo << "No hostname given" << endl;
208  return false;
209  }
210 
211  // Make sure this is 0
212  d->mDisconnectId = 0;
213 
214 // if (!d->mMessageServer) {
215 // // FIXME: What shall we do here? Probably must stop a running game.
216 // kdWarning (11001) << k_funcinfo << "We are already connected to another server!" << endl;
218 
219  if (d->mMessageServer) {
220  // FIXME: What shall we do here? Probably must stop a running game.
221  kdWarning(11001) << "we are server but we are trying to connect to another server! "
222  << "make sure that all clients connect to that server! "
223  << "quitting the local server now..." << endl;
224  stopServerConnection();
225  d->mMessageClient->setServer((KMessageIO*)0);
226  delete d->mMessageServer;
227  d->mMessageServer = 0;
228  }
229 
230  kdDebug(11001) << " about to set server" << endl;
231  d->mMessageClient->setServer(host, port);
232  emit signalAdminStatusChanged(false); // as we delete the connection above isAdmin() is always false now!
233 
234  // OK: We say that we already have connected, but this isn't so yet!
235  // If the connection cannot be established, it will look as being disconnected
236  // again ("slotConnectionLost" is called).
237  // Shall we differ between these?
238  kdDebug(11001) << "connected to " << host << ":" << port << endl;
239  return true;
240 }
241 
242 TQ_UINT16 KGameNetwork::port() const
243 {
244  if (isNetwork()) {
245  if (isOfferingConnections()) {
246  return d->mMessageServer->serverPort();
247  } else {
248  return d->mMessageClient->peerPort();
249  }
250  }
251  return 0;
252 }
253 
254 TQString KGameNetwork::hostName() const
255 {
256  return d->mMessageClient->peerName();
257 }
258 
259 bool KGameNetwork::stopServerConnection()
260 {
261  // We still are the Master, we just don't accept further connections!
262  tryStopPublishing();
263  if (d->mMessageServer) {
264  d->mMessageServer->stopNetwork();
265  return true;
266  }
267  return false;
268 }
269 
270 bool KGameNetwork::isOfferingConnections() const
271 { return (d->mMessageServer && d->mMessageServer->isOfferingConnections()); }
272 
273 void KGameNetwork::disconnect()
274 {
275  // TODO MH
276  kdDebug(11001) << k_funcinfo << endl;
277  stopServerConnection();
278  if (d->mMessageServer) {
279  TQValueList <TQ_UINT32> list=d->mMessageServer->clientIDs();
280  TQValueList<TQ_UINT32>::Iterator it;
281  for( it = list.begin(); it != list.end(); ++it )
282  {
283  kdDebug(11001) << "Client id=" << (*it) << endl;
284  KMessageIO *client=d->mMessageServer->findClient(*it);
285  if (!client)
286  {
287  continue;
288  }
289  kdDebug(11001) << " rtti=" << client->rtti() << endl;
290  if (client->rtti()==2)
291  {
292  kdDebug(11001) << "DIRECT IO " << endl;
293  }
294  else
295  {
296  d->mMessageServer->removeClient(client,false);
297  }
298  }
299  }
300  else
301  {
302  kdDebug(11001) << k_funcinfo << "before client->disconnect() id="<<gameId()<< endl;
303  //d->mMessageClient->setServer((KMessageIO*)0);
304  kdDebug(11001) << "+++++++++++++++++++++++++++++++++++++++++++++++++++++++"<<endl;
305  d->mMessageClient->disconnect();
306 
307  kdDebug(11001) << "++++++--------------------------------------------+++++"<<endl;
308  }
309  //setMaster();
310  /*
311  if (d->mMessageServer) {
312  //delete d->mMessageServer;
313  //d->mMessageServer=0;
314  server=true;
315  kdDebug(11001) << " server true" << endl;
316  d->mMessageServer->deleteClients();
317  kdDebug(11001) << " server deleteClients" << endl;
318  }
319  */
320  kdDebug(11001) << k_funcinfo << "DONE" << endl;
321 }
322 
323 void KGameNetwork::aboutToLoseConnection(TQ_UINT32 clientID)
324 {
325  kdDebug(11001) << "Storing client id of connection "<<clientID<<endl;
326  d->mDisconnectId = clientID;
327 }
328 
329 void KGameNetwork::slotResetConnection()
330 {
331  kdDebug(11001) << "Resseting client disconnect id"<<endl;
332  d->mDisconnectId = 0;
333 }
334 
335 void KGameNetwork::electAdmin(TQ_UINT32 clientID)
336 {
337  if (!isAdmin()) {
338  kdWarning(11001) << k_funcinfo << "only ADMIN is allowed to call this!" << endl;
339  return;
340  }
341  TQByteArray buffer;
342  TQDataStream stream(buffer,IO_WriteOnly);
343  stream << static_cast<TQ_UINT32>( KMessageServer::REQ_ADMIN_CHANGE );
344  stream << clientID;
345  d->mMessageClient->sendServerMessage(buffer);
346 }
347 
348 void KGameNetwork::setMaxClients(int max)
349 {
350  if (!isAdmin()) {
351  kdWarning(11001) << k_funcinfo << "only ADMIN is allowed to call this!" << endl;
352  return;
353  }
354  TQByteArray buffer;
355  TQDataStream stream(buffer,IO_WriteOnly);
356  stream << static_cast<TQ_UINT32>( KMessageServer::REQ_MAX_NUM_CLIENTS );
357  stream << (TQ_INT32)max;
358  d->mMessageClient->sendServerMessage(buffer);
359 }
360 
361 void KGameNetwork::lock()
362 {
363  if (messageClient()) {
364  messageClient()->lock();
365  }
366 }
367 
368 void KGameNetwork::unlock()
369 {
370  if (messageClient()) {
371  messageClient()->unlock();
372  }
373 }
374 
375 // --------------------- send messages ---------------------------
376 
377 bool KGameNetwork::sendSystemMessage(int data, int msgid, TQ_UINT32 receiver, TQ_UINT32 sender)
378 {
379  TQByteArray buffer;
380  TQDataStream stream(buffer,IO_WriteOnly);
381  stream << data;
382  return sendSystemMessage(buffer,msgid,receiver,sender);
383 }
384 
385 bool KGameNetwork::sendSystemMessage(const TQString &msg, int msgid, TQ_UINT32 receiver, TQ_UINT32 sender)
386 {
387  TQByteArray buffer;
388  TQDataStream stream(buffer, IO_WriteOnly);
389  stream << msg;
390  return sendSystemMessage(buffer, msgid, receiver, sender);
391 }
392 
393 bool KGameNetwork::sendSystemMessage(const TQDataStream &msg, int msgid, TQ_UINT32 receiver, TQ_UINT32 sender)
394 { return sendSystemMessage(((TQBuffer*)msg.device())->buffer(), msgid, receiver, sender); }
395 
396 bool KGameNetwork::sendSystemMessage(const TQByteArray& data, int msgid, TQ_UINT32 receiver, TQ_UINT32 sender)
397 {
398  TQByteArray buffer;
399  TQDataStream stream(buffer,IO_WriteOnly);
400  if (!sender) {
401  sender = gameId();
402  }
403 
404  TQ_UINT32 receiverClient = KGameMessage::rawGameId(receiver); // KGame::gameId()
405  int receiverPlayer = KGameMessage::rawPlayerId(receiver); // KPlayer::id()
406 
407  KGameMessage::createHeader(stream, sender, receiver, msgid);
408  stream.writeRawBytes(data.data(), data.size());
409 
410  /*
411  kdDebug(11001) << "transmitGameClientMessage msgid=" << msgid << " recv="
412  << receiver << " sender=" << sender << " Buffersize="
413  << buffer.size() << endl;
414  */
415 
416  if (!d->mMessageClient) {
417  // No client created, this should never happen!
418  // Having a local game means we have our own
419  // KMessageServer and we are the only client.
420  kdWarning (11001) << k_funcinfo << "We don't have a client! Should never happen!" << endl;
421  return false;
422  }
423 
424  if (receiverClient == 0 || receiverPlayer != 0)
425  {
426  // if receiverClient == 0 this is a broadcast message. if it is != 0 but
427  // receiverPlayer is also != 0 we have to send broadcast anyway, because the
428  // KPlayer object on all clients needs to receive the message.
429  d->mMessageClient->sendBroadcast(buffer);
430  }
431  else
432  {
433  d->mMessageClient->sendForward(buffer, receiverClient);
434  }
435  return true;
436 }
437 
438 bool KGameNetwork::sendMessage(int data, int msgid, TQ_UINT32 receiver, TQ_UINT32 sender)
439 { return sendSystemMessage(data,msgid+KGameMessage::IdUser,receiver,sender); }
440 
441 bool KGameNetwork::sendMessage(const TQString &msg, int msgid, TQ_UINT32 receiver, TQ_UINT32 sender)
442 { return sendSystemMessage(msg,msgid+KGameMessage::IdUser,receiver,sender); }
443 
444 bool KGameNetwork::sendMessage(const TQDataStream &msg, int msgid, TQ_UINT32 receiver, TQ_UINT32 sender)
445 { return sendSystemMessage(msg, msgid+KGameMessage::IdUser, receiver, sender); }
446 
447 bool KGameNetwork::sendMessage(const TQByteArray &msg, int msgid, TQ_UINT32 receiver, TQ_UINT32 sender)
448 { return sendSystemMessage(msg, msgid+KGameMessage::IdUser, receiver, sender); }
449 
450 void KGameNetwork::sendError(int error,const TQByteArray& message, TQ_UINT32 receiver, TQ_UINT32 sender)
451 {
452  TQByteArray buffer;
453  TQDataStream stream(buffer,IO_WriteOnly);
454  stream << (TQ_INT32) error;
455  stream.writeRawBytes(message.data(), message.size());
456  sendSystemMessage(stream,KGameMessage::IdError,receiver,sender);
457 }
458 
459 
460 // ----------------- receive messages from the network
461 void KGameNetwork::receiveNetworkTransmission(const TQByteArray& receiveBuffer, TQ_UINT32 clientID)
462 {
463  TQDataStream stream(receiveBuffer, IO_ReadOnly);
464  int msgid;
465  TQ_UINT32 sender; // the id of the KGame/KPlayer who sent the message
466  TQ_UINT32 receiver; // the id of the KGame/KPlayer the message is for
467  KGameMessage::extractHeader(stream, sender, receiver, msgid);
468 // kdDebug(11001) << k_funcinfo << "id=" << msgid << " sender=" << sender << " recv=" << receiver << endl;
469 
470  // No broadcast : receiver==0
471  // No player isPlayer(receiver)
472  // Different game gameId()!=receiver
473  if (receiver && receiver!=gameId() && !KGameMessage::isPlayer(receiver) )
474  {
475  // receiver=0 is broadcast or player message
476  kdDebug(11001) << k_funcinfo << "Message not meant for us "
477  << gameId() << "!=" << receiver << " rawid="
478  << KGameMessage::rawGameId(receiver) << endl;
479  return;
480  }
481  else if (msgid==KGameMessage::IdError)
482  {
483  TQString text;
484  TQ_INT32 error;
485  stream >> error;
486  kdDebug(11001) << k_funcinfo << "Got IdError " << error << endl;
487  text = KGameError::errorText(error, stream);
488  kdDebug(11001) << "Error text: " << text.latin1() << endl;
489  emit signalNetworkErrorMessage((int)error,text);
490  }
491  else
492  {
493  networkTransmission(stream, msgid, receiver, sender, clientID);
494  }
495 }
496 
497 // -------------- slots for the signals of the client
498 void KGameNetwork::slotAdminStatusChanged(bool isAdmin)
499 {
500  emit signalAdminStatusChanged(isAdmin);
501 
502 // TODO: I'm pretty sure there are a lot of things that should be done here...
503 }
504 
505 void KGameNetwork::Debug()
506 {
507  kdDebug(11001) << "------------------- KNETWORKGAME -------------------------" << endl;
508  kdDebug(11001) << "gameId " << gameId() << endl;
509  kdDebug(11001) << "gameMaster " << isMaster() << endl;
510  kdDebug(11001) << "gameAdmin " << isAdmin() << endl;
511  kdDebug(11001) << "---------------------------------------------------" << endl;
512 }
KGameNetwork::messageServer
KMessageServer * messageServer() const
Don't use this unless you really know what you are doing! You might experience some strange behaviour...
Definition: kgamenetwork.cpp:110
KGameNetwork::isMaster
bool isMaster() const
Is this the game MASTER (i.e.
Definition: kgamenetwork.cpp:101
KGameNetwork::messageClient
KMessageClient * messageClient() const
Don't use this unless you really know what youre doing! You might experience some strange behaviour i...
Definition: kgamenetwork.cpp:107
KGameNetwork::offerConnections
bool offerConnections(TQ_UINT16 port)
Inits a network game as network MASTER.
Definition: kgamenetwork.cpp:174
KGameNetwork::isNetwork
bool isNetwork() const
Definition: kgamenetwork.cpp:83
KGameNetwork::isAdmin
bool isAdmin() const
The admin of a game is the one who initializes newly connected clients using negotiateNetworkGame and...
Definition: kgamenetwork.cpp:104
KGameNetwork::aboutToLoseConnection
void aboutToLoseConnection(TQ_UINT32 id)
Called when the network connection is about to terminate.
Definition: kgamenetwork.cpp:323
KGameNetwork::receiveNetworkTransmission
void receiveNetworkTransmission(const TQByteArray &a, TQ_UINT32 clientID)
Called by KMessageClient::broadcastReceived() and will check if the message format is valid.
Definition: kgamenetwork.cpp:461
KGameNetwork::lock
virtual void lock()
You should call this before doing thigs like, e.g.
Definition: kgamenetwork.cpp:361
KGameNetwork::signalClientDisconnected
void signalClientDisconnected(TQ_UINT32 clientID, bool broken)
This signal is emitted whenever the KMessageServer sends us a message that a connection to a client w...
KGameNetwork::Debug
virtual void Debug()
Gives debug output of the game status.
Definition: kgamenetwork.cpp:505
KGameNetwork::slotResetConnection
void slotResetConnection()
Called when the network connection is terminated.
Definition: kgamenetwork.cpp:329
KGameNetwork::disconnect
void disconnect()
Disconnect the current connection and establish a new local one.
Definition: kgamenetwork.cpp:273
KGameNetwork::hostName
TQString hostName() const
Definition: kgamenetwork.cpp:254
KGameNetwork::signalClientConnected
void signalClientConnected(TQ_UINT32 clientID)
This signal is emitted whenever the KMessageServer sends us a message that a new client connected.
KGameNetwork::gameId
TQ_UINT32 gameId() const
The unique ID of this game.
Definition: kgamenetwork.cpp:86
KGameNetwork::cookie
int cookie() const
Application cookie.
Definition: kgamenetwork.cpp:98
KGameNetwork::sendSystemMessage
bool sendSystemMessage(const TQByteArray &buffer, int msgid, TQ_UINT32 receiver=0, TQ_UINT32 sender=0)
Sends a network message msg with a given msg id msgid to all clients.
Definition: kgamenetwork.cpp:396
KGameNetwork::sendMessage
bool sendMessage(const TQByteArray &buffer, int msgid, TQ_UINT32 receiver=0, TQ_UINT32 sender=0)
Send a network message msg with a given message ID msgid to all clients.
Definition: kgamenetwork.cpp:447
KGameNetwork::isOfferingConnections
bool isOfferingConnections() const
Are we still offer offering server connections - only for game MASTER.
Definition: kgamenetwork.cpp:270
KGameNetwork::setMaxClients
void setMaxClients(int max)
Changes the maximal connection number of the KMessageServer to max.
Definition: kgamenetwork.cpp:348
KGameNetwork::slotAdminStatusChanged
void slotAdminStatusChanged(bool isAdmin)
This KGame object receives or loses the admin status.
Definition: kgamenetwork.cpp:498
KGameNetwork::electAdmin
void electAdmin(TQ_UINT32 clientID)
If you are the ADMIN of the game you can give the ADMIN status away to another client.
Definition: kgamenetwork.cpp:335
KGameNetwork::port
TQ_UINT16 port() const
Definition: kgamenetwork.cpp:242
KGameNetwork::signalConnectionBroken
void signalConnectionBroken()
Our connection to the KMessageServer has broken.
KGameNetwork::unlock
virtual void unlock()
Definition: kgamenetwork.cpp:368
KGameNetwork::setDiscoveryInfo
void setDiscoveryInfo(const TQString &type, const TQString &name=TQString())
Announces game MASTER on network using DNS-SD.
Definition: kgamenetwork.cpp:150
KGameNetwork::sendError
void sendError(int error, const TQByteArray &message, TQ_UINT32 receiver=0, TQ_UINT32 sender=0)
Sends a network message.
Definition: kgamenetwork.cpp:450
KGameNetwork::KGameNetwork
KGameNetwork(int cookie=42, TQObject *parent=0)
Create a KGameNetwork object.
Definition: kgamenetwork.cpp:62
KGameNetwork::signalNetworkErrorMessage
void signalNetworkErrorMessage(int error, TQString text)
A network error occurred.
KGameNetwork::connectToServer
bool connectToServer(const TQString &host, TQ_UINT16 port)
Inits a network game as a network CLIENT.
Definition: kgamenetwork.cpp:204
KGameNetwork::stopServerConnection
bool stopServerConnection()
Stops offering server connections - only for game MASTER.
Definition: kgamenetwork.cpp:259
KGameNetwork::networkTransmission
virtual void networkTransmission(TQDataStream &, int, TQ_UINT32, TQ_UINT32, TQ_UINT32 clientID)=0
Called by ReceiveNetworkTransmission().
KGameNetwork::signalAdminStatusChanged
void signalAdminStatusChanged(bool isAdmin)
This client gets or loses the admin status.
KMessageClient
A client to connect to a KMessageServer.
Definition: kmessageclient.h:51
KMessageClient::lock
void lock()
Once this function is called no message will be received anymore.
Definition: kmessageclient.cpp:354
KMessageClient::unlock
void unlock()
Deliver every message that was delayed by lock() and actually deliver all messages that get received ...
Definition: kmessageclient.cpp:359
KMessageIO
This abstract base class represents one end of a message connections between two clients.
Definition: kmessageio.h:57
KMessageIO::rtti
virtual int rtti() const
The runtime idendifcation.
Definition: kmessageio.h:75
KMessageServer
A server for message sending and broadcasting, using TCP/IP connections.
Definition: kmessageserver.h:176

libtdegames

Skip menu "libtdegames"
  • Main Page
  • Class Hierarchy
  • Alphabetical List
  • Class List
  • File List
  • Class Members
  • Related Pages

libtdegames

Skip menu "libtdegames"
  • libtdegames
Generated for libtdegames by doxygen 1.9.1
This website is maintained by Timothy Pearson.