Git-Mirrors/RetroShare
1
0
Fork 0
mirror of https://github.com/RetroShare/RetroShare.git synced 2025-06-19 03:49:29 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

added game plugin solocards

Browse source 
git-svn-id: http://svn.code.sf.net/p/retroshare/code/trunk@2346 b45a01b8-16f6-495d-af2f-9b41ad6348cc
This commit is contained in:
defnax 2010-02-17 01:14:52 +00:00
parent f2f23e7ece
commit 082d5732b0
92 changed files with 24978 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

259
plugins/qsolocards_plugin/KlondikeFlipStack.cpp Normal file
View file

@ -0,0 +1,259 @@
/*
QSoloCards is a collection of Solitaire card games written using Qt
Copyright (C) 2009 Steve Moore
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 3 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 "KlondikeFlipStack.h"
#include "CardPixmaps.h"
#include <QtGui/QPainter>
#include <QtGui/QPixmap>
const qreal KlondikeFlipStack::ExposedPrecent=.18;
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
KlondikeFlipStack::KlondikeFlipStack()
:CardStack(),
m_bRectVector(),
m_cardsShown(1),
m_firstShowCard(0)
{
}
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
KlondikeFlipStack::~KlondikeFlipStack()
{
}
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
QPointF KlondikeFlipStack::getGlobalCardAddPt() const
{
QPointF pt(0,0);
const PlayingCardVector & cardVector=this->getCardVector();
// We are going to do this by the bounding rects and not by actual cards
// in the stacks. That way we can add something before doing animations
// and then update the display when the animation is complete
if (m_bRectVector.size()>0 && cardVector.size()>=m_bRectVector.size())
{
pt=m_bRectVector[m_bRectVector.size()-1].topLeft();
pt.rx()+=this->getOverlapIncrement(cardVector,m_bRectVector.size()-1,m_firstShowCard);
}
return mapToScene(pt);
}
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
QPointF KlondikeFlipStack::getGlobalLastCardPt() const
{
QPointF pt(0,0);
const PlayingCardVector & cardVector=this->getCardVector();
// We are going to do this by the bounding rects and not by actual cards
// in the stacks. That way we can add something before doing animations
// and then update the display when the animation is complete
if (m_bRectVector.size()>0 && cardVector.size()>=m_bRectVector.size())
{
pt=m_bRectVector[m_bRectVector.size()-1].topLeft();
}
return mapToScene(pt);
}
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
QPointF KlondikeFlipStack::getGlobalCardPt(int index) const
{
QPointF pt(0,0);
if (index>=0 && index<(int)m_bRectVector.size())
{
pt=m_bRectVector[index].topLeft();
}
return mapToScene(pt);
}
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
void KlondikeFlipStack::updateStack()
{
PlayingCardVector cardVector=this->getCardVector();
m_bRectVector.clear();
// if the stack has no cards in it just call the base
// class to render the empty stack.
if (0==cardVector.size())
{
CardStack::updateStack();
return;
}
// figure out the index of the first card to show
if (m_cardsShown>=cardVector.size())
{
m_firstShowCard=0;
}
else
{
m_firstShowCard=cardVector.size()-m_cardsShown;
}
// now calc the size of the pixmap we will need
QSize pixmapSize;
this->calcPixmapSize(cardVector,pixmapSize,m_firstShowCard);
QPixmap pixmap(pixmapSize);
// for linux the transparent fill must be done before
// we associate the pixmap with the painter
pixmap.fill(Qt::transparent);
QPainter painter;
painter.begin(&pixmap);
QPoint pt(0,0);
QSize cardSize(CardPixmaps::getInst().getCardSize());
unsigned int i;
for (i=0;i<cardVector.size();i++)
{
unsigned int incrementValue=getOverlapIncrement(cardVector,i,
m_firstShowCard);
if (i>=m_firstShowCard)
{
bool hl=((hintHighlightIndex()>=0 && hintHighlightIndex()<=(int)i) ||
((cardVector.size()-1==i) && isHighlighted()));
if (cardVector[i].isFaceUp())
{
painter.drawPixmap(pt,CardPixmaps::getInst().getCardPixmap(cardVector[i],hl));
}
else
{
painter.drawPixmap(pt,CardPixmaps::getInst().getCardBackPixmap(hl));
}
}
if (cardVector.size()-1==i)
{
m_bRectVector.push_back(QRectF(QPoint(pt.x(),0),
cardSize));
}
else
{
m_bRectVector.push_back(QRectF(QPoint(pt.x(),0),
QSize(incrementValue,cardSize.height())));
}
// increment the point that we are going to paint the
// card pixmap onto this pixmap
pt.rx()+=incrementValue;
}
painter.end();
this->setPixmap(pixmap);
}
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
bool KlondikeFlipStack::getCardIndex(const QPointF & pos,unsigned int & index)
{
bool rc=false;
unsigned int i;
// go through the bounding rect backwards. The ones lower for cards that are
// not visible are just place holders.
for(i=m_bRectVector.size();i>0;i--)
{
if (m_bRectVector[i-1].contains(pos))
{
index=i-1;
rc=true;
break;
}
}
return rc;
}
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
void KlondikeFlipStack::calcPixmapSize(const PlayingCardVector & cardVector,
QSize & size,unsigned int showIndex)
{
QSize cardSize(CardPixmaps::getInst().getCardSize());
unsigned int i;
size.setWidth(0);
size.setHeight(cardSize.height());
for(i=0;i<cardVector.size();i++)
{
if (cardVector.size()-1==i)
{
size.rwidth()+=cardSize.width();
}
else
{
size.rwidth()+=this->getOverlapIncrement(cardVector,i,showIndex);
}
}
}
///////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////
int KlondikeFlipStack::getOverlapIncrement(const PlayingCardVector & cardVector,
unsigned int index,unsigned int showIndex) const
{
int increment=0;
if (index<cardVector.size())
{
if (index>=showIndex)
{
increment=CardPixmaps::getInst().getCardSize().width()*ExposedPrecent;
}
}
return increment;
}
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
bool KlondikeFlipStack::canMoveCard(unsigned int index) const
{
bool rc=false;
// ok the only time a card can be moved is if the card is the last in the stack.
if (!this->isEmpty() && (index==(this->getCardVector().size()-1)))
{
rc=true;
}
return rc;
}