2 Copyright (c) 2006 Paolo Capriotti <p.capriotti@sns.it>
3 (c) 2006 Maurizio Monge <maurizio.monge@kdemail.net>
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.
11 #include "crazyhouse_p.h"
12 #include "crazyhouse.h"
13 #include "piecesprite.h"
14 #include "xchess/animator.impl.h"
16 //BEGIN CrazyhousePiece
18 CrazyhousePiece::CrazyhousePiece(ChessPiece::Color color, ChessPiece::Type type, bool promoted)
19 : ChessPiece(color, type)
20 , m_promoted(promoted) { }
22 CrazyhousePiece::CrazyhousePiece(const CrazyhousePiece& other)
24 , m_promoted(other.m_promoted) { }
26 CrazyhousePiece::CrazyhousePiece(const ChessPiece& other)
28 , m_promoted(false) { }
32 //BEGIN CrazyhouseMove
34 CrazyhouseMove::CrazyhouseMove(const ChessMove& m)
36 , m_drop(INVALID_COLOR, INVALID_TYPE) { }
38 CrazyhouseMove::CrazyhouseMove(const Point& from, const Point& to, PieceType promotionType)
39 : ChessMove(from, to, promotionType)
40 , m_drop(INVALID_COLOR, INVALID_TYPE) { }
42 CrazyhouseMove::CrazyhouseMove(const CrazyhouseMove& other)
44 , m_drop(other.m_drop) { }
46 CrazyhouseMove::CrazyhouseMove(CrazyhousePiece piece, const Point& to)
47 : ChessMove(Point::invalid(), to)
52 //BEGIN CrazyhousePosition
54 CrazyhousePosition::CrazyhousePosition() {
57 CrazyhousePosition::CrazyhousePosition(const OptList&) {
60 CrazyhousePosition::CrazyhousePosition(const CrazyhousePosition& other)
64 CrazyhousePosition::CrazyhousePosition(const ChessPosition& other)
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) {
73 CrazyhousePosition* CrazyhousePosition::clone() const {
74 return new CrazyhousePosition(*this);
77 CrazyhousePiece::Color CrazyhousePosition::moveTurn(const Move& move) const {
78 if (move.m_drop.valid() )
79 return move.m_drop.color();
81 return Base::moveTurn(move);
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));
91 bool CrazyhousePosition::pseudolegal(Move& move) const {
93 if (move.m_drop.valid()) {
94 Q_ASSERT(valid(move.to));
96 // cannot drop on occupied squares
97 if (m_board[move.to]) return false;
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))
108 return Base::pseudolegal(move);
111 void CrazyhousePosition::move(const Move& move) {
113 if (move.m_drop.valid()) {
114 Q_ASSERT(m_pool.count(move.m_drop));
115 Q_ASSERT(!m_board[move.to]);
117 basicDropPiece(new Piece(move.m_drop), move.to);
118 if(!--m_pool[move.m_drop])
119 m_pool.erase(move.m_drop);
126 if (move.type() == Move::Promotion) {
127 m_board[move.to].setPromoted(true);
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;
137 void CrazyhousePosition::executeCaptureOn(const Point& point) {
138 Piece piece = m_board[point];
140 Piece downgraded( Piece::oppositeColor(piece.color()),
141 piece.promoted() ? PAWN : piece.type());
142 m_pool[downgraded]++;
144 Base::executeCaptureOn(point);
147 CrazyhouseMove CrazyhousePosition::getMove(const AlgebraicNotation& san, bool& ok) const {
150 Piece piece(m_turn, (PieceType)san.type);
152 if ( !m_pool.count( piece )) {
154 return CrazyhouseMove::invalid();
158 return CrazyhouseMove( piece, san.to);
162 return Base::getMove(san, ok);
165 void CrazyhousePosition::dump() const {
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;
172 bool CrazyhousePosition::operator==(const CrazyhousePosition& pos) const {
173 return pool() == pos.pool() && Base::operator==(pos);
176 //END CrazyhousePosition
178 #include "animation.h"
179 #include "graphicalposition.h"
180 #include "pointconverter.h"
183 //BEGIN CrazyhouseAnimator
186 CrazyhouseAnimator::CrazyhouseAnimator(PointConverter* converter, GraphicalPosition* position)
187 : ChessAnimator(converter, position) {
190 CrazyhouseAnimator::AnimationPtr CrazyhouseAnimator::warp(AbstractPosition::Ptr final) {
191 m_position->updatePool(final->pool());
193 return ChessAnimator::warp(final);
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);
203 if(!drop_sprite->visible())
204 res->addPreAnimation(
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))
211 res->addPreAnimation(
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)))
219 res->addPostAnimation(warp(final));
223 return ChessAnimator::forward(final, move);
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(
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))
240 res->addPostAnimation(warp(final));
244 return ChessAnimator::back(final, move);
247 //END CrazyhouseAnimator
251 //BEGIN CrazyhouseVariant
254 #include "highlevel.h"
255 #include "moveserializer.impl.h"
257 class CrazyhouseVariantInfo {
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(); }
271 const char *CrazyhouseVariantInfo::m_name = "Crazyhouse";
272 const char *CrazyhouseVariantInfo::m_theme_proxy = "Chess";
274 VariantInfo* CrazyhouseVariant::static_crazyhouse_variant = 0;
276 void CrazyhouseVariantInfo::forallPieces(PieceFunction& f) {
277 return ChessVariant::forallPieces(f);
280 VariantInfo* CrazyhouseVariant::info() {
281 if (!static_crazyhouse_variant)
282 static_crazyhouse_variant = new WrappedVariantInfo<CrazyhouseVariantInfo>;
283 return static_crazyhouse_variant;
286 //END CrazyhouseVariant