void Fortyeight::restart( const QList<KCard*> & cards )
{
lastdeal = false;
QList<KCard*> cardList = cards;
for ( int r = 0; r < 4; ++r )
{
for ( int column = 0; column < 8; ++column )
{
QPointF initPos = stack[column]->pos() - QPointF( 0, 2 * deck()->cardHeight() );
addCardForDeal( stack[column], cardList.takeLast(), true, initPos );
}
}
while ( !cardList.isEmpty() )
{
KCard * c = cardList.takeFirst();
c->setPos( talon->pos() );
c->setFaceUp( false );
talon->add( c );
}
startDealAnimation();
flipCardToPile( talon->topCard(), pile, DURATION_MOVE );
emit newCardsPossible( true );
}
void ClockSolver::translate_layout()
{
/* Read the workspace. */
int total = 0;
for ( int w = 0; w < 8; ++w )
{
int i = translate_pile(deal->store[w], W[w], 52);
Wp[w] = &W[w][i - 1];
Wlen[w] = i;
total += i;
}
/* Output piles, if any. */
for (int i = 0; i < 12; ++i)
{
KCard *c = deal->target[i]->topCard();
// It is not safe to assume that each target pile will always have a
// card on it. If it takes particularly long to render the card graphics
// at the start of a new game, it is possible that this method can be
// called before the initial deal has been completed.
if (c)
W[8][i] = translateSuit( c->suit() ) + c->rank();
}
Wp[8] = &W[8][11];
Wlen[8] = 12;
}
void Gypsy::restart( const QList<KCard*> & cards )
{
QList<KCard*> cardList = cards;
for ( int round = 0; round < 8; ++round )
addCardForDeal(store[round], cardList.takeLast(), false, store[round]->pos() + QPointF(-2*deck()->cardWidth(),-1.1*deck()->cardHeight()));
for ( int round = 0; round < 8; ++round )
addCardForDeal(store[round], cardList.takeLast(), true, store[round]->pos() + QPointF(-3*deck()->cardWidth(),-1.6*deck()->cardHeight()));
for ( int round = 0; round < 8; ++round )
addCardForDeal(store[round], cardList.takeLast(), true, store[round]->pos() + QPointF(-4*deck()->cardWidth(),-2.1*deck()->cardHeight()));
while ( !cardList.isEmpty() )
{
KCard * c = cardList.takeFirst();
c->setPos( talon->pos() );
c->setFaceUp( false );
talon->add( c );
}
startDealAnimation();
emit newCardsPossible(true);
}
MoveHint YukonSolver::translateMove( const MOVE &m )
{
PatPile *frompile = 0;
frompile = deal->store[m.from];
KCard *card = frompile->at( frompile->count() - m.card_index - 1);
if ( m.totype == O_Type )
{
PatPile *target = 0;
PatPile *empty = 0;
for (int i = 0; i < 4; ++i) {
KCard *c = deal->target[i]->topCard();
if (c) {
if ( c->suit() == card->suit() )
{
target = deal->target[i];
break;
}
} else if ( !empty )
empty = deal->target[i];
}
if ( !target )
target = empty;
return MoveHint( card, target, m.pri );
} else {
return MoveHint( card, deal->store[m.to], m.pri );
}
}
void YukonSolver::translate_layout()
{
/* Read the workspace. */
int total = 0;
for ( int w = 0; w < 7; ++w ) {
int i = translate_pile(deal->store[w], W[w], 52);
Wp[w] = &W[w][i - 1];
Wlen[w] = i;
total += i;
}
/* Output piles, if any. */
for (int i = 0; i < 4; ++i) {
O[i] = NONE;
}
if (total != 52) {
for (int i = 0; i < 4; ++i) {
KCard *c = deal->target[i]->topCard();
if (c) {
O[translateSuit( c->suit() ) >> 4] = c->rank();
total += c->rank();
}
}
}
Q_ASSERT( total == 52 );
}
bool Gypsy::newCards()
{
if ( talon->isEmpty() )
return false;
for ( int round = 0; round < 8; ++round )
{
KCard * c = talon->topCard();
flipCardToPileAtSpeed( c, store[round], DEAL_SPEED );
c->setZValue( c->zValue() + 8 - round );
}
if (talon->isEmpty())
emit newCardsPossible(false);
return true;
}
void Grandf::deal( const QList<KCard*> & cardsToDeal )
{
setKeyboardModeActive( false );
QList<KCard*> cards = cardsToDeal;
QPointF initPos( 1.4 * 3 * deck()->cardWidth(), 1.2 * deck()->cardHeight() );
int start = 0;
int stop = 7-1;
int dir = 1;
for (int round=0; round < 7; round++)
{
int i = start;
do
{
if (!cards.isEmpty())
addCardForDeal( store[i], cards.takeLast(), (i == start), initPos );
i += dir;
} while ( i != stop + dir);
int t = start;
start = stop;
stop = t+dir;
dir = -dir;
}
int i = 0;
while (!cards.isEmpty())
{
addCardForDeal( store[i+1], cards.takeLast(), true, initPos );
i = (i+1)%6;
}
for (int round=0; round < 7; round++)
{
KCard *c = store[round]->topCard();
if (c)
c->setFaceUp(true);
}
startDealAnimation();
}
MoveHint KlondikeSolver::translateMove( const MOVE &m )
{
PatPile *frompile = 0;
if ( m.from == 8 && m.to == 7 )
return MoveHint();
Q_ASSERT( m.from != 8 );
if ( m.from == 7 )
frompile = deal->pile;
else
frompile = deal->play[m.from];
KCard *card = frompile->at( frompile->count() - m.card_index - 1);
if ( m.totype == O_Type )
{
PatPile *target = 0;
PatPile *empty = 0;
for (int i = 0; i < 4; ++i) {
KCard *c = deal->target[i]->topCard();
if (c) {
if ( c->suit() == card->suit() )
{
target = deal->target[i];
break;
}
} else if ( !empty )
empty = deal->target[i];
}
if ( !target )
target = empty;
return MoveHint( card, target, m.pri );
} else {
if ( m.to == 7 )
{
return MoveHint( card, deal->pile, m.pri );
} else if ( m.to == 8 )
return MoveHint();
else
return MoveHint( card, deal->play[m.to], m.pri );
}
}
bool Spider::newCards()
{
// The solver doesn't distinguish between dealing a new row of cards and
// removing complete runs from the tableau. So it we're in demo mode and
// newCards() is called, we should check to see if there are any complete
// runs to move before dealing a new row.
if ( isDemoActive() )
{
for ( int i = 0; i < 10; ++i )
{
if ( pileHasFullRun( stack[i] ) )
{
moveFullRunToLeg( stack[i] );
return true;
}
}
}
if ( m_redeal > 4 )
return false;
redeals[m_redeal]->setVisible(false);
recalculatePileLayouts();
for ( int column = 0; column < 10; ++column )
{
KCard * c = redeals[m_redeal]->topCard();
if ( !c )
break;
flipCardToPileAtSpeed( c, stack[column], DEAL_SPEED );
c->setZValue( c->zValue() + 10 - column );
}
++m_redeal;
if (m_redeal > 4)
emit newCardsPossible(false);
return true;
}
void SimonSolver::translate_layout()
{
/* Read the workspace. */
int total = 0;
for ( int w = 0; w < 10; ++w ) {
int i = translate_pile(deal->store[w], W[w], 52);
Wp[w] = &W[w][i - 1];
Wlen[w] = i;
total += i;
}
for (int i = 0; i < 4; ++i) {
O[i] = -1;
KCard *c = deal->target[i]->topCard();
if (c) {
total += 13;
O[i] = translateSuit( c->suit() );
}
}
}
bool Fortyeight::canPutStore( const KCardPile * pile, const QList<KCard*> &cards ) const
{
int frees = 0;
for (int i = 0; i < 8; i++)
if (stack[i]->isEmpty()) frees++;
if ( pile->isEmpty()) // destination is empty
frees--;
if (int( cards.count()) > 1<<frees)
return false;
// ok if the target is empty
if ( pile->isEmpty())
return true;
KCard *c = cards.first(); // we assume there are only valid sequences
return pile->topCard()->suit() == c->suit()
&& pile->topCard()->rank() == c->rank() + 1;
}
MoveHint FreecellSolver::translateMove( const MOVE &m )
{
// this is tricky as we need to want to build the "meta moves"
PatPile *frompile = 0;
if ( m.from < 8 )
frompile = deal->store[m.from];
else
frompile = deal->freecell[m.from-8];
KCard *card = frompile->at( frompile->count() - m.card_index - 1);
if ( m.totype == O_Type )
{
PatPile *target = 0;
PatPile *empty = 0;
for (int i = 0; i < 4; ++i) {
KCard *c = deal->target[i]->topCard();
if (c) {
if ( c->suit() == card->suit() )
{
target = deal->target[i];
break;
}
} else if ( !empty )
empty = deal->target[i];
}
if ( !target )
target = empty;
return MoveHint( card, target, m.pri );
} else {
PatPile *target = 0;
if ( m.to < 8 )
target = deal->store[m.to];
else
target = deal->freecell[m.to-8];
return MoveHint( card, target, m.pri );
}
}
void FreecellSolver::translate_layout()
{
/* Read the workspace. */
int total = 0;
for ( int w = 0; w < 8; ++w ) {
int i = translate_pile(deal->store[w], W[w], 52);
Wp[w] = &W[w][i - 1];
Wlen[w] = i;
total += i;
if (w == Nwpiles) {
break;
}
}
/* Temp cells may have some cards too. */
for (int w = 0; w < Ntpiles; ++w)
{
int i = translate_pile( deal->freecell[w], W[w+Nwpiles], 52 );
Wp[w+Nwpiles] = &W[w+Nwpiles][i-1];
Wlen[w+Nwpiles] = i;
total += i;
}
/* Output piles, if any. */
for (int i = 0; i < 4; ++i) {
O[i] = NONE;
}
if (total != 52) {
for (int i = 0; i < 4; ++i) {
KCard *c = deal->target[i]->topCard();
if (c) {
O[translateSuit( c->suit() ) >> 4] = c->rank();
total += c->rank();
}
}
}
}
void Spider::moveFullRunToLeg( KCardPile * pile )
{
QList<KCard*> run = pile->topCards( 13 );
PatPile * leg = legs[m_leg];
++m_leg;
leg->setVisible( true );
recalculatePileLayouts();
for ( int i = 0; i < 10; ++i )
if ( stack[i] != pile )
updatePileLayout( stack[i], DURATION_RELAYOUT );
for ( int i = 0; i < run.size(); ++i )
{
KCard * c = run.at( i );
leg->add( c );
int duration = DURATION_AUTODROP * (0.7 + i / 10.0);
c->animate( leg->pos(), leg->zValue() + i, 0, true, true, duration );
}
updatePileLayout( pile, DURATION_RELAYOUT );
}
void KlondikeSolver::translate_layout()
{
/* Read the workspace. */
int total = 0;
for ( int w = 0; w < 7; ++w ) {
int i = translate_pile(deal->play[w], W[w], 52);
Wp[w] = &W[w][i - 1];
Wlen[w] = i;
total += i;
}
int i = translate_pile( deal->pile, W[7], 52 );
Wp[7] = &W[7][i-1];
Wlen[7] = i;
total += i;
i = translate_pile( deal->talon, W[8], 52 );
Wp[8] = &W[8][i-1];
Wlen[8] = i;
total += i;
/* Output piles, if any. */
for (int i = 0; i < 4; ++i) {
O[i] = NONE;
}
if (total != 52) {
for (int i = 0; i < 4; ++i) {
KCard *c = deal->target[i]->topCard();
if (c) {
O[translateSuit( c->suit() ) >> 4] = c->rank();
total += c->rank();
}
}
}
}
void GypsySolver::translate_layout()
{
/* Read the workspace. */
for ( int w = 0; w < 8; ++w ) {
int i = translate_pile(deal->store[w], W[w], 52);
Wp[w] = &W[w][i - 1];
Wlen[w] = i;
}
deck = 8;
int i = translate_pile( deal->talon, W[deck], 80 );
Wp[deck] = &W[deck][i-1];
Wlen[deck] = i;
outs = 9;
/* Output piles, if any. */
for (int i = 0; i < 8; ++i)
{
Wlen[outs + i] = 0;
Wp[outs + i] = &W[outs + i][-1];
}
for (int i = 0; i < 8; ++i) {
KCard *c = deal->target[i]->topCard();
if (c) {
int suit = translateSuit( c->suit() ) >> 4;
int target = outs + suit*2;
if ( Wlen[target] )
target++;
Wp[target]++;
Wlen[target]++;
*Wp[target] = ( suit << 4 ) + c->rank();
}
}
}
