• 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
39class KGameNetworkPrivate
40{
41public:
42 KGameNetworkPrivate()
43 {
44 mMessageClient = 0;
45 mMessageServer = 0;
46 mDisconnectId = 0;
47 mService = 0;
48 }
49
50public:
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 ------------------------
62KGameNetwork::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
74KGameNetwork::~KGameNetwork()
75{
76 kdDebug(11001) << k_funcinfo << "this=" << this << endl;
77// Debug();
78 delete d->mService;
79 delete d;
80}
81
82// ----------------------------- status methods
83bool KGameNetwork::isNetwork() const
84{ return isOfferingConnections() || d->mMessageClient->isNetwork();}
85
86TQ_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
98int KGameNetwork::cookie() const
99{ return d->mCookie; }
100
101bool KGameNetwork::isMaster() const
102{ return (d->mMessageServer != 0); }
103
104bool KGameNetwork::isAdmin() const
105{ return (d->mMessageClient->isAdmin()); }
106
107KMessageClient* KGameNetwork::messageClient() const
108{ return d->mMessageClient; }
109
110KMessageServer* KGameNetwork::messageServer() const
111{ return d->mMessageServer; }
112
113// ----------------------- network init
114void 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
150void 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
158void 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
169void KGameNetwork::tryStopPublishing()
170{
171 if (d->mService) d->mService->stop();
172}
173
174bool 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
204bool 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
242TQ_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
254TQString KGameNetwork::hostName() const
255{
256 return d->mMessageClient->peerName();
257}
258
259bool 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
270bool KGameNetwork::isOfferingConnections() const
271{ return (d->mMessageServer && d->mMessageServer->isOfferingConnections()); }
272
273void 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
323void KGameNetwork::aboutToLoseConnection(TQ_UINT32 clientID)
324{
325 kdDebug(11001) << "Storing client id of connection "<<clientID<<endl;
326 d->mDisconnectId = clientID;
327}
328
329void KGameNetwork::slotResetConnection()
330{
331 kdDebug(11001) << "Resseting client disconnect id"<<endl;
332 d->mDisconnectId = 0;
333}
334
335void 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
348void 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
361void KGameNetwork::lock()
362{
363 if (messageClient()) {
364 messageClient()->lock();
365 }
366}
367
368void KGameNetwork::unlock()
369{
370 if (messageClient()) {
371 messageClient()->unlock();
372 }
373}
374
375// --------------------- send messages ---------------------------
376
377bool 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
385bool 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
393bool KGameNetwork::sendSystemMessage(const TQDataStream &msg, int msgid, TQ_UINT32 receiver, TQ_UINT32 sender)
394{ return sendSystemMessage(((TQBuffer*)msg.device())->buffer(), msgid, receiver, sender); }
395
396bool 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
438bool KGameNetwork::sendMessage(int data, int msgid, TQ_UINT32 receiver, TQ_UINT32 sender)
439{ return sendSystemMessage(data,msgid+KGameMessage::IdUser,receiver,sender); }
440
441bool KGameNetwork::sendMessage(const TQString &msg, int msgid, TQ_UINT32 receiver, TQ_UINT32 sender)
442{ return sendSystemMessage(msg,msgid+KGameMessage::IdUser,receiver,sender); }
443
444bool KGameNetwork::sendMessage(const TQDataStream &msg, int msgid, TQ_UINT32 receiver, TQ_UINT32 sender)
445{ return sendSystemMessage(msg, msgid+KGameMessage::IdUser, receiver, sender); }
446
447bool KGameNetwork::sendMessage(const TQByteArray &msg, int msgid, TQ_UINT32 receiver, TQ_UINT32 sender)
448{ return sendSystemMessage(msg, msgid+KGameMessage::IdUser, receiver, sender); }
449
450void 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
461void 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
498void 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
505void 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.4
This website is maintained by Timothy Pearson.