#include<windows.h>
#include<stdlib.h>
#include<time.h>
#include<string.h>
#include<stdio.h>
#include<bios.h>
#include<dos.h>
#include<io.h>

#include"adogd.h"
#include"adogdres.h"

/*#define DEBUG 0*/

typedef struct
{
	BITMAPINFOHEADER bmiHeader;
	RGBQUAD bmiColors[16];
} xxBITMAPINFO;

HWND hMakeDialog[3];
HANDLE hInst;
HANDLE hMem;
HBITMAP hLegend = 0;
HWND hWnd;
PAINTSTRUCT ps;
charinfo Player;
HCURSOR hCursor;
HANDLE hTerning, hPlayer;
HMENU hMenu;
BYTE Method;
BOOL bThief = FALSE;
BOOL bRogue = FALSE;
BOOL bWizard = FALSE;
BOOL bCleric = FALSE;
BOOL bBard = FALSE;
BOOL bSpecialist = FALSE;
BOOL bRebuilt = FALSE;


void SetHeadLine(void);

/***************************************************************************/

int PASCAL WinMain(hInstance, hPrevInstance, lpCmdLine, nCmdShow)
HANDLE hInstance;
HANDLE hPrevInstance;
LPSTR lpCmdLine;
int nCmdShow;
{
	MSG msg;


	if (!hPrevInstance)
		if (!InitApplication(hInstance))
			return (FALSE);

	if (!InitInstance(hInstance, nCmdShow))
	{
		return (FALSE);
	}

	while (GetMessage(&msg,NULL,NULL,NULL))
	{
		if(!IsDialogMessage(hMakeDialog[0], &msg) ||
			 !IsDialogMessage(hMakeDialog[1], &msg) ||
			 !IsDialogMessage(hMakeDialog[2], &msg))
		{
			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}
	}
	return (msg.wParam);
}




BOOL InitApplication(hInstance)
HANDLE hInstance;
{
	WNDCLASS	wc;

	wc.style = CS_VREDRAW | CS_HREDRAW | CS_SAVEBITS;
	wc.lpfnWndProc = MainWndProc;
	wc.cbClsExtra = 0;
	wc.cbWndExtra = 0;
	wc.hInstance = hInstance;
	wc.hIcon = LoadIcon(hInstance, (LPSTR)"ADOGDCAVE");
	wc.hCursor = NULL;
	wc.hbrBackground = GetStockObject(WHITE_BRUSH);
	wc.lpszMenuName =	"adogdMenu";
	wc.lpszClassName = "adogdWClass";

	if(!RegisterClass(&wc))
	{
		return FALSE;
	}

	wc.style = NULL;
	wc.lpfnWndProc = Make;
	wc.cbClsExtra = 0;
	wc.cbWndExtra = DLGWINDOWEXTRA + sizeof(HANDLE) + sizeof(pcharinfo);
	wc.hInstance = hInstance;
	wc.hIcon = NULL;
	wc.hCursor = LoadCursor(hInstance, "SVERD");
	wc.hbrBackground = GetStockObject(LTGRAY_BRUSH);
	wc.lpszMenuName =	NULL;
	wc.lpszClassName = "MakeClass";

	return (RegisterClass(&wc));
}




BOOL InitInstance(hInstance, nCmdShow)
HANDLE hInstance;
int	nCmdShow;
{
	hInst = hInstance;

	/* Create a main window for this application instance.	*/

	hWnd = CreateWindow("adogdWClass", "AD&D",
											 WS_OVERLAPPED | WS_CLIPCHILDREN | WS_MAXIMIZE |
											 WS_MINIMIZEBOX | WS_SYSMENU,
											 CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
											 CW_USEDEFAULT, NULL, NULL, hInstance, NULL);



	if (!hWnd)
		return (FALSE);

	SetHeadLine();
	hCursor = LoadCursor(hInstance, "SVERD");
	hMenu = GetMenu(hWnd);

	CheckMenuItem(hMenu, Method + IDM_DEFAULT, MF_CHECKED);

	srand((unsigned)time(NULL));

	ShowWindow(hWnd, SW_SHOWMAXIMIZED);
	UpdateWindow(hWnd);

	return (TRUE);
}



long FAR PASCAL MainWndProc(hWnd, message, wParam, lParam)
HWND hWnd;
unsigned message;
WORD wParam;
LONG lParam;
{
	FARPROC fpDialog;
	HDC hDC;
	register BYTE i;


	switch (message)
	{
		case WM_COMMAND:
			switch (wParam)
			{
				case IDM_NEW:
					bThief = FALSE;
					bWizard = FALSE;
					bCleric = FALSE;
					bBard = FALSE;
					bSpecialist = FALSE;
					bRebuilt = FALSE;
					Player.strbonus = 0;

					if(Player.thiefskills != NULL)
					{
						LocalFree(Player.thiefskills);
						Player.thiefskills = NULL;
					}
					if(Player.spells != NULL)
					{
						LocalFree(Player.spells);
						Player.spells = NULL;
					}

					EnableMenuItem(hMenu, 0, MF_BYPOSITION | MF_DISABLED | MF_GRAYED);
					DrawMenuBar(hWnd);

					if(new() == FALSE)
					{
						MessageBox(hWnd, "FUCK WINDOWS!!!\nOut of memory", NULL, MB_OK);
						break;
					}
				break;

				case IDM_LOOK:
					fpDialog = MakeProcInstance((FARPROC)Look, hInst);
					DialogBox(hInst, "COMPL_CHAR", hWnd, fpDialog);
					FreeProcInstance(fpDialog);
				break;

				case IDM_REBUILD:
					bThief = FALSE;
					bWizard = FALSE;
					bCleric = FALSE;
					bBard = FALSE;
					bSpecialist = FALSE;
					bRebuilt = TRUE;

					EnableMenuItem(hMenu, 0, MF_BYPOSITION | MF_DISABLED | MF_GRAYED);
					DrawMenuBar(hWnd);
					fpDialog = MakeProcInstance(Rebuild, hInst);
					DialogBox(hInst, "EDIT_CHAR", hWnd, fpDialog);
					FreeProcInstance(fpDialog);
				break;

				case IDM_SAVE:
					print_char(FIL, hWnd);
				break;

				case IDM_PRINT:
					print_char(PRINTER, hWnd);
				break;

				case IDM_DEFAULT:
				case IDM_METHOD1:
				case IDM_METHOD2:
				case IDM_METHOD3:
				case IDM_METHOD4:
				case IDM_METHOD5:
				case IDM_METHOD6:
					CheckMenuItem(hMenu, Method + IDM_DEFAULT, MF_UNCHECKED);
					Method = wParam - IDM_DEFAULT;
					CheckMenuItem(hMenu, wParam, MF_CHECKED);
					SetHeadLine();
				break;

				case IDM_ABOUT:
					fpDialog = MakeProcInstance((FARPROC)About, hInst);
					DialogBox(hInst, "ADOGDABOUT", hWnd, fpDialog);
					FreeProcInstance(fpDialog);
				break;

				default:
					return (DefWindowProc(hWnd, message, wParam, lParam));
			}
		break;

		case WM_CHAR:
			switch(wParam)
			{
				case '1':
				case '2':
				case '3':
					if(hMakeDialog[0] != 0)
					{
						SendMessage(hMakeDialog[wParam - '1'], WM_COMMAND, IDM_OK, NULL);
					}
				return TRUE;

				default:
					return (DefWindowProc(hWnd, message, wParam, lParam));
			}

		case WM_CREATE:
			{
				WORD status;

				if((hLegend = load_bmpfile("Legend.bmp", hWnd, &status)) == NULL)
				{
					switch(status)
					{
						case 1:
							MessageBox(hWnd, "Couldnt open .BMP file", NULL,
												 MB_OK | MB_ICONINFORMATION);
						break;

						case 2:
							MessageBox(hWnd, "Illegal .BMP file", NULL,
												 MB_OK | MB_ICONINFORMATION);
						break;

						case 3:
							MessageBox(hWnd, "Out of memory for BMP!", NULL,
												 MB_OK | MB_ICONINFORMATION);
						break;
					}
				}
			}

			Method = GetProfileInt("ADOGD", "Method", 0);
			Player.thiefskills = NULL;
			Player.spells = NULL;

		return (DefWindowProc(hWnd, message, wParam, lParam));

		case WM_PAINT:
			BeginPaint(hWnd, &ps);
			{
				HDC hMemoryDC;
				RECT area;

				hDC = GetDC(hWnd);
				hMemoryDC = CreateCompatibleDC(hDC);
				SelectObject(hMemoryDC, hLegend);
				GetClientRect(hWnd, &area);

				BitBlt(hDC, (640-area.right)/2, (480/area.bottom)/2,
										 640, 480, hMemoryDC, 0, 0, SRCCOPY);

				DeleteDC(hMemoryDC);
				ReleaseDC(hWnd, hDC);
			}
			EndPaint(hWnd, &ps);
		break;

		case WM_SIZE:
			if(wParam == SIZEICONIC)
			{
				if(hMakeDialog[0] != 0)
				{
					for(i = 0; i < 3; i++)
					{
						ShowWindow(hMakeDialog[i], SW_HIDE);
					}
				}
			}
			else if(wParam == SIZEFULLSCREEN && hMakeDialog[0] != 0)
			{
				for(i = 0; i < 3; i++)
				{
						ShowWindow(hMakeDialog[i], SW_SHOW);
				}
			}
			else if(wParam == SIZENORMAL)
			{
				ShowWindow(hWnd, SW_SHOWMAXIMIZED);
			}
		break;

		case WM_MOVE:

		break;

		case WM_MOUSEMOVE:
			SetCursor(hCursor);
		break;

		case WM_SETCURSOR:
			if(wParam != hWnd)
			{
				break;
			}
			else if(LOWORD(lParam) == HTCLIENT);
			{
				SetCursor(hCursor);
			}
		break;

		case WM_DESTROY:
			{
				BYTE dummy[2];

				sprintf(dummy, "%d", Method);
				WriteProfileString("ADOGD", "Method", dummy);
			}

			if(hMakeDialog[0] != 0)
			{
				for(i = 0; i < 3; i++)
				{
					DestroyWindow(hMakeDialog[i]);
				}
			}
			if(hLegend != NULL)
			{
				DeleteObject(hLegend);
			}
			if(Player.thiefskills != 0)
			{
				LocalFree(Player.thiefskills);
			}
			if(Player.spells != 0)
			{
				LocalFree(Player.spells);
			}
			PostQuitMessage(0);
		break;

		default:
			return (DefWindowProc(hWnd, message, wParam, lParam));
	}
	return (NULL);
}


/* About dialogbox */

BOOL FAR PASCAL About(HWND hDlg, unsigned message, WORD wParam, LONG lParam)
{
	switch(message)
	{
		case WM_INITDIALOG:
		return TRUE;

		case WM_COMMAND:
			switch(wParam)
			{
				case IDM_OK:
					EndDialog(hDlg, NULL);
				return TRUE;
			}
		break;
	}
	return FALSE;
}




/* Look-character dialogbox */

BOOL FAR PASCAL Look(HWND hDlg, unsigned message, WORD wParam, LONG lParam)
{
	BYTE i;
	int ID;
	char dummy[20];
	static FARPROC procLookThief, procLookSpells;
	static HWND hThiefWnd, hSpellsWnd;
	BYTE hvor;

	switch(message)
	{
		case WM_INITDIALOG:
			procLookThief = NULL;
			procLookSpells = NULL;

			hThiefWnd = 0;
			hSpellsWnd = 0;

			if(bThief == TRUE || bBard == TRUE)
			{
				procLookThief = MakeProcInstance(LookThief, hInst);
				hThiefWnd = CreateDialog(hInst, "THIEFLOOK", hWnd, procLookThief);
				ShowWindow(hThiefWnd, SW_SHOW);
			}
			if(bWizard == TRUE)
			{
				procLookSpells = MakeProcInstance(LookSpells, hInst);
				hSpellsWnd = CreateDialog(hInst, "SPELLS", hWnd, procLookSpells);
				ShowWindow(hSpellsWnd, SW_SHOW);
			}

			/* skal fortsette */
		case UPDATE:
			for(i = 0, ID = STR_SUM; ID <= CML_SUM; i++, ID += 10)
			{
				SetDlgItemInt(hDlg, ID, Player.skill[i], FALSE);
			}

			if(Player.strbonus != 0)
			{
				SetDlgItemInt(hDlg, STR_BONUS, Player.strbonus, FALSE);
			}
			else
			{
				SetDlgItemText(hDlg, STR_BONUS, "");
			}

			if(Player.race == 0)
			{
				SetDlgItemText(hDlg, RACE, "---");
			}
			else
			{
				LoadString(hInst, Player.race, dummy, 19);
				SetDlgItemText(hDlg, RACE, (LPSTR) dummy);
			}

			SetDlgItemText(hDlg, CLASS, (LPSTR) Player.class);
			SetDlgItemText(hDlg, SOCIAL_CLASS, (LPSTR) Player.sclass);

			if(Player.sex == 0)
			{
				SetDlgItemText(hDlg, SEX, "---");
			}
			else
			{
				LoadString(hInst, Player.sex, dummy, 19);
				SetDlgItemText(hDlg, SEX, (LPSTR) dummy);
			}

			SetDlgItemText(hDlg, FAMILY, (LPSTR) Player.family);
			SetDlgItemText(hDlg, STATUS, (LPSTR) Player.status);
			SetDlgItemText(hDlg, NAME, (LPSTR) Player.name);

			if(Player.birthrank == 0)
			{
				SetDlgItemText(hDlg, WEIGHT, "---");
				SetDlgItemText(hDlg, HEIGHT, "---");
				SetDlgItemText(hDlg, BIRTH_RANK, "---");
				SetDlgItemText(hDlg, AGE, "---");
			}
			else
			{
				sprintf(dummy, "%d/%d", Player.birthrank, Player.siblings + 1);
				SetDlgItemText(hDlg, BIRTH_RANK, (LPSTR) dummy);
				SetDlgItemInt(hDlg, WEIGHT, Player.weight, FALSE);
				SetDlgItemInt(hDlg, HEIGHT, Player.height, FALSE);
				SetDlgItemInt(hDlg, AGE, Player.age, FALSE);
			}

			if(Player.gp == 0)
			{
				SetDlgItemText(hDlg, GOLD, "---");
				SetDlgItemText(hDlg, HITPOINTS, "---");
			}
			else
			{
				SetDlgItemInt(hDlg, GOLD, Player.gp, FALSE);
				SetDlgItemInt(hDlg, HITPOINTS, (WORD) Player.hp, FALSE);
			}

		return TRUE;

		case WM_COMMAND:
			switch(wParam)
			{
				case NAME:
					switch(lParam)
					{
						case EN_CHANGE:
						case EN_UPDATE:
							return TRUE;
					}
				break;

				case IDM_SAVE:
				case IDM_PRINT:
					{
						char tall;
						char streng[NAMELENGTH];

						tall = GetDlgItemText(hDlg, NAME, (LPSTR)streng, NAMELENGTH - 1);
						streng[tall] = NULL;

						if(strlen(streng) > 0)
						{
							_fstrcpy((char FAR *)Player.name, (char FAR *)streng);
						}
					}
					if(wParam == IDM_SAVE)
					{
						hvor = FIL;
					}
					else
					{
						hvor = PRINTER;
					}
					print_char(hvor, hDlg);
				return TRUE;

				case IDM_OK:
					{
						char tall;
						char streng[NAMELENGTH];

						tall = GetDlgItemText(hDlg, NAME, (LPSTR)streng, NAMELENGTH - 1);
						streng[tall] = NULL;

						if(strlen(streng) > 0)
						{
							_fstrcpy((char FAR *)Player.name, (char FAR *)streng);
						}
					}
					if(hThiefWnd != NULL)
					{
						DestroyWindow(hThiefWnd);
						FreeProcInstance(procLookThief);
						hThiefWnd = 0;
					}
					if(hSpellsWnd != NULL)
					{
						DestroyWindow(hSpellsWnd);
						FreeProcInstance(procLookSpells);
						hSpellsWnd = 0;
					}

					EndDialog(hDlg, NULL);
					return TRUE;
			}
		break;
	}
	return FALSE;
}


/* Funksjon som loader en bitmap fra fil */
#pragma warn -sig
HBITMAP load_bmpfile(char *filnavn, HWND hWnd, WORD *status)
{
	xxBITMAPINFO bi;
	DWORD i, j, *dw_t;
	WORD *w_t;
	HANDLE hMinne;
	HDC hDC;
	HBITMAP hBmp;
	char huge *pMinne, huge *curadr;
	static char buff[BMPHSIZE];
	int fh;

	*status = 1;
	if((fh = _lopen((LPSTR)filnavn, OF_READ)) == -1)
	{
		return NULL;
	}

	(*status)++;
	if(_lread(fh, (LPSTR)buff, BMPHSIZE) != BMPHSIZE)
	{
		_lclose(fh);
		return NULL;
	}

	(*status)++;
	dw_t = (DWORD *)(&buff[18]);
	w_t = (WORD *)(&buff[26]);
	bi.bmiHeader.biSize	= 40;
	bi.bmiHeader.biWidth = dw_t[0];
	bi.bmiHeader.biHeight	= dw_t[1];
	bi.bmiHeader.biPlanes	= w_t[0];
	bi.bmiHeader.biBitCount	= w_t[1];

	bi.bmiHeader.biCompression = 0;

	bi.bmiHeader.biSizeImage =
		WIDTHBYTES(bi.bmiHeader.biWidth*bi.bmiHeader.biBitCount)*
		bi.bmiHeader.biHeight;

	bi.bmiHeader.biXPelsPerMeter = 0;
	bi.bmiHeader.biYPelsPerMeter = 0;
	bi.bmiHeader.biClrUsed = 0;
	bi.bmiHeader.biClrImportant = 0;

	if( (hMinne =
		GlobalAlloc( GMEM_NOCOMPACT, bi.bmiHeader.biSizeImage)) == NULL ||
		(pMinne = (char huge *)GlobalLock( hMinne)) == NULL)
	{
		if( hMinne)
		{
			GlobalFree( hMinne);
		}
		_lclose( fh);
		return NULL;
	}
	(*status)++;
	curadr = pMinne;
	for( i = (bi.bmiHeader.biSizeImage / READBLOCK); i > 0L; i--)
	{
		_lread( fh, (LPSTR) curadr, (WORD) READBLOCK);
		curadr += READBLOCK;
	}

	if( (i = (bi.bmiHeader.biSizeImage % READBLOCK)) > 0L)
	{
		_lread( fh, (LPSTR) curadr, (WORD) i);
	}

	_lclose( fh);

	for( i=0 , j=54; i < 16; i++, j +=4)
	{
		bi.bmiColors[i].rgbBlue 	= buff[j];
		bi.bmiColors[i].rgbGreen	= buff[j+1];
		bi.bmiColors[i].rgbRed		= buff[j+2];
		bi.bmiColors[i].rgbReserved = 0;
	}
	if( (hBmp = CreateBitmap( (int) bi.bmiHeader.biWidth,
		(int) bi.bmiHeader.biHeight, 4, 1, NULL)) != NULL)
	{
		hDC = GetDC( hWnd);
		SetDIBits( hDC, hBmp, 0, (WORD) bi.bmiHeader.biHeight,
			(LPSTR) pMinne, (LPBITMAPINFO) &bi, DIB_RGB_COLORS);
		ReleaseDC(hWnd, hDC);
		*status = 0;
	}

	GlobalUnlock( hMinne);
	GlobalFree( hMinne);

	return hBmp;
}
#pragma warn +sig

void print_char(BYTE hvor, HWND hParentWnd)
{
	pThiefSkills TyvPeker;
	pSpells SpellPeker;
	BYTE printer[80];
	BYTE filnavn[20];
	BYTE streng[20];
	BYTE pre[10];
	BYTE i;
	int iFileHandle;
	OFSTRUCT OfStruct;

	if(hvor == FIL)
	{
		if(Player.name[0] == NULL)
		{
			strcpy(filnavn, "CHARACTE.CHA\0");
		}
		else
		{
			for(i = 0; i < 8; i++)
			{
				if(Player.name[i] == NULL)
				{
					break;
				}
				filnavn[i] = Player.name[i];
				if(filnavn[i] == ' ')
				{
					filnavn[i] = '_';
				}
			}
			filnavn[i] = NULL;
			strcat(filnavn, ".CHA\0");
		}

		if((iFileHandle = OpenFile(filnavn, &OfStruct, OF_CREATE | OF_WRITE))
				== -1)
		{
			MessageBox(hParentWnd, "Cannot save character!!!", NULL, MB_OK);
			return;
		}
	}
	else
	{
		if((iFileHandle = OpenFile("prn", &OfStruct, OF_WRITE)) == -1)
		{
			MessageBox(hParentWnd, "Cannot print character!!!", NULL, MB_OK);
			return;
		}
	}

	if(bRebuilt == TRUE)
	{
		strcpy(pre, "pre-built \0");
	}
	else
	{
		pre[0] = NULL;
	}

	sprintf(printer,"\n\rYour %scharacter: %s\n\r", pre, Player.name);
	write(iFileHandle, printer, strlen(printer));

	sprintf(printer,"STR : %2d ", Player.skill[STR]);
	write(iFileHandle, printer, strlen(printer));

	if(Player.strbonus != 0)
	{
		 sprintf(printer,"%d",Player.strbonus);
		 write(iFileHandle, printer, strlen(printer));
	}
	sprintf(printer,"\n\rDEX : %2d", Player.skill[DEX]);
	write(iFileHandle, printer, strlen(printer));

	sprintf(printer,"\n\rCON : %2d", Player.skill[CON]);
	write(iFileHandle, printer, strlen(printer));

	sprintf(printer,"\n\rINT : %2d", Player.skill[INT]);
	write(iFileHandle, printer, strlen(printer));

	sprintf(printer,"\n\rWIS : %2d", Player.skill[WIS]);
	write(iFileHandle, printer, strlen(printer));

	sprintf(printer,"\n\rCHA : %2d", Player.skill[CHA]);
	write(iFileHandle, printer, strlen(printer));

	sprintf(printer,"\n\rCML : %2d", Player.skill[CML]);
	write(iFileHandle, printer, strlen(printer));

	LoadString(hInst, Player.race, streng, 19);
	sprintf(printer,"\n\r\n\rRace         : %s",streng);
	write(iFileHandle, printer, strlen(printer));

	LoadString(hInst, Player.sex, streng, 19);
	sprintf(printer,"\n\rSex          : %s",streng);
	write(iFileHandle, printer, strlen(printer));

	sprintf(printer,"\n\rClass        : %s",Player.class);
	write(iFileHandle, printer, strlen(printer));

	sprintf(printer,"\n\rHit Points   : %d",Player.hp);
	write(iFileHandle, printer, strlen(printer));

	sprintf(printer,"\n\r\n\rAge          : %d",Player.age);
	write(iFileHandle, printer, strlen(printer));

	sprintf(printer,"\n\rHeight       : %d",Player.height);
	write(iFileHandle, printer, strlen(printer));

	sprintf(printer,"\n\rWeight       : %d",Player.weight);
	write(iFileHandle, printer, strlen(printer));

	sprintf(printer,"\n\r\n\rFamily       : %s",Player.family);
	write(iFileHandle, printer, strlen(printer));

	sprintf(printer,"\n\rSocial class : %s",Player.sclass);
	write(iFileHandle, printer, strlen(printer));

	sprintf(printer,"\n\rStatus       : %s",Player.status);
	write(iFileHandle, printer, strlen(printer));

	sprintf(printer,"\n\r\n\rBirth-rank   : %d/%d",Player.birthrank,
																						 Player.siblings+1);
	write(iFileHandle, printer, strlen(printer));

	sprintf(printer,"\n\r\n\rGold         : %d",Player.gp);
	write(iFileHandle, printer, strlen(printer));

	sprintf(printer,"\n\r\n\r");
	write(iFileHandle, printer, strlen(printer));

	if(bThief == TRUE || bBard == TRUE)
	{
		sprintf(printer, "\n\rThieves\' skills:\n\r\n\r");
		write(iFileHandle, printer, strlen(printer));

		TyvPeker = (pThiefSkills) LocalLock(Player.thiefskills);

		sprintf(printer, "Pick Pocket       :  %d\n\r", TyvPeker[PICK]);
		write(iFileHandle, printer, strlen(printer));

		if(bBard == FALSE)
		{
			sprintf(printer, "Open Locks        :  %d\n\r", TyvPeker[LOCK]);
			write(iFileHandle, printer, strlen(printer));

			sprintf(printer, "Find/Remove Traps :  %d\n\r", TyvPeker[TRAP]);
			write(iFileHandle, printer, strlen(printer));

			sprintf(printer, "Move Silent       :  %d\n\r", TyvPeker[MOVE]);
			write(iFileHandle, printer, strlen(printer));

			sprintf(printer, "Hide In Shadows   :  %d\n\r", TyvPeker[HIDE]);
			write(iFileHandle, printer, strlen(printer));
		}

		sprintf(printer, "Detect Noise      :  %d\n\r", TyvPeker[NOISE]);
		write(iFileHandle, printer, strlen(printer));

		sprintf(printer, "Climb Walls       :  %d\n\r", TyvPeker[CLIMB]);
		write(iFileHandle, printer, strlen(printer));

		sprintf(printer, "Read Languages    :  %d\n\r", TyvPeker[READL]);
		write(iFileHandle, printer, strlen(printer));

		LocalUnlock(Player.thiefskills);
	}

	if(bWizard == TRUE)
	{
		SpellPeker = (pSpells) LocalLock(Player.spells);

		sprintf(printer, "\n\rYour Spells:\n\r");
		write(iFileHandle, printer, strlen(printer));

		sprintf(printer, "Offensive Spell     : %s\n\r", SpellPeker->Offensive);
		write(iFileHandle, printer, strlen(printer));

		sprintf(printer, "Defensive Spell     : %s\n\r", SpellPeker->Defensive);
		write(iFileHandle, printer, strlen(printer));

		sprintf(printer, "Miscelleanous Spell : %s\n\r", SpellPeker->Miscelleanous);
		write(iFileHandle, printer, strlen(printer));

		sprintf(printer, "Bonus Spell         : %s\n\r", SpellPeker->Bonus);
		write(iFileHandle, printer, strlen(printer));

		LocalUnlock(Player.spells);
	}

	sprintf(printer, "\f");
	write(iFileHandle, printer, strlen(printer));

	close(iFileHandle);
}


void SetHeadLine(void)
{
	BYTE dummy[50];
	switch(Method)
	{
		case DEFAULT:
			strcpy(dummy, "AD&D character-generator (Default Method)");
		break;

		case METHOD1:
			strcpy(dummy, "AD&D character-generator (Method I)");
		break;

		case METHOD2:
			strcpy(dummy, "AD&D character-generator (Method II)");
		break;

		case METHOD3:
			strcpy(dummy, "AD&D character-generator (Method III)");
		break;

		case METHOD4:
			strcpy(dummy, "AD&D character-generator (Method IV)");
		break;

		case METHOD5:
			strcpy(dummy, "AD&D character-generator (Method V)");
		break;

		case METHOD6:
			strcpy(dummy, "AD&D character-generator (Method VI)");
		break;
	}

	SetWindowText(hWnd, (LPSTR) dummy);
}