SlackwareThis Forum is for the discussion of Slackware Linux.
Notices
Welcome to LinuxQuestions.org, a friendly and active Linux Community.
You are currently viewing LQ as a guest. By joining our community you will have the ability to post topics, receive our newsletter, use the advanced search, subscribe to threads and access many other special features. Registration is quick, simple and absolutely free. Join our community today!
Note that registered members see fewer ads, and ContentLink is completely disabled once you log in.
If you have any problems with the registration process or your account login, please contact us. If you need to reset your password, click here.
Having a problem logging in? Please visit this page to clear all LQ-related cookies.
Get a virtual cloud desktop with the Linux distro that you want in less than five minutes with Shells! With over 10 pre-installed distros to choose from, the worry-free installation life is here! Whether you are a digital nomad or just looking for flexibility, Shells can put your Linux machine on the device that you want to use.
Exclusive for LQ members, get up to 45% off per month. Click here for more info.
My wife refuses to give up kde3, because they changed the rules for her favorite solitaire-game "Mod3" in Kpat in kde4,
This means that I am responsible for kde 3 to be present on her computer (slackware 13.1)
It works now, but soon I am afraid that my reputation as "the data-guru" is going down a couple of points if
I can't came up with something else.
I don't knew anything about programming but found two files. mod3.cpp and mod3.h in the source-file of kpat (kde 4.4.3).
I belive this is C++ and in mod5.cpp I found this..
Code:
// Special pile type used for the fourth row. Automatically grabs a new card
// from the deck when emptied.
class Mod3Pile : public Pile
{
public:
Mod3Pile( int _index, Pile * pile, const QString & objectName = QString() )
: Pile( _index, objectName ), drawPile( pile ) {}
virtual void relayoutCards()
{
if ( isEmpty() && !drawPile->isEmpty() )
animatedAdd( drawPile->top(), true );
else
Pile::relayoutCards();
}
Pile * drawPile;
};
..in kde3 it doesn't "automatically grabs a new card from the deck" when there is a empty place in the fourth raw,
you can pick any card you want to go there...and that is how my wife likes it.
I don't knew anything about programming but found two files. mod3.cpp and mod3.h in the source-file of kpat (kde 4.4.3).
I belive this is C++ and in mod5.cpp I found this..
Code:
// Special pile type used for the fourth row. Automatically grabs a new card
// from the deck when emptied.
class Mod3Pile : public Pile
{
public:
Mod3Pile( int _index, Pile * pile, const QString & objectName = QString() )
: Pile( _index, objectName ), drawPile( pile ) {}
virtual void relayoutCards()
{
if ( isEmpty() && !drawPile->isEmpty() )
animatedAdd( drawPile->top(), true );
else
Pile::relayoutCards();
}
Pile * drawPile;
};
..in kde3 it doesn't "automatically grabs a new card from the deck" when there is a empty place in the fourth raw,
you can pick any card you want to go there...and that is how my wife likes it.
Is it possible to modify this so it does that?
/Håkan
Assuming that is the class definition for the pile used in the mod3 game, you can probably remove the if check and just have it run Pile::relayoutCards() by default -- but I have *not* tested this and I have *not* looked over the code so I don't know what happens when Pile::relayoutCards() is called with an empty place. I also have not played this version of the game so definitely be cautious with my guess. If it does cause a problem when calling Pile::relayoutCards() with an empty place then you may need to check for the empty space but do not run animatedAdd() if found...but that may have other consequences.
I am not too strong in C++, and I certainly haven't looked over *anything* so keep that in mind. The following *might* work.
Code:
// Special pile type used for the fourth row. Automatically grabs a new card
// from the deck when emptied.
class Mod3Pile : public Pile
{
public:
Mod3Pile( int _index, Pile * pile, const QString & objectName = QString() )
: Pile( _index, objectName ), drawPile( pile ) {}
virtual void relayoutCards()
{
Pile::relayoutCards();
}
Pile * drawPile;
};
I'm sure there's a more elegant solution as well, especially since Mod3Pile::relayoutCards() is just calling Pile::relayoutCards() from the base class, but aside from bad form the above might work.
Now in Kde 4.5.5 they have changed the "c++" for "mod3" so I am lost again , is there anyone who can help me solve this (to the same behavior as above).
Code:
/*
* Copyright (C) 1997 Rodolfo Borges <barrett@labma.ufrj.br>
* Copyright (C) 1998-2009 Stephan Kulow <coolo@kde.org>
* Copyright (C) 2010 Parker Coates <parker.coates@kdemail.net>
*
* License of original code:
* -------------------------------------------------------------------------
* Permission to use, copy, modify, and distribute this software and its
* documentation for any purpose and without fee is hereby granted,
* provided that the above copyright notice appear in all copies and that
* both that copyright notice and this permission notice appear in
* supporting documentation.
*
* This file is provided AS IS with no warranties of any kind. The author
* shall have no liability with respect to the infringement of copyrights,
* trade secrets or any patents by this file or any part thereof. In no
* event will the author be liable for any lost revenue or profits or
* other special, indirect and consequential damages.
* -------------------------------------------------------------------------
*
* License of modifications/additions made after 2009-01-01:
* -------------------------------------------------------------------------
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of
* the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
* -------------------------------------------------------------------------
*/
#include "mod3.h"
#include "dealerinfo.h"
#include "patsolve/mod3solver.h"
#include "Shuffle"
#include <KLocale>
void Mod3::initialize()
{
// Piles are placed very close together. Set layoutSpacing to 0 to prevent
// interference between them.
setLayoutSpacing(0.0);
const qreal dist_x = 1.114;
const qreal dist_y = 1.31;
const qreal bottomRowY = 3 * dist_y + 0.2;
const qreal rightColumX = 8 * dist_x + 0.8;
// This patience uses 2 deck of cards.
static_cast<KStandardCardDeck*>( deck() )->setDeckContents( 2 );
talon = new PatPile( this, 0, "talon" );
talon->setPileRole(PatPile::Stock);
talon->setLayoutPos(rightColumX, bottomRowY);
talon->setSpread(0, 0);
talon->setKeyboardSelectHint( KCardPile::NeverFocus );
talon->setKeyboardDropHint( KCardPile::NeverFocus );
connect( talon, SIGNAL(clicked(KCard*)), SLOT(drawDealRowOrRedeal()) );
aces = new PatPile( this, 50, "aces");
aces->setPileRole(PatPile::FoundationType1);
aces->setLayoutPos(rightColumX, 0.5);
aces->setReservedSpace( 0, 0, 1, 2 );
aces->setKeyboardSelectHint( KCardPile::NeverFocus );
aces->setKeyboardDropHint( KCardPile::ForceFocusTop );
for ( int r = 0; r < 4; ++r )
{
for ( int c = 0; c < 8; ++c )
{
int pileIndex = r * 10 + c + 1;
QString objectName = QString( "stack%1_%2" ).arg( r ).arg( c );
stack[r][c] = new PatPile( this, pileIndex, objectName );
// The first 3 rows are the playing field, the fourth is the store.
if ( r < 3 )
{
stack[r][c]->setLayoutPos( dist_x * c, dist_y * r );
// Very tight spread makes it easy to quickly tell number of
// cards in each pile and we don't care about the cards beneath.
stack[r][c]->setSpread( 0, 0.08 );
stack[r][c]->setReservedSpace( 0, 0, 1, 1.23 );
}
else
{
stack[r][c]->setLayoutPos( dist_x * c, bottomRowY );
stack[r][c]->setReservedSpace( 0, 0, 1, 1.8 );
}
stack[r][c]->setPileRole( r == 0 ? PatPile::FoundationType2
: r == 1 ? PatPile::FoundationType3
: r == 2 ? PatPile::FoundationType4
: PatPile::Tableau );
stack[r][c]->setKeyboardSelectHint( KCardPile::AutoFocusTop );
stack[r][c]->setKeyboardDropHint( KCardPile::AutoFocusTop );
}
}
setActions(DealerScene::Hint | DealerScene::Demo | DealerScene::Deal);
setSolver( new Mod3Solver( this ) );
}
bool mod3CheckAdd(int baseRank, const QList<KCard*> & oldCards, const QList<KCard*> & newCards)
{
if (oldCards.isEmpty())
return getRank( newCards.first() ) == baseRank;
else
return getRank( oldCards.first() ) == baseRank
&& getSuit( newCards.first() ) == getSuit( oldCards.last() )
&& getRank( newCards.first() ) == getRank( oldCards.last() ) + 3;
}
bool Mod3::checkAdd(const PatPile * pile, const QList<KCard*> & oldCards, const QList<KCard*> & newCards) const
{
switch (pile->pileRole())
{
case PatPile::FoundationType1:
return newCards.size() == 1 && getRank( newCards.first() ) == KStandardCardDeck::Ace;
case PatPile::FoundationType2:
return mod3CheckAdd(KStandardCardDeck::Two, oldCards, newCards);
case PatPile::FoundationType3:
return mod3CheckAdd(KStandardCardDeck::Three, oldCards, newCards);
case PatPile::FoundationType4:
return mod3CheckAdd(KStandardCardDeck::Four, oldCards, newCards);
case PatPile::Tableau:
return oldCards.isEmpty();
case PatPile::Stock:
default:
return false;
}
}
bool Mod3::checkRemove(const PatPile * pile, const QList<KCard*> & cards) const
{
switch (pile->pileRole())
{
case PatPile::FoundationType2:
case PatPile::FoundationType3:
case PatPile::FoundationType4:
case PatPile::Tableau:
return cards.first() == pile->top();
case PatPile::FoundationType1:
case PatPile::Stock:
default:
return false;
}
}
void Mod3::moveCardsToPile( QList<KCard*> cards, KCardPile * pile, int duration )
{
PatPile * p = dynamic_cast<PatPile*>( cards.first()->pile() );
DealerScene::moveCardsToPile( cards, pile, duration );
if ( p
&& p->pileRole() == PatPile::Tableau
&& p->isEmpty()
&& !talon->isEmpty() )
{
flipCardToPile( talon->top(), p, duration );
}
}
void Mod3::restart()
{
clearHighlightedItems();
QList<KCard*> cards = shuffled( deck()->cards(), gameNumber() );
while ( !cards.isEmpty() )
{
KCard * c = cards.takeFirst();
c->setPos( talon->pos() );
c->setFaceUp( false );
talon->add( c );
}
for ( int r = 0; r < 4; r++ )
{
for ( int c = 0; c < 8; ++c )
{
KCard * card = talon->top();
card->setFaceUp( true );
moveCardToPileAtSpeed( card, stack[r][c], DEAL_SPEED );
// Fudge the z values to keep cards from popping through one another.
card->setZValue( card->zValue() + ((4 - r) * (4 - r)) + ((8 - c) * (8 - c)) );
}
}
emit newCardsPossible(true);
}
bool Mod3::newCards()
{
if ( talon->isEmpty() )
return false;
for ( int c = 0; c < 8; ++c )
{
if ( talon->isEmpty() )
break;
flipCardToPileAtSpeed( talon->top(), stack[3][c], DEAL_SPEED * 2 );
}
if (talon->isEmpty())
emit newCardsPossible(false);
return true;
}
void Mod3::setGameState(const QString &)
{
emit newCardsPossible(!talon->isEmpty());
}
static class Mod3DealerInfo : public DealerInfo
{
public:
Mod3DealerInfo()
: DealerInfo(I18N_NOOP("Mod3"), Mod3Id)
{}
virtual DealerScene *createGame() const
{
return new Mod3();
}
} mod3DealerInfo;
#include "mod3.moc"
OK, they really changed a lot and this is not as obvious. I haven't tested this, so I may be wrong, but I believe the following patch should work for mod3.cpp:
LinuxQuestions.org is looking for people interested in writing
Editorials, Articles, Reviews, and more. If you'd like to contribute
content, let us know.