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