src/tagua.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 LOWLEVEL_H
  12 #define LOWLEVEL_H
  13
  14 #include <map>
  15 #include <boost/shared_ptr.hpp>
  16 #include <QString>
  17 #include <QStringList>
  18 #include "point.h"
  19 #include "usermove.h"
  20 #include "index.h"
  21 #include "option.h"
  22 #include "decoratedmove.h"
  23 #include "interactiontype.h"
  24 #include "turnpolicy.h"
  25 #include "fwd.h"
  26
  27 class GraphicalAPI;
  28 class ICSAPI;
  29 class ActionCollection;
  30
  31 /**
  32   * @file tagua.h
  33   * @brief Low level abstract classes used by the interface framework.
  34   *
  35   * This file includes definitions for abstract classes used from within
  36   * the interface framework to access variant details using dynamic time
  37   * polymorphism.
  38   *
  39   * One of the big problems with this approach is what I call 'lack of
  40   * functional dependency support' for runtime polymorphism.
  41   * What is missing is the ability to override a virtual member function
  42   * in a derived class changing its signature. Or better, it is possible
  43   * to only change its return type with a covariant type, while it would
  44   * often be useful to change any of its argument types with covariant or
  45   * even controvariant types.
  46   * For controvariant types, I foresee no problems, and all type checking
  47   * can be done statically (of course the method has to be dynamically
  48   * bound) as they are now.
  49   * When using covariant types, the compiler could insert appropriate
  50   * dynamic cast's and type checks in the calling code, when there's no
  51   * way to know the exact type of an argument at compile time.
  52   *
  53   * The file @ref tagua_wrapped.h tries to address this problem doing part
  54   * of the compiler's work. One exception is that type checking code
  55   * is inserted in a method wrapper, instead of the calling place, so
  56   * even calling a method of a noncasted instance would cause some
  57   * upcast / downcast overhead; this is negligible, though, because
  58   * that scenario is rather unlikely, since wrapped classes are always
  59   * kept in variables of abstract types.
  60   */
  61
  62
  63 /**
  64   * @brief A superclass for all the piece classes.
  65   */
  66 class AbstractPiece {
  67 public:
  68   typedef boost::shared_ptr<AbstractPiece> Ptr;
  69   virtual ~AbstractPiece() { }
  70
  71   /**
  72     * Piece equality. Return false if the second pointer
  73     * is null.
  74     */
  75   virtual bool equals(const PiecePtr& other) const = 0;
  76
  77   /**
  78     * Return a unique key for the piece.
  79     * Used to store pixmaps.
  80     */
  81   virtual QString name() const = 0;
  82
  83   /**
  84     * Create a deep copy of the piece.
  85     */
  86   virtual PiecePtr clone() const = 0;
  87 };
  88
  89
  90 /**
  91   * @brief A superclass for all the move classes.
  92   *
  93   * An abstract move is simply something that can serialize
  94   * itself either as SAN notation, or as coordinate notation.
  95   */
  96 class AbstractMove {
  97 public:
  98   typedef boost::shared_ptr<AbstractMove> Ptr;
  99   virtual ~AbstractMove() { }
 100
 101   /**
 102     * Return a compact SAN representation for the move.
 103     */
 104   virtual QString SAN(const PositionPtr& ref) const = 0;
 105
 106   /**
 107     * Return a decorated representation for the move.
 108     */
 109   virtual DecoratedMove toDecoratedMove(const PositionPtr& ref) const = 0;
 110
 111   /**
 112     * Return the move in coordinate notation.
 113     */
 114   virtual QString toString(const PositionPtr& ref) const = 0;
 115
 116   /**
 117     * Convert the move to a normal user move. Used to
 118     * perform move highlighting.
 119     */
 120   virtual NormalUserMove toUserMove() const = 0;
 121
 122   /**
 123     * Checks if the two moves are equal.
 124     */
 125   virtual bool equals(const MovePtr& other) const = 0;
 126
 127 };
 128
 129 /**
 130   * @brief Superclass for pools
 131   *
 132   * A general interface for pools.
 133   */
 134 class AbstractPool {
 135 public:
 136   typedef boost::shared_ptr<AbstractPool> Ptr;
 137   virtual ~AbstractPool() {}
 138
 139   /**
 140     * \return the number of items in the pool
 141     */
 142   virtual int size() = 0;
 143
 144   /**
 145     * Inserts a piece in the pool, preferably at the position \a pref_index.
 146     * But the pool can be unpredictable and the piece can be placed at an arbitrary position.
 147     * \return the position at which the item was placed.
 148     */
 149   virtual int insert(int pref_index, const PiecePtr& piece) = 0;
 150
 151   /**
 152     * Gets the piece at the position \a index in the pool.
 153     */
 154   virtual PiecePtr get(int index) = 0;
 155
 156   /**
 157     * Removes the piece at the position \a index in the pool.
 158     * \return the removed piece.
 159     */
 160   virtual PiecePtr take(int index) = 0;
 161 };
 162
 163
 164
 165 /**
 166   * @brief A superclass for all the position classes.
 167   *
 168   * A general interface for positions. It is used from within
 169   * the graphical framework to validate external input wrt
 170   * the played variant.
 171   */
 172 class AbstractPosition {
 173 public:
 174   typedef boost::shared_ptr<AbstractPosition> Ptr;
 175   typedef boost::shared_ptr<AbstractPool> PoolPtr;
 176   virtual ~AbstractPosition() { }
 177
 178   /**
 179     * Return board size in logical units. This could be
 180     * static if C++ permitted virtual static functions.
 181     */
 182   virtual Point size() const = 0;
 183
 184   /**
 185     * Returns the text to be used for the border surrounding this position in a board
 186     */
 187   virtual QStringList borderCoords() const = 0;
 188
 189   /**
 190     * Create the starting piece setup.
 191     */
 192   virtual void setup() = 0;
 193
 194   /**
 195     * Retrieve the piece on square @a p.
 196     * Return a null pointer if that square is empty.
 197     */
 198   virtual PiecePtr get(const Point& p) const = 0;
 199
 200   /**
 201     * Set a piece on the board.
 202     */
 203   virtual void set(const Point& p, const PiecePtr& piece) = 0;
 204
 205   /**
 206     * \return an interface to modify the pool of the board relative to \a player
 207     */
 208   virtual PoolPtr pool(int player) = 0;
 209
 210   /**
 211     * Set a position pool, copying it from a given position.
 212     */
 213   virtual void copyPoolFrom(const PositionPtr& pos) = 0;
 214
 215   /**
 216     * \return 1 if the piece can be moved, -1 if could be moved in the future (premove), or else 0.
 217     */
 218   virtual InteractionType movable(const TurnPolicy::Collection& test, const Point& p) const = 0;
 219
 220   /**
 221     * \return 1 if this pool can be dropped, -1 if could be dropped in the future (premove), or else 0.
 222     */
 223   virtual InteractionType droppable(const TurnPolicy::Collection& test, int) const = 0;
 224
 225   /**
 226     * \return an id corresponding to the player
 227     * who is in turn.
 228     */
 229   virtual int turn() const = 0;
 230
 231   /**
 232     * Sets the player on move
 233     */
 234   virtual void setTurn(int) = 0;
 235
 236   /**
 237     * \return the player that just moved
 238     */
 239   virtual int previousTurn() const = 0;
 240
 241   /**
 242     * Switch to the next player.
 243     */
 244   virtual void switchTurn() = 0;
 245
 246   /**
 247     * Check move legality. Set move fields as needed.
 248     * Return whether the move is legal.
 249     * This function should return immediately if \a m
 250     * has already been tested.
 251     */
 252   virtual bool testMove(const MovePtr& m) const = 0;
 253
 254   /**
 255     * Execute move \a m. Assume that \a m is legal and tested.
 256     */
 257   virtual void move(const MovePtr& m) = 0;
 258
 259   /**
 260     * Create a deep copy of the position.
 261     */
 262   virtual PositionPtr clone() const = 0;
 263
 264   /**
 265     * Make the position equal to the given one.
 266     */
 267   virtual void copyFrom(const PositionPtr&) = 0;
 268
 269   /**
 270     * Tests if two positions are equal.
 271     */
 272   virtual bool equals(const PositionPtr& p) const = 0;
 273
 274   /**
 275     * Return a move from an algebraic notation, or a null pointer.
 276     */
 277   virtual MovePtr getMove(const QString&) const = 0;
 278
 279   /**
 280     * Return a string representing the current state of the position.
 281     */
 282   virtual QString state() const = 0;
 283
 284   /**
 285     * Return a FEN representation for the position, assuming
 286     * @a halfmove as halfmove clock and @a fullmove as full move
 287     * number.
 288     */
 289   virtual QString fen(int halfmove, int fullmove) const = 0;
 290
 291   /**
 292     * A piece somehow representing or related to the move
 293     * which has to be drawn by the interface.
 294     * Examples:
 295     * * for one click moves, the piece that would
 296     *    appear on the square.
 297     * * for promotions in chesslike variants, the promoted
 298     *   piece.
 299     * @note Return a null pointer if the move has no valid
 300     *       piece hint defined.
 301     */
 302   virtual PiecePtr moveHint(const MovePtr&) const = 0;
 303
 304   /**
 305     * Variant introspection
 306     */
 307   virtual QString variant() const = 0;
 308
 309   /**
 310     * For debugging
 311     */
 312   virtual void dump() const = 0;
 313 };
 314
 315 class AnimationGroup;
 316
 317 /**
 318   * @brief An abstract superclass for all animator classes.
 319   *
 320   * An animator is a class which is given a difference between
 321   * a graphical and a logical position, and schedules an animation
 322   * which graphically does an update.
 323   * If the difference is due to a move, the animator tries to
 324   * create a smooth animation which could possibly work for many
 325   * chess-like variants, and then fills in the gaps with a direct
 326   * update.
 327   */
 328 class AbstractAnimator {
 329 public:
 330   typedef boost::shared_ptr<AbstractAnimator> Ptr;
 331   virtual ~AbstractAnimator() { }
 332
 333   /**
 334     * Sync the graphical position with the given position.
 335     */
 336   virtual AnimationPtr warp(const PositionPtr&) = 0;
 337
 338   /**
 339     * Animate forward syncing to the given position.
 340     */
 341   virtual AnimationPtr forward(const PositionPtr&, const MovePtr&) = 0;
 342
 343   /**
 344     * Animate back syncing to the given position.
 345     */
 346   virtual AnimationPtr back(const PositionPtr&, const MovePtr&) = 0;
 347 };
 348
 349
 350 class VariantInfo {
 351 public:
 352   virtual ~VariantInfo() { }
 353   virtual PositionPtr createPosition() = 0;
 354   virtual PositionPtr createCustomPosition(const OptList& l) = 0;
 355   virtual PositionPtr createPositionFromFEN(const QString& fen) = 0;
 356   virtual void forallPieces(class PieceFunction&) = 0;
 357   virtual int moveListLayout() const = 0;
 358   virtual AnimatorPtr createAnimator(GraphicalAPI* graphical_api) = 0;
 359   virtual MovePtr createNormalMove(const NormalUserMove&) = 0;
 360   virtual MovePtr createDropMove(const DropUserMove&) = 0;
 361   virtual MovePtr getVerboseMove(int turn, const class VerboseNotation&) const = 0;
 362
 363   /**
 364     * \return if moves are done by just clicking
 365     */
 366   virtual bool simpleMoves() = 0;
 367
 368   /**
 369     * \return the name of the variant
 370     */
 371   virtual QString name() const = 0;
 372
 373   /**
 374     * \return the name of the theme proxy variant, ie the variant whose theme can be used
 375     * for the current one (for instance crazyhouse can use chess themes).
 376     */
 377   virtual QString themeProxy() const = 0;
 378
 379   /**
 380     * \return the (subvariant) options that can be specified for position creation, such as board size, etc
 381     */
 382   virtual OptList positionOptions() const = 0;
 383
 384   /**
 385     * \return The ICS API for this variant, or a null pointer, if the variant does not support
 386     *         ICS (in that case a Dummy variant will be used).
 387     */
 388   virtual ICSAPIPtr icsAPI() const = 0;
 389
 390   /**
 391     * Setup a list of variant specific actions to be displayed on a game toolbar
 392     * and menu.
 393     */
 394   virtual ActionCollection* actions() = 0;
 395
 396   /**
 397     * Add variant specific information (i.e. promotionType) to a move.
 398     */
 399   virtual void setupMove(NormalUserMove& m) const = 0;
 400 };
 401
 402
 403 class VariantFactory {
 404 public:
 405   virtual ~VariantFactory() { }
 406   virtual VariantInfo* createVariant() const = 0;
 407 };
 408
 409
 410 #endif // LOWLEVEL_H