src/variants/crazyhouse.cpp_

   1 /*
   2   Copyright (c) 2006 Paolo Capriotti <p.capriotti@sns.it>
   3             (c) 2006 Maurizio Monge <maurizio.monge@kdemail.net>
   4
   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.
   9 */
  10
  11 #include "crazyhouse_p.h"
  12 #include "crazyhouse.h"
  13 #include "piecesprite.h"
  14 #include "xchess/animator.impl.h"
  15
  16 //BEGIN CrazyhousePiece
  17
  18 CrazyhousePiece::CrazyhousePiece(ChessPiece::Color color, ChessPiece::Type type, bool promoted)
  19 : ChessPiece(color, type)
  20 , m_promoted(promoted) { }
  21
  22 CrazyhousePiece::CrazyhousePiece(const CrazyhousePiece& other)
  23 : ChessPiece(other)
  24 , m_promoted(other.m_promoted) { }
  25
  26 CrazyhousePiece::CrazyhousePiece(const ChessPiece& other)
  27 : ChessPiece(other)
  28 , m_promoted(false) { }
  29
  30 //END CrazyhousePiece
  31
  32 //BEGIN CrazyhouseMove
  33
  34 CrazyhouseMove::CrazyhouseMove(const ChessMove& m)
  35 : ChessMove(m)
  36 , m_drop(INVALID_COLOR, INVALID_TYPE) { }
  37
  38 CrazyhouseMove::CrazyhouseMove(const Point& from, const Point& to, PieceType promotionType)
  39 : ChessMove(from, to, promotionType)
  40 , m_drop(INVALID_COLOR, INVALID_TYPE) { }
  41
  42 CrazyhouseMove::CrazyhouseMove(const CrazyhouseMove& other)
  43 : ChessMove(other)
  44 , m_drop(other.m_drop) { }
  45
  46 CrazyhouseMove::CrazyhouseMove(CrazyhousePiece piece, const Point& to)
  47 : ChessMove(Point::invalid(), to)
  48 , m_drop(piece) { }
  49
  50 //END CrazyhouseMove
  51
  52 //BEGIN CrazyhousePosition
  53
  54 CrazyhousePosition::CrazyhousePosition() {
  55 }
  56
  57 CrazyhousePosition::CrazyhousePosition(const OptList&) {
  58 }
  59
  60 CrazyhousePosition::CrazyhousePosition(const CrazyhousePosition& other)
  61 : Base(other) {
  62 }
  63
  64 CrazyhousePosition::CrazyhousePosition(const ChessPosition& other)
  65 : Base(other) {
  66 }
  67
  68 CrazyhousePosition::CrazyhousePosition(CrazyhousePiece::Color turn, bool wk, bool wq,
  69                                           bool bk, bool bq, const Point& ep)
  70 : Base(turn, wk, wq, bk, bq, ep) {
  71 }
  72
  73 CrazyhousePosition* CrazyhousePosition::clone() const {
  74   return new CrazyhousePosition(*this);
  75 }
  76
  77 CrazyhousePiece::Color CrazyhousePosition::moveTurn(const Move& move) const {
  78   if (move.m_drop.valid() )
  79     return move.m_drop.color();
  80   else
  81     return Base::moveTurn(move);
  82 }
  83
  84 boost::shared_ptr<AbstractGenerator<CrazyhouseMove> >
  85 CrazyhousePosition::createLegalGenerator() const {
  86   return boost::shared_ptr<AbstractGenerator<CrazyhouseMove> >(
  87     new MoveGenerator<CrazyhousePosition,
  88       LegalMove<CrazyhousePosition> >(*this));
  89 }
  90
  91 bool CrazyhousePosition::pseudolegal(Move& move) const {
  92
  93   if (move.m_drop.valid()) {
  94     Q_ASSERT(valid(move.to));
  95
  96     // cannot drop on occupied squares
  97     if (m_board[move.to]) return false;
  98
  99     // cannot drop pawns in first or eighth rank
 100     if (move.m_drop.type() == PAWN &&
 101         (move.to.y == 0 || move.to.y == 7))
 102       return false;
 103
 104     return true;
 105   }
 106   // normal move
 107   else
 108     return Base::pseudolegal(move);
 109 }
 110
 111 void CrazyhousePosition::move(const Move& move) {
 112   // drop
 113   if (move.m_drop.valid()) {
 114     Q_ASSERT(m_pool.count(move.m_drop));
 115     Q_ASSERT(!m_board[move.to]);
 116
 117     basicDropPiece(new Piece(move.m_drop), move.to);
 118     if(!--m_pool[move.m_drop])
 119       m_pool.erase(move.m_drop);
 120   }
 121   else {
 122     // normal move
 123     Base::move(move);
 124
 125     // set promoted flag
 126     if (move.type() == Move::Promotion) {
 127       m_board[move.to].setPromoted(true);
 128     }
 129   }
 130
 131 #if 0
 132   for(Pool::iterator i = m_pool.begin(); i != m_pool.end(); ++i)
 133     std::cout << i->first.color() << "." << i->first.type() << " " << i->second <<std::endl;
 134 #endif
 135 }
 136
 137 void CrazyhousePosition::executeCaptureOn(const Point& point) {
 138   Piece piece = m_board[point];
 139   if (piece) {
 140     Piece downgraded( Piece::oppositeColor(piece.color()),
 141                 piece.promoted() ? PAWN : piece.type());
 142     m_pool[downgraded]++;
 143   }
 144   Base::executeCaptureOn(point);
 145 }
 146
 147 CrazyhouseMove CrazyhousePosition::getMove(const AlgebraicNotation& san, bool& ok) const {
 148
 149   if (san.drop) {
 150     Piece piece(m_turn, (PieceType)san.type);
 151
 152     if ( !m_pool.count( piece )) {
 153       ok = false;
 154       return CrazyhouseMove::invalid();
 155     }
 156     else {
 157       ok = true;
 158       return CrazyhouseMove( piece, san.to);
 159     }
 160   }
 161   else
 162     return Base::getMove(san, ok);
 163 }
 164
 165 void CrazyhousePosition::dump() const {
 166   Base::dump();
 167
 168   for(Pool::const_iterator i = m_pool.begin(); i != m_pool.end(); ++i)
 169     std::cout << i->first.color() << "." << i->first.type() << " " << i->second <<std::endl;
 170 }
 171
 172 bool CrazyhousePosition::operator==(const CrazyhousePosition& pos) const {
 173   return pool() == pos.pool() && Base::operator==(pos);
 174 }
 175
 176 //END CrazyhousePosition
 177
 178 #include "animation.h"
 179 #include "graphicalposition.h"
 180 #include "pointconverter.h"
 181
 182 #if 0
 183 //BEGIN CrazyhouseAnimator
 184
 185
 186 CrazyhouseAnimator::CrazyhouseAnimator(PointConverter* converter, GraphicalPosition* position)
 187 : ChessAnimator(converter, position) {
 188 }
 189
 190 CrazyhouseAnimator::AnimationPtr CrazyhouseAnimator::warp(AbstractPosition::Ptr final) {
 191   m_position->updatePool(final->pool());
 192
 193   return ChessAnimator::warp(final);
 194 }
 195
 196 CrazyhouseAnimator::AnimationPtr CrazyhouseAnimator::forward(AbstractPosition::Ptr final,
 197                                                       const CrazyhouseMove& move) {
 198   if(move.m_drop.valid()) {
 199     AnimationPtr res(new AnimationGroup);
 200     AbstractPiece::Ptr drop = final->get(move.to);
 201     boost::shared_ptr<PieceSprite> drop_sprite = m_position->setPiece(move.to, drop, true);
 202
 203     if(!drop_sprite->visible())
 204       res->addPreAnimation(
 205         m_anim_fade
 206         ? boost::shared_ptr<Animation>(new FadeAnimation(drop_sprite,
 207                                       m_converter->toReal(move.to), 0, 255 ))
 208         : boost::shared_ptr<Animation>(new DropAnimation(drop_sprite))
 209       );
 210     else
 211       res->addPreAnimation(
 212         m_anim_movement
 213         ? boost::shared_ptr<Animation>(new MovementAnimation(drop_sprite,
 214                                             m_converter->toReal(move.to)))
 215         : boost::shared_ptr<Animation>(new InstantAnimation(drop_sprite,
 216                                             m_converter->toReal(move.to)))
 217       );
 218
 219     res->addPostAnimation(warp(final));
 220     return res;
 221   }
 222   else
 223     return ChessAnimator::forward(final, move);
 224 }
 225
 226 CrazyhouseAnimator::AnimationPtr CrazyhouseAnimator::back(AbstractPosition::Ptr final,
 227                                                       const CrazyhouseMove& move) {
 228   if(move.m_drop.valid()) {
 229     AnimationPtr res(new AnimationGroup);
 230     boost::shared_ptr<PieceSprite> drop_sprite = m_position->getSprite(move.to);
 231     m_position->removeElement(move.to);
 232     boost::shared_ptr<FadeAnimation> fadeoff(new FadeAnimation(drop_sprite,
 233                                                 m_converter->toReal(move.to), 255, 0));
 234     res->addPreAnimation(
 235       m_anim_fade
 236       ? boost::shared_ptr<Animation>(new FadeAnimation(drop_sprite,
 237                                        m_converter->toReal(move.to), 255, 0))
 238       : boost::shared_ptr<Animation>(new CaptureAnimation(drop_sprite))
 239     );
 240     res->addPostAnimation(warp(final));
 241     return res;
 242   }
 243   else
 244     return ChessAnimator::back(final, move);
 245 }
 246
 247 //END CrazyhouseAnimator
 248
 249 #endif
 250
 251 //BEGIN CrazyhouseVariant
 252
 253
 254 #include "highlevel.h"
 255 #include "moveserializer.impl.h"
 256
 257 class CrazyhouseVariantInfo {
 258 public:
 259   typedef CrazyhousePosition Position;
 260   typedef Position::Move Move;
 261   typedef Position::Piece Piece;
 262   typedef SimpleAnimator<CrazyhouseVariantInfo> Animator;
 263   static const bool m_simple_moves = false;
 264   static void forallPieces(PieceFunction& f);
 265   static int moveListLayout(){ return 0; }
 266   static const char *m_name;
 267   static const char *m_theme_proxy;
 268   static OptList positionOptions() { return OptList(); }
 269 };
 270
 271 const char *CrazyhouseVariantInfo::m_name = "Crazyhouse";
 272 const char *CrazyhouseVariantInfo::m_theme_proxy = "Chess";
 273
 274 VariantInfo* CrazyhouseVariant::static_crazyhouse_variant = 0;
 275
 276 void CrazyhouseVariantInfo::forallPieces(PieceFunction& f) {
 277   return ChessVariant::forallPieces(f);
 278 }
 279
 280 VariantInfo* CrazyhouseVariant::info() {
 281   if (!static_crazyhouse_variant)
 282     static_crazyhouse_variant = new WrappedVariantInfo<CrazyhouseVariantInfo>;
 283   return static_crazyhouse_variant;
 284 }
 285
 286 //END CrazyhouseVariant