kreversi/kreversiscene.h

   1 /*******************************************************************
   2  *
   3  * Copyright 2006 Dmitry Suzdalev <dimsuz@gmail.com>
   4  *
   5  * This file is part of the KDE project "KReversi"
   6  *
   7  * KReversi is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2, or (at your option)
  10  * any later version.
  11  *
  12  * KReversi is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with KReversi; see the file COPYING.  If not, write to
  19  * the Free Software Foundation, 51 Franklin Street, Fifth Floor,
  20  * Boston, MA 02110-1301, USA.
  21  *
  22  ********************************************************************/
  23 #ifndef KREVERSI_SCENE_H
  24 #define KREVERSI_SCENE_H
  25
  26 #include <QGraphicsScene>
  27 #include <QPixmap>
  28
  29 #include "commondefs.h"
  30
  31 class KReversiGame;
  32 class KReversiChipFrameSet;
  33 class KReversiChip;
  34 class KGamePopupItem;
  35 class QPainter;
  36 class QTimer;
  37
  38 /**
  39  *  This class provides graphical representation of KReversiGame
  40  *  using QGraphicsScene for graphics display.
  41  *  It displays the reversi board in its current state,
  42  *  receives a mouse events, translates them so KReversiGame can understand,
  43  *  sends them to it,
  44  *  receives board-changed notifications, nicely animates them.
  45  *  It also drives the gameflow, i.e. it tells KReversiGame when to make
  46  *  the next move.
  47  */
  48 class KReversiScene : public QGraphicsScene
  49 {
  50     Q_OBJECT
  51 public:
  52     /**
  53      * @param chipsPath path to the svg pixmap with animation frames
  54      */
  55     KReversiScene( KReversiGame* game, const QString& chipsPath );
  56     ~KReversiScene();
  57
  58     /**
  59      *  Sets the game object which this scene will visualize/use.
  60      *  KReversiScene takes ownership of this object and will delete it when appropriate
  61      */
  62     void setGame( KReversiGame* game );
  63     /**
  64      *  Sets the chips pixmap to be one found in chipsPrefix
  65      *  @see KReversiChipFrameSet
  66      */
  67     void setChipsPrefix( const QString& chipsPrefix );
  68     /**
  69      *  Sets whether to show board labels.
  70      *  You'll need to call
  71      *  QGraphicsView::resetCachedContent();
  72      *  QGraphicsView::update()
  73      *  for this to take effect
  74      */
  75     void setShowBoardLabels( bool show );
  76     /**
  77      *  Performs scene resize - rescales all corresponding svg's,
  78      *  recalcs playfield rect etc etc
  79      */
  80     void resizeScene( int width, int height );
  81     /**
  82      *  This function will tell you if the scene is currently performing
  83      *  some kind of "better-don't-interrupt-me" operation.
  84      *
  85      *  For example this call is used in KReversiMainWindow to decide
  86      *  whether it is feasible to perform undo action (which makes a little sence
  87      *  during, for example animation of computer move)
  88      */
  89     bool isBusy() const;
  90     /**
  91      *  @return whether the scene is in demo-mode
  92      */
  93     bool isDemoModeToggled() const { return m_demoMode; }
  94     /**
  95      *  Sets the animation speed (0 - slow, 1 - normal, 2 - fast)
  96      */
  97     void setAnimationSpeed(int speed);
  98 public slots:
  99     /**
 100      *  Synchronizes graphical board with m_game's board
 101      */
 102     void updateBoard();
 103     /**
 104      *  This will make scene visually mark the last made move
 105      */
 106     void setShowLastMove( bool show );
 107     /**
 108      *  This will make scene visually mark squares with possible moves
 109      */
 110     void setShowLegalMoves( bool show );
 111     /**
 112      *  Shows hint for player
 113      */
 114     void slotHint();
 115     /**
 116      *  Sets Demo Mode.
 117      *  In this mode KReversiScene would not wait for user
 118      *  clicks to produce his turn. It will let computer
 119      *  play for user
 120      *  @see m_demoMode
 121      */
 122     void toggleDemoMode(bool toggle);
 123     /**
 124      *  @return whether game is in demo mode
 125      */
 126     bool isInDemoMode() const { return m_demoMode; }
 127 private slots:
 128     void slotGameMoveFinished();
 129     void slotAnimationStep();
 130     void slotGameOver();
 131     void slotComputerCantMove();
 132     void slotPlayerCantMove();
 133 signals:
 134     /**
 135      *  emitted when Scene finishes displaying last move
 136      */
 137     void moveFinished();
 138 private:
 139     /**
 140      *  Draws a background with 8x8 cell matrix.
 141      *  Reimplemented from QGraphicsScene.
 142      */
 143     virtual void drawBackground( QPainter *p, const QRectF& rect );
 144     /**
 145      *  Mouse presses event handler
 146      */
 147     virtual void mousePressEvent( QGraphicsSceneMouseEvent* );
 148     /**
 149      *  Makes pending new game object a current one.
 150      *  @see m_pendingNewGame @see setGame
 151      */
 152     void setNewGameObject( KReversiGame* game );
 153     /**
 154      *  Visually displays last move and possible moves
 155      *  (if the scene is set up to show them)
 156      */
 157     void displayLastAndPossibleMoves();
 158     /**
 159      *  If scene is showing hint animation this function will stop it
 160      */
 161     void stopHintAnimation();
 162     /**
 163      *  Returns the center point of cell (row,col)
 164      */
 165     QPointF cellCenter( int row, int col ) const;
 166     /**
 167      *  Returns the top-left point of cell (row,col)
 168      */
 169     QPointF cellTopLeft( int row, int col ) const;
 170     /**
 171      * Position of the board within the scene
 172      */
 173     QRectF m_boardRect;
 174     /**
 175      *  The Game object
 176      */
 177     KReversiGame *m_game;
 178     /**
 179      *  This pointer is meant for temporal storage of new game object being set.
 180      *  New game object is *actually* set after animation slot gets called by timer
 181      */
 182     KReversiGame *m_pendingNewGame;
 183     /**
 184      *  This will hold pixmap which is rendered by m_possMovesRenderer.
 185      *  It will be rerendered on resizes
 186      */
 187     QPixmap m_possMovePix;
 188     /**
 189      *  Animation frameset for chips
 190      */
 191     KReversiChipFrameSet *m_frameSet;
 192     /**
 193      *  Current size of chip
 194      */
 195     qreal m_curCellSize;
 196     /**
 197      *  This list will hold a changed chips
 198      *  after each turn. It is received from the game object.
 199      *  Used to animate corresponding chips.
 200      */
 201     PosList m_changedChips;
 202     /**
 203      *  Animation timer
 204      */
 205     QTimer* m_animTimer;
 206     /**
 207      *  This is our "hint-chip" - used to show hints
 208      */
 209     KReversiChip* m_hintChip;
 210     /**
 211      *  This will hold a pointer to chip which has "last-move" mark
 212      */
 213     KReversiChip* m_lastMoveChip;
 214     /**
 215      *  Delay between animation frames
 216      */
 217     int m_timerDelay;
 218     /**
 219      *  Holds true if the scene is showing hint to the player
 220      */
 221     bool m_showingHint;
 222     /**
 223      *  Specifies whether computer should play human moves
 224      */
 225     bool m_demoMode;
 226     /**
 227      *  If true, then last made turn will be shown to the player
 228      */
 229     bool m_showLastMove;
 230     /**
 231      *  If true, then all possible moves will be shown to the player
 232      */
 233     bool m_showPossibleMoves;
 234     /**
 235      *  If true board labels will be rendered
 236      */
 237     bool m_showLabels;
 238     /**
 239      *  List of items which are used to show possible moves.
 240      *  This list behaves like this:
 241      *  it is created only once and grows only as needed.
 242      *  If number of items in it is sufficient to display all possible moves,
 243      *  than these items are reused, if not then it grows with new items until
 244      *  there are enough of them.
 245      *  Example: at start of the game there are 4 items (4 possible move to highlight)
 246      *  if after the next turn there will be 6 possible moves, this list
 247      *  will be grown by 2 rect items and previous 4 will be reused (their position
 248      *  can change though).
 249      *
 250      *  (isn't that too much words for this little thingie? ;) )
 251      */
 252     QList<QGraphicsPixmapItem*> m_possibleMovesItems;
 253     /**
 254      * Item to show messages to user
 255      */
 256     KGamePopupItem* m_messageItem;
 257 };
 258 #endif