src/variants/ultima.h__

   1 #ifndef ULTIMA_H
   2 #define ULTIMA_H
   3
   4 #include <QMatrix>
   5 #include "common.h"
   6 #include "position.h"
   7 #include "spriteloader.h"
   8 #include "serverreference.h"
   9
  10 class UltimaMove;
  11 class UltimaPosition;
  12
  13 class UltimaPiece {
  14 public:
  15   enum Type {
  16     InvalidType = -1,
  17     Pawn,
  18     LongLeaper,
  19     Chameleon,
  20     Coordinator,
  21     Withdrawer,
  22     King,
  23     Immobilizer
  24   };
  25   typedef PieceColor Color;
  26 private:
  27   Color m_color;
  28   Type m_type;
  29
  30   bool checkPawnCapture(const UltimaPosition& position, const Point& pos, const Point& direction, std::vector<Point>& targets) const;
  31 public:
  32   UltimaPiece(const Color& color, const Type& type)
  33   : m_color(color), m_type(type) { }
  34   UltimaPiece& operator=(const UltimaPiece& other) {
  35     m_color = other.m_color;
  36     m_type = other.m_type;
  37     return *this;
  38   }
  39   bool operator==(const UltimaPiece& other) const {
  40     return equals(&other);
  41   }
  42
  43   Color color() const { return m_color; }
  44   Type type() const { return m_type; }
  45   QString typeName() const;
  46
  47   bool equals(const UltimaPiece* other) const;
  48   bool sameColor(const UltimaPiece* other) const;
  49   static QString typeSymbol(Type type);
  50
  51   bool canMove(UltimaMove& m, const UltimaPosition& pos) const;
  52   bool canMoveAs(const UltimaMove& m, const UltimaPosition& pos,
  53                  std::vector<Point>& targets, Type actualType) const;
  54 };
  55
  56 class UltimaMove {
  57 public:
  58   Point from;
  59   Point to;
  60   std::vector<Point> targets;
  61
  62   UltimaMove(const Point& from, const Point& to, PieceType /* ignored */ = INVALID_TYPE)
  63   : from(from)
  64   , to(to) { }
  65
  66   static UltimaMove invalid() {
  67     return UltimaMove(Point::invalid(), Point::invalid());
  68   }
  69
  70   bool valid() const {
  71     return from != Point::invalid();
  72   }
  73
  74   ChessMove::Type type() const { return ChessMove::Normal; }
  75 };
  76
  77 class UltimaPosition {
  78 public:
  79   typedef UltimaPiece Piece;
  80   typedef UltimaMove Move;
  81   typedef ChessPosition::State State;
  82
  83   UltimaPosition();
  84   virtual ~UltimaPosition();
  85   virtual UltimaPosition* clone() const { return new UltimaPosition(*this); }
  86
  87 private:
  88   Piece::Color m_turn;
  89   PointerGrid<Piece> m_board;
  90
  91 public:
  92   virtual void setup();
  93   Piece::Color turn() const { return m_turn; }
  94   Piece* operator[](const Point& p) const;
  95   void setPiece(const Point& p, Piece* piece);
  96   bool operator==(const UltimaPosition& other) const;
  97
  98   Point findKing(Piece::Color color) const;
  99   PathInfo path(const Point& from, const Point& to) const {
 100     return m_board.path(from, to);
 101   }
 102
 103   bool valid(const Point& p) const;
 104   Move getMove(const AlgebraicNotation&, bool&) const {
 105                         Q_ASSERT(!"unimplemented"); return *(Move*)0; }
 106   bool testMove(Move&) const;
 107   bool pseudolegal(Move&) const;
 108   void move(const Move& mv);
 109   void switchTurn();
 110   State state() const { return ChessPosition::BlackWins; }
 111
 112   void dump() const;
 113 };
 114
 115 template <>
 116 class LoadPieces<UltimaPosition> : public LoadPiecesBase<UltimaPosition> {
 117   typedef LoadPiecesBase<UltimaPosition> Base;
 118   typedef UltimaPiece Piece;
 119 public:
 120   LoadPieces(InnerSpriteLoader& data, InnerSpriteLoader::Pixmaps& cache, int size)
 121   : Base(data, cache, size) { }
 122
 123   #define LOAD(color, type) \
 124     load(Piece(color, Piece::type))
 125   virtual void apply() {
 126     LOAD(WHITE, King);
 127     LOAD(WHITE, Withdrawer);
 128     LOAD(WHITE, Coordinator);
 129     LOAD(WHITE, Chameleon);
 130     LOAD(WHITE, LongLeaper);
 131     LOAD(WHITE, Pawn);
 132     LOAD(BLACK, King);
 133     LOAD(BLACK, Withdrawer);
 134     LOAD(BLACK, Coordinator);
 135     LOAD(BLACK, Chameleon);
 136     LOAD(BLACK, LongLeaper);
 137     LOAD(BLACK, Pawn);
 138
 139     loadUpsideDownRook(WHITE);
 140     loadUpsideDownRook(BLACK);
 141   }
 142   #undef LOAD
 143
 144   void loadUpsideDownRook(Piece::Color color) {
 145     Piece coo(color, Piece::Coordinator);
 146     Piece imm(color, Piece::Immobilizer);
 147
 148     SpriteStore::Token rookToken = PieceToken<Piece>::get(&coo);
 149     SpriteStore::Token immToken = PieceToken<UltimaPiece>::get(&imm);
 150     QImage rookImage = m_data.store->get(rookToken);
 151     QImage res = rookImage.transformed(
 152       QMatrix(1, 0, 0, -1, 0, rookImage.height()));
 153     m_data.store->add(immToken, res);
 154     scale(immToken);
 155   }
 156 };
 157
 158
 159 template <>
 160 class MoveSerializer<UltimaPosition> {
 161   typedef UltimaPosition::Move Move;
 162   Move m_move;
 163 public:
 164   MoveSerializer(const Move& m, const UltimaPosition& /*ref*/)
 165   : m_move(m) { }
 166
 167   virtual QString SAN() const { return ""; }
 168 };
 169
 170
 171 template <>
 172 struct ComparePosition<UltimaPosition> {
 173   static bool apply(const UltimaPosition& /*chessPos*/, const UltimaPosition& /*pos*/) {
 174     return true;
 175   }
 176 };
 177
 178 #endif // ULTIMA_H