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.
15 #include <boost/shared_ptr.hpp>
17 #include <QStringList>
22 #include "decoratedmove.h"
23 #include "interactiontype.h"
24 #include "turnpolicy.h"
32 * @brief Low level abstract classes used by the interface framework.
34 * This file includes definitions for abstract classes used from within
35 * the interface framework to access variant details using dynamic time
38 * One of the big problems with this approach is what I call 'lack of
39 * functional dependency support' for runtime polymorphism.
40 * What is missing is the ability to override a virtual member function
41 * in a derived class changing its signature. Or better, it is possible
42 * to only change its return type with a covariant type, while it would
43 * often be useful to change any of its argument types with covariant or
44 * even controvariant types.
45 * For controvariant types, I foresee no problems, and all type checking
46 * can be done statically (of course the method has to be dynamically
47 * bound) as they are now.
48 * When using covariant types, the compiler could insert appropriate
49 * dynamic cast's and type checks in the calling code, when there's no
50 * way to know the exact type of an argument at compile time.
52 * The file @ref tagua_wrapped.h tries to address this problem doing part
53 * of the compiler's work. One exception is that type checking code
54 * is inserted in a method wrapper, instead of the calling place, so
55 * even calling a method of a noncasted instance would cause some
56 * upcast / downcast overhead; this is negligible, though, because
57 * that scenario is rather unlikely, since wrapped classes are always
58 * kept in variables of abstract types.
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(const PiecePtr
& 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 PiecePtr
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(const PositionPtr
& ref
) const = 0;
106 * Return a decorated representation for the move.
108 virtual DecoratedMove
toDecoratedMove(const PositionPtr
& ref
) const = 0;
111 * Return the move in coordinate notation.
113 virtual QString
toString(const PositionPtr
& 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(const MovePtr
& other
) const = 0;
129 * @brief Superclass for pools
131 * A general interface for pools.
135 typedef boost::shared_ptr
<AbstractPool
> Ptr
;
136 virtual ~AbstractPool() {}
139 * \return the number of items in the pool
141 virtual int size() = 0;
144 * Inserts a piece in the pool, preferably at the position \a pref_index.
145 * But the pool can be unpredictable and the piece can be placed at an arbitrary position.
146 * \return the position at which the item was placed.
148 virtual int insert(int pref_index
, const PiecePtr
& piece
) = 0;
151 * Gets the piece at the position \a index in the pool.
153 virtual PiecePtr
get(int index
) = 0;
156 * Removes the piece at the position \a index in the pool.
157 * \return the removed piece.
159 virtual PiecePtr
take(int index
) = 0;
165 * @brief A superclass for all the position classes.
167 * A general interface for positions. It is used from within
168 * the graphical framework to validate external input wrt
169 * the played variant.
171 class AbstractPosition
{
173 typedef boost::shared_ptr
<AbstractPosition
> Ptr
;
174 typedef boost::shared_ptr
<AbstractPool
> PoolPtr
;
175 virtual ~AbstractPosition() { }
178 * Return board size in logical units. This could be
179 * static if C++ permitted virtual static functions.
181 virtual Point
size() const = 0;
184 * Returns the text to be used for the border surrounding this position in a board
186 virtual QStringList
borderCoords() const = 0;
189 * Create the starting piece setup.
191 virtual void setup() = 0;
194 * Retrieve the piece on square @a p.
195 * Return a null pointer if that square is empty.
197 virtual PiecePtr
get(const Point
& p
) const = 0;
200 * Set a piece on the board.
202 virtual void set(const Point
& p
, const PiecePtr
& piece
) = 0;
205 * \return an interface to modify the pool of the board relative to \a player
207 virtual PoolPtr
pool(int player
) = 0;
210 * Set a position pool, copying it from a given position.
212 virtual void copyPoolFrom(const PositionPtr
& pos
) = 0;
215 * \return 1 if the piece can be moved, -1 if could be moved in the future (premove), or else 0.
217 virtual InteractionType
movable(const TurnPolicy::Collection
& test
, const Point
& p
) const = 0;
220 * \return 1 if this pool can be dropped, -1 if could be dropped in the future (premove), or else 0.
222 virtual InteractionType
droppable(const TurnPolicy::Collection
& test
, int) const = 0;
225 * \return an id corresponding to the player
228 virtual int turn() const = 0;
231 * Sets the player on move
233 virtual void setTurn(int) = 0;
236 * \return the player that just moved
238 virtual int previousTurn() const = 0;
241 * Switch to the next player.
243 virtual void switchTurn() = 0;
246 * Check move legality. Set move fields as needed.
247 * Return whether the move is legal.
248 * This function should return immediately if \a m
249 * has already been tested.
251 virtual bool testMove(const MovePtr
& m
) const = 0;
254 * Execute move \a m. Assume that \a m is legal and tested.
256 virtual void move(const MovePtr
& m
) = 0;
259 * Create a deep copy of the position.
261 virtual PositionPtr
clone() const = 0;
264 * Make the position equal to the given one.
266 virtual void copyFrom(const PositionPtr
&) = 0;
269 * Tests if two positions are equal.
271 virtual bool equals(const PositionPtr
& p
) const = 0;
274 * Return a move from an algebraic notation, or a null pointer.
276 virtual MovePtr
getMove(const QString
&) const = 0;
279 * Return a string representing the current state of the position.
281 virtual QString
state() const = 0;
284 * Return a FEN representation for the position, assuming
285 * @a halfmove as halfmove clock and @a fullmove as full move
288 virtual QString
fen(int halfmove
, int fullmove
) const = 0;
291 * A piece somehow representing or related to the move
292 * which has to be drawn by the interface.
294 * * for one click moves, the piece that would
295 * appear on the square.
296 * * for promotions in chesslike variants, the promoted
298 * @note Return a null pointer if the move has no valid
299 * piece hint defined.
301 virtual PiecePtr
moveHint(const MovePtr
&) const = 0;
304 * Variant introspection
306 virtual QString
variant() const = 0;
311 virtual void dump() const = 0;
314 class AnimationGroup
;
317 * @brief An abstract superclass for all animator classes.
319 * An animator is a class which is given a difference between
320 * a graphical and a logical position, and schedules an animation
321 * which graphically does an update.
322 * If the difference is due to a move, the animator tries to
323 * create a smooth animation which could possibly work for many
324 * chess-like variants, and then fills in the gaps with a direct
327 class AbstractAnimator
{
329 typedef boost::shared_ptr
<AbstractAnimator
> Ptr
;
330 virtual ~AbstractAnimator() { }
333 * Sync the graphical position with the given position.
335 virtual AnimationPtr
warp(const PositionPtr
&) = 0;
338 * Animate forward syncing to the given position.
340 virtual AnimationPtr
forward(const PositionPtr
&, const MovePtr
&) = 0;
343 * Animate back syncing to the given position.
345 virtual AnimationPtr
back(const PositionPtr
&, const MovePtr
&) = 0;
351 virtual ~VariantInfo() { }
352 virtual PositionPtr
createPosition() = 0;
353 virtual PositionPtr
createCustomPosition(const OptList
& l
) = 0;
354 virtual PositionPtr
createPositionFromFEN(const QString
& fen
) = 0;
355 virtual void forallPieces(class PieceFunction
&) = 0;
356 virtual int moveListLayout() const = 0;
357 virtual AnimatorPtr
createAnimator(GraphicalAPI
* graphical_api
) = 0;
358 virtual MovePtr
createNormalMove(const NormalUserMove
&) = 0;
359 virtual MovePtr
createDropMove(const DropUserMove
&) = 0;
360 virtual MovePtr
getVerboseMove(int turn
, const class VerboseNotation
&) const = 0;
363 * \return if moves are done by just clicking
365 virtual bool simpleMoves() = 0;
368 * \return the name of the variant
370 virtual QString
name() const = 0;
373 * \return the name of the theme proxy variant, ie the variant whose theme can be used
374 * for the current one (for instance crazyhouse can use chess themes).
376 virtual QString
themeProxy() const = 0;
379 * \return the (subvariant) options that can be specified for position creation, such as board size, etc
381 virtual OptList
positionOptions() const = 0;
384 * \return The ICS API for this variant, or a null pointer, if the variant does not support
385 * ICS (in that case a Dummy variant will be used).
387 virtual ICSAPIPtr
icsAPI() const = 0;
391 class VariantFactory
{
393 virtual ~VariantFactory() { }
394 virtual VariantInfo
* createVariant() const = 0;