kgameio.h

/*
    This file is part of the KDE games library
    Copyright (C) 2001 Martin Heni (kde at heni-online.de)
    Copyright (C) 2001 Andreas Beckermann ([email protected])

    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 __KGAMEIO_H__
#define __KGAMEIO_H__

#include <QString>
#include <QObject>

#include "libkdegamesprivate_export.h"

class QEvent;
class QGraphicsScene;
class QKeyEvent;
class QMouseEvent;
class KPlayer;
class KGame;
class KGameIOPrivate;
class KGameKeyIOPrivate;
class KGameMouseIOPrivate;
class KGameProcessIOPrivate;
class KGameComputerIOPrivate;

class KDEGAMESPRIVATE_EXPORT KGameIO : public QObject
{
  Q_OBJECT

public:
   KGameIO();
   explicit KGameIO(KPlayer*);
   virtual ~KGameIO();

   void Debug();

   enum IOMode {GenericIO=1,KeyIO=2,MouseIO=4,ProcessIO=8,ComputerIO=16};
   virtual int rtti() const = 0;  // Computer, network, local, ...

   KPlayer *player() const;

   KGame* game() const;

   void setPlayer(KPlayer *p);

   virtual void initIO(KPlayer *p);

    virtual void notifyTurn(bool b);

    bool sendInput(QDataStream& stream, bool transmit = true, quint32 sender = 0);

Q_SIGNALS:
    void signalPrepareTurn(QDataStream & stream, bool turn, KGameIO *io, bool * send);


private:
    friend class KGameIOPrivate;
    KGameIOPrivate *const d;

    Q_DISABLE_COPY(KGameIO)
};

class KDEGAMESPRIVATE_EXPORT KGameKeyIO : public KGameIO
{
  Q_OBJECT

public:
    explicit KGameKeyIO(QWidget *parent);
    virtual ~KGameKeyIO();

    int rtti() const override;

Q_SIGNALS:
      void signalKeyEvent(KGameIO *io,QDataStream &stream,QKeyEvent *m,bool *eatevent);

protected:
       bool eventFilter( QObject *o, QEvent *e ) override;

private:
    friend class KGameKeyIOPrivate;
    KGameKeyIOPrivate *const d;

    Q_DISABLE_COPY(KGameKeyIO)
};

class KDEGAMESPRIVATE_EXPORT KGameMouseIO : public KGameIO
{
  Q_OBJECT

public:
    explicit KGameMouseIO(QWidget *parent,bool trackmouse=false);
    explicit KGameMouseIO(QGraphicsScene *parent,bool trackmouse=false);
    virtual ~KGameMouseIO();

    void setMouseTracking(bool b);
    int rtti() const override;

Q_SIGNALS:
      void signalMouseEvent(KGameIO *io,QDataStream &stream,QMouseEvent *m,bool *eatevent);

protected:
      bool eventFilter( QObject *o, QEvent *e ) override;

private:
    friend class KGameMouseIOPrivate;
    KGameMouseIOPrivate *const d;

    Q_DISABLE_COPY(KGameMouseIO)
};


class KDEGAMESPRIVATE_EXPORT KGameProcessIO : public KGameIO
{
  Q_OBJECT

public:
    explicit KGameProcessIO(const QString& name);

    virtual ~KGameProcessIO();

    int rtti() const override;

    void sendMessage(QDataStream &stream,int msgid, quint32 receiver, quint32 sender);

    void sendSystemMessage(QDataStream &stream, int msgid, quint32 receiver, quint32 sender);

    void initIO(KPlayer *p) override;

    void notifyTurn(bool turn) override;

  protected:
    void sendAllMessages(QDataStream &stream,int msgid, quint32 receiver, quint32 sender, bool usermsg);

  protected Q_SLOTS:
    void receivedMessage(const QByteArray& receiveBuffer);


Q_SIGNALS:
  void signalProcessQuery(QDataStream &stream,KGameProcessIO *me);

  void signalIOAdded(KGameIO *game,QDataStream &stream,KPlayer *p,bool *send);

  void signalReceivedStderr(const QString &msg);

private:
    friend class KGameProcessIOPrivate;
    KGameProcessIOPrivate *const d;

    Q_DISABLE_COPY(KGameProcessIO)
};

class KDEGAMESPRIVATE_EXPORT KGameComputerIO : public KGameIO
{
  Q_OBJECT

public:
    KGameComputerIO();
    explicit KGameComputerIO(KPlayer* player);
    ~KGameComputerIO();

    int rtti() const override;

    void setReactionPeriod(int advanceCalls);
    int reactionPeriod() const;

    void setAdvancePeriod(int ms);

    void stopAdvancePeriod();

    void pause(int calls = -1);

    void unpause();

public Q_SLOTS:
    virtual void advance();

Q_SIGNALS:
    void signalReaction();

protected:
    virtual void reaction();

private:
    friend class KGameComputerIOPrivate;
    KGameComputerIOPrivate *const d;

    Q_DISABLE_COPY(KGameComputerIO)
};


#endif