src/hlvariant/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 "movefactory.h"
   7 #include "nopool.h"
   8 #include "variantdata.h"
   9
  10 #ifdef Q_CC_GNU
  11   #define __FUNC__ __PRETTY_FUNCTION__
  12 #else
  13   #define __FUNC__ __FUNCTION__
  14 #endif
  15
  16 #define MISMATCH(x,y) (std::cout << " --> Error in "<<__FUNC__<<", MISMATCH!" << std::endl \
  17                        << "     got type   " << prettyTypeName(typeid(x).name()) << std::endl \
  18                        << "     instead of " << prettyTypeName(typeid(y).name()) << std::endl \
  19                        << "     this is    " << prettyTypeName(typeid(*this).name()) << std::endl)
  20
  21 namespace HLVariant {
  22
  23   template <typename Variant> class WrappedPosition;
  24
  25   template <typename Variant>
  26   class WrappedPool { };
  27
  28   template <typename Variant>
  29   class WrappedPiece : public AbstractPiece {
  30     typedef typename VariantData<Variant>::Piece Piece;
  31
  32     Piece m_piece;
  33   public:
  34     const Piece& inner() const { return m_piece; }
  35
  36     WrappedPiece(const Piece& piece)
  37     : m_piece(piece) { }
  38
  39     virtual bool equals(const PiecePtr& _other) const {
  40       if (!_other) return false;
  41       WrappedPiece<Variant>* other = dynamic_cast<WrappedPiece<Variant>*>(_other.get());
  42
  43       if (other)
  44         return m_piece == other->inner();
  45       else {
  46         MISMATCH(*_other.get(),WrappedPiece<Variant>);
  47         return false;
  48       }
  49     }
  50
  51     virtual QString name() const {
  52       return m_piece.name();
  53     }
  54
  55     virtual PiecePtr clone() const {
  56       return PiecePtr(new WrappedPiece<Variant>(m_piece));
  57     }
  58   };
  59
  60   template <typename Variant>
  61   class WrappedMove : public AbstractMove {
  62     typedef typename VariantData<Variant>::LegalityCheck LegalityCheck;
  63     typedef typename VariantData<Variant>::Serializer Serializer;
  64     typedef typename VariantData<Variant>::Move Move;
  65     typedef typename VariantData<Variant>::GameState GameState;
  66
  67     Move m_move;
  68   public:
  69     const Move& inner() const { return m_move; }
  70     Move& inner() { return m_move; }
  71
  72     WrappedMove(const Move& move)
  73     : m_move(move) { }
  74
  75     virtual QString SAN(const PositionPtr& _ref) const {
  76       WrappedPosition<Variant>* ref = dynamic_cast<WrappedPosition<Variant>*>(_ref.get());
  77
  78       if (ref) {
  79         Serializer serializer(Serializer::COMPACT);
  80         return serializer.serialize(m_move, ref->inner());
  81       }
  82       else {
  83         MISMATCH(*_ref.get(), WrappedPosition<Variant>);
  84         return "$@%";
  85       }
  86     }
  87
  88     virtual DecoratedMove toDecoratedMove(const PositionPtr&) const {
  89       return DecoratedMove(); // BROKEN
  90     }
  91
  92     virtual QString toString(const PositionPtr&) const {
  93       return ""; // BROKEN
  94     }
  95
  96     virtual NormalUserMove toUserMove() const {
  97       return NormalUserMove(); // BROKEN
  98     }
  99
 100     virtual bool equals(const MovePtr& _other) const {
 101       WrappedMove<Variant>* other = dynamic_cast<WrappedMove<Variant>*>(_other.get());
 102
 103       if (other)
 104         return m_move == other->inner();
 105       else {
 106         MISMATCH(*_other.get(), WrappedMove<Variant>);
 107         return false;
 108       }
 109     }
 110   };
 111
 112   /**
 113     * Metafunction that returns a null pointer when
 114     * its template argument is NoPool.
 115     */
 116   template <typename Variant, typename Pool>
 117   struct ReturnPoolAux {
 118     static PoolPtr apply(typename Variant::GameState& state, int player) {
 119       return PoolPtr(new WrappedPool<Variant>(state.pool(player)));
 120     }
 121   };
 122
 123   template <typename Variant>
 124   struct ReturnPoolAux<Variant, NoPool> {
 125     static PoolPtr apply(typename Variant::GameState&, int) {
 126       return PoolPtr();
 127     }
 128   };
 129
 130   template <typename Variant>
 131   struct ReturnPool {
 132     static PoolPtr apply(typename Variant::GameState& state, int player) {
 133       return ReturnPoolAux<Variant, typename Variant::GameState::Pool>(state, player);
 134     }
 135   };
 136
 137   template <typename Variant>
 138   class WrappedPosition : public AbstractPosition {
 139     typedef typename VariantData<Variant>::LegalityCheck LegalityCheck;
 140     typedef typename VariantData<Variant>::GameState GameState;
 141     typedef typename VariantData<Variant>::Board Board;
 142     typedef typename VariantData<Variant>::Piece Piece;
 143     typedef typename VariantData<Variant>::Move Move;
 144     typedef typename VariantData<Variant>::Serializer Serializer;
 145
 146     GameState m_state;
 147   public:
 148     const GameState& inner() const { return m_state; }
 149     GameState& inner() { return m_state; }
 150
 151     WrappedPosition(const GameState& state)
 152     : m_state(state) { }
 153
 154     virtual Point size() const {
 155       return m_state.board().size();
 156     }
 157
 158     virtual QStringList borderCoords() const {
 159       // BROKEN
 160       return QStringList();
 161     }
 162
 163     virtual void setup() {
 164       m_state.setup();
 165     }
 166
 167     virtual PiecePtr get(const Point& p) const {
 168       Piece piece = m_state.board().get(p);
 169       if (piece != Piece())
 170         return PiecePtr(new WrappedPiece<Variant>(piece));
 171       else
 172         return PiecePtr();
 173     }
 174
 175     virtual void set(const Point& p, const PiecePtr& _piece) {
 176       if (!_piece) {
 177         m_state.board().set(p, Piece());
 178       }
 179       else {
 180         WrappedPiece<Variant>* piece = dynamic_cast<WrappedPiece<Variant>*>(_piece.get());
 181
 182         if (piece)
 183           m_state.board().set(p, piece->inner());
 184         else
 185           MISMATCH(*_piece.get(), WrappedPiece<Variant>);
 186       }
 187     }
 188
 189     virtual PoolPtr pool(int) {
 190       // BROKEN
 191       return PoolPtr();
 192     }
 193
 194     virtual void copyPoolFrom(const PositionPtr&) {
 195       // BROKEN
 196     }
 197
 198     virtual InteractionType movable(const TurnTest& test, const Point& p) const {
 199       LegalityCheck check(m_state);
 200       return check.movable(test, p);
 201     }
 202
 203     virtual InteractionType droppable(const TurnTest& test, int index) const {
 204       LegalityCheck check(m_state);
 205       return check.droppable(test, index);
 206     }
 207
 208     virtual int turn() const {
 209       return static_cast<int>(m_state.turn());
 210     }
 211
 212     virtual void setTurn(int turn) {
 213       m_state.setTurn(static_cast<typename Piece::Color>(turn));
 214     }
 215
 216     virtual int previousTurn() const {
 217       return static_cast<int>(m_state.previousTurn());
 218     }
 219
 220     virtual void switchTurn() {
 221       m_state.switchTurn();
 222     }
 223
 224     virtual bool testMove(const MovePtr& _move) const {
 225       WrappedMove<Variant>* move = dynamic_cast<WrappedMove<Variant>*>(_move.get());
 226
 227       if (move) {
 228         LegalityCheck check(m_state);
 229         return check.legal(move->inner());
 230       }
 231       else {
 232         MISMATCH(*_move.get(), WrappedMove<Variant>);
 233         return false;
 234       }
 235     }
 236
 237     virtual void move(const MovePtr& _move) {
 238       WrappedMove<Variant>* move = dynamic_cast<WrappedMove<Variant>*>(_move.get());
 239
 240       if (move)
 241         m_state.move(move->inner());
 242       else
 243         MISMATCH(*_move.get(), WrappedMove<Variant>);
 244     }
 245
 246     virtual PositionPtr clone() const {
 247       return PositionPtr(new WrappedPosition<Variant>(m_state));
 248     }
 249
 250     virtual void copyFrom(const PositionPtr& _p) {
 251       // TODO: check if this is used somewhere
 252       WrappedPosition<Variant>* p = dynamic_cast<WrappedPosition<Variant>*>(_p.get());
 253
 254       if (p)
 255         m_state = p->inner();
 256       else
 257         MISMATCH(*_p.get(), WrappedPosition);
 258     }
 259
 260     virtual bool equals(const PositionPtr& _other) const {
 261       WrappedPosition<Variant>* other = dynamic_cast<WrappedPosition<Variant>*>(_other.get());
 262
 263       if (other)
 264         return m_state == other->inner();
 265       else {
 266         MISMATCH(*_other.get(), WrappedPosition<Variant>);
 267         return false;
 268       }
 269     }
 270
 271     virtual MovePtr getMove(const AlgebraicNotation&) const {
 272       // BROKEN
 273       return MovePtr();
 274     }
 275
 276     virtual MovePtr getMove(const QString& san) const {
 277       Serializer serializer(Serializer::COMPACT);
 278       Move res = serializer.deserialize(san, m_state);
 279       if (res.valid()) {
 280         return MovePtr(new WrappedMove<Variant>(res));
 281       }
 282       else
 283         return MovePtr();
 284     }
 285
 286     virtual QString state() const {
 287       return ""; // BROKEN
 288     }
 289
 290     virtual QString fen(int, int) const {
 291       return ""; // BROKEN
 292     }
 293
 294     virtual PiecePtr moveHint(const MovePtr&) const {
 295       return PiecePtr(); // BROKEN
 296     }
 297
 298     virtual QString variant() const {
 299       return Variant::m_name;
 300     }
 301
 302     virtual void dump() const {
 303       // BROKEN
 304     }
 305
 306   };
 307 }
 308
 309 #include "graphicalapi_unwrapped.h"
 310
 311 namespace HLVariant {
 312
 313   template <typename Variant>
 314   class WrappedAnimator : public AbstractAnimator {
 315     typedef typename VariantData<Variant>::GameState GameState;
 316     typedef typename VariantData<Variant>::Animator Animator;
 317     typedef typename VariantData<Variant>::Move Move;
 318
 319     Animator m_animator;
 320   public:
 321     const Animator& inner() const { return m_animator; }
 322
 323     WrappedAnimator(const Animator& animator)
 324     : m_animator(animator) { }
 325
 326     virtual AnimationPtr warp(const PositionPtr& _pos) {
 327       WrappedPosition<Variant>* pos = dynamic_cast<WrappedPosition<Variant>*>(_pos.get());
 328       if (pos)
 329         return m_animator.warp(pos->inner());
 330       else {
 331         MISMATCH(*_pos.get(), WrappedPosition<Variant>);
 332         return AnimationPtr();
 333       }
 334     }
 335
 336     virtual AnimationPtr forward(const PositionPtr& _pos, const MovePtr& _move) {
 337       WrappedPosition<Variant>* pos = dynamic_cast<WrappedPosition<Variant>*>(_pos.get());
 338       WrappedMove<Variant>* move = dynamic_cast<WrappedMove<Variant>*>(_move.get());
 339
 340       if (move && pos)
 341         return m_animator.forward(pos->inner(), move->inner());
 342       else {
 343         if (!move)
 344           MISMATCH(*_move.get(), WrappedMove<Variant>);
 345         if (!pos)
 346           MISMATCH(*_pos.get(), WrappedPosition<Variant>);
 347         return AnimationPtr();
 348       }
 349     }
 350
 351     virtual AnimationPtr back(const PositionPtr& _pos, const MovePtr& _move) {
 352       WrappedPosition<Variant>* pos = dynamic_cast<WrappedPosition<Variant>*>(_pos.get());
 353       WrappedMove<Variant>* move = dynamic_cast<WrappedMove<Variant>*>(_move.get());
 354
 355       if (move && pos)
 356         return m_animator.back(pos->inner(), move->inner());
 357       else {
 358         if (!move)
 359           MISMATCH(*_move.get(), WrappedMove<Variant>);
 360         if (!pos)
 361           MISMATCH(*_pos.get(), WrappedPosition<Variant>);
 362         return AnimationPtr();
 363       }
 364     }
 365   };
 366
 367
 368
 369   template <typename Variant>
 370   class WrappedVariantInfo : public VariantInfo {
 371     typedef typename VariantData<Variant>::Animator Animator;
 372     typedef typename VariantData<Variant>::GameState GameState;
 373     typedef typename VariantData<Variant>::Piece Piece;
 374     typedef typename VariantData<Variant>::Move Move;
 375 //     typedef typename VariantData<Variant>::Pool Pool;
 376   public:
 377     virtual PositionPtr createPosition() {
 378       return PositionPtr(
 379         new WrappedPosition<Variant>(GameState()));
 380     }
 381
 382     virtual PositionPtr createCustomPosition(const OptList&) {
 383       return PositionPtr(
 384         new WrappedPosition<Variant>(GameState())); // BROKEN
 385     }
 386
 387     virtual PositionPtr createPositionFromFEN(const QString&) {
 388       return PositionPtr(); // BROKEN
 389     }
 390
 391     virtual void forallPieces(class PieceFunction&) {
 392       // BROKEN
 393     }
 394
 395     virtual int moveListLayout() const {
 396       return Variant::moveListLayout();
 397     }
 398
 399     virtual AnimatorPtr createAnimator(GraphicalAPI* graphical_api) {
 400       return AnimatorPtr(
 401         new WrappedAnimator<Variant>(
 402                 Animator(typename UnwrappedGraphicalAPI<Variant>::Ptr(
 403                       new UnwrappedGraphicalAPI<Variant>(graphical_api)))));
 404     }
 405
 406     virtual MovePtr createNormalMove(const NormalUserMove& move) {
 407       MoveFactory<GameState> factory;
 408       Move m = factory.createNormalMove(move);
 409       return MovePtr(new WrappedMove<Variant>(m));
 410     }
 411
 412     virtual MovePtr createDropMove(const DropUserMove& move) {
 413       MoveFactory<GameState> factory;
 414       Move m = factory.createDropMove(move);
 415       return MovePtr(new WrappedMove<Variant>(m));
 416     }
 417
 418     virtual MovePtr getVerboseMove(int turn, const VerboseNotation& m) const {
 419       return MovePtr(); // BROKEN
 420     }
 421
 422     virtual bool simpleMoves() {
 423       return Variant::m_simple_moves;
 424     }
 425
 426     virtual QString name() const {
 427       return Variant::m_name;
 428     }
 429
 430     virtual QString themeProxy() const {
 431       return Variant::m_theme_proxy;
 432     }
 433
 434     virtual OptList positionOptions() const {
 435       return Variant::positionOptions();
 436     }
 437
 438     virtual ICSAPIPtr icsAPI() const {
 439       return ICSAPIPtr(); // BROKEN
 440     }
 441   };
 442 }
 443
 444 #endif // HLVARIANT__TAGUA_WRAPPED_H
 445