615 lines
16 KiB
C++
615 lines
16 KiB
C++
/***************************************************************************/
|
|
/** Microsoft Windows **/
|
|
/** Copyright(c) Microsoft Corp., 1991, 1992 **/
|
|
/***************************************************************************/
|
|
|
|
/****************************************************************************
|
|
|
|
player.cpp
|
|
|
|
Aug 92, JimH
|
|
May 93, JimH chico port
|
|
|
|
Methods for player objects
|
|
|
|
****************************************************************************/
|
|
|
|
#include "hearts.h"
|
|
|
|
#include "main.h" // friendly access
|
|
#include "resource.h"
|
|
#include "debug.h"
|
|
|
|
#include <stdlib.h> // qsort() prototype
|
|
#include <stdio.h>
|
|
|
|
|
|
extern "C" { // compare routine for qsort()
|
|
int __cdecl CompareCards(card *c1, card *c2);
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
player::player
|
|
|
|
****************************************************************************/
|
|
|
|
player::player(int n, int pos) : id(n), position(pos)
|
|
{
|
|
// Set up font
|
|
BYTE charset = 0;
|
|
int fontsize = 0;
|
|
CString fontname, charsetstr, fontsizestr;
|
|
fontname.LoadString(IDS_FONTFACE);
|
|
charsetstr.LoadString(IDS_CHARSET);
|
|
fontsizestr.LoadString(IDS_FONTSIZE);
|
|
charset = (BYTE)_ttoi(charsetstr);
|
|
fontsize = _ttoi(fontsizestr);
|
|
font.CreateFont(fontsize, 0, 0, 0, 700, 0, 0, 0, charset, 0, 0, 0, 0, fontname);
|
|
|
|
CRect rect = CMainWindow::m_TableRect;
|
|
|
|
POINT centre;
|
|
const int offset = 30; // offset from centre for playloc
|
|
|
|
mode = STARTING;
|
|
|
|
centre.x = (rect.right / 2) - (card::dxCrd / 2);
|
|
centre.y = (rect.bottom / 2) - (card::dyCrd / 2);
|
|
playloc = centre;
|
|
score = 0;
|
|
|
|
CClientDC dc(::pMainWnd);
|
|
TEXTMETRIC tm;
|
|
dc.GetTextMetrics(&tm);
|
|
int nTextHeight = tm.tmHeight + tm.tmExternalLeading;
|
|
|
|
switch (position) {
|
|
case 0:
|
|
loc.x = (rect.right - (12 * HORZSPACING + card::dxCrd)) / 2;
|
|
loc.y = rect.bottom - card::dyCrd - IDGE;
|
|
dx = HORZSPACING;
|
|
dy = 0;
|
|
playloc.x -= 5;
|
|
playloc.y += offset;
|
|
dotloc.x = loc.x + (HORZSPACING / 2);
|
|
dotloc.y = loc.y - IDGE;
|
|
homeloc.x = playloc.x;
|
|
homeloc.y = rect.bottom + card::dyCrd;
|
|
nameloc.x = loc.x + card::dxCrd + IDGE;
|
|
nameloc.y = rect.bottom - nTextHeight - IDGE;
|
|
break;
|
|
|
|
case 1:
|
|
loc.x = 3 * IDGE;
|
|
loc.y = (rect.bottom - (12 * VERTSPACING + card::dyCrd)) / 2;
|
|
dx = 0;
|
|
dy = VERTSPACING;
|
|
playloc.x -= offset;
|
|
playloc.y -= 5;
|
|
dotloc.x = loc.x + card::dxCrd + IDGE;
|
|
dotloc.y = loc.y + (VERTSPACING / 2);
|
|
homeloc.x = -card::dxCrd;
|
|
homeloc.y = playloc.y;
|
|
nameloc.x = loc.x + 2;
|
|
nameloc.y = loc.y - nTextHeight;
|
|
break;
|
|
|
|
case 2:
|
|
loc.x = ((rect.right - (12 * HORZSPACING + card::dxCrd)) / 2)
|
|
+ (12 * HORZSPACING);
|
|
loc.y = IDGE;
|
|
dx = -HORZSPACING;
|
|
dy = 0;
|
|
playloc.x += 5;
|
|
playloc.y -= offset;
|
|
dotloc.x = loc.x + card::dxCrd - (HORZSPACING / 2);
|
|
dotloc.y = loc.y + card::dyCrd + IDGE;
|
|
homeloc.x = playloc.x;
|
|
homeloc.y = -card::dyCrd;
|
|
nameloc.x = ((rect.right - (12 * HORZSPACING + card::dxCrd)) / 2)
|
|
+ (12 * HORZSPACING) + card::dxCrd + IDGE;
|
|
nameloc.y = IDGE;
|
|
break;
|
|
|
|
case 3:
|
|
loc.x = rect.right - (card::dxCrd + (3 * IDGE));
|
|
loc.y = ((rect.bottom - (12 * VERTSPACING + card::dyCrd)) / 2)
|
|
+ (12 * VERTSPACING);
|
|
dx = 0;
|
|
dy = -VERTSPACING;
|
|
playloc.x += offset;
|
|
playloc.y += 5;
|
|
dotloc.x = loc.x - IDGE;
|
|
dotloc.y = loc.y + card::dyCrd - (VERTSPACING / 2);
|
|
homeloc.x = rect.right;
|
|
homeloc.y = playloc.y;
|
|
nameloc.x = ((rect.right - (12 * HORZSPACING + card::dxCrd)) / 2)
|
|
- IDGE - 2;
|
|
nameloc.y = ((rect.bottom - (12 * VERTSPACING + card::dyCrd)) / 2)
|
|
+ (12 * VERTSPACING) + card::dyCrd;
|
|
break;
|
|
}
|
|
|
|
ResetLoc();
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
player::ResetLoc
|
|
|
|
This routine puts cards in locations based on their slot number.
|
|
It is used to initialize their x,y locs, or after cards have been sorted.
|
|
|
|
****************************************************************************/
|
|
|
|
void player::ResetLoc()
|
|
{
|
|
int x = loc.x;
|
|
int y = loc.y;
|
|
|
|
for (SLOT s = 0; s < MAXSLOT; s++)
|
|
{
|
|
if (cd[s].IsInHand())
|
|
cd[s].SetLoc(x, y);
|
|
x += dx;
|
|
y += dy;
|
|
}
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
player::Sort
|
|
|
|
****************************************************************************/
|
|
|
|
void player::Sort()
|
|
{
|
|
qsort( (void *)cd,
|
|
MAXSLOT,
|
|
sizeof(card),
|
|
(int (__cdecl *)(const void *, const void *))CompareCards );
|
|
|
|
ResetLoc();
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
CompareCards
|
|
|
|
This is the compare function for player::Sort.
|
|
|
|
Aces are high, cards not in hand sort high, and order of suits is
|
|
clubs, diamonds, spades, hearts (alternating colours)
|
|
|
|
****************************************************************************/
|
|
|
|
int __cdecl CompareCards(card *c1, card *c2)
|
|
{
|
|
int v1 = c1->Value2();
|
|
int v2 = c2->Value2();
|
|
int s1 = c1->Suit();
|
|
int s2 = c2->Suit();
|
|
|
|
if (!(c1->IsInHand()))
|
|
v1 = EMPTY;
|
|
|
|
if (!(c2->IsInHand()))
|
|
v2 = EMPTY;
|
|
|
|
if (v1 == EMPTY || v2 == EMPTY)
|
|
{
|
|
if (v1 == v2) // they're both EMPTY
|
|
return 0;
|
|
else if (v1 == EMPTY)
|
|
return 1;
|
|
else
|
|
return -1;
|
|
}
|
|
|
|
if (s1 != s2) // different suits?
|
|
{
|
|
if (s1 == HEARTS && s2 == SPADES) // these two suits reversed
|
|
return 1;
|
|
else if (s1 == SPADES && s2 == HEARTS)
|
|
return -1;
|
|
else
|
|
return (s1 - s2);
|
|
}
|
|
|
|
return (v1 - v2);
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
player::GetSlot
|
|
|
|
converts a card id to a slot number
|
|
|
|
****************************************************************************/
|
|
|
|
SLOT player::GetSlot(int id)
|
|
{
|
|
SLOT s = EMPTY;
|
|
|
|
for (int num = 0; num < MAXSLOT; num++)
|
|
{
|
|
if (GetID(num) == id)
|
|
{
|
|
s = num;
|
|
break;
|
|
}
|
|
}
|
|
|
|
ASSERT(s != EMPTY);
|
|
return s;
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
player::GetCardLoc
|
|
|
|
Loc gets location of upper-left corner of specified card slot.
|
|
Returns true if slot s is valid.
|
|
|
|
****************************************************************************/
|
|
|
|
BOOL player::GetCardLoc(SLOT s, POINT& loc)
|
|
{
|
|
if (!cd[s].IsValid())
|
|
return FALSE;
|
|
|
|
loc.x = cd[s].GetX();
|
|
loc.y = cd[s].GetY();
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
player::GetCoverRect
|
|
|
|
returns a rect that covers all cards in hand
|
|
|
|
****************************************************************************/
|
|
|
|
CRect &player::GetCoverRect(CRect& rect)
|
|
{
|
|
rect.left = (dx < 0 ? loc.x + 12 * dx : loc.x);
|
|
rect.right = rect.left + (dx != 0 ?
|
|
card::dxCrd + 12 * abs(dx) : card::dxCrd);
|
|
rect.top = (dy < 0 ? loc.y + 12 * dy : loc.y);
|
|
rect.bottom = rect.top + (dy != 0 ?
|
|
card::dyCrd + 12 * abs(dy) : card::dyCrd);
|
|
|
|
// expand rect to include selection indicators
|
|
|
|
if (position == 0)
|
|
rect.top -= POPSPACING;
|
|
else if (position == 1)
|
|
rect.right += 2 * IDGE;
|
|
else if (position == 2)
|
|
rect.bottom += 2 * IDGE;
|
|
else
|
|
rect.left -= 2 * IDGE;
|
|
|
|
return rect;
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
rect::GetMarkingRect
|
|
|
|
returns a rect that covers all selection marking dots
|
|
|
|
****************************************************************************/
|
|
|
|
CRect &player::GetMarkingRect(CRect& rect)
|
|
{
|
|
rect.left = (dx < 0 ? dotloc.x + (12 * dx) : dotloc.x);
|
|
rect.right = (dx < 0 ? dotloc.x + 2 : dotloc.x + (12 * dx) + 2);
|
|
rect.top = (dy < 0 ? dotloc.y + (12 * dy) : dotloc.y);
|
|
rect.bottom = (dy < 0 ? dotloc.y + 2 : dotloc.y + (12 * dy) + 2);
|
|
|
|
return rect;
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
player::Draw
|
|
|
|
Draws all the cards belonging to this player. bCheating defaults to
|
|
FALSE, and SLOT defaults to ALL.
|
|
|
|
****************************************************************************/
|
|
|
|
void player::Draw(CDC &dc, BOOL bCheating, SLOT slot)
|
|
{
|
|
DisplayName(dc);
|
|
SLOT start = (slot == ALL ? 0 : slot);
|
|
SLOT stop = (slot == ALL ? MAXSLOT : slot+1);
|
|
|
|
SLOT playedslot = EMPTY; // must draw cards in play last for EGA
|
|
|
|
for (SLOT s = start; s < stop; s++)
|
|
{
|
|
if (cd[s].IsPlayed())
|
|
playedslot = s; // save and draw later
|
|
else if (bCheating)
|
|
cd[s].Draw(dc);
|
|
else
|
|
cd[s].Draw(dc, FACEDOWN);
|
|
}
|
|
|
|
if (playedslot != EMPTY)
|
|
cd[playedslot].Draw(dc);
|
|
}
|
|
|
|
void player::DisplayName(CDC &dc)
|
|
{
|
|
CFont *oldfont = dc.SelectObject(&font);
|
|
dc.SetBkColor(::pMainWnd->GetBkColor());
|
|
dc.TextOut(nameloc.x, nameloc.y, name, name.GetLength());
|
|
dc.SelectObject(oldfont);
|
|
}
|
|
|
|
void player::SetName(CString& newname, CDC& dc)
|
|
{
|
|
static RECT rect; // client rect of main window
|
|
static BOOL bFirst = TRUE; // first time through this routine?
|
|
|
|
if (bFirst)
|
|
::pMainWnd->GetClientRect(&rect);
|
|
|
|
if (rect.right > 100) // app started non-iconic
|
|
bFirst = FALSE;
|
|
|
|
name = newname;
|
|
CFont *oldfont = dc.SelectObject(&font);
|
|
if (position == 0)
|
|
{
|
|
CSize size = dc.GetTextExtent(name, name.GetLength());
|
|
nameloc.x = ((rect.right - (12 * HORZSPACING + card::dxCrd)) / 2)
|
|
- IDGE - size.cx;
|
|
}
|
|
else if (position == 3)
|
|
{
|
|
CSize size = dc.GetTextExtent(name, name.GetLength());
|
|
nameloc.x = rect.right - size.cx - (3*IDGE) - 2;
|
|
}
|
|
dc.SelectObject(oldfont);
|
|
}
|
|
|
|
/****************************************************************************
|
|
|
|
player::ReturnSelectedCards
|
|
player::ReceiveSelectedCards
|
|
|
|
When cards are passed from player to player, the first function is used
|
|
to return the selected cards. The second is used to pass another player's
|
|
selections in.
|
|
|
|
****************************************************************************/
|
|
|
|
void player::ReturnSelectedCards(int c[])
|
|
{
|
|
c[0] = EMPTY; // default
|
|
c[1] = EMPTY;
|
|
c[2] = EMPTY;
|
|
|
|
if (mode == STARTING || mode == SELECTING)
|
|
return;
|
|
|
|
for (int i = 0, j = 0; j < 3; i++)
|
|
{
|
|
if (cd[i].IsSelected())
|
|
c[j++] = cd[i].ID();
|
|
|
|
if (i >= MAXSLOT)
|
|
{ ASSERT(i < MAXSLOT); }
|
|
}
|
|
}
|
|
|
|
void player::ReceiveSelectedCards(int c[])
|
|
{
|
|
for (int i = 0, j = 0; j < 3; i++)
|
|
{
|
|
if (cd[i].IsSelected())
|
|
{
|
|
cd[i].SetID(c[j++]);
|
|
cd[i].Select(FALSE);
|
|
}
|
|
ASSERT(i < MAXSLOT);
|
|
}
|
|
|
|
SetMode(WAITING);
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
player::MarkSelectedCards
|
|
|
|
This virtual function puts white dots beside selected cards for all
|
|
non-local_human players.
|
|
|
|
****************************************************************************/
|
|
|
|
void player::MarkSelectedCards(CDC &dc)
|
|
{
|
|
COLORREF color = RGB(255, 255, 255);
|
|
|
|
for (int s = 0; s < MAXSLOT; s++)
|
|
{
|
|
if (cd[s].IsSelected())
|
|
{
|
|
int x = dotloc.x + (s * dx);
|
|
int y = dotloc.y + (s * dy);
|
|
dc.SetPixel(x, y, color);
|
|
dc.SetPixel(x+1, y, color);
|
|
dc.SetPixel(x, y+1, color);
|
|
dc.SetPixel(x+1, y+1, color);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
player::GlideToCentre
|
|
|
|
This function takes a selected card and glides it to its play location.
|
|
The other normal cards (cards still in hand) are each checked to see if
|
|
the card is to be moved. If so, their image is drawn into the background
|
|
bitmap.
|
|
|
|
****************************************************************************/
|
|
|
|
void player::GlideToCentre(SLOT s, BOOL bFaceup)
|
|
{
|
|
CRect rectCard, rectSrc, rectDummy;
|
|
|
|
CClientDC dc(::pMainWnd);
|
|
#ifdef USE_MIRRORING
|
|
SetLayout(dc.m_hDC, 0);
|
|
SetLayout(dc.m_hAttribDC, 0);
|
|
#endif
|
|
|
|
CDC *memdc = new CDC;
|
|
memdc->CreateCompatibleDC(&dc);
|
|
|
|
memdc->SelectObject(&card::m_bmBgnd);
|
|
memdc->SelectObject(&CMainWindow::m_BgndBrush);
|
|
memdc->PatBlt(0, 0, card::dxCrd, card::dyCrd, PATCOPY);
|
|
|
|
cd[s].GetRect(rectCard);
|
|
|
|
for (SLOT i = 0; i < MAXSLOT; i++)
|
|
{
|
|
if (cd[i].IsNormal() && (i != s))
|
|
{
|
|
cd[i].GetRect(rectSrc);
|
|
if (IntersectRect(&rectDummy, &rectSrc, &rectCard))
|
|
{
|
|
cd[i].Draw(*memdc, // CDC
|
|
rectSrc.left-rectCard.left, // x
|
|
rectSrc.top-rectCard.top, // y
|
|
bFaceup ? FACEUP : FACEDOWN, // mode
|
|
FALSE); // don't update loc
|
|
}
|
|
}
|
|
}
|
|
delete memdc; // must delete before Glide() called
|
|
|
|
cd[s].CleanDraw(dc);
|
|
cd[s].Glide(dc, playloc.x, playloc.y); // glide to play location
|
|
cd[s].Play(); // mark card as played
|
|
|
|
SetMode(WAITING);
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
player::ResetCardsWon
|
|
|
|
cardswon[] keeps track of point cards won this hand. This function
|
|
clears this data for a new hand.
|
|
|
|
****************************************************************************/
|
|
|
|
void player::ResetCardsWon()
|
|
{
|
|
for (int i = 0; i < MAXCARDSWON; i++)
|
|
cardswon[i] = EMPTY;
|
|
|
|
numcardswon = 0;
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
player::WinCard
|
|
|
|
Cards won in tricks are passed in. If they are point cards (hearts
|
|
or queen on spades) the id is saved in cardswon[].
|
|
|
|
****************************************************************************/
|
|
|
|
void player::WinCard(CDC &dc, card *c)
|
|
{
|
|
if ((c->IsHeart()) || (c->ID() == BLACKLADY))
|
|
cardswon[numcardswon++] = c->ID();
|
|
|
|
RegEntry Reg(szRegPath);
|
|
DWORD dwSpeed = Reg.GetNumber(regvalSpeed, IDC_NORMAL);
|
|
|
|
int oldstep = c->SetStepSize(dwSpeed == IDC_SLOW ? 5 : 30);
|
|
c->Glide(dc, homeloc.x, homeloc.y);
|
|
c->SetStepSize(oldstep);
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
player::EvaluateScore
|
|
|
|
Points stored in cardswon[] are added to players total score.
|
|
|
|
****************************************************************************/
|
|
|
|
int player::EvaluateScore(BOOL &bMoonShot)
|
|
{
|
|
for (int i = 0; i < MAXCARDSWON; i++)
|
|
{
|
|
if (cardswon[i] == BLACKLADY)
|
|
score += 13;
|
|
else if (cardswon[i] != EMPTY)
|
|
score++;
|
|
}
|
|
|
|
if (cardswon[MAXCARDSWON-1] != EMPTY) // if player got ALL point cards
|
|
bMoonShot = TRUE;
|
|
else
|
|
bMoonShot = FALSE;
|
|
|
|
return score;
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
player::DisplayHeartsWon
|
|
|
|
****************************************************************************/
|
|
|
|
void player::DisplayHeartsWon(CDC &dc)
|
|
{
|
|
card c;
|
|
int x = loc.x;
|
|
int y = loc.y;
|
|
|
|
x += ((MAXCARDSWON - numcardswon) / 2) * dx;
|
|
y += ((MAXCARDSWON - numcardswon) / 2) * dy;
|
|
|
|
for (int i = 0; i < numcardswon; i++)
|
|
{
|
|
c.SetID(cardswon[i]);
|
|
c.SetLoc(x, y);
|
|
c.Draw(dc);
|
|
x += dx;
|
|
y += dy;
|
|
}
|
|
|
|
DisplayName(dc);
|
|
}
|