src/graphicalsystem.h

   1 /*
   2   Copyright (c) 2006 Paolo Capriotti <p.capriotti@gmail.com>
   3             (c) 2006 Maurizio Monge <maurizio.monge@kdemail.net>
   4
   5   This program is free software; you can redistribute it and/or modify
   6   it under the terms of the GNU General Public License as published by
   7   the Free Software Foundation; either version 2 of the License, or
   8   (at your option) any later version.
   9 */
  10
  11 #ifndef GRAPHICALSYSTEM_H
  12 #define GRAPHICALSYSTEM_H
  13
  14 #include <boost/shared_ptr.hpp>
  15 #include <QObject>
  16 #include <core/taguaapi.h>
  17 #include <core/piece.h>
  18 #include <core/state_fwd.h>
  19 #include <core/namedsprite.h>
  20
  21 class ChessBoard;
  22 class ChessTable;
  23 class Components;
  24 class IAnimator;
  25 class INamer;
  26 class IState;
  27 class Move;
  28 class IndexConverter;
  29 class PointConverter;
  30 class UserEntity;
  31
  32 class GraphicalSystem : public QObject,
  33                         private TaguaAPI {
  34 Q_OBJECT
  35
  36 public:
  37
  38   /** The current chess table */
  39   ChessTable* m_view;
  40
  41   /** The current board */
  42   // FIXME: why is this needed? couldn't it be extracted from the view dynamically?
  43   ChessBoard* m_board;
  44
  45   /** The current state */
  46   StatePtr m_state;
  47
  48   /** The variant specific animator */
  49   IAnimator* m_animator;
  50
  51   Components* m_components;
  52
  53   /** @a GraphicalPosition interface function implementation */
  54 //   virtual void addTag(const QString& name, Point, bool over = false);
  55
  56   /** @a GraphicalPosition interface function implementation */
  57 //   virtual void clearTags(const QString& name);
  58
  59   /** @a GraphicalPosition interface function implementation */
  60 //   virtual void setTags(const QString& name, Point p1 = Point::invalid(), Point p2 = Point::invalid(),
  61 //                                       Point p3 = Point::invalid(), Point p4 = Point::invalid(),
  62 //                                       Point p5 = Point::invalid(), Point p6 = Point::invalid() );
  63
  64 public Q_SLOTS:
  65   /** internal function to listen at setting changes */
  66   void settingsChanged();
  67
  68 private:
  69   /**
  70     * @return the board point converter. (interface for TaguaAPI)
  71     */
  72   virtual const PointConverter* converter() const;
  73
  74   /**
  75     * @return the index converter of the specified pool.
  76     */
  77   virtual const IndexConverter* indexConverter(int pool) const;
  78
  79   /**
  80     * @return the current abstract position. (interface for TaguaAPI)
  81     */
  82   virtual const IState* state() const;
  83
  84   /**
  85     * @return a sprite at the position @a index in the graphical pool. (interface for TaguaAPI)
  86     */
  87   virtual NamedSprite getSprite(const Point& p);
  88
  89   /**
  90     * Removes a sprite at the position @a index in the graphical pool. (interface for TaguaAPI)
  91     * @return the newly created sprite.
  92     */
  93   virtual NamedSprite takeSprite(const Point& p);
  94
  95   /**
  96     * Sets the piece at the position @a index in the graphical pool. (interface for TaguaAPI)
  97     * @return the newly created sprite.
  98     */
  99   virtual NamedSprite setPiece(const Point& p, const Piece& piece, bool show);
 100
 101   /**
 102     *  Create a new piece, but do not add it to the graphical system.
 103     * @return the newly created sprite.
 104     */
 105   virtual NamedSprite createPiece(const Point& p, const Piece& piece, bool show);
 106
 107   /**
 108     * Sets the sprite at the position @a index in the graphical pool. (interface for TaguaAPI)
 109     * @return the newly created sprite.
 110     */
 111   virtual void setSprite(const Point& p, const NamedSprite& sprite);
 112
 113   /**
 114     * @return how many sprites are contained in the pool
 115     */
 116   virtual int poolSize(int pool);
 117
 118   /**
 119     * @return the sprite at the position @a index in the graphical pool. (interface for TaguaAPI)
 120     */
 121   virtual NamedSprite getPoolSprite(const IColor* pool, int index);
 122
 123   /**
 124     * Removes the sprite at the position @a index in the graphical pool. (interface for TaguaAPI)
 125     */
 126   virtual void removePoolSprite(const IColor* pool, int index);
 127
 128   /**
 129     * Removes the sprite at the position @a index in the graphical pool (only for drops).
 130     * (interface for TaguaAPI)
 131     * @return the removed sprite.
 132     */
 133   virtual NamedSprite takePoolSprite(const IColor* pool, int index);
 134
 135   /**
 136     * Inserts a sprite at the position @a index in the graphical pool. (interface for TaguaAPI)
 137     * @return the newly created sprite.
 138     */
 139   virtual NamedSprite insertPoolPiece(const IColor* pool,
 140                                       int index,
 141                                       const Piece& piece);
 142
 143   /**
 144     * @return the piece of the pool that has been dropped, or (-1,-1). (interface for TaguaAPI)
 145     */
 146   virtual std::pair<const IColor*, int> droppedPoolPiece();
 147
 148 public:
 149   /** Constructor */
 150   GraphicalSystem(ChessTable* view, const StatePtr& startingPosition, Components* components);
 151   virtual ~GraphicalSystem();
 152
 153   /** Sets the reference entity */
 154   void setup(const boost::shared_ptr<UserEntity>& entity);
 155
 156   /** Goes forward playing a move, that has to be legal and checked */
 157   void forward(const Move& move,
 158                const StatePtr& pos,
 159                const SpritePtr& = SpritePtr());
 160
 161   /** Goes back undoing a move, that has to be legal and checked */
 162   void back(const Move& lastMove,
 163             const Move& move,
 164             const StatePtr& pos);
 165
 166   /** Warps to a new position */
 167   void warp(const Move& lastMove,
 168             const StatePtr& pos);
 169
 170   /** Adjusts a sprite to the correct position */
 171   void adjustSprite(const Point& p);
 172
 173   /** Sets the current turn */
 174   void setTurn(const IColor* turn);
 175
 176
 177
 178   // TAGUA API
 179   Components* components() const;
 180
 181   virtual AnimationPtr group(const QString& flags) const;
 182   virtual AnimationPtr appear(const NamedSprite& sprite,
 183                               const QString& flags) const;
 184   virtual AnimationPtr disappear(const NamedSprite& sprite,
 185                                  const QString& flags) const;
 186   virtual AnimationPtr move(const NamedSprite& sprite,
 187                             const Point& destination,
 188                             const QString& flags) const;
 189   virtual AnimationPtr move(const NamedSprite& sprite,
 190                             int pool,
 191                             int destination,
 192                             const QString& flags) const;
 193   virtual AnimationPtr morph(const NamedSprite& sprite1,
 194                              const NamedSprite& sprite2,
 195                              const QString& flags) const;
 196 };
 197
 198
 199 #endif //GRAPHICALSYSTEM_H