tests/hlvariants/prototype/tagua_wrapped.h

   1 #ifndef HLVARIANT__TAGUA_WRAPPED_H
   2 #define HLVARIANT__TAGUA_WRAPPED_H
   3
   4 #include "tagua.h"
   5 #include "fwd.h"
   6 #include "nopool.h"
   7
   8 #ifdef Q_CC_GNU
   9   #define __FUNC__ __PRETTY_FUNCTION__
  10 #else
  11   #define __FUNC__ __FUNCTION__
  12 #endif
  13
  14 #define MISMATCH(x,y) (std::cout << " --> Error in "<<__FUNC__<<", MISMATCH!" << std::endl \
  15                        << "     got type   " << prettyTypeName(typeid(x).name()) << std::endl \
  16                        << "     instead of " << prettyTypeName(typeid(y).name()) << std::endl \
  17                        << "     this is    " << prettyTypeName(typeid(*this).name()) << std::endl)
  18
  19 namespace HLVariant {
  20
  21   template <typename Variant> class WrappedPosition;
  22
  23   template <typename Variant>
  24   class WrappedPool { };
  25
  26   template <typename Variant>
  27   class WrappedPiece : public AbstractPiece {
  28     typedef typename Variant::LegalityCheck::GameState::Board::Piece Piece;
  29
  30     Piece m_piece;
  31   public:
  32     const Piece& inner() const { return m_piece; }
  33
  34     WrappedPiece(const Piece& piece)
  35     : m_piece(piece) { }
  36
  37     virtual bool equals(const PiecePtr& _other) const {
  38       if (!_other) return false;
  39       WrappedPiece<Variant>* other = dynamic_cast<WrappedPiece<Variant>*>(_other.get());
  40
  41       if (other)
  42         return m_piece == other->inner();
  43       else {
  44         MISMATCH(*_other.get(),WrappedPiece<Variant>);
  45         return false;
  46       }
  47     }
  48
  49     virtual QString name() const {
  50       return m_piece.name();
  51     }
  52
  53     virtual PiecePtr clone() const {
  54       return PiecePtr(new WrappedPiece<Variant>(m_piece));
  55     }
  56   };
  57
  58   template <typename Variant>
  59   class WrappedMove : public AbstractMove {
  60     typedef typename Variant::LegalityCheck LegalityCheck;
  61     typedef typename LegalityCheck::Move Move;
  62     typedef typename LegalityCheck::GameState GameState;
  63
  64     Move m_move;
  65   public:
  66     const Move& inner() const { return m_move; }
  67     Move& inner() { return m_move; }
  68
  69     WrappedMove(const Move& move)
  70     : m_move(move) { }
  71
  72     virtual QString SAN(const PositionPtr& _ref) const {
  73       WrappedPosition<Variant>* ref = dynamic_cast<WrappedPosition<Variant>*>(_ref.get());
  74
  75       if (ref) {
  76 //         MoveSerializer<Position> serializer(m_move, pos->inner());
  77         return ""; //BROKEN
  78       }
  79       else {
  80         MISMATCH(*_ref.get(), WrappedPosition<Variant>);
  81         return "$@%";
  82       }
  83     }
  84
  85     virtual DecoratedMove toDecoratedMove(const PositionPtr& _pos) const {
  86       return DecoratedMove(); // BROKEN
  87     }
  88
  89     virtual QString toString(const PositionPtr& _pos) const {
  90       return ""; // BROKEN
  91     }
  92
  93     virtual NormalUserMove toUserMove() const {
  94       return NormalUserMove(); // BROKEN
  95     }
  96
  97     virtual bool equals(const MovePtr& _other) const {
  98       WrappedMove<Variant>* other = dynamic_cast<WrappedMove<Variant>*>(_other.get());
  99
 100       if (other)
 101         return m_move == other->inner();
 102       else {
 103         MISMATCH(*_other.get(), WrappedMove<Variant>);
 104         return false;
 105       }
 106     }
 107   };
 108
 109   /**
 110     * Metafunction that returns a null pointer when
 111     * its template argument is NoPool.
 112     */
 113   template <typename Variant, typename Pool>
 114   struct ReturnPoolAux {
 115     static PoolPtr apply(typename Variant::GameState& state, int player) {
 116       return PoolPtr(new WrappedPool<Variant>(state.pool(player)));
 117     }
 118   };
 119
 120   template <typename Variant>
 121   struct ReturnPoolAux<Variant, NoPool> {
 122     static PoolPtr apply(typename Variant::GameState&, int) {
 123       return PoolPtr();
 124     }
 125   };
 126
 127   template <typename Variant>
 128   struct ReturnPool {
 129     static PoolPtr apply(typename Variant::GameState& state, int player) {
 130       return ReturnPoolAux<Variant, typename Variant::GameState::Pool>(state, player);
 131     }
 132   };
 133
 134   template <typename Variant>
 135   class WrappedPosition : public AbstractPosition {
 136     typedef typename Variant::LegalityCheck LegalityCheck;
 137     typedef typename LegalityCheck::GameState GameState;
 138     typedef typename GameState::Board Board;
 139     typedef typename Board::Piece Piece;
 140     typedef typename GameState::Move Move;
 141
 142     GameState m_state;
 143   public:
 144     const GameState& inner() const { return m_state; }
 145     GameState& inner() { return m_state; }
 146
 147     WrappedPosition(const GameState& state)
 148     : m_state(state) { }
 149
 150     virtual Point size() const {
 151       return m_state.board().size();
 152     }
 153
 154     virtual QStringList borderCoords() const {
 155       // BROKEN
 156       return QStringList();
 157     }
 158
 159     virtual void setup() {
 160       m_state.setup();
 161     }
 162
 163     virtual PiecePtr get(const Point& p) const {
 164       Piece piece = m_state.board().get(p);
 165       if (piece != Piece())
 166         return PiecePtr(new WrappedPiece<Variant>(piece));
 167       else
 168         return PiecePtr();
 169     }
 170
 171     virtual void set(const Point& p, const PiecePtr& _piece) {
 172       if (!_piece) {
 173         m_state.board().set(p, Piece());
 174       }
 175       else {
 176         WrappedPiece<Variant>* piece = dynamic_cast<WrappedPiece<Variant>*>(_piece.get());
 177
 178         if (piece)
 179           m_state.board().set(p, piece->inner());
 180         else
 181           MISMATCH(*_piece.get(), WrappedPiece<Variant>);
 182       }
 183     }
 184
 185     virtual PoolPtr pool(int) {
 186       // BROKEN
 187       return PoolPtr();
 188     }
 189
 190     virtual void copyPoolFrom(const PositionPtr&) {
 191       // BROKEN
 192     }
 193
 194     virtual InteractionType movable(const TurnTest&, const Point&) const {
 195       return Moving; // BROKEN
 196     }
 197
 198     virtual InteractionType droppable(const TurnTest&, int) const {
 199       return Moving; // BROKEN
 200     }
 201
 202     virtual int turn() const {
 203       return static_cast<int>(m_state.turn());
 204     }
 205
 206     virtual void setTurn(int turn) {
 207       m_state.setTurn(static_cast<typename Piece::Color>(turn));
 208     }
 209
 210     virtual int previousTurn() const {
 211       return static_cast<int>(m_state.previousTurn());
 212     }
 213
 214     virtual void switchTurn() {
 215       m_state.switchTurn();
 216     }
 217
 218     virtual bool testMove(const MovePtr& _move) const {
 219       WrappedMove<Variant>* move = dynamic_cast<WrappedMove<Variant>*>(_move.get());
 220
 221       if (move) {
 222         LegalityCheck check(m_state);
 223         return check.legal(move->inner());
 224       }
 225       else {
 226         MISMATCH(*_move.get(), WrappedMove<Variant>);
 227         return false;
 228       }
 229     }
 230
 231     virtual void move(const MovePtr& _move) {
 232       WrappedMove<Variant>* move = dynamic_cast<WrappedMove<Variant>*>(_move.get());
 233
 234       if (move)
 235         m_state.move(move->inner());
 236       else
 237         MISMATCH(*_move.get(), WrappedMove<Variant>);
 238     }
 239
 240     virtual PositionPtr clone() const {
 241       return PositionPtr(new WrappedPosition<Variant>(m_state));
 242     }
 243
 244     virtual void copyFrom(const PositionPtr& _p) {
 245       // TODO: check if this is used somewhere
 246       WrappedPosition<Variant>* p = dynamic_cast<WrappedPosition<Variant>*>(_p.get());
 247
 248       if (p)
 249         m_state = p->inner();
 250       else
 251         MISMATCH(*_p.get(), WrappedPosition);
 252     }
 253
 254     virtual bool equals(const PositionPtr& _other) const {
 255       WrappedPosition<Variant>* other = dynamic_cast<WrappedPosition<Variant>*>(_other.get());
 256
 257       if (other)
 258         return m_state == other->inner();
 259       else {
 260         MISMATCH(*_other.get(), WrappedPosition<Variant>);
 261         return false;
 262       }
 263     }
 264
 265     virtual MovePtr getMove(const AlgebraicNotation&) const {
 266       // BROKEN
 267       return MovePtr();
 268     }
 269
 270     virtual MovePtr getMove(const QString&) const {
 271       // BROKEN
 272       return MovePtr();
 273     }
 274
 275     virtual QString state() const {
 276       return ""; // TODO
 277     }
 278
 279     virtual QString fen(int, int) const {
 280       return ""; // BROKEN
 281     }
 282
 283     virtual PiecePtr moveHint(const MovePtr&) const {
 284       return PiecePtr(); // BROKEN
 285     }
 286
 287     virtual QString variant() const {
 288       return Variant::m_name;
 289     }
 290
 291     virtual void dump() const {
 292       // BROKEN
 293     }
 294
 295   };
 296
 297 }
 298
 299 #endif // HLVARIANT__TAGUA_WRAPPED_H
 300