kgame.h

Go to the documentation of this file.

/*
    This file is part of the KDE games library
    Copyright (C) 2001 Martin Heni (kde at 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.
*/

#ifndef __KGAME_H_
#define __KGAME_H_

#include <QtCore/QDataStream>
#include <QtCore/QString>
#include <QtCore/QList>

#include "kgamenetwork.h"
#include "../libkdegamesprivate_export.h"
class KRandomSequence;

class KPlayer;
class KGamePropertyBase;
class KGamePropertyHandler;
class KGameSequence;

class KGamePrivate;

class KDEGAMESPRIVATE_EXPORT KGame : public KGameNetwork
{
  Q_OBJECT

public:
    typedef QList<KPlayer*> KGamePlayerList;

    enum GamePolicy
    {
        PolicyUndefined = 0,
        PolicyClean = 1,
        PolicyDirty = 2,
        PolicyLocal = 3
    };

    explicit KGame(int cookie=42,QObject* parent=0);

    virtual ~KGame();

    virtual void Debug();

    enum GameStatus
    {
        Init = 0,
        Run = 1,
        Pause = 2,
        End = 3,
        Abort = 4,
        SystemPause = 5,
        Intro = 6,
        UserStatus = 7
    };

    // Properties
    KGamePlayerList *playerList();

    const KGamePlayerList *playerList() const;

    KGamePlayerList *inactivePlayerList();

    const KGamePlayerList *inactivePlayerList() const;

    KRandomSequence *random() const;

    KGameSequence *gameSequence() const;

    bool isRunning() const;

    // Player handling
    KPlayer *findPlayer(quint32 id) const;

    void setGameSequence(KGameSequence* sequence);

    bool addPlayer(KPlayer* newplayer);

    //AB: TODO: make sendMessage to return if the message will be able to be
    //sent, eg if a socket is connected, etc. If sendMessage returns false
    //remove the player directly using systemRemovePlayer
    bool removePlayer(KPlayer * player) { return removePlayer(player, 0); }

    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);

    // Input events
    virtual bool sendPlayerInput(QDataStream &msg,KPlayer *player,quint32 sender=0);

    virtual bool systemPlayerInput(QDataStream &msg,KPlayer *player,quint32 sender=0);

    virtual KPlayer *createPlayer(int rtti,int io,bool isvirtual);

    // load/save
    virtual bool load(QDataStream &stream,bool reset=true);

    virtual bool load(const QString& filename,bool reset=true);

    virtual bool save(QDataStream &stream,bool saveplayers=true);

    virtual bool save(const QString& filename,bool saveplayers=true);

    virtual bool reset();


    // Game sequence
    int gameStatus() const;

    void setGameStatus(int status);

    bool addProperty(KGamePropertyBase* data);

    bool sendPlayerProperty(int msgid, QDataStream& s, quint32 playerId);

    KGamePropertyBase* findProperty(int id) const;

    void setPolicy(GamePolicy p,bool recursive=true);

    GamePolicy policy() const;

    bool sendGroupMessage(const QByteArray& msg, int msgid, quint32 sender, const QString& group);
    bool sendGroupMessage(const QDataStream &msg, int msgid, quint32 sender, const QString& group);
    bool sendGroupMessage(int msg, int msgid, quint32 sender, const QString& group);
    bool sendGroupMessage(const QString& msg, int msgid, quint32 sender, const QString& group);

    virtual void networkTransmission(QDataStream &stream, int msgid, quint32 receiver, quint32 sender, quint32 clientID);

    KGamePropertyHandler* dataHandler() const;

protected Q_SLOTS:
    void sendProperty(int msgid, QDataStream& stream, bool* sent);

    void emitSignal(KGamePropertyBase *me);

    virtual void prepareNext();


    void slotClientConnected(quint32 clientId);

    void slotClientDisconnected(quint32 clientId,bool broken);

    void slotServerDisconnected();

Q_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, quint32 receiver, quint32 sender);

    void signalMessageUpdate(int msgid,quint32 receiver,quint32 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(quint32 clientid,KGame *me);

    void signalClientLeftGame(int clientID,int oldgamestatus,KGame *me);


protected:
    virtual bool playerInput(QDataStream &msg,KPlayer *player)=0;


    KPlayer *playerInputFinished(KPlayer *player);


    virtual void newPlayersJoin(KGamePlayerList *oldplayer,
                KGamePlayerList *newplayer,
                QList<int> &inactivate) {
        Q_UNUSED( oldplayer );
        Q_UNUSED( newplayer );
        Q_UNUSED( 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);

    bool systemAddPlayer(KPlayer* newplayer);

    void systemRemovePlayer(KPlayer* player,bool deleteit);

    virtual void negotiateNetworkGame(quint32 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);

private:
    //AB: this is to hide the "receiver" parameter from the user. It shouldn't be
    //used if possible (except for init).
    //void addPlayer(KPlayer* newplayer, quint32 receiver);

    bool removePlayer(KPlayer * player, quint32 receiver);

    void setupGame(quint32 sender);

    void setupGameContinue(QDataStream& msg, quint32 sender);

    bool systemRemove(KPlayer* player,bool deleteit);


private:
    KGamePrivate* const d;
};

#endif