mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
709 lines
19 KiB
709 lines
19 KiB
/****************************************************************************
|
|
|
|
Display.c
|
|
|
|
June 91, JimH initial code
|
|
Oct 91, JimH port to Win32
|
|
|
|
|
|
Contains routines dealing with pixels and card shuffling.
|
|
|
|
****************************************************************************/
|
|
|
|
#include "freecell.h"
|
|
#include "freecons.h"
|
|
#include <assert.h>
|
|
#include <stdlib.h> // rand() prototype
|
|
#include <time.h>
|
|
|
|
// This static data has to do with positions of the cards on the screen.
|
|
// See CalcOffsets() below for descriptions. Note that wOffset[TOPROW]
|
|
// is the left edge of the leftmose home cell.
|
|
|
|
static UINT wOffset[MAXCOL]; // left edge of column n (n from 1 to 8)
|
|
static UINT wIconOffset; // left edge of icon (btwn home & free)
|
|
static UINT wVSpace; // vert space between home and columns
|
|
static UINT wUpdateCol, wUpdatePos; // card user chose to transfer FROM
|
|
static BOOL bCardRevealed; // right mouse button show a card?
|
|
|
|
#define BGND (255) // used for cdtDrawExt
|
|
#define ICONY ((dyCrd - ICONHEIGHT) / 3)
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
CalcOffsets
|
|
|
|
This function determines the locations where cards are drawn.
|
|
|
|
****************************************************************************/
|
|
|
|
VOID CalcOffsets(HWND hWnd)
|
|
{
|
|
RECT rect;
|
|
UINT i;
|
|
UINT leftedge;
|
|
BOOL bEGAmode = FALSE;
|
|
|
|
if (GetSystemMetrics(SM_CYSCREEN) <= 350) // EGA
|
|
bEGAmode = TRUE;
|
|
|
|
GetClientRect(hWnd, &rect);
|
|
|
|
wOffset[TOPROW] = rect.right - (4 * dxCrd); // home cells
|
|
|
|
leftedge = (rect.right - ((MAXCOL-1) * dxCrd)) / MAXCOL;
|
|
for (i = 1; i < MAXCOL; i++)
|
|
wOffset[i] = leftedge + (((i-1) * (rect.right-leftedge)) / (MAXCOL-1));
|
|
|
|
/* place icon half way between free cells and home cells */
|
|
|
|
wIconOffset = (rect.right-ICONWIDTH) / 2;
|
|
|
|
if (bEGAmode)
|
|
wVSpace = 4;
|
|
else
|
|
wVSpace = 10;
|
|
|
|
/* dyTops is the vertical space between stacked cards. To fit the
|
|
theoretical maximum, the formula is dyTops = (dyCrd * 9) / 50.
|
|
A compromise is used to make the cards easier to see. It is possible,
|
|
therefore, that some stacks could get long enough for the bottom
|
|
cards no to be visible. The situation for EGA is worse, as cards
|
|
are both closer together, and more likely to fall off the bottom.
|
|
An alternative is to squish the bitmaps dyCrd = (35 * dyCrd) / 48. */
|
|
|
|
dyTops = (dyCrd * 9) / 46; // space between tops of cards in columns
|
|
|
|
if (bEGAmode)
|
|
dyTops = (dyTops * 4) / 5;
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
ShuffleDeck
|
|
|
|
If seed is non-zero, that number is used as rand() seed to shuffle
|
|
deck. Otherwise, a seed is generated and presented to the user who
|
|
may change it in a dialog box.
|
|
|
|
****************************************************************************/
|
|
|
|
VOID ShuffleDeck(HWND hWnd, UINT_PTR seed)
|
|
{
|
|
UINT i, j; // generic counters
|
|
UINT col, pos;
|
|
UINT wLeft = 52; // cards left to be chosen in shuffle
|
|
CARD deck[52]; // deck of 52 unique cards
|
|
|
|
if (seed == 0) // if user must select seed
|
|
{
|
|
gamenumber = GenerateRandomGameNum();
|
|
|
|
/* Keep calling GameNumDlg until valid number chosen. */
|
|
|
|
while (!DialogBox(hInst, TEXT("GameNum"), hWnd, GameNumDlg))
|
|
{
|
|
}
|
|
|
|
if (gamenumber == CANCELGAME) // if user chose CANCEL button
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
gamenumber = (INT) seed;
|
|
}
|
|
|
|
LoadString(hInst, IDS_APPNAME2, bigbuf, BIG);
|
|
wsprintf(smallbuf, bigbuf, gamenumber);
|
|
SetWindowText(hWnd, smallbuf);
|
|
|
|
for (col = 0; col < MAXCOL; col++) // clear the deck
|
|
{
|
|
for (pos = 0; pos < MAXPOS; pos++)
|
|
{
|
|
card[col][pos] = EMPTY;
|
|
}
|
|
}
|
|
|
|
/* shuffle cards */
|
|
|
|
for (i = 0; i < 52; i++) // put unique card in each deck loc.
|
|
{
|
|
deck[i] = i;
|
|
}
|
|
|
|
if (gamenumber == -1) // special unwinnable shuffle
|
|
{
|
|
i = 0;
|
|
|
|
for (pos = 0; pos < 7; pos++)
|
|
{
|
|
for (col = 1; col < 5; col++)
|
|
{
|
|
card[col][pos] = i++;
|
|
}
|
|
|
|
i+= 4;
|
|
}
|
|
|
|
for (pos = 0; pos < 6; pos++)
|
|
{
|
|
i -= 12;
|
|
|
|
for (col = 5; col < 9; col++)
|
|
{
|
|
card[col][pos] = i++;
|
|
}
|
|
}
|
|
}
|
|
else if (gamenumber == -2)
|
|
{
|
|
i = 3;
|
|
|
|
for (col = 1; col < 5; col++)
|
|
{
|
|
card[col][0] = i--;
|
|
}
|
|
|
|
i = 51;
|
|
|
|
for (pos = 1; pos < 7; pos++)
|
|
{
|
|
for (col = 1; col < 5; col++)
|
|
{
|
|
card[col][pos] = i--;
|
|
}
|
|
}
|
|
|
|
for (pos = 0; pos < 6; pos++)
|
|
{
|
|
for (col = 5; col < 9; col++)
|
|
{
|
|
card[col][pos] = i--;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
|
|
//
|
|
// Caution:
|
|
// This shuffle algorithm has been published to people all around. The intention
|
|
// was to let people track the games by game numbers. So far all the games between
|
|
// 1 and 32767 except one have been proved to have a winning solution. Do not change
|
|
// the shuffling algorithm else you will incur the wrath of people who have invested
|
|
// a huge amount of time solving these games.
|
|
//
|
|
|
|
// The game number can now be upto a million as the srand takes an integer but the
|
|
// the random value generated by rand() is only from 0 to 32767.
|
|
//
|
|
|
|
srand(gamenumber);
|
|
for (i = 0; i < 52; i++)
|
|
{
|
|
j = rand() % wLeft;
|
|
wLeft --;
|
|
card[(i%8)+1][i/8] = deck[j];
|
|
deck[j] = deck[wLeft];
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
PaintMainWindow
|
|
|
|
This function is called in response to WM_PAINT.
|
|
|
|
****************************************************************************/
|
|
|
|
VOID PaintMainWindow(HWND hWnd)
|
|
{
|
|
PAINTSTRUCT ps;
|
|
UINT col, pos;
|
|
UINT y; // y location of icon
|
|
CARD c;
|
|
INT mode; // mode to draw card (FACEUP or HILITE)
|
|
HCURSOR hCursor; // original cursor
|
|
HPEN hOldPen;
|
|
|
|
BeginPaint(hWnd, &ps);
|
|
|
|
/* Draw icon with 3D box around it. */
|
|
|
|
y = ICONY;
|
|
|
|
hOldPen = SelectObject(ps.hdc, hBrightPen);
|
|
MoveToEx(ps.hdc, wIconOffset-3, y + ICONHEIGHT + 1, NULL);
|
|
LineTo(ps.hdc, wIconOffset-3, y-3);
|
|
LineTo(ps.hdc, wIconOffset+ICONWIDTH + 2, y-3);
|
|
|
|
SelectObject(ps.hdc, GetStockObject(BLACK_PEN));
|
|
MoveToEx(ps.hdc, wIconOffset + ICONWIDTH + 2, y-2, NULL);
|
|
LineTo(ps.hdc, wIconOffset + ICONWIDTH + 2, y + ICONHEIGHT + 2);
|
|
LineTo(ps.hdc, wIconOffset - 3, y + ICONHEIGHT + 2);
|
|
|
|
DrawKing(ps.hdc, SAME, TRUE);
|
|
|
|
hCursor = SetCursor(LoadCursor(NULL, IDC_WAIT));
|
|
ShowCursor(TRUE);
|
|
|
|
/* Top row first */
|
|
|
|
for (pos = 0; pos < 8; pos++)
|
|
{
|
|
mode = FACEUP;
|
|
if ((c = card[TOPROW][pos]) == EMPTY)
|
|
c = IDGHOST;
|
|
else if (wMouseMode == TO && pos == wFromPos && TOPROW == wFromCol)
|
|
mode = HILITE;
|
|
|
|
DrawCard(ps.hdc, TOPROW, pos, c, mode);
|
|
}
|
|
|
|
/* Then, the 8 columns */
|
|
|
|
for (col = 1; col < MAXCOL; col++)
|
|
{
|
|
for (pos = 0; pos < MAXPOS; pos++)
|
|
{
|
|
if ((c = card[col][pos]) == EMPTY)
|
|
break;
|
|
|
|
if (wMouseMode == TO && pos == wFromPos && col == wFromCol)
|
|
mode = HILITE;
|
|
else
|
|
mode = FACEUP;
|
|
|
|
DrawCard(ps.hdc, col, pos, c, mode);
|
|
}
|
|
}
|
|
|
|
if (bWonState)
|
|
Payoff(ps.hdc);
|
|
|
|
ShowCursor(FALSE);
|
|
SetCursor(hCursor);
|
|
SelectObject(ps.hdc, hOldPen);
|
|
EndPaint(hWnd, &ps);
|
|
DisplayCardCount(hWnd);
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
DrawCard
|
|
|
|
This function takes a card value and position (in col and pos),
|
|
converts it to x and y, and displays it in the specified mode.
|
|
|
|
****************************************************************************/
|
|
|
|
VOID DrawCard(HDC hDC, UINT col, UINT pos, CARD card, INT mode)
|
|
{
|
|
UINT x, y;
|
|
HDC hMemDC;
|
|
HBITMAP hOldBitmap;
|
|
|
|
Card2Point(col, pos, &x, &y);
|
|
if (card == IDGHOST && hBM_Ghost)
|
|
{
|
|
hMemDC = CreateCompatibleDC(hDC);
|
|
if (hMemDC)
|
|
{
|
|
hOldBitmap = SelectObject(hMemDC, hBM_Ghost);
|
|
BitBlt(hDC, x, y, dxCrd, dyCrd, hMemDC, 0, 0, SRCCOPY);
|
|
SelectObject(hMemDC, hOldBitmap);
|
|
DeleteDC(hMemDC);
|
|
}
|
|
}
|
|
else
|
|
cdtDrawExt(hDC, x, y, dxCrd, dyCrd, card, mode, BGND);
|
|
}
|
|
|
|
VOID DrawCardMem(HDC hMemDC, CARD card, INT mode)
|
|
{
|
|
cdtDrawExt(hMemDC, 0, 0-dyTops, dxCrd, dyCrd, card, mode, BGND);
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
RevealCard
|
|
|
|
When the user chooses a hidden card by clicking the right mouse button,
|
|
this function displays the entire card bitmap.
|
|
|
|
****************************************************************************/
|
|
|
|
VOID RevealCard(HWND hWnd, UINT x, UINT y)
|
|
{
|
|
UINT col, pos;
|
|
HDC hDC;
|
|
|
|
bCardRevealed = FALSE; // no card revealed yet
|
|
if (Point2Card(x, y, &col, &pos))
|
|
{
|
|
wUpdateCol = col; // save for RestoreColumn()
|
|
wUpdatePos = pos;
|
|
}
|
|
else
|
|
return; // not a card
|
|
|
|
if (col == 0 || pos == (MAXPOS-1))
|
|
return;
|
|
|
|
if (card[col][pos+1] == EMPTY)
|
|
return;
|
|
|
|
hDC = GetDC(hWnd);
|
|
DrawCard(hDC, col, pos, card[col][pos], FACEUP);
|
|
ReleaseDC(hWnd, hDC);
|
|
bCardRevealed = TRUE; // ok, card has been revealed
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
RestoreColumn
|
|
|
|
After RevealCard has messed up a column by revealing a hidden card,
|
|
this routine patches it up again by redisplaying all the cards from
|
|
the revealed card down to the bottom of the column. If the bottom card
|
|
is selected for a move, it is correctly shown hilighted.
|
|
|
|
****************************************************************************/
|
|
|
|
VOID RestoreColumn(HWND hWnd)
|
|
{
|
|
HDC hDC;
|
|
UINT pos;
|
|
UINT lastpos = EMPTY; // last pos in column (for HILITE mode)
|
|
INT mode; // HILITE or FACEUP
|
|
|
|
if (!bCardRevealed)
|
|
return;
|
|
|
|
if (wMouseMode == TO)
|
|
lastpos = FindLastPos(wUpdateCol);
|
|
|
|
hDC = GetDC(hWnd);
|
|
mode = FACEUP;
|
|
for (pos = (wUpdatePos + 1); pos < MAXPOS; pos++)
|
|
{
|
|
if (card[wUpdateCol][pos] == EMPTY)
|
|
break;
|
|
|
|
if (wMouseMode == TO && pos == lastpos && wUpdateCol == wFromCol)
|
|
mode = HILITE;
|
|
|
|
DrawCard(hDC, wUpdateCol, pos, card[wUpdateCol][pos], mode);
|
|
}
|
|
ReleaseDC(hWnd, hDC);
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
Point2Card
|
|
|
|
Given an x,y location (typically a mouse click) this function returns
|
|
the column and position of that card through pointers. The function
|
|
return value is TRUE if it found a card, and FALSE otherwise.
|
|
|
|
****************************************************************************/
|
|
|
|
BOOL Point2Card(UINT x, UINT y, UINT *col, UINT *pos)
|
|
{
|
|
if (y < dyCrd) // TOPROW
|
|
{
|
|
if (x < (UINT) (4 * dxCrd)) // free cells
|
|
{
|
|
*col = TOPROW;
|
|
*pos = x / dxCrd;
|
|
return TRUE;
|
|
}
|
|
else if (x < wOffset[TOPROW]) // between free cells & home cells
|
|
return FALSE;
|
|
|
|
x -= wOffset[TOPROW];
|
|
if (x < (UINT) (4 * dxCrd)) // home cells
|
|
{
|
|
*col = TOPROW;
|
|
*pos = (x / dxCrd) + 4;
|
|
return TRUE;
|
|
}
|
|
else // right of home cells
|
|
return FALSE;
|
|
}
|
|
|
|
if (y < (dyCrd + wVSpace)) // above column cards
|
|
return FALSE;
|
|
|
|
if (x < wOffset[1]) // left of column 1
|
|
return FALSE;
|
|
|
|
*col = (x - wOffset[1]) / (wOffset[2] - wOffset[1]);
|
|
(*col)++;
|
|
|
|
if (x > (wOffset[*col] + dxCrd))
|
|
return FALSE; // between columns
|
|
|
|
y -= (dyCrd + wVSpace);
|
|
|
|
*pos = min((y / dyTops), MAXPOS);
|
|
|
|
if (card[*col][0] == EMPTY)
|
|
return FALSE; // empty column
|
|
|
|
if (*pos < (MAXPOS-1))
|
|
{
|
|
if (card[*col][(*pos)+1] != EMPTY) // if partially hidden card...
|
|
return TRUE; // we're done
|
|
}
|
|
|
|
while (card[*col][*pos] == EMPTY)
|
|
(*pos)--;
|
|
|
|
if (y > ((*pos * dyTops) + dyCrd))
|
|
return FALSE; // below last card in column
|
|
else
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
Card2Point
|
|
|
|
Given a column and position, this function returns the x and y pixel
|
|
location of the upper left hand corner of the card.
|
|
|
|
****************************************************************************/
|
|
|
|
VOID Card2Point(UINT col, UINT pos, UINT *x, UINT *y)
|
|
{
|
|
assert(col <= MAXCOL);
|
|
assert(pos <= MAXPOS);
|
|
|
|
if (col == TOPROW) // column 0 is really the top row of 8 slots
|
|
{
|
|
*y = 0;
|
|
*x = pos * dxCrd;
|
|
if (pos > 3)
|
|
*x += wOffset[TOPROW] - (4 * dxCrd);
|
|
}
|
|
else
|
|
{
|
|
*x = wOffset[col];
|
|
*y = dyCrd + wVSpace + (pos * dyTops);
|
|
}
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
DisplayCardCount
|
|
|
|
This function displays wCardCount (the number of cards not in home cells)
|
|
at the right edge of the menu bar. If necessary, the old value is erased.
|
|
|
|
****************************************************************************/
|
|
|
|
VOID DisplayCardCount(HWND hWnd)
|
|
{
|
|
RECT rect; // client rect
|
|
HDC hDC;
|
|
TCHAR buffer[25]; // current value in ASCII stored here
|
|
TCHAR oldbuffer[25]; // previous value in ASCII
|
|
UINT xLoc; // x pixel loction for count
|
|
UINT wCount; // temp wCardCount holder
|
|
static UINT yLoc = 0; // y pixel location for count
|
|
static UINT wOldCount = 0; // previous count value
|
|
HFONT hOldFont = NULL;
|
|
SIZE size;
|
|
|
|
|
|
if (IsIconic(hWnd)) // don't draw on icon!
|
|
return;
|
|
|
|
hDC = GetWindowDC(hWnd); // get DC for entire window
|
|
if (!hDC)
|
|
return;
|
|
|
|
SetBkColor(hDC, GetSysColor(COLOR_MENU));
|
|
|
|
if (hMenuFont)
|
|
hOldFont = SelectObject(hDC, hMenuFont);
|
|
|
|
wCount = wCardCount;
|
|
if (wCount == 0xFFFF) // decremented past 0?
|
|
wCount = 0;
|
|
|
|
LoadString(hInst, IDS_CARDSLEFT, smallbuf, SMALL);
|
|
wsprintf(buffer, smallbuf, wCount);
|
|
|
|
if (yLoc == 0) // needs to be set only once
|
|
{
|
|
TEXTMETRIC tm;
|
|
int offset;
|
|
|
|
GetTextMetrics(hDC, &tm);
|
|
offset = (GetSystemMetrics(SM_CYMENU) - tm.tmHeight) / 2;
|
|
|
|
yLoc = GetSystemMetrics(SM_CYFRAME) // sizing frame
|
|
+ GetSystemMetrics(SM_CYCAPTION) // height of caption
|
|
+ offset;
|
|
}
|
|
|
|
GetClientRect(hWnd, &rect);
|
|
GetTextExtentPoint32(hDC, buffer, lstrlen(buffer), &size);
|
|
xLoc = rect.right - size.cx;
|
|
|
|
if (xLoc > xOldLoc) // need to erase old score?
|
|
{
|
|
SetTextColor(hDC, GetSysColor(COLOR_MENU)); // background colour
|
|
wsprintf(oldbuffer, smallbuf, wOldCount);
|
|
TextOut(hDC, xOldLoc, yLoc, oldbuffer, lstrlen(buffer));
|
|
}
|
|
SetTextColor(hDC, GetSysColor(COLOR_MENUTEXT));
|
|
TextOut(hDC, xLoc, yLoc, buffer, lstrlen(buffer));
|
|
|
|
xOldLoc = xLoc;
|
|
wOldCount = wCount;
|
|
|
|
if (hMenuFont)
|
|
SelectObject(hDC, hOldFont);
|
|
|
|
ReleaseDC(hWnd, hDC);
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
Payoff
|
|
|
|
Draws the Big King when you win the game.
|
|
|
|
****************************************************************************/
|
|
|
|
VOID Payoff(HDC hDC)
|
|
{
|
|
HDC hMemDC; // bitmap memory DC
|
|
HBITMAP hBitmap;
|
|
HBITMAP hOldBitmap;
|
|
INT xStretch = 320; // stretched size of bitmap
|
|
INT yStretch = 320;
|
|
|
|
if (GetSystemMetrics(SM_CYSCREEN) <= 350) // EGA
|
|
{
|
|
xStretch = 32 * 8;
|
|
yStretch = 32 * 6;
|
|
}
|
|
|
|
DrawKing(hDC, NONE, TRUE);
|
|
|
|
hMemDC = CreateCompatibleDC(hDC);
|
|
if (!hMemDC)
|
|
return;
|
|
|
|
hBitmap = LoadBitmap(hInst, TEXT("KingSmile"));
|
|
|
|
if (hBitmap)
|
|
{
|
|
hOldBitmap = SelectObject(hMemDC, hBitmap);
|
|
StretchBlt(hDC, 10, dyCrd + 10, xStretch, yStretch, hMemDC, 0, 0,
|
|
BMWIDTH, BMHEIGHT, SRCCOPY);
|
|
SelectObject(hMemDC, hOldBitmap);
|
|
DeleteObject(hBitmap);
|
|
}
|
|
DeleteDC(hMemDC);
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
DrawKing
|
|
|
|
Draws the small king in the box between the free and home cells.
|
|
If state is SAME, the previous bitmap is displayed. If bDraw is
|
|
FALSE, oldstate is updated, but the bitmap is not displayed.
|
|
|
|
****************************************************************************/
|
|
|
|
VOID DrawKing(HDC hDC, UINT state, BOOL bDraw)
|
|
{
|
|
HDC hMemDC; // bitmap memory DC
|
|
HBITMAP hBitmap;
|
|
HBITMAP hOldBitmap;
|
|
static UINT oldstate = RIGHT; // previous state -- RIGHT is default
|
|
HBRUSH hOldBrush;
|
|
|
|
if (state == oldstate)
|
|
return;
|
|
|
|
if (state == SAME)
|
|
state = oldstate;
|
|
|
|
if (!bDraw)
|
|
{
|
|
oldstate = state;
|
|
return;
|
|
}
|
|
|
|
hMemDC = CreateCompatibleDC(hDC);
|
|
if (!hMemDC)
|
|
return;
|
|
|
|
if (state == RIGHT)
|
|
hBitmap = LoadBitmap(hInst, TEXT("KingBitmap"));
|
|
else if (state == LEFT)
|
|
hBitmap = LoadBitmap(hInst, TEXT("KingLeft"));
|
|
else if (state == SMILE)
|
|
hBitmap = LoadBitmap(hInst, TEXT("KingSmile"));
|
|
else // NONE
|
|
hBitmap = CreateCompatibleBitmap(hDC, BMWIDTH, BMHEIGHT);
|
|
|
|
if (hBitmap)
|
|
{
|
|
hOldBitmap = SelectObject(hMemDC, hBitmap);
|
|
if (state == NONE)
|
|
{
|
|
hOldBrush = SelectObject(hMemDC, hBgndBrush);
|
|
PatBlt(hMemDC, 0, 0, BMWIDTH, BMHEIGHT, PATCOPY);
|
|
SelectObject(hMemDC, hOldBrush);
|
|
}
|
|
BitBlt(hDC,wIconOffset,ICONY,BMWIDTH,BMHEIGHT,hMemDC,0,0,SRCCOPY);
|
|
SelectObject(hMemDC, hOldBitmap);
|
|
DeleteObject(hBitmap);
|
|
}
|
|
DeleteDC(hMemDC);
|
|
oldstate = state;
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
GenerateRandomGameNum
|
|
|
|
returns a UINT from 1 to MAXGAMENUBMER
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
UINT GenerateRandomGameNum()
|
|
{
|
|
UINT wGameNum;
|
|
|
|
srand((unsigned int)time(NULL));
|
|
rand();
|
|
rand();
|
|
wGameNum = rand();
|
|
while (wGameNum < 1 || wGameNum > MAXGAMENUMBER)
|
|
wGameNum = rand();
|
|
return wGameNum;
|
|
}
|