KGame Class Reference
#include <kgame.h>
Inheritance diagram for KGame:

Detailed Description
The main KDE game object.The KGame class is the central game object. A game basically consists of following features:
- Player handling (add, remove,...)
- Game status (end,start,pause,...)
- load/save
- Move (and message) handling
- nextPlayer and gameOver()
- Network connection (for KGameNetwork)
Example:
Definition at line 62 of file kgame.h.
Public Types | |
enum | GamePolicy { PolicyUndefined = 0, PolicyClean = 1, PolicyDirty = 2, PolicyLocal = 3 } |
enum | GameStatus { Init = 0, Run = 1, Pause = 2, End = 3, Abort = 4, SystemPause = 5, Intro = 6, UserStatus = 7 } |
typedef QPtrList< KPlayer > | KGamePlayerList |
Signals | |
void | signalReplacePlayerIO (KPlayer *player, bool *remove) |
void | signalLoadPrePlayers (QDataStream &stream) |
void | signalLoad (QDataStream &stream) |
void | signalSavePrePlayers (QDataStream &stream) |
void | signalSave (QDataStream &stream) |
void | signalLoadError (QDataStream &stream, bool network, int cookie, bool &result) |
void | signalNetworkData (int msgid, const QByteArray &buffer, Q_UINT32 receiver, Q_UINT32 sender) |
void | signalMessageUpdate (int msgid, Q_UINT32 receiver, Q_UINT32 sender) |
void | signalPlayerLeftGame (KPlayer *player) |
void | signalPlayerJoinedGame (KPlayer *player) |
void | signalPropertyChanged (KGamePropertyBase *property, KGame *me) |
void | signalGameOver (int status, KPlayer *current, KGame *me) |
void | signalClientJoinedGame (Q_UINT32 clientid, KGame *me) |
void | signalClientLeftGame (int clientID, int oldgamestatus, KGame *me) |
Public Member Functions | |
KGame (int cookie=42, QObject *parent=0) | |
virtual | ~KGame () |
virtual void | Debug () |
KGamePlayerList * | playerList () |
const KGamePlayerList * | playerList () const |
KGamePlayerList * | inactivePlayerList () |
const KGamePlayerList * | inactivePlayerList () const |
KRandomSequence * | random () const |
KGameSequence * | gameSequence () const |
bool | isRunning () const |
KPlayer * | findPlayer (Q_UINT32 id) const |
void | setGameSequence (KGameSequence *sequence) |
void | addPlayer (KPlayer *newplayer) |
bool | removePlayer (KPlayer *player) |
void | playerDeleted (KPlayer *player) |
bool | activatePlayer (KPlayer *player) |
bool | inactivatePlayer (KPlayer *player) |
void | setMaxPlayers (uint maxnumber) |
int | maxPlayers () const |
void | setMinPlayers (uint minnumber) |
uint | minPlayers () const |
uint | playerCount () const |
virtual KPlayer * | nextPlayer (KPlayer *last, bool exclusive=true) |
virtual bool | sendPlayerInput (QDataStream &msg, KPlayer *player, Q_UINT32 sender=0) |
virtual bool | systemPlayerInput (QDataStream &msg, KPlayer *player, Q_UINT32 sender=0) |
virtual KPlayer * | createPlayer (int rtti, int io, bool isvirtual) |
virtual bool | load (QDataStream &stream, bool reset=true) |
virtual bool | load (QString filename, bool reset=true) |
virtual bool | save (QDataStream &stream, bool saveplayers=true) |
virtual bool | save (QString filename, bool saveplayers=true) |
virtual bool | reset () |
int | gameStatus () const |
void | setGameStatus (int status) |
bool | addProperty (KGamePropertyBase *data) |
bool | sendPlayerProperty (int msgid, QDataStream &s, Q_UINT32 playerId) |
KGamePropertyBase * | findProperty (int id) const |
void | setPolicy (GamePolicy p, bool recursive=true) |
GamePolicy | policy () const |
bool | sendGroupMessage (const QByteArray &msg, int msgid, Q_UINT32 sender, const QString &group) |
bool | sendGroupMessage (const QDataStream &msg, int msgid, Q_UINT32 sender, const QString &group) |
bool | sendGroupMessage (int msg, int msgid, Q_UINT32 sender, const QString &group) |
bool | sendGroupMessage (const QString &msg, int msgid, Q_UINT32 sender, const QString &group) |
virtual void | networkTransmission (QDataStream &stream, int msgid, Q_UINT32 receiver, Q_UINT32 sender, Q_UINT32 clientID) |
KGamePropertyHandler * | dataHandler () const |
Protected Slots | |
void | sendProperty (int msgid, QDataStream &stream, bool *sent) |
void | emitSignal (KGamePropertyBase *me) |
virtual void | prepareNext () |
void | slotClientConnected (Q_UINT32 clientId) |
void | slotClientDisconnected (Q_UINT32 clientId, bool broken) |
void | slotServerDisconnected () |
Protected Member Functions | |
virtual bool | playerInput (QDataStream &msg, KPlayer *player)=0 |
KPlayer * | playerInputFinished (KPlayer *player) |
virtual void | newPlayersJoin (KGamePlayerList *oldplayer, KGamePlayerList *newplayer, QValueList< int > &inactivate) |
void | savePlayers (QDataStream &stream, KGamePlayerList *list=0) |
void | savePlayer (QDataStream &stream, KPlayer *player) |
KPlayer * | loadPlayer (QDataStream &stream, bool isvirtual =false) |
bool | systemInactivatePlayer (KPlayer *player) |
bool | systemActivatePlayer (KPlayer *player) |
void | systemAddPlayer (KPlayer *newplayer) |
void | systemRemovePlayer (KPlayer *player, bool deleteit) |
virtual void | negotiateNetworkGame (Q_UINT32 clientID) |
void | syncRandom () |
void | deletePlayers () |
void | deleteInactivePlayers () |
virtual int | checkGameOver (KPlayer *player) |
virtual bool | loadgame (QDataStream &stream, bool network, bool reset) |
virtual bool | savegame (QDataStream &stream, bool network, bool saveplayers) |
Member Enumeration Documentation
enum KGame::GamePolicy |
The policy of the property.
This can be PolicyClean (setVale uses send), PolicyDirty (setValue uses changeValue) or PolicyLocal (setValue uses setLocal).
A "clean" policy means that the property is always the same on every client. This is achieved by calling send which actually changes the value only when the message from the MessageServer is received.
A "dirty" policy means that as soon as setValue is called the property is changed immediately. And additionally sent over network. This can sometimes lead to bugs as the other clients do not immediately have the same value. For more information see changeValue.
PolicyLocal means that a KGameProperty behaves like ever "normal" variable. Whenever setValue is called (e.g. using "=") the value of the property is changes immediately without sending it over network. You might want to use this if you are sure that all clients set the property at the same time.
enum KGame::GameStatus |
Constructor & Destructor Documentation
KGame::KGame | ( | int | cookie = 42 , |
|
QObject * | parent = 0 | |||
) |
Member Function Documentation
void KGame::Debug | ( | ) | [virtual] |
KGame::KGamePlayerList * KGame::playerList | ( | ) |
const KGame::KGamePlayerList * KGame::playerList | ( | ) | const |
KGame::KGamePlayerList * KGame::inactivePlayerList | ( | ) |
const KGame::KGamePlayerList * KGame::inactivePlayerList | ( | ) | const |
The same as inactivePlayerList but returns a const pointer.
KRandomSequence * KGame::random | ( | ) | const |
KGameSequence * KGame::gameSequence | ( | ) | const |
bool KGame::isRunning | ( | ) | const |
KPlayer * KGame::findPlayer | ( | Q_UINT32 | id | ) | const |
void KGame::setGameSequence | ( | KGameSequence * | sequence | ) |
Set a new KGameSequence to control player management.
By default KGame uses a normal KGameSequence object. You might want to subclass that and provide your own object.
The previous sequence will get deleted.
- Parameters:
-
sequence The new game sequence object. KGame takes ownership and will delete it on destruction!
void KGame::addPlayer | ( | KPlayer * | newplayer | ) |
Note that KPlayer::save must be implemented properly, as well as KPlayer::rtti This will only send a message to all clients.
The player is _not_ added directly! See also playerInput which will be called as soon as the player really has been added.
Note that an added player will first get into a "queue" and won't be in the game. It will be added to the game as soon as systemAddPlayer is called what will happen as soon as IdAddPlayer is received.
Note: you probably want to connect to signalPlayerJoinedGame for further initialization!
- Parameters:
-
newplayer The player you want to add. KGame will send a message to all clients and add the player using systemAddPlayer
bool KGame::removePlayer | ( | KPlayer * | player | ) | [inline] |
void KGame::playerDeleted | ( | KPlayer * | player | ) |
bool KGame::activatePlayer | ( | KPlayer * | player | ) |
bool KGame::inactivatePlayer | ( | KPlayer * | player | ) |
void KGame::setMaxPlayers | ( | uint | maxnumber | ) |
int KGame::maxPlayers | ( | ) | const |
void KGame::setMinPlayers | ( | uint | minnumber | ) |
uint KGame::minPlayers | ( | ) | const |
uint KGame::playerCount | ( | ) | const |
bool KGame::sendPlayerInput | ( | QDataStream & | msg, | |
KPlayer * | player, | |||
Q_UINT32 | sender = 0 | |||
) | [virtual] |
Called by KPlayer to send a player input to the KMessageServer.
bool KGame::systemPlayerInput | ( | QDataStream & | msg, | |
KPlayer * | player, | |||
Q_UINT32 | sender = 0 | |||
) | [virtual] |
Called when a player input arrives from KMessageServer.
Calls prepareNext (using QTimer::singleShot) if gameOver() returns 0. This function should normally not be used outside KGame. It could be made non-virtual,protected in a later version. At the moment it is a virtual function to give you more control over KGame.
For documentation see playerInput.
KPlayer * KGame::createPlayer | ( | int | rtti, | |
int | io, | |||
bool | isvirtual | |||
) | [virtual] |
This virtual function is called if the KGame needs to create a new player.
This happens only over a network and with load/save. Doing nothing will create a default KPlayer. If you want to have your own player you have to create one with the given rtti here. Note: If your game uses a player class derived from KPlayer you MUST override this function and create your player here. Otherwise the game will crash. Example:
KPlayer *MyGame::createPlayer(int rtti,int io,bool isvirtual) { KPlayer *player=new MyPlayer; if (!isvirtual) // network player ? { // Define something like this to add the IO modules createIO(player,(KGameIO::IOMode)io); } return player; }
- Parameters:
-
rtti is the type of the player (0 means default KPlayer) io is the 'or'ed rtti of the KGameIO's isvirtual true if player is virtual
bool KGame::load | ( | QDataStream & | stream, | |
bool | reset = true | |||
) | [virtual] |
Load a saved game, from file OR network.
This function has to be overwritten or you need to connect to the load signal if you have game data other than KGameProperty. For file load you should reset() the game before any load attempt to make sure you load into an clear state.
- Parameters:
-
stream a data stream where you can stream the game from reset - shall the game be reset before loading
- Returns:
- true?
bool KGame::load | ( | QString | filename, | |
bool | reset = true | |||
) | [virtual] |
bool KGame::save | ( | QDataStream & | stream, | |
bool | saveplayers = true | |||
) | [virtual] |
bool KGame::save | ( | QString | filename, | |
bool | saveplayers = true | |||
) | [virtual] |
bool KGame::reset | ( | ) | [virtual] |
int KGame::gameStatus | ( | ) | const |
void KGame::setGameStatus | ( | int | status | ) |
bool KGame::addProperty | ( | KGamePropertyBase * | data | ) |
bool KGame::sendPlayerProperty | ( | int | msgid, | |
QDataStream & | s, | |||
Q_UINT32 | playerId | |||
) |
This is called by KPlayer::sendProperty only! Internal function!
KGamePropertyBase * KGame::findProperty | ( | int | id | ) | const |
void KGame::setPolicy | ( | GamePolicy | p, | |
bool | recursive = true | |||
) |
KGame::GamePolicy KGame::policy | ( | ) | const |
bool KGame::sendGroupMessage | ( | const QByteArray & | msg, | |
int | msgid, | |||
Q_UINT32 | sender, | |||
const QString & | group | |||
) |
See KGameNetwork::sendMessage.
Send a network message msg with a given message ID msgid to all players of a given group (see KPlayer::group)
- Parameters:
-
msg the message which will be send. See messages.txt for contents msgid an id for this message sender the id of the sender group the group of the receivers
- Returns:
- true if worked
void KGame::networkTransmission | ( | QDataStream & | stream, | |
int | msgid, | |||
Q_UINT32 | receiver, | |||
Q_UINT32 | sender, | |||
Q_UINT32 | clientID | |||
) | [virtual] |
This will either forward an incoming message to a specified player (see KPlayer::networkTransmission) or handle the message directly (e.g.
if msgif==IdRemovePlayer it will remove the (in the stream) specified player). If both is not possible (i.e. the message is user specified data) the signal signalNetworkData is emitted.
This emits signalMessageUpdate before doing anything with the message. You can use this signal when you want to be notified about an update/change.
- Parameters:
-
msgid Specifies the kind of the message. See messages.txt for further information stream The message that is being sent receiver The is of the player this message is for. 0 For broadcast. sender clientID the client from which we received the transmission - hardly used
Implements KGameNetwork.
KGamePropertyHandler * KGame::dataHandler | ( | ) | const |
void KGame::sendProperty | ( | int | msgid, | |
QDataStream & | stream, | |||
bool * | sent | |||
) | [protected, slot] |
void KGame::emitSignal | ( | KGamePropertyBase * | me | ) | [protected, slot] |
void KGame::prepareNext | ( | ) | [protected, virtual, slot] |
void KGame::slotClientConnected | ( | Q_UINT32 | clientId | ) | [protected, slot] |
void KGame::slotClientDisconnected | ( | Q_UINT32 | clientId, | |
bool | broken | |||
) | [protected, slot] |
This slot is called whenever the connection to a client is lost (ie the signal KGameNetwork::signalClientDisconnected is emitted) and will remove the players from that client.
- Parameters:
-
clientId The client the connection has been lost to broken (ignore this - not used)
void KGame::slotServerDisconnected | ( | ) | [protected, slot] |
This slot is called whenever the connection to the server is lost (ie the signal KGameNetwork::signalConnectionBroken is emitted) and will switch to local game mode.
void KGame::signalReplacePlayerIO | ( | KPlayer * | player, | |
bool * | remove | |||
) | [signal] |
When a client disconnects from the game usually all players from that client are removed.
But if you use completely the KGame structure you probably don't want this. You just want to replace the KGameIO of the (human) player by a computer KGameIO. So this player continues game but is from this point on controlled by the computer.
You achieve this by connecting to this signal. It is emitted as soon as a client disconnects on all other clients. Make sure to add a new KGameIO only once! you might want to use isAdmin for this. If you added a new KGameIO set *remove=false otherwise the player is completely removed.
- Parameters:
-
player The player that is about to be removed. Add your new KGameIO here - but only on one client! remove Set this to FALSE if you don't want this player to be removed completely.
void KGame::signalLoadPrePlayers | ( | QDataStream & | stream | ) | [signal] |
The game will be loaded from the given stream.
Load from here the data which is NOT a game or player property. It is not necessary to use this signal for a full property game.
This signal is emitted before the players are loaded by KGame. See also signalLoad
You must load exactly the same data from the stream that you have saved in signalSavePrePlayers. Otherwise player loading will not work anymore.
- Parameters:
-
stream the load stream
void KGame::signalLoad | ( | QDataStream & | stream | ) | [signal] |
The game will be loaded from the given stream.
Load from here the data which is NOT a game or player property. It is not necessary to use this signal for a full property game.
- Parameters:
-
stream the load stream
void KGame::signalSavePrePlayers | ( | QDataStream & | stream | ) | [signal] |
The game will be saved to the given stream.
Fill this with data which is NOT a game or player property. It is not necessary to use this signal for a full property game.
This signal is emitted before the players are saved by KGame. See also signalSave
If you can choose between signalSavePrePlayers and signalSave then better use signalSave
- Parameters:
-
stream the save stream
void KGame::signalSave | ( | QDataStream & | stream | ) | [signal] |
The game will be saved to the given stream.
Fill this with data which is NOT a game or player property. It is not necessary to use this signal for a full property game.
- Parameters:
-
stream the save stream
void KGame::signalLoadError | ( | QDataStream & | stream, | |
bool | network, | |||
int | cookie, | |||
bool & | result | |||
) | [signal] |
Is emmited if a game with a different version cookie is loaded.
Normally this should result in an error. But maybe you do support loading of older game versions. Here would be a good place to do a conversion.
- Parameters:
-
stream - the load stream network - true if this is a network connect. False for load game cookie - the saved cookie. It differs from KGame::cookie() result - set this to true if you managed to load the game
void KGame::signalNetworkData | ( | int | msgid, | |
const QByteArray & | buffer, | |||
Q_UINT32 | receiver, | |||
Q_UINT32 | sender | |||
) | [signal] |
void KGame::signalMessageUpdate | ( | int | msgid, | |
Q_UINT32 | receiver, | |||
Q_UINT32 | sender | |||
) | [signal] |
We got an network message.
this can be used to notify us that something changed. What changed can be seen in the message id. Whether this is the best possible method to do this is unclear...
void KGame::signalPlayerLeftGame | ( | KPlayer * | player | ) | [signal] |
a player left the game because of a broken connection or so!
Note that when this signal is emitted the player is not part of playerList anymore but the pointer is still valid. You should do some final cleanups here since the player is usually deleted after the signal is emitted.
- Parameters:
-
player the player who left the game
void KGame::signalPlayerJoinedGame | ( | KPlayer * | player | ) | [signal] |
a player joined the game
- Parameters:
-
player the player who joined the game
void KGame::signalPropertyChanged | ( | KGamePropertyBase * | property, | |
KGame * | me | |||
) | [signal] |
This signal is emmited if a player property changes its value and the property is set to notify this change.
Is emitted after a call to gameOver() returns a non zero return code.
This code is forwarded to this signal as 'status'.
- Parameters:
-
status the return code of gameOver() current the player who did the last move me a pointer to the KGame object
void KGame::signalClientJoinedGame | ( | Q_UINT32 | clientid, | |
KGame * | me | |||
) | [signal] |
Is emmited after a client is successfully connected to the game.
The client id is the id of the new game client. An easy way to check whether that's us is
if (clientid==gameid()) .. // we joined else ... // someone joined the game
- Parameters:
-
clientid - The id of the new client me - our game pointer
void KGame::signalClientLeftGame | ( | int | clientID, | |
int | oldgamestatus, | |||
KGame * | me | |||
) | [signal] |
This signal is emitted after a network partner left the game (either by a broken connection or voluntarily).
All changes to the network players have already be done. If there are not enough players left, the game might have been paused. To check this you get the old gamestatus before the disconnection as argument here. The id of the client who left the game allows to distinguish who left the game. If it is 0, the server disconnected and you were a client which has been switched back to local play. You can use this signal to, e.g. set some menues back to local player when they were network before.
- Parameters:
-
clientID - 0:server left, otherwise the client who left oldgamestatus - the gamestatus before the loss me - our game pointer
virtual bool KGame::playerInput | ( | QDataStream & | msg, | |
KPlayer * | player | |||
) | [protected, pure virtual] |
A player input occurred.
This is the most important function as the given message will contain the current move made by the given player. Note that you HAVE to overwrite this function. Otherwise your game makes no sense at all. Generally you have to return TRUE in this function. Only then the game sequence is proceeded by calling playerInputFinished which in turn will check for game over or the next player However, if you have a delayed move, because you e.g. move a card or a piece you want to return FALSE to pause the game sequence and then manually call playerInputFinished to resume it. Example:
bool MyClass::playerInput(QDataStream &msg,KPlayer *player) { Q_INT32 move; msg >> move; kdDebug() << " Player " << player->id() << " moved to " << move << endl; return true; }
- Parameters:
-
msg the move message player the player who did the move
- Returns:
- true - input ready, false: input manual
Called after the player input is processed by the game.
Here the checks for game over and nextPlayer (in the case of turn base games) are processed. Call this manually if you have a delayed move, i.e. your playerInput function returns FALSE. If it returns true you need not do anything here.
- Returns:
- the current player
virtual void KGame::newPlayersJoin | ( | KGamePlayerList * | oldplayer, | |
KGamePlayerList * | newplayer, | |||
QValueList< int > & | inactivate | |||
) | [inline, protected, virtual] |
This virtual function can be overwritten for your own player management.
It is called when a new game connects to an existing network game or to the network master. In case you do not want all players of both games to be present in the new network game, you can deactivate players here. This is of particular importance if you have a game with fixed number of player like e.g. chess. A network connect needs to disable one player of each game to make sense.
Not overwriting this function will activate a default behaviour which will deactivate players until the maxPlayers() numebr is reached according to the KPlayer::networkPriority() value. Players with a low value will be kicked out first. With equal priority players of the new client will leave first. This means, not setting this value and not overwriting this function will never allow a chess game to add client players!!! On the other hand setting one player of each game to a networkPriorty of say 10, already does most of the work for you.
The parameters of this function are the playerlist of the network game, which is playerList(). The second argument is the player list of the new client who wants to join and the third argument serves as return parameter. All player ID's which are written into this list will be removed from the created game. You do this by an
inactivate.append(player->id());
- Parameters:
-
oldplayer - the list of the network players newplayer - the list of the client players inactivate - the value list of ids to be deactivated
void KGame::savePlayers | ( | QDataStream & | stream, | |
KGamePlayerList * | list = 0 | |||
) | [protected] |
Save the player list to a stream.
Used for network game and load/save. Can be overwritten if you know what you are doing
- Parameters:
-
stream is the stream to save the player ot list the optional list is the player list to be saved, default is playerList()
void KGame::savePlayer | ( | QDataStream & | stream, | |
KPlayer * | player | |||
) | [protected] |
Prepare a player for being added.
Put all data about a player into the stream so that it can be sent to the KGameCommunicationServer using addPlayer (e.g.)
This function ensures that the code for adding a player is the same in addPlayer as well as in negotiateNetworkGame
- Parameters:
-
stream is the stream to add the player player The player to add
KPlayer * KGame::loadPlayer | ( | QDataStream & | stream, | |
bool | isvirtual = false | |||
) | [protected] |
bool KGame::systemInactivatePlayer | ( | KPlayer * | player | ) | [protected] |
bool KGame::systemActivatePlayer | ( | KPlayer * | player | ) | [protected] |
void KGame::systemAddPlayer | ( | KPlayer * | newplayer | ) | [protected] |
void KGame::systemRemovePlayer | ( | KPlayer * | player, | |
bool | deleteit | |||
) | [protected] |
void KGame::negotiateNetworkGame | ( | Q_UINT32 | clientID | ) | [protected, virtual] |
This member function will transmit e.g.
all players to that client, as well as all properties of these players (at least if they have been added by KPlayer::addProperty) so that the client will finally have the same status as the master. You want to overwrite this function if you expand KGame by any properties which have to be known by all clients.
Only the ADMIN is allowed to call this.
- Parameters:
-
clientID The ID of the message client which has connected
void KGame::syncRandom | ( | ) | [protected] |
int KGame::checkGameOver | ( | KPlayer * | player | ) | [protected, virtual] |
- Deprecated:
- Use KGameSequence instead.
- Parameters:
-
player the player who made the last move
- Returns:
- anything else but 0 is considered as game over
bool KGame::loadgame | ( | QDataStream & | stream, | |
bool | network, | |||
bool | reset | |||
) | [protected, virtual] |
Load a saved game, from file OR network.
Internal. Warning: loadgame must not rely that all players all already activated. Actually the network will activate a player AFTER the loadgame only. This is not true anymore. But be careful anyway.
- Parameters:
-
stream a data stream where you can stream the game from network is it a network call -> make players virtual reset shall the game be reset before loading
- Returns:
- true?
bool KGame::savegame | ( | QDataStream & | stream, | |
bool | network, | |||
bool | saveplayers | |||
) | [protected, virtual] |
Save a game, to file OR network.
Internal.
- Parameters:
-
stream a data stream where you can stream the game from network is it a call from the network or from a file (unused but informative) saveplayers shall the players be saved too (should be TRUE)
- Returns:
- true?
The documentation for this class was generated from the following files: