windows-xp/Source/XPSP1/NT/shell/osshell/ep/snake/grafix.c

/*******************/
/* file: grafix.c */
/*******************/

#define  _WINDOWS
#include <windows.h>
#include <port1632.h>

#include "snake.h"
#include "res.h"
#include "rtns.h"
#include "grafix.h"
#include "blk.h"
#include "sound.h"
#include "pref.h"

#define cbDibHeader (16*4 + sizeof(BITMAPINFOHEADER))

HANDLE  hresWall = NULL;
LPSTR   lpDibWall;

HANDLE  hresLvl = NULL;
LPSTR   lpDibLvl;

HANDLE  hresSnk = NULL;
LPSTR   lpDibSnk;

HDC     hdcBlk;
HBITMAP hbmpBlk;
HDC     hdcCor;
HBITMAP hbmpCor;
HDC     hdcNum;
HBITMAP hbmpNum;


HDC     hdcMain;	/* DC for main window */

HPEN    hpenGray;
HBRUSH  hbrushGreen;

/* Score Stuff */

INT rgnum[numMax];
INT cMoveScore = 0;		/* 0 if not moving score */
INT inumMoveMac;			/* first number to move ( >1 if moving several 9 -> 0) */
INT score;
INT scoreCurr;				/* Current displayed score */


#define DKGREEN 0x00007F00L
#define LTGREEN 0x0000FF00L

LONG coDarkGreen;
LONG coLiteGreen;


/*** External Data ***/

extern HWND   hwndMain;
extern HANDLE hInst;
extern BOOL   fEGA;

extern POS posHead;
extern POS posTail;

extern BLK mpposblk[posMax];

extern INT cLevel;
extern INT cTimeLeft;
extern INT cLives;
extern INT ctickMove;

extern INT dypCaption;
extern INT dypMenu;
extern INT dypBorder; 
extern INT dxpBorder;

extern INT dxpWindow;
extern INT dypWindow;

extern STATUS status;
extern PREF   Preferences;

extern BOOL   fWipe;


/****** S T A R T  D R A W ******/

VOID StartDraw(VOID)
{
	hdcMain = GetDC(hwndMain);
}


/****** E N D  D R A W ******/

VOID EndDraw(VOID)
{
	ReleaseDC(hwndMain, hdcMain);
}



BOOL FLoadBitmaps(VOID)
{
	hresSnk = LoadResource(hInst,
		FindResource(hInst, MAKEINTRESOURCE(ID_BMP_SNK+(!Preferences.fColor)), RT_BITMAP));

	if (hresSnk == NULL)
		return fFalse;

	lpDibSnk  = LockResource(hresSnk);

	hbmpBlk   = LoadBitmap(hInst, MAKEINTRESOURCE(ID_BMP_BLK+(!Preferences.fColor)) );
	SelectObject(hdcBlk, hbmpBlk);

	coDarkGreen = Preferences.fColor ? DKGREEN : 0x007F7F7FL;
	coLiteGreen = Preferences.fColor ? LTGREEN : 0x00FFFFFFL;

	SetLevelColor();

	return fTrue;
}

VOID FreeBitmaps(VOID)
{
	UnlockResource(hresSnk);
}


/****** F  I N I T  L O C A L ******/

BOOL FInitLocal(VOID)
{
	hresWall  = LoadResource(hInst, FindResource(hInst, MAKEINTRESOURCE(ID_BMP_WALL), RT_BITMAP));

	hresLvl   = LoadResource(hInst, FindResource(hInst, MAKEINTRESOURCE(ID_BMP_LVL), RT_BITMAP));

	hdcNum    = CreateCompatibleDC(NULL);
	hbmpNum   = LoadBitmap(hInst, MAKEINTRESOURCE(ID_BMP_NUM));

	hdcBlk    = CreateCompatibleDC(NULL);

	StartDraw();
	hdcCor    = CreateCompatibleDC(NULL);
	hbmpCor   = CreateCompatibleBitmap(hdcMain, dxpCor, dypCorMax);
	EndDraw();

	if ((hresWall == NULL) || (hresLvl == NULL) ||
			(hdcNum == NULL) || (hbmpNum == NULL) ||
			(hdcCor == NULL) || (hbmpCor == NULL) || (hdcBlk == NULL) )
		return fFalse;

	lpDibWall = LockResource(hresWall);
	lpDibLvl  = (LPVOID) ((LPBYTE) LockResource(hresLvl)	+ sizeof(BITMAPINFOHEADER) + 8);
	SelectObject(hdcNum, hbmpNum);
	SelectObject(hdcCor, hbmpCor);

	if (fEGA)
		{
		hpenGray = CreatePen(PS_SOLID, 1, RGB(64, 64, 64));
		}
	else
		{
		hpenGray = CreatePen(PS_SOLID, 1, RGB(128, 128, 128));
		}

	hbrushGreen = CreateSolidBrush(RGB(0,128,0));

	InitTunes();

	return (FLoadBitmaps());
}


/****** C L E A N  U P ******/

VOID CleanUp(VOID)
{
	EndTunes();
	FreeBitmaps();
	UnlockResource(hresWall);
	UnlockResource(hresLvl);
	DeleteDC(hdcBlk);
	DeleteDC(hdcCor);
	DeleteDC(hdcNum);
}


/*======================== Snakes/Lives ================================*/

VOID DrawLives(VOID)
{
	INT x = dxpLifeOff;
	HBRUSH hbrush;
	INT i;

	SetROP2(hdcMain, R2_BLACK);	/* ???? */

	hbrush = SelectObject(hdcMain, hbrushGreen);
	for (i = 0; i++ < cLives;)
		{
		SetDIBitsToDevice(hdcMain, x, dypLifeOff, dxpLife, dypLife,
			0, 0, 0, dypLife,
			lpDibSnk + (Preferences.fColor ? cbDibHeader : (2*4 + sizeof(BITMAPINFOHEADER))),
			(LPBITMAPINFO) lpDibSnk, DIB_RGB_COLORS);
		x += dxpLifeSpace;
		}

	SelectObject(hdcMain, GetStockObject(LTGRAY_BRUSH));
	for (i=cLives; i++ < cLivesMax;)
		{
		PatBlt(hdcMain, x, dypLifeOff, dxpLife, dypLife, PATCOPY);
		x += dxpLifeSpace;
		}
	SelectObject(hdcMain, hbrush);
}

VOID DisplayLives(VOID)
{
	StartDraw();
	DrawLives();
	EndDraw();
}


/*============================ SCORE ROUTINES ============================*/


/****** D R A W  N U M ******/

VOID DrawNum(INT x, INT num)
{
	BitBlt(hdcMain, x, dypNumOff, dxpNum, dypNum-1, hdcNum, 0, num, SRCCOPY);
}


/****** D R A W  S C O R E ******/

VOID DrawScore(VOID)
{
	INT x;
	INT inum;

	x = dxpNumOff;
	for (inum = numMax; inum--  > 0;)
		{
		DrawNum(x, rgnum[inum]);
		x += dxpSpaceNum;
		}

	SetROP2(hdcMain, R2_BLACK);	/* ???? */

	x = dxpNumOff-1;
	for (inum = numMax+1; inum-- > 0;)
		{
		MMoveTo(hdcMain, x, dypNumOff-1);
		LineTo(hdcMain, x, dypNumOff+dypNum);
		x += dxpSpaceNum;
		}
	MMoveTo(hdcMain, dxpNumOff-1, dypNumOff-1);
	LineTo(hdcMain, dxpNumOff+dxpSpaceNum*numMax, dypNumOff-1);
	MMoveTo(hdcMain, dxpNumOff-1, dypNumOff+dypNum-1);
	LineTo(hdcMain, dxpNumOff+dxpSpaceNum*numMax, dypNumOff+dypNum-1);
}


VOID DisplayScore(VOID)
{
	StartDraw();
	DrawScore();
	EndDraw();
}


/****** I N C  S C O R E ******/

VOID IncScore(VOID)
{
	cMoveScore = dypNum/2 + 1;
	inumMoveMac = 0;

	while ((rgnum[inumMoveMac++] == 9*dypNum) && (inumMoveMac < numMax))
		;
	if ((++scoreCurr % 100) == 0)
		if (cLives < cLivesMax)
			{
			cLives++;
			DisplayLives();
			}
}


/****** M O V E  S C O R E ******/

VOID MoveScore(VOID)
{
	REGISTER INT x = dxpNumOff + dxpNumMax;
	REGISTER dy = 2;
	INT inum;

#if 0		/* More efficient to do in "DoTimer" */
	if (cMoveScore == 0)
		return;
#endif

	if (cMoveScore == 1)
		dy = 1;
	StartDraw();
	for (inum = 0; inum < inumMoveMac; inum++)
#if 1
		DrawNum(x -= dxpSpaceNum, rgnum[inum] += dy);
#else
		DrawNum(x -= dxpSpaceNum, ++(rgnum[inum]));
#endif
	EndDraw();

	if (--cMoveScore == 0)
		{
		inum = 0;
		while (rgnum[inum] >= 10*dypNum)	/* Reset number to proper zero */
			rgnum[inum++] = 0;
		if (scoreCurr != score)
			IncScore();
		}

}


/****** A D D  S C O R E ******/

VOID AddScore(INT n)
{
	score += n;
	if (score > 9999)
		ResetScore();
	if (cMoveScore == 0)
		IncScore();
}


/****** R E S E T  S C O R E ******/

VOID ResetScore(VOID)
{
	REGISTER INT i;

	scoreCurr = score = cMoveScore = 0;
	for (i = numMax; i-- > 0;)
		rgnum[i] = 0;
}




/*======================== TIMER ================================*/


VOID DrawTime(VOID)
{
	HBRUSH hbrush;

	hbrush = SelectObject(hdcMain, Preferences.fColor ? hbrushGreen : GetStockObject(GRAY_BRUSH));
	PatBlt(hdcMain, dxpTimeOff, dypTimeOff, cTimeLeft, dypTime, PATCOPY);
	PatBlt(hdcMain, dxpTimeOff+cTimeLeft, dypTimeOff, dxpTime-cTimeLeft, dypTime, BLACKNESS);
	SelectObject(hdcMain, hbrush);
}

VOID DisplayTime(VOID)
{
	StartDraw();
	DrawTime();
	EndDraw();
}

VOID UpdateTime(VOID)
{
/*	HBRUSH hbrush; */

	StartDraw();
	PatBlt(hdcMain, dxpTimeOff+cTimeLeft, dypTimeOff, 1, dypTime, BLACKNESS);
	EndDraw();
}


/*======================== Border stuff ================================*/


/****** S E T  T H E  P E N ******/

VOID SetThePen(BOOL fNormal)
{
	if (fNormal)
		SetROP2(hdcMain, R2_WHITE);
	else
		{
		SetROP2(hdcMain, R2_COPYPEN);
		SelectObject(hdcMain, hpenGray);
		}
}


/****** D R A W  B O R D E R ******/

/* 0 - white, gray
   1 - gray,  white
*/

VOID DrawBorder(INT x1, INT y1, INT x2, INT y2, INT width, BOOL fNormal)
{
	INT i = 0;

	SetThePen(fNormal);

	while (i++ < width)
		{
		MMoveTo(hdcMain, x1, --y2);
		LineTo(hdcMain, x1++, y1);
		LineTo(hdcMain, x2--, y1++);
		}

	SetThePen(!fNormal);

	while (--i)
		{
		MMoveTo(hdcMain, x1--,  ++y2);
		LineTo(hdcMain, ++x2, y2);
		LineTo(hdcMain, x2, --y1);
		}
}

VOID DrawBackground(VOID)
{
	
/* Main Raised Border */
/*	int x, y; */
/*	DrawBorder(0, 0, x = dxpWindow, y = dypWindow, 3, fTrue); */

	DrawBorder(dxpNumOff-2, dypNumOff-2,
		dxpNumOff + dxpSpaceNum*numMax, dypNumOff+dypNum, 1, fFalse);

	DrawBorder(dxpTimeOff-2, dypTimeOff-2,
		dxpTimeOff + dxpTime+1, dypTimeOff+dypTime+1, 2, fTrue);

}

/*======================== ? ? ? ================================*/


/****** D R A W  S C R E E N ******/

VOID DrawScreen(HDC hdc)
{
	hdcMain = hdc;
	if (fWipe)
		ReWipe();
	DrawBackground();
	DrawLives();
	DrawScore();
	if (!fWipe)
		DrawGrid();
	DrawTime();
}

VOID DisplayScreen(VOID)
{
	StartDraw();
	DrawScreen(hdcMain);
	EndDraw();
}