732 lines
18 KiB
C
732 lines
18 KiB
C
/******************************Module*Header*******************************\
|
|
* Module Name: ftmaze.c
|
|
*
|
|
* Example test.
|
|
*
|
|
* Created: 26-May-1991 12:38:18
|
|
* Author: Patrick Haluptzok patrickh
|
|
*
|
|
* Copyright (c) 1990 Microsoft Corporation
|
|
\**************************************************************************/
|
|
|
|
#include "precomp.h"
|
|
#pragma hdrstop
|
|
|
|
#define ROOM_SIZE 10
|
|
#define WALL_SIZE 1
|
|
|
|
#define DOT_START ((ROOM_SIZE + 1) / 2)
|
|
#define DOT_SIZE 3
|
|
|
|
LONG glSeed = 0;
|
|
LONG glJump;
|
|
|
|
LOGFONT lfnt; // logical font description
|
|
HFONT hfont; // handle to font
|
|
|
|
#define MAX_MAZE_SIZE (1024/10) * (768/10)
|
|
|
|
int giMaze[MAX_MAZE_SIZE];
|
|
int giPath[MAX_MAZE_SIZE];
|
|
|
|
BOOL bBuild(HDC, RECT*);
|
|
void vTravel(HDC, RECT*);
|
|
void vDrawBox(HDC, HBRUSH, int, int, int, int, int);
|
|
|
|
// Global handles to color brushes
|
|
|
|
HBRUSH ghbrushRed;
|
|
HBRUSH ghbrushGreen;
|
|
HBRUSH ghbrushBlue;
|
|
HBRUSH ghbrushWhite;
|
|
HBRUSH ghbrushBlack;
|
|
|
|
ULONG argb[4] = {0x00ff0000, 0x0000ff00, 0x000000ff, 0x00ff00ff};
|
|
|
|
BOOL bBuild(HDC hdc, RECT *prc);
|
|
void vTravel(HDC hdc, RECT *prc);
|
|
|
|
/******************************Public*Routine******************************\
|
|
* vInitMaze
|
|
*
|
|
* Creates a handle to hfont.
|
|
*
|
|
* History:
|
|
* 27-May-1991 -by- Patrick Haluptzok patrickh
|
|
* Wrote it.
|
|
\**************************************************************************/
|
|
|
|
VOID vInitMaze(VOID)
|
|
{
|
|
// Create a logical font
|
|
|
|
memset(&lfnt, 0, sizeof(lfnt)); // zero out the structure!!
|
|
lfnt.lfEscapement = 0;
|
|
lfnt.lfUnderline = 0;
|
|
lfnt.lfStrikeOut = 0;
|
|
|
|
// Create a logical font
|
|
|
|
if ((hfont = CreateFontIndirect(&lfnt)) == NULL)
|
|
{
|
|
DbgPrint("Logical font creation failed.\n");
|
|
}
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
* vMazeTest
|
|
*
|
|
* Example Test procedure.
|
|
*
|
|
* History:
|
|
* 26-May-1991 -by- Patrick Haluptzok patrickh
|
|
* Wrote it.
|
|
\**************************************************************************/
|
|
|
|
//!!! Should create and delete font in this module. Get rid of global
|
|
//!!! variables, every test should clean up after itself.
|
|
|
|
VOID vTestMaze(HWND hwnd, HDC hdc, PRECT prclClient)
|
|
{
|
|
HFONT hfontOriginal; // handle of font originally in DC
|
|
LARGE_INTEGER time;
|
|
HBRUSH hbrushOrg;
|
|
|
|
// wait for WM_PAINT to be hit
|
|
|
|
|
|
NtQuerySystemTime(&time);
|
|
glSeed = time.LowPart;
|
|
|
|
// create the brushes
|
|
|
|
ghbrushRed = CreateSolidBrush(RGB(0xff,0x00,0x00));
|
|
ghbrushGreen = CreateSolidBrush(RGB(0x00,0xff,0x00));
|
|
ghbrushBlue = CreateSolidBrush(RGB(0x00,0x00,0xff));
|
|
ghbrushWhite = CreateSolidBrush(RGB(0xff,0xff,0xff));
|
|
ghbrushBlack = CreateSolidBrush(RGB(0x00,0x00,0x00));
|
|
|
|
// Select font into DC
|
|
|
|
hfontOriginal = (HFONT) SelectObject(hdc, hfont);
|
|
hbrushOrg = SelectObject(hdc, ghbrushRed);
|
|
|
|
// Set text alignment
|
|
|
|
SetTextAlign(hdc, TA_LEFT | TA_TOP | TA_NOUPDATECP);
|
|
|
|
if (bBuild(hdc, prclClient))
|
|
vTravel(hdc, prclClient);
|
|
|
|
SelectObject(hdc, hfontOriginal);
|
|
SelectObject(hdc, hbrushOrg);
|
|
|
|
DeleteObject(ghbrushRed);
|
|
DeleteObject(ghbrushGreen);
|
|
DeleteObject(ghbrushBlue);
|
|
DeleteObject(ghbrushWhite);
|
|
DeleteObject(ghbrushBlack);
|
|
}
|
|
|
|
////////////////////////////
|
|
// All the maze functions //
|
|
////////////////////////////
|
|
|
|
LONG lRandom()
|
|
{
|
|
glSeed *= 69069;
|
|
glSeed++;
|
|
return(glSeed);
|
|
}
|
|
|
|
HRGN hrgnCircle(LONG xC, LONG yC, LONG lRadius)
|
|
{
|
|
HRGN hrgn, hrgnTmp;
|
|
LONG x = 0;
|
|
LONG y = lRadius;
|
|
LONG d = 3 - 2 * lRadius;
|
|
|
|
hrgn = CreateRectRgn(0, 0, 0, 0);
|
|
if (hrgn == (HRGN) 0)
|
|
return(hrgn);
|
|
|
|
hrgnTmp = CreateRectRgn(0, 0, 0, 0);
|
|
if (hrgnTmp == (HRGN) 0)
|
|
{
|
|
DeleteObject(hrgn);
|
|
return((HRGN) 0);
|
|
}
|
|
|
|
while (x < y)
|
|
{
|
|
if (d < 0)
|
|
d = d + 4 * x + 6;
|
|
else
|
|
{
|
|
SetRectRgn(hrgnTmp, xC - x, yC - y, xC + x + 1, yC + y + 1);
|
|
if (CombineRgn(hrgn, hrgn, hrgnTmp, RGN_OR) == ERROR)
|
|
{
|
|
DeleteObject(hrgn);
|
|
DeleteObject(hrgnTmp);
|
|
return((HRGN) 0);
|
|
}
|
|
|
|
SetRectRgn(hrgnTmp, xC - y, yC - x, xC + y + 1, yC + x + 1);
|
|
if (CombineRgn(hrgn, hrgn, hrgnTmp, RGN_OR) == ERROR)
|
|
{
|
|
DeleteObject(hrgn);
|
|
DeleteObject(hrgnTmp);
|
|
return((HRGN) 0);
|
|
}
|
|
|
|
d = d + 4 * (x - y) + 10;
|
|
y--;
|
|
}
|
|
|
|
x++;
|
|
}
|
|
|
|
if (x == y)
|
|
{
|
|
SetRectRgn(hrgnTmp, xC - x, yC - y, xC + x + 1, yC + y + 1);
|
|
if (CombineRgn(hrgn, hrgn, hrgnTmp, RGN_OR) == ERROR)
|
|
{
|
|
DeleteObject(hrgn);
|
|
DeleteObject(hrgnTmp);
|
|
return((HRGN) 0);
|
|
}
|
|
}
|
|
|
|
DeleteObject(hrgnTmp);
|
|
return(hrgn);
|
|
}
|
|
|
|
void vNumber(HDC hdc, LONG l, LONG x, LONG y)
|
|
{
|
|
LONG lPOT;
|
|
LONG lDigit;
|
|
CHAR ach[12]; // Build string here
|
|
LONG cch = 0; // Length of the string
|
|
|
|
if (!l)
|
|
{
|
|
ach[cch++] = '0';
|
|
goto out;
|
|
}
|
|
|
|
if (l < 0)
|
|
{
|
|
ach[cch++] = '-';
|
|
l = -l;
|
|
}
|
|
|
|
lPOT = 1;
|
|
while (lPOT <= l)
|
|
lPOT *= 10;
|
|
|
|
while (lPOT > 1)
|
|
{
|
|
lPOT /= 10;
|
|
lDigit = l / lPOT;
|
|
l -= (lDigit * lPOT);
|
|
ach[cch++] = (CHAR)('0' + lDigit);
|
|
}
|
|
|
|
out:
|
|
TextOut(hdc, x, y, ach, cch);
|
|
|
|
}
|
|
|
|
void vClear(HDC hdc, int iPos, int iDir, int cColume)
|
|
{
|
|
LONG x, y;
|
|
|
|
y = (iPos / cColume) * ROOM_SIZE;
|
|
x = (iPos % cColume) * ROOM_SIZE;
|
|
|
|
switch(iDir)
|
|
{
|
|
case 0:
|
|
BitBlt(hdc,
|
|
x + WALL_SIZE,
|
|
y - WALL_SIZE,
|
|
ROOM_SIZE - (2 * WALL_SIZE),
|
|
2 * WALL_SIZE,
|
|
(HDC) 0, 0, 0, BLACKNESS);
|
|
break;
|
|
case 1:
|
|
BitBlt(hdc,
|
|
x + ROOM_SIZE - WALL_SIZE,
|
|
y + WALL_SIZE,
|
|
2 * WALL_SIZE,
|
|
ROOM_SIZE - (2 * WALL_SIZE),
|
|
(HDC) 0, 0, 0, BLACKNESS);
|
|
break;
|
|
case 2:
|
|
BitBlt(hdc,
|
|
x + WALL_SIZE,
|
|
y + ROOM_SIZE - WALL_SIZE,
|
|
ROOM_SIZE - (2 * WALL_SIZE),
|
|
2 * WALL_SIZE,
|
|
(HDC) 0, 0, 0, BLACKNESS);
|
|
break;
|
|
case 3:
|
|
BitBlt(hdc,
|
|
x - WALL_SIZE,
|
|
y + WALL_SIZE,
|
|
2 * WALL_SIZE,
|
|
ROOM_SIZE - (2 * WALL_SIZE),
|
|
(HDC) 0, 0, 0, BLACKNESS);
|
|
break;
|
|
}
|
|
}
|
|
|
|
#define NORTH 0x01
|
|
#define EAST 0x02
|
|
#define SOUTH 0x04
|
|
#define WEST 0x08
|
|
#define VIRGIN 0x10
|
|
|
|
BOOL bBuild(HDC hdc, RECT *prc)
|
|
{
|
|
HRGN hrgn;
|
|
int i;
|
|
int iPos;
|
|
int iScan;
|
|
int cLeft;
|
|
int iTry;
|
|
int cTry;
|
|
int cStuck;
|
|
BOOL bStuck;
|
|
HBRUSH hbrushOld;
|
|
|
|
int cColume = prc->right / ROOM_SIZE;
|
|
int cRow = prc->bottom / ROOM_SIZE;
|
|
int cMazeSize = cColume * cRow;
|
|
|
|
|
|
if ((prc->bottom < ROOM_SIZE) || (prc->right < ROOM_SIZE))
|
|
{
|
|
DbgPrint("Client area too small to run maze\n");
|
|
return(FALSE);
|
|
}
|
|
|
|
if ((hrgn = CreateRectRgn(0, 0, prc->right, prc->bottom)) == (HRGN) NULL)
|
|
{
|
|
DbgPrint("ERROR bBuild CreateRectRgn failed\n");
|
|
return(FALSE);
|
|
}
|
|
|
|
if (SelectClipRgn(hdc, hrgn) == ERROR)
|
|
{
|
|
DbgPrint("ERROR bBuild SelectClipRgn failed\n");
|
|
DeleteObject(hrgn);
|
|
return(FALSE);
|
|
}
|
|
|
|
DeleteObject(hrgn);
|
|
|
|
BitBlt(hdc, 0, 0, prc->right, prc->bottom, (HDC) 0, 0, 0, BLACKNESS);
|
|
|
|
if ((hrgn = CreateRectRgn(0, 0, prc->right, ROOM_SIZE)) == (HRGN) NULL)
|
|
return(FALSE);
|
|
|
|
if (SelectClipRgn(hdc, hrgn) == ERROR)
|
|
{
|
|
DbgPrint("ERROR bBuild SelectClipRgn failed\n");
|
|
DeleteObject(hrgn);
|
|
return(FALSE);
|
|
}
|
|
|
|
DeleteObject(hrgn);
|
|
|
|
for (i = 0; i < cColume; i++)
|
|
if (ExcludeClipRect(hdc,
|
|
ROOM_SIZE * i + WALL_SIZE,
|
|
WALL_SIZE,
|
|
ROOM_SIZE * i + ROOM_SIZE - WALL_SIZE,
|
|
ROOM_SIZE - WALL_SIZE) == ERROR)
|
|
{
|
|
DbgPrint("ERROR bBuild excludeClipRgn failed\n");
|
|
return(FALSE);
|
|
}
|
|
|
|
hbrushOld = SelectObject(hdc,ghbrushGreen);
|
|
for (i = 0; i < cRow; i++)
|
|
{
|
|
BitBlt(hdc, 0, 0, prc->right, prc->bottom, (HDC) 0, 0, 0, PATCOPY);
|
|
|
|
if (OffsetClipRgn(hdc, 0, ROOM_SIZE) == ERROR)
|
|
return(FALSE);
|
|
}
|
|
SelectObject(hdc,hbrushOld);
|
|
|
|
if (SelectClipRgn(hdc, (HRGN) 0) == ERROR)
|
|
{
|
|
DbgPrint("ERROR bBuild SelectClipRgn failed\n");
|
|
return(FALSE);
|
|
}
|
|
|
|
glJump = 0;
|
|
|
|
for (i = 0; i < cMazeSize; i++)
|
|
giMaze[i] = NORTH | EAST | SOUTH | WEST | VIRGIN;
|
|
|
|
cStuck = 512;
|
|
iPos = (lRandom() & 0x7fffffff) % cMazeSize;
|
|
cLeft = cMazeSize - 1;
|
|
giMaze[iPos] ^= VIRGIN;
|
|
|
|
while (cLeft)
|
|
{
|
|
do
|
|
{
|
|
cTry = (cStuck >> 9) + ((lRandom() >> 30) & 3);
|
|
iTry = (lRandom() >> 30) & 3;
|
|
bStuck = TRUE;
|
|
|
|
while(bStuck && cTry)
|
|
{
|
|
switch(iTry)
|
|
{
|
|
case 0:
|
|
if ((iPos >= cColume) &&
|
|
(giMaze[iPos - cColume] & VIRGIN))
|
|
{
|
|
vClear(hdc, iPos, iTry, cColume);
|
|
giMaze[iPos] ^= NORTH;
|
|
iPos -= cColume;
|
|
giMaze[iPos] ^= SOUTH;
|
|
bStuck = FALSE;
|
|
}
|
|
break;
|
|
case 1:
|
|
if (((iPos % cColume) != (cColume - 1)) &&
|
|
(giMaze[iPos + 1] & VIRGIN))
|
|
{
|
|
vClear(hdc, iPos, iTry, cColume);
|
|
giMaze[iPos] ^= EAST;
|
|
iPos++;
|
|
giMaze[iPos] ^= WEST;
|
|
bStuck = FALSE;
|
|
}
|
|
break;
|
|
case 2:
|
|
if ((iPos < (cMazeSize - cColume)) &&
|
|
(giMaze[iPos + cColume] & VIRGIN))
|
|
{
|
|
vClear(hdc, iPos, iTry, cColume);
|
|
giMaze[iPos] ^= SOUTH;
|
|
iPos += cColume;
|
|
giMaze[iPos] ^= NORTH;
|
|
bStuck = FALSE;
|
|
}
|
|
break;
|
|
case 3:
|
|
if ((iPos % cColume) &&
|
|
(giMaze[iPos - 1] & VIRGIN))
|
|
{
|
|
vClear(hdc, iPos, iTry, cColume);
|
|
giMaze[iPos] ^= WEST;
|
|
iPos--;
|
|
giMaze[iPos] ^= EAST;
|
|
bStuck = FALSE;
|
|
}
|
|
break;
|
|
}
|
|
|
|
iTry = (iTry + 1) & 3;
|
|
cTry--;
|
|
}
|
|
|
|
if (!bStuck)
|
|
{
|
|
giMaze[iPos] ^= VIRGIN;
|
|
cLeft--;
|
|
}
|
|
} while (!bStuck);
|
|
|
|
if (!cLeft)
|
|
return(TRUE);
|
|
|
|
// We're stuck, find someplace we've been before and continue
|
|
// building the path from there.
|
|
|
|
glJump++;
|
|
|
|
// Make it less likely we'll get stuck again.
|
|
|
|
cStuck++;
|
|
|
|
iScan = (lRandom() & 0x7fffffff) % cMazeSize;
|
|
|
|
do
|
|
{
|
|
do
|
|
{
|
|
iScan = (iScan + 1) % cMazeSize;
|
|
} while (giMaze[iScan] & VIRGIN);
|
|
|
|
// OK, we've found a likely prospect make sure its next to
|
|
// someplace we've never been
|
|
|
|
if ((iScan >= cColume) &&
|
|
(giMaze[iScan - cColume] & VIRGIN))
|
|
bStuck = FALSE;
|
|
|
|
if (((iScan % cColume) != (cColume - 1)) &&
|
|
(giMaze[iScan + 1] & VIRGIN))
|
|
bStuck = FALSE;
|
|
|
|
if ((iScan < (cMazeSize - cColume)) &&
|
|
(giMaze[iScan + cColume] & VIRGIN))
|
|
bStuck = FALSE;
|
|
|
|
if ((iScan % cColume) &&
|
|
(giMaze[iScan - 1] & VIRGIN))
|
|
bStuck = FALSE;
|
|
|
|
} while (bStuck);
|
|
|
|
// Put ourselves in the new position.
|
|
|
|
iPos = iScan;
|
|
}
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
void vTravel(HDC hdc, RECT *prc)
|
|
{
|
|
HRGN hrgn;
|
|
int i;
|
|
int iPos;
|
|
int iPath;
|
|
int iFinal;
|
|
LONG lVisit = 0;
|
|
LONG lStart;
|
|
LONG lFinal;
|
|
BOOL bRetAll = TRUE;
|
|
|
|
HBRUSH hbrushOld;
|
|
int iBkModeOld;
|
|
int cColume = prc->right / ROOM_SIZE;
|
|
int cRow = prc->bottom / ROOM_SIZE;
|
|
int cMazeSize = cColume * cRow;
|
|
int hStart, vStart;
|
|
|
|
|
|
hrgn = hrgnCircle(DOT_START, DOT_START, DOT_SIZE);
|
|
if (hrgn == (HRGN) NULL)
|
|
return;
|
|
|
|
if (SelectClipRgn(hdc, hrgn) == ERROR)
|
|
return;
|
|
|
|
DeleteObject(hrgn);
|
|
|
|
lStart = (lRandom() >> 30) & 3;
|
|
switch (lStart)
|
|
{
|
|
case 0:
|
|
iPos = 0;
|
|
break;
|
|
case 1:
|
|
iPos = cColume - 1;
|
|
OffsetClipRgn(hdc, ROOM_SIZE * (cColume - 1), 0);
|
|
break;
|
|
case 2:
|
|
iPos = cMazeSize - 1;
|
|
OffsetClipRgn(hdc, ROOM_SIZE * (cColume - 1), ROOM_SIZE * (cRow - 1));
|
|
break;
|
|
case 3:
|
|
iPos = cMazeSize - cColume;
|
|
OffsetClipRgn(hdc, 0, ROOM_SIZE * (cRow - 1));
|
|
break;
|
|
}
|
|
|
|
do
|
|
{
|
|
lFinal = (lRandom() >> 30) & 3;
|
|
}
|
|
while (lFinal == lStart);
|
|
|
|
switch (lFinal)
|
|
{
|
|
case 0:
|
|
iFinal = 0;
|
|
break;
|
|
case 1:
|
|
iFinal = cColume - 1;
|
|
break;
|
|
case 2:
|
|
iFinal = cMazeSize - 1;
|
|
break;
|
|
case 3:
|
|
iFinal = cMazeSize - cColume;
|
|
break;
|
|
}
|
|
|
|
iPath = 0;
|
|
giPath[iPath] = 0;
|
|
|
|
start:
|
|
hbrushOld = SelectObject(hdc,ghbrushWhite);
|
|
BitBlt(hdc, 0, 0, prc->right, prc->bottom, (HDC) 0, 0, 0, PATCOPY);
|
|
SelectObject(hdc,hbrushOld);
|
|
|
|
giMaze[iPos] |= VIRGIN;
|
|
lVisit++;
|
|
|
|
while (iPos != iFinal)
|
|
{
|
|
i = giPath[iPath];
|
|
switch(i)
|
|
{
|
|
case 0:
|
|
if (!(giMaze[iPos] & NORTH) &&
|
|
!(giMaze[iPos - cColume] & VIRGIN))
|
|
{
|
|
OffsetClipRgn(hdc, 0, -ROOM_SIZE);
|
|
iPos -= cColume;
|
|
giPath[++iPath] = 0;
|
|
goto start;
|
|
}
|
|
giPath[iPath] = 1;
|
|
|
|
case 1:
|
|
if (!(giMaze[iPos] & EAST) &&
|
|
!(giMaze[iPos + 1] & VIRGIN))
|
|
{
|
|
OffsetClipRgn(hdc, ROOM_SIZE, 0);
|
|
iPos++;
|
|
giPath[++iPath] = 0;
|
|
goto start;
|
|
}
|
|
giPath[iPath] = 2;
|
|
|
|
case 2:
|
|
if (!(giMaze[iPos] & SOUTH) &&
|
|
!(giMaze[iPos + cColume] & VIRGIN))
|
|
{
|
|
OffsetClipRgn(hdc, 0, ROOM_SIZE);
|
|
iPos += cColume;
|
|
giPath[++iPath] = 0;
|
|
goto start;
|
|
}
|
|
giPath[iPath] = 3;
|
|
|
|
case 3:
|
|
if (!(giMaze[iPos] & WEST) &&
|
|
!(giMaze[iPos - 1] & VIRGIN))
|
|
{
|
|
OffsetClipRgn(hdc, -ROOM_SIZE, 0);
|
|
iPos--;
|
|
giPath[++iPath] = 0;
|
|
goto start;
|
|
}
|
|
giPath[iPath] = 4;
|
|
}
|
|
|
|
|
|
// mark where we've been
|
|
|
|
hbrushOld = SelectObject(hdc,ghbrushBlack);
|
|
BitBlt(hdc, 0, 0, prc->right, prc->bottom, (HDC) 0, 0, 0, PATCOPY);
|
|
SelectObject(hdc,ghbrushBlue);
|
|
BitBlt(hdc,
|
|
(LONG)((iPos % cColume) * ROOM_SIZE + DOT_START - 1),
|
|
(LONG)((iPos / cColume) * ROOM_SIZE + DOT_START - 1),
|
|
2, 2, (HDC) 0, 0, 0, PATCOPY);
|
|
SelectObject(hdc,hbrushOld);
|
|
|
|
giMaze[iPos] ^= VIRGIN;
|
|
|
|
switch(giPath[--iPath])
|
|
{
|
|
case 0:
|
|
iPos += cColume;
|
|
OffsetClipRgn(hdc, 0, ROOM_SIZE);
|
|
break;
|
|
case 1:
|
|
iPos--;
|
|
OffsetClipRgn(hdc, -ROOM_SIZE, 0);
|
|
break;
|
|
case 2:
|
|
iPos -= cColume;
|
|
OffsetClipRgn(hdc, 0, -ROOM_SIZE);
|
|
break;
|
|
case 3:
|
|
iPos++;
|
|
OffsetClipRgn(hdc, ROOM_SIZE, 0);
|
|
break;
|
|
}
|
|
|
|
giPath[iPath]++;
|
|
}
|
|
|
|
|
|
if (TRUE)
|
|
{
|
|
iPath++;
|
|
SelectClipRgn(hdc, (HRGN) 0);
|
|
|
|
// flash the screen to show we finished
|
|
|
|
for (i = 0; i < 20; i++)
|
|
BitBlt(hdc, 0, 0, prc->right, prc->bottom, (HDC) 0, 0, 0, DSTINVERT);
|
|
|
|
hbrushOld = SelectObject(hdc,ghbrushBlack);
|
|
|
|
hStart = (prc->right - 280) / 2;
|
|
vStart = (prc->bottom -160) / 2;
|
|
|
|
if (hStart < 0)
|
|
hStart = 0;
|
|
|
|
if (vStart < 0)
|
|
vStart = 0;
|
|
|
|
BitBlt(hdc, hStart - 2, vStart - 2, 284, 164, (HDC) 0, 0, 0, PATCOPY);
|
|
vDrawBox(hdc, ghbrushRed, hStart, vStart, 280, 160, 2);
|
|
vDrawBox(hdc, ghbrushWhite, hStart+4, vStart+4, 272, 150, 2);
|
|
vDrawBox(hdc, ghbrushBlue, hStart+8, vStart+8, 264, 142, 2);
|
|
|
|
SelectObject(hdc,hbrushOld);
|
|
|
|
SetTextColor(hdc, argb[glJump & 3]);
|
|
SetROP2(hdc,R2_COPYPEN);
|
|
iBkModeOld = SetBkMode(hdc,TRANSPARENT);
|
|
|
|
bRetAll &= TextOut(hdc, hStart+16, vStart+20, " Maze statistics ", 24);
|
|
bRetAll &=TextOut(hdc, hStart+16, vStart+60, "Jumps needed to create: ", 24);
|
|
vNumber(hdc, glJump, hStart+216, vStart+60);
|
|
bRetAll &=TextOut(hdc, hStart+16, vStart+90, "Rooms visited to solve: ", 24);
|
|
vNumber(hdc, lVisit, hStart+216, vStart+90);
|
|
bRetAll &=TextOut(hdc, hStart+16, vStart+120, "Path length of solution:", 24);
|
|
vNumber(hdc, (LONG) iPath, hStart+216, vStart+120);
|
|
SetBkMode(hdc,iBkModeOld);
|
|
|
|
if (!bRetAll)
|
|
DbgPrint("vTravel: One or more TextOut calls failed\n");
|
|
|
|
GdiFlush();
|
|
vSleep(1);
|
|
}
|
|
}
|
|
|
|
void vDrawBox(HDC hdc, HBRUSH hbr, int x, int y, int w, int h, int size)
|
|
|
|
{
|
|
HBRUSH hbrOld;
|
|
|
|
hbrOld = SelectObject(hdc,hbr);
|
|
|
|
BitBlt(hdc, x, y, w, size, (HDC) 0, 0, 0, PATCOPY);
|
|
BitBlt(hdc, x + w, y, size, h + size, (HDC) 0, 0, 0, PATCOPY);
|
|
BitBlt(hdc, x, y + h, w, size, (HDC) 0, 0, 0, PATCOPY);
|
|
BitBlt(hdc, x, y, size, h, (HDC) 0, 0, 0, PATCOPY);
|
|
|
|
SelectObject(hdc,hbrOld);
|
|
}
|