2 Copyright (c) 2006 Paolo Capriotti <p.capriotti@sns.it>
3 (c) 2006 Maurizio Monge <maurizio.monge@kdemail.net>
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.
20 * @brief Low level abstract classes used by the interface framework.
22 * This file includes definitions for abstract classes used from within
23 * the interface framework to access variant details using dynamic time
26 * One of the big problems with this approach is what I call 'lack of
27 * functional dependency support' for runtime polymorphism.
28 * What is missing is the ability to override a virtual member function
29 * in a derived class changing its signature. Or better, it is possible
30 * to only change its return type with a covariant type, while it would
31 * often be useful to change any of its argument types with covariant or
32 * even controvariant types.
33 * For controvariant types, I foresee no problems, and all type checking
34 * can be done statically (of course the method has to be dynamically
35 * bound) as they are now.
36 * When using covariant types, the compiler could insert appropriate
37 * dynamic cast's and type checks in the calling code, when there's no
38 * way to know the exact type of an argument at compile time.
40 * The file @ref kboard_wrapped.h tries to address this problem doing part
41 * of the compiler's work. One exception is that type checking code
42 * is inserted in a method wrapper, instead of the calling place, so
43 * even calling a method of a noncasted instance would cause some
44 * upcast / downcast overhead; this is negligible, though, because
45 * that scenario is rather unlikely, since wrapped classes are always
46 * kept in variables of abstract types.
50 #include <boost/shared_ptr.hpp>
52 #include <QStringList>
57 #include "decoratedmove.h"
58 #include "interactiontype.h"
63 * @brief A superclass for all the piece classes.
67 typedef boost::shared_ptr
<AbstractPiece
> Ptr
;
68 virtual ~AbstractPiece() { }
71 * Piece equality. Return false if the second pointer
74 virtual bool equals(AbstractPiece::Ptr other
) const = 0;
77 * Return a unique key for the piece.
78 * Used to store pixmaps.
80 virtual QString
name() const = 0;
83 * Create a deep copy of the piece.
85 virtual AbstractPiece::Ptr
clone() const = 0;
90 * @brief A superclass for all the move classes.
92 * An abstract move is simply something that can serialize
93 * itself either as SAN notation, or as coordinate notation.
97 typedef boost::shared_ptr
<AbstractMove
> Ptr
;
98 virtual ~AbstractMove() { }
101 * Return a compact SAN representation for the move.
103 virtual QString
SAN(boost::shared_ptr
<AbstractPosition
> ref
) const = 0;
106 * Return a decorated representation for the move.
108 virtual DecoratedMove
toDecoratedMove(boost::shared_ptr
<AbstractPosition
> ref
) const = 0;
111 * Return the move in coordinate notation.
113 virtual QString
toString(boost::shared_ptr
<AbstractPosition
> ref
) const = 0;
116 * Convert the move to a normal user move. Used to
117 * perform move highlighting.
119 virtual NormalUserMove
toUserMove() const = 0;
122 * Checks if the two moves are equal.
124 virtual bool equals(Ptr other
) const = 0;
130 * @brief Superclass for pools
132 * A general interface for pools.
136 typedef boost::shared_ptr
<AbstractPool
> Ptr
;
137 virtual ~AbstractPool() {}
140 * \return the number of items in the pool
142 virtual int size() = 0;
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.
149 virtual int insert(int pref_index
, AbstractPiece::Ptr piece
) = 0;
152 * Gets the piece at the position \a index in the pool.
154 virtual AbstractPiece::Ptr
get(int index
) = 0;
157 * Removes the piece at the position \a index in the pool.
158 * \return the removed piece.
160 virtual AbstractPiece::Ptr
take(int index
) = 0;
166 * @brief A superclass for all the position classes.
168 * A general interface for positions. It is used from within
169 * the graphical framework to validate external input wrt
170 * the played variant.
172 class AbstractPosition
{
174 typedef boost::shared_ptr
<AbstractPosition
> Ptr
;
175 typedef boost::shared_ptr
<AbstractPool
> PoolPtr
;
176 virtual ~AbstractPosition() { }
179 * Return board size in logical units. This could be
180 * static if C++ permitted virtual static functions.
182 virtual Point
size() const = 0;
185 * Returns the text to be used for the border surrounding this position in a board
187 virtual QStringList
borderCoords() const = 0;
190 * Create the starting piece setup.
192 virtual void setup() = 0;
195 * Retrieve the piece on square @a p.
196 * Return a null pointer if that square is empty.
198 virtual AbstractPiece::Ptr
get(const Point
& p
) const = 0;
201 * Set a piece on the board.
203 virtual void set(const Point
& p
, AbstractPiece::Ptr piece
) = 0;
206 * \return an interface to modify the pool of the board relative to \a player
208 // virtual AbstractPool::Ptr pool(int player) = 0;
211 * \return 1 if the piece can be moved, -1 if could be moved in the future (premove), or else 0.
213 virtual InteractionType
movable(const Point
& p
) const = 0;
216 * \return 1 if this pool can be dropped, -1 if could be dropped in the future (premove), or else 0.
218 virtual InteractionType
droppable(int) const = 0;
221 * \return an id corresponding to the player
224 virtual int turn() const = 0;
227 * Sets the player on move
229 virtual void setTurn(int) = 0;
232 * \return the player that just moved
234 virtual int previousTurn() const = 0;
237 * Switch to the next player.
239 virtual void switchTurn() = 0;
242 * Check move legality. Set move fields as needed.
243 * Return whether the move is legal.
244 * This function should return immediately if \a m
245 * has already been tested.
247 virtual bool testMove(AbstractMove::Ptr m
) const = 0;
250 * Execute move \a m. Assume that \a m is legal and tested.
252 virtual void move(AbstractMove::Ptr m
) = 0;
255 * Create a deep copy of the position.
257 virtual AbstractPosition::Ptr
clone() const = 0;
260 * Make the position equal to the given one.
262 virtual void copyFrom(const AbstractPosition::Ptr
&) = 0;
265 * Tests if two positions are equal.
267 virtual bool equals(AbstractPosition::Ptr p
) const = 0;
270 * Return a move from an algebraic notation, or a null pointer.
272 virtual AbstractMove::Ptr
getMove(const class AlgebraicNotation
&) const = 0;
275 * Return a move from an algebraic notation, or a null pointer.
277 virtual AbstractMove::Ptr
getMove(const QString
&) const = 0;
280 * Return a string representing the current state of the position.
282 virtual QString
state() const = 0;
285 * Return a FEN representation for the position, assuming
286 * @a halfmove as halfmove clock and @a fullmove as full move
289 virtual QString
fen(int halfmove
, int fullmove
) const = 0;
292 * A piece somehow representing or related to the move
293 * which has to be drawn by the interface.
295 * * for one click moves, the piece that would
296 * appear on the square.
297 * * for promotions in chesslike variants, the promoted
299 * @note Return a null pointer if the move has no valid
300 * piece hint defined.
302 virtual AbstractPiece::Ptr
moveHint(AbstractMove::Ptr
) const = 0;
305 * Variant introspection
307 virtual QString
variant() const = 0;
312 virtual void dump() const = 0;
315 class AnimationGroup
;
318 * @brief An abstract superclass for all animator classes.
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
328 class AbstractAnimator
{
330 typedef boost::shared_ptr
<AbstractAnimator
> Ptr
;
331 virtual ~AbstractAnimator() { }
334 * Sync the graphical position with the given position.
336 virtual AnimationPtr
warp(AbstractPosition::Ptr
) = 0;
339 * Animate forward syncing to the given position.
341 virtual AnimationPtr
forward(AbstractPosition::Ptr
, AbstractMove::Ptr
) = 0;
344 * Animate back syncing to the given position.
346 virtual AnimationPtr
back(AbstractPosition::Ptr
, AbstractMove::Ptr
) = 0;
352 virtual ~VariantInfo() { }
353 virtual AbstractPosition::Ptr
createPosition() = 0;
354 virtual AbstractPosition::Ptr
createCustomPosition(const OptList
& l
) = 0;
355 virtual AbstractPosition::Ptr
createPositionFromFEN(const QString
& fen
) = 0;
356 virtual AbstractPosition::Ptr
createChessboard(int turn
, bool, bool, bool, bool, const Point
&) = 0;
357 virtual void forallPieces(class PieceFunction
&) = 0;
358 virtual int moveListLayout() const = 0;
359 virtual AbstractAnimator::Ptr
createAnimator(GraphicalAPI
* graphical_api
) = 0;
360 virtual AbstractMove::Ptr
createNormalMove(const NormalUserMove
&) = 0;
361 virtual AbstractMove::Ptr
createDropMove(const DropUserMove
&) = 0;
362 virtual AbstractMove::Ptr
getVerboseMove(int turn
, const class VerboseNotation
&) const = 0;
365 * \return if moves are done by just clicking
367 virtual bool simpleMoves() = 0;
370 * \return the name of the variant
372 virtual QString
name() const = 0;
375 * \return the name of the theme proxy variant, ie the variant whose theme can be used
376 * for the current one (for instance crazyhouse can use chess themes).
378 virtual QString
themeProxy() const = 0;
381 * \return the (subvariant) options that can be specified for position creation, such as board size, etc
383 virtual OptList
positionOptions() const = 0;