/******************************************************
Card.cpp -- support classes for patience type card games
Copyright (C) 1995 Paul Olav Tvete
* 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.
*******************************************************/
#include <math.h>
#include <assert.h>
#include <tqpainter.h>
#include <kdebug.h>
#include "card.h"
#include "pile.h"
#include "cardmaps.h"
static const char *suit_names[] = {"Clubs", "Diamonds", "Hearts", "Spades"};
static const char *rank_names[] = {"Ace", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight",
"Nine", "Ten", "Jack", "Queen", "King" };
// Run time type id
const int Card::RTTI = 1001;
Card::Card( Rank r, Suit s, TQCanvas* _parent )
: TQCanvasRectangle( _parent ),
m_suit( s ), m_rank( r ),
m_source(0), scaleX(1.0), scaleY(1.0), tookDown(false)
{
// Set the name of the card
// FIXME: i18n()
m_name = TQString("%1 %2").arg(suit_names[s-1]).arg(rank_names[r-1]).utf8();
// Default for the card is face up, standard size.
m_faceup = true;
setSize( cardMap::CARDX(), cardMap::CARDY() );
m_destX = 0;
m_destY = 0;
m_destZ = 0;
m_flipping = false;
m_animSteps = 0;
m_flipSteps = 0;
}
Card::~Card()
{
// If the card is in a pile, remove it from there.
if (source())
source()->remove(this);
hide();
}
// ----------------------------------------------------------------
// Member functions regarding graphics
// Return the pixmap of the card
//
TQPixmap Card::pixmap() const
{
return cardMap::self()->image( m_rank, m_suit );
}
// Turn the card if necessary. If the face gets turned up, the card
// is activated at the same time.
//
void Card::turn( bool _faceup )
{
if (m_faceup != _faceup) {
m_faceup = _faceup;
setActive(!isActive()); // abuse
}
}
// Draw the card on the painter 'p'.
//
void Card::draw( TQPainter &p )
{
TQPixmap side;
// Get the image to draw (front / back)
if( isFaceUp() )
side = cardMap::self()->image( m_rank, m_suit, isSelected());
else
side = cardMap::self()->backSide();
// Rescale the image if necessary.
if (scaleX <= 0.98 || scaleY <= 0.98) {
TQWMatrix s;
s.scale( scaleX, scaleY );
side = side.xForm( s );
int xoff = side.width() / 2;
int yoff = side.height() / 2;
p.drawPixmap( int(x() + cardMap::CARDX()/2 - xoff),
int(y() + cardMap::CARDY()/2 - yoff), side );
} else
p.drawPixmap( int(x()), int(y()), side );
}
void Card::moveBy(double dx, double dy)
{
TQCanvasRectangle::moveBy(dx, dy);
}
// Return the X of the cards real position. This is the destination
// of the animation if animated, and the current X otherwise.
//
int Card::realX() const
{
if (animated())
return m_destX;
else
return int(x());
}
// Return the Y of the cards real position. This is the destination
// of the animation if animated, and the current Y otherwise.
//
int Card::realY() const
{
if (animated())
return m_destY;
else
return int(y());
}
// Return the > of the cards real position. This is the destination
// of the animation if animated, and the current Z otherwise.
//
int Card::realZ() const
{
if (animated())
return m_destZ;
else
return int(z());
}
// Return the "face up" status of the card.
//
// This is the destination of the animation if animated and animation
// is more than half way, the original if animated and animation is
// less than half way, and the current "face up" status otherwise.
//
bool Card::realFace() const
{
if (animated() && m_flipping) {
bool face = isFaceUp();
if ( m_animSteps >= m_flipSteps / 2 - 1 )
return !face;
else
return face;
} else
return isFaceUp();
}
/// the following copyright is for the flipping code
/**********************************************************************
** Copyright (C) 2000 Trolltech AS. All rights reserved.
**
** This file is part of TQt Palmtop Environment.
**
** This file may be distributed and/or modified under the terms of the
** GNU General Public License version 2 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
** See http://www.trolltech.com/gpl/ for GPL licensing information.
**
** Contact info@trolltech.com if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
// Used to create an illusion of the card being lifted while flipped.
static const double flipLift = 1.2;
// The current maximum Z value. This is used so that new cards always
// get placed on top of the old ones and don't get placed in the
// middle of a destination pile.
int Card::Hz = 0;
void Card::setZ(double z)
{
TQCanvasRectangle::setZ(z);
if (z > Hz)
Hz = int(z);
}
// Start a move of the card using animation.
//
// 'steps' is the number of steps the animation should take.
//
void Card::moveTo(int x2, int y2, int z2, int steps)
{
m_destX = x2;
m_destY = y2;
m_destZ = z2;
double x1 = x();
double y1 = y();
double dx = x2 - x1;
double dy = y2 - y1;
if (!dx && !dy) {
setZ(z2);
return;
}
setZ(Hz++);
if (steps) {
// Ensure a good speed
while ( fabs(dx/steps)+fabs(dy/steps) < 5.0 && steps > 4 )
steps--;
setAnimated(true);
setVelocity(dx/steps, dy/steps);
m_animSteps = steps;
} else {
// _really_ fast
setAnimated(true);
setAnimated(false);
emit stoped(this);
}
}
// Animate a move to (x2, y2), and at the same time flip the card.
//
void Card::flipTo(int x2, int y2, int steps)
{
// Check that we are not already animating.
assert(!animated());
int x1 = (int)x();
int y1 = (int)y();
double dx = x2 - x1;
double dy = y2 - y1;
// Mark this animation as a flip as well.
m_flipping = true;
m_flipSteps = steps;
// Set the target of the animation
m_destX = x2;
m_destY = y2;
m_destZ = int(z());
// Let the card be above all others during the animation.
setZ(Hz++);
m_animSteps = steps;
setVelocity(dx/m_animSteps, dy/m_animSteps-flipLift);
setAnimated(TRUE);
}
// Advance a card animation one step. This function adds flipping of
// the card to the translation animation that TQCanvasRectangle offers.
//
void Card::advance(int stage)
{
if ( stage==1 ) {
// If the animation is finished, emit stoped. (FIXME: name)
if ( m_animSteps-- <= 0 ) {
setAnimated(false);
emit stoped(this);
} else {
// Animation is not finished. Check for flipping and add
// that animation to the simple translation.
if ( m_flipping ) {
if ( m_animSteps > m_flipSteps / 2 ) {
// animSteps = flipSteps .. flipSteps/2 (flip up) -> 1..0
scaleX = ((double)m_animSteps/m_flipSteps-0.5)*2;
} else {
// animSteps = flipSteps/2 .. 0 (flip down) -> 0..1
scaleX = 1-((double)m_animSteps/m_flipSteps)*2;
}
if ( m_animSteps == m_flipSteps / 2-1 ) {
setYVelocity(yVelocity()+flipLift*2);
turn( !isFaceUp() );
}
}
}
}
// Animate the translation of the card.
TQCanvasRectangle::advance(stage);
}
// Set 'animated' status to a new value, and set secondary values as
// well.
//
void Card::setAnimated(bool anim)
{
// If no more animation, reset some other values as well.
if (animated() && !anim) {
// Reset all things that might have changed during the animation.
scaleX = 1.0;
scaleY = 1.0;
m_flipping = FALSE;
setVelocity(0, 0);
// Move the card to its destination immediately.
move(m_destX, m_destY);
setZ(m_destZ);
}
TQCanvasRectangle::setAnimated(anim);
}
void Card::setTakenDown(bool td)
{
if (td)
kdDebug(11111) << "took down " << name() << endl;
tookDown = td;
}
bool Card::takenDown() const
{
return tookDown;
}
// Get the card to the top.
void Card::getUp(int steps)
{
m_destZ = int(z());
m_destX = int(x());
m_destY = int(y());
setZ(Hz+1);
// Animation
m_animSteps = steps;
setVelocity(0, 0);
setAnimated(TRUE);
}
#include "card.moc"