Archived

This topic is now archived and is closed to further replies.

n0p3x

Look over my code.

Recommended Posts

Hey, I'm just in the process of getting to grips with DirectX and I wrote the following attempt at a game the other day. It wasn't origionally going to be a game, I just got carried away adding things to it. So that should explain the wierdness of it. It all more-ales works but if you people don't mind reading over it and giving any pointers as you go along it would be much appreciated. If anyone wants the graphics or anything else let me know.. The main source code:
    
/*
TITLE: 		DirectX Game Shell
AUTHOR: 		David Stubbs
DATE: 		30/5/00
EMAIL: 		root@cod3r.cjb.net
WEB: 			http://cod3r.cjb.net

TEL: 			+44 7968 397782

TODO: Tidy code and libs
      Optimise where posible
      Comment more
      Add end screen
      Make all important stages logged to error log file
      Work out why sometimes near the end of prog blt gives error invalid params
      ...and the surface is lost before GAME_END
      Stop good guy flickering
      make sure too many bad guys arnt attempted to be created at end of game
*/
//---------------------------------------------------------------------------

//Library Files

#define WIN32_LEAN_AND_MEAN  										// just say no to MFC


#include <windows.h>   							  // include important windows stuff
#include <windowsx.h> 
#include <mmsystem.h>
#include <iostream.h> 								 // include important C/C++ stuff
#include <conio.h>
#include <stdlib.h>
#include <malloc.h>
#include <memory.h>
#include <string.h>
#include <stdarg.h>
#include <stdio.h> 
#include <math.h>
#include <io.h>
#include <fcntl.h>


#include <c:\mssdk\include\ddraw.h>   						//DirectDraw header file
#include <c:\mssdk\include\dinput.h>                 //DirectInput header file
//---------------------------------------------------------------------------

//Constants

#define WINDOW_CLASS_NAME "WINCLASS1"
//---------------------------------------------------------------------------

//Globals

HWND      				hMainWindow		= NULL; 		 // globally track main window

HINSTANCE 				hModule        = NULL; 			// globally track hinstance


LPDIRECTDRAW			lpdd 				= NULL;				// The DirectDraw Object

LPDIRECTDRAW4			lpdd4 			= NULL;				// DirectX 6 interafce 4

DDSURFACEDESC2 		ddsd;											//Surface description

LPDIRECTDRAWSURFACE4	lpddsprimary 	= NULL;			  //Primary surface pointer

LPDIRECTDRAWSURFACE4	lpddsback 		= NULL;
LPDIRECTDRAWSURFACE4	MySprite 		= NULL;
LPDIRECTDRAWSURFACE4	MySprite2 		= NULL;

LPDIRECTINPUT        lpdi      		= NULL;    					  // dinput object

LPDIRECTINPUTDEVICE  lpdikey   		= NULL;    					// dinput keyboard


UCHAR        			keyboard_state[256]; 	 // contains keyboard state table


int						LevelTimer		= 0;
int						FPS				= 0;
int						FrameCount		= 0;
int						Lives				= 3;
int						Level				= 1;
char						TextOutput[256]= "Sprite ";
char						Temp[10] 		= " ";
int						WindowClosed = 0;
//---------------------------------------------------------------------------

struct Sprite_Type
{
	int	x, y;
   int 	xv, yv;
	int	AnimState;
   LPDIRECTDRAWSURFACE4	Surface[8];
   int 	Frame;
} Sprite[30];

Sprite_Type				Unit;
int						Frame;
//---------------------------------------------------------------------------

const int SCREEN_WIDTH  = 640;
const int SCREEN_HEIGHT = 480;
const int SCREEN_RES    = 16;
//---------------------------------------------------------------------------

#include "routines.cpp"
//---------------------------------------------------------------------------

//Function prototypes

LRESULT CALLBACK WindowProc(HWND hwnd,UINT msg,WPARAM wparam,LPARAM lparam);
int Game_Main(void);
//---------------------------------------------------------------------------

LRESULT CALLBACK WindowProc(HWND hwnd,UINT msg,WPARAM wparam,LPARAM lparam)
{
PAINTSTRUCT				ps;											// used in WM_PAINT

HDC						hdc;								// handle to a device context


switch(msg)
{

	case WM_CREATE:
   {
		SetTimer(hwnd, 1, 1000, NULL);
   }break;

   case WM_TIMER:
   {
   	FPS=FrameCount;
      FrameCount=0;
   }break;

	case WM_PAINT:
   {
   	hdc = BeginPaint(hwnd,&ps);								//Validate the window

      EndPaint(hwnd,&ps); 													//End painting

   }break;

	case WM_DESTROY:
   {
   	PostQuitMessage(0);  						//Send WM_QUIT, kills application
   }break;

	default:break;
};
                                             //Let windows deal with all other

return (DefWindowProc(hwnd, msg, wparam, lparam));                  //messages

}
//---------------------------------------------------------------------------

void	DoCharacter(void)
{
lpdikey->GetDeviceState(256, (LPVOID)keyboard_state); 	//Get keyboard state



if (keyboard_state[DIK_RIGHT])			 //If right arrow move x right 5 pixels

	Unit.x+=5;

else if (keyboard_state[DIK_LEFT])//else if keyboard left move x left 5 pixels

	Unit.x+=-5;

if (keyboard_state[DIK_UP])             					//If up move y -5 pixels

	Unit.y+=-5;

else if (keyboard_state[DIK_DOWN])
	Unit.y+=5;         								  //else if down move y +5 pixles


if (Unit.x<=1)
	Unit.x=1;    				 //If user at end of screen on left hold them there


else if (Unit.x>=SCREEN_WIDTH-50)
	Unit.x = SCREEN_WIDTH-50;						  		//Same for right hand side


if (Unit.y<=1)
	Unit.y=1;       													//And top of screeen


else if (Unit.y>=SCREEN_HEIGHT-50)
	Unit.y = SCREEN_HEIGHT-50;        									//Finally left


Unit.Frame++;     									//Move onto next animation frame


if (Unit.Frame >=9)
	Unit.Frame=1;  					//If at end of animation sequence start again


																			//Draw unit to screen

BlitSurface(Unit.Surface[Unit.Frame], lpddsback, 140, 100, 50, 30, Unit.x, Unit.y);
}
//---------------------------------------------------------------------------

void DoEnemy(void)
{
for (int i=0; i<Level+5; i++)										//For all the enemy sprites

{
	Sprite<i>.x+=Sprite[i].xv;				//Increment x + y positions by velocity

   Sprite[i].y+=Sprite[i].yv;

   if (Sprite[i].x <= 1)
   	Sprite[i].xv = 3;		//If sprite hits left wayy set velocity to positive


   if (Sprite[i].x>SCREEN_WIDTH-51) 			//Right wall then set moving left

   	Sprite[i].xv = -3;

   if (Sprite[i].y <=1 )    										//Top set moving down

   	Sprite[i].yv = 3;

   if (Sprite[i].y>SCREEN_HEIGHT-51)   				  	  //Bottom set movinf up

   	Sprite[i].yv = -3;

   if (Sprite[i].AnimState==0)	 	  //Check which animation frame and draw it

   {
   	BlitSurface(MySprite, lpddsback, 280, 140, 50, 50,Sprite[i].x, Sprite[i].y);
      Sprite[i].AnimState=1;
   }
   else if (Sprite[i].AnimState=1)
   {
   	BlitSurface(MySprite2, lpddsback, 280, 140, 50, 50,Sprite[i].x, Sprite[i].y);
      Sprite[i].AnimState=0;
   }

   													//Check for user and enemy collision

   if ((Unit.x >= Sprite[i].x) && (Unit.x <= Sprite[i].x+50))
   	if ((Unit.y >= Sprite[i].y) && (Unit.y <= Sprite[i].y+50))
      {
      	Lives--;											  		//If so decrement lives

         Unit.x=320;    								  //Move user to centre screen

         Unit.y=240;
         if (Lives<1)     								  //If no more lives then quit

         	{
         	PostMessage(hMainWindow,WM_CLOSE,0,0);
            WindowClosed = 1;
            }
      }
}
}
//---------------------------------------------------------------------------

int Game_Main(void)
{

DWORD StartTime=GetTickCount();       	   //Get tickcount at start of routine


LevelTimer++;
if (LevelTimer % 500 == 0)
	Level++;

if (WindowClosed)   										//Don't re-run code after exit

	return(0);

lpdikey->GetDeviceState(256, (LPVOID)keyboard_state); 	//Get keyboard state


if (keyboard_state[DIK_ESCAPE])			 //If right arrow move x right 5 pixels						  //Test for escapoe key, if so quit
{
   WindowClosed = 1;
   PostMessage(hMainWindow,WM_CLOSE,0,0);
   return(0);
}

FillScreen(lpddsback, RGB(0,0,0)); 								  //Clear back buffer


DoCharacter();															 //Sort out character

DoEnemy();                                                         //And enemy


																		  //Display screen stats

wsprintf(TextOutput, "Frames Per Second: %d Lives: %d Level: %d", FPS, Lives, Level);
Draw_Text_GDI(TextOutput,0, 0, RGB(0, 255, 0), lpddsback);

lpddsprimary->Flip(NULL, DDFLIP_WAIT);				//Flip primary and back buffer


FrameCount++;														//Another frame rendered


int difference=GetTickCount();						  //Get finish time of routine


										//If we arnt running at 30FPS slow down to 30FPS

if ((difference - StartTime) < 33)
  	Sleep (difference);

return(1);
}
//---------------------------------------------------------------------------

int Game_Init(void *parms = NULL, int num_parms = 0)
{
HFILE File;

DeleteFile("errors.log");   	 //Delete old log file and create empty new one

_lcreat("errors.log", 0);
_lclose(File);

ShowCursor(FALSE);   											//Hide the mouse cursor


LogProg("STARTING: GameInit", FALSE);

DirectDrawCreate(NULL, &lpdd, NULL);						    //Get DD4 Interface

lpdd->QueryInterface(IID_IDirectDraw4, (LPVOID *)&lpdd4);
lpdd->Release();

LogProg("          Setting coop level", FALSE);        //Set cooperation level

lpdd4->SetCooperativeLevel(hMainWindow, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN | DDSCL_ALLOWMODEX | DDSCL_ALLOWREBOOT);

LogProg("          Setting display mode", FALSE); 		  		//Set display mode

lpdd4->SetDisplayMode(SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_RES, 0, 0);

DDRAW_INIT_STRUCT(ddsd);				  //clear surface description and set size


ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;      	//Enable valid fields


ddsd.dwBackBufferCount = 1; 									  //Enable 1 back buffer


ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_COMPLEX | DDSCAPS_FLIP;

LogProg("          Creating surface", FALSE);
lpdd4->CreateSurface(&ddsd, &lpddsprimary, NULL); //Create the primary surface


ddsd.ddsCaps.dwCaps = DDSCAPS_BACKBUFFER;//And get a handle to the back buffer

lpddsprimary->GetAttachedSurface(&ddsd.ddsCaps, &lpddsback);

LogProg("          Attaching clipper to primary buffer", FALSE);
RECT	RectList[1]={0,0,SCREEN_WIDTH,SCREEN_HEIGHT};
AttachClipper(lpddsprimary, 1, RectList);//Attach a clipper to the full screen


LogProg("          Attaching clipper to back buffer", FALSE);
AttachClipper(lpddsback, 1, RectList);//Attach a clipper to the full screen


LogProg("          Loading and drawing logo to primary surface", FALSE);
													 //Draw the startup image to the screen

BlitSurface(File2NewSurface("logo.bmp"), lpddsprimary, 640, 480, 640, 480,0,0);

LogProg("          Loading oponent sprites", FALSE);
											  //Load opponents images and output progress

MySprite=File2NewSurface("n0p3x.bmp");
Draw_Text_GDI("Loading Images.",0, 0, RGB(0, 255, 0), lpddsprimary);
MySprite2=File2NewSurface("n0p3x2.bmp");;
Draw_Text_GDI("Loading Images..",0, 0, RGB(0, 255, 0), lpddsprimary);

LogProg("          Loading users animation frames", FALSE);
  									    //Load all frames of animation for users unit

Unit.Surface[1]=File2NewSurface("unit1.bmp");
Draw_Text_GDI("Loading Images...",0, 0, RGB(0, 255, 0), lpddsprimary);
Unit.Surface[2]=File2NewSurface("unit2.bmp");
Draw_Text_GDI("Loading Images....",0, 0, RGB(0, 255, 0), lpddsprimary);
Unit.Surface[3]=File2NewSurface("unit3.bmp");
Draw_Text_GDI("Loading Images.....",0, 0, RGB(0, 255, 0), lpddsprimary);
Unit.Surface[4]=File2NewSurface("unit4.bmp");
Draw_Text_GDI("Loading Images......",0, 0, RGB(0, 255, 0), lpddsprimary);
Unit.Surface[5]=File2NewSurface("unit5.bmp");
Draw_Text_GDI("Loading Images.......",0, 0, RGB(0, 255, 0), lpddsprimary);
Unit.Surface[6]=File2NewSurface("unit6.bmp");
Draw_Text_GDI("Loading Images........",0, 0, RGB(0, 255, 0), lpddsprimary);
Unit.Surface[7]=File2NewSurface("unit7.bmp");
Draw_Text_GDI("Loading Images.........",0, 0, RGB(0, 255, 0), lpddsprimary);
Unit.Surface[8]=File2NewSurface("unit8.bmp");
Draw_Text_GDI("Loading Images..........done",0, 0, RGB(0, 255, 0), lpddsprimary);

Unit.Frame=1; 										//Set current annimation frame to 1


LogProg("          Initialising sprites start positions", FALSE);
												   	 //Initialise all opponents details

Draw_Text_GDI("Initialising sprites....",0, 12, RGB(0, 255, 0), lpddsprimary);
for (int i=0; i<21; i++)
{
	Sprite[i].x   =rand()%SCREEN_WIDTH;
   Sprite[i].y   =rand()%SCREEN_HEIGHT;
   Sprite[i].xv =3;
   Sprite[i].yv =3;
   Sprite[i].AnimState=0;
}

Unit.x=320; 									   		//Set users starting position

Unit.y=240;

Draw_Text_GDI("Initialising sprites.......done",0, 12, RGB(0, 255, 0), lpddsprimary);

Draw_Text_GDI("Initialising keyboard...",0, 24, RGB(0, 255, 0), lpddsprimary);

LogProg("          Creating DINPUT object", FALSE);
															//Create the direct input object

if (DirectInputCreate(hModule,DIRECTINPUT_VERSION,&lpdi,NULL)!=DI_OK)
   return(0);

LogProg("          Creating a keyboard device", FALSE);
																	//Create a keyboard device

if (lpdi->CreateDevice(GUID_SysKeyboard, &lpdikey, NULL)!=DI_OK)
   return(0);

LogProg("          Setting keyboard co-op level", FALSE);
																		//Set cooperation level

if (lpdikey->SetCooperativeLevel(hMainWindow,
                 DISCL_NONEXCLUSIVE | DISCL_BACKGROUND)!=DI_OK)
    return(0);

LogProg("          Setting keyboard data format", FALSE);
if (lpdikey->SetDataFormat(&c_dfDIKeyboard)!=DI_OK)          //Set data format

   return(0);

LogProg("          Acquiring the keyboard", FALSE);
if (lpdikey->Acquire()!=DI_OK)          					  //Acquire the keyboard

   return(0);

Draw_Text_GDI("Initialising keyboard...done",0, 24, RGB(0, 255, 0), lpddsprimary);

LogProg("          Waiting for enter key before continuing", FALSE);
do 																 //Loop until enter pressed

{
	lpdikey->GetDeviceState(256, (LPVOID)keyboard_state);
}
while (!keyboard_state[DIK_RETURN]);

LogProg("ENDING:   GameInit", FALSE);

return(1);
}
//---------------------------------------------------------------------------

int Game_Shutdown(void *parms = NULL, int num_parms = 0)
{
LogProg("STARTING: Game_Shutdown", FALSE);

//Surface is lost by this point. Why?

//BlitSurface(File2NewSurface("end.bmp"), lpddsprimary, 640, 480, 640, 480,0,0);

LogProg("          Releasing keyboard", FALSE);
lpdikey->Unacquire();											 //Release the keyboard

lpdikey->Release();
lpdi->Release();

LogProg("          Releasing users sprite animation frames", FALSE);
for (int i=1; i<8; i++)							  //Kill all frames of users sprite

	if (Unit.Surface[i])
   {
		Unit.Surface[i]->Release();
   	Unit.Surface[i]=NULL;
   }

LogProg("          Releasing opponent sprite animation frames", FALSE);
if (MySprite)													   //Kill opponent sprites

{
	MySprite->Release();
   MySprite=NULL;
}
if (MySprite2)
{
	MySprite2->Release();
   MySprite=NULL;
}

LogProg("          Releasing back buffer", FALSE);
if (lpddsback)          										 //Kill the back buffer

{
	lpddsback->Release();
   lpddsback=NULL;
}

LogProg("          Releasing primary surface", FALSE);
if (lpddsprimary)     										  //...The primary surface

{
   lpddsprimary->Release();
   lpddsprimary=NULL;
}

LogProg("          Releasing DDraw object", FALSE);
if (lpdd4)    														//Finally the DD object

{
	lpdd4->Release();
	lpdd4 = NULL;
}

LogProg("ENDING:   Game_Shutdown", FALSE);

return(1);
}
//---------------------------------------------------------------------------

int WINAPI WinMain(	HINSTANCE hinstance,
					HINSTANCE hprevinstance,
					LPSTR lpcmdline,
					int ncmdshow)
{

WNDCLASSEX winclass; 						 //This will hold the class we create

HWND	     hwnd;	 											  //Generic window handle

MSG		  msg;		 												  //Generic message

HDC        hdc;      									   //Graphics device context

			  				   	  		  	//First fill in the window class stucture

winclass.cbSize         = sizeof(WNDCLASSEX);
winclass.style			   = CS_DBLCLKS | CS_OWNDC |
                          CS_HREDRAW | CS_VREDRAW;
winclass.lpfnWndProc	   = WindowProc;
winclass.cbClsExtra		= 0;
winclass.cbWndExtra		= 0;
winclass.hInstance		= hinstance;
winclass.hIcon			   = LoadIcon(NULL, IDI_APPLICATION);
winclass.hCursor	    	= LoadCursor(NULL, IDC_ARROW);
winclass.hbrBackground	= (HBRUSH)GetStockObject(BLACK_BRUSH);
winclass.lpszMenuName	= NULL;
winclass.lpszClassName	= WINDOW_CLASS_NAME;
winclass.hIconSm        = LoadIcon(NULL, IDI_APPLICATION);

hModule = hinstance;          							//Save hinstance in global


if (!RegisterClassEx(&winclass)) 					  //Register the window class

	return(0);

// create the window

if (!(hwnd = CreateWindowEx(NULL,                  			 //Extended style

                            WINDOW_CLASS_NAME,     						 //Class

						          "DirectX Game Shell" , 						 //Title

						          WS_VISIBLE | WS_POPUP,
					 	          0,0,	  										 //Initial x,y
						          400,300,  						//Initial width, height
						          NULL,	  							  //Handle to parent

						          NULL,	  							    //Handle to menu

						          hinstance,			  //Instance of this application

						          NULL)))							 //Extra creation parms

	LogProg("ERROR:    WinMain, CreateWindow", TRUE);

hMainWindow = hwnd;											 //Save main window handle


Game_Init();														 //Initialize game here


while(TRUE)															//Enter main event loop

{
   						     //Test if there is a message in queue, if so get it
	if (PeekMessage(&msg,NULL,0,0,PM_REMOVE))
   {
      				    						   	        //Test if this is a quit

       if (msg.message == WM_QUIT)
           break;

	   TranslateMessage(&msg);                //Translate any accelerator keys


	   DispatchMessage(&msg);            //Send the message to the window proc

   }
    

   Game_Main();										//Main game processing goes here

       
}

Game_Shutdown();													   	//Close down game


ShowCursor(TRUE);										  //Give the user the cursor back

LogProg("*END*", FALSE);

return(msg.wParam);
}
//---------------------------------------------------------------------------

[/source]

The routines.cpp file: 

[source]
#define WIN32_LEAN_AND_MEAN  // just say no to MFC
//----------------------------------------------------------------------------

#define _RGB16BIT565(r,g,b) ((b%32) + ((g%64) << 5) + ((r%32) << 11))
#define DDRAW_INIT_STRUCT(ddstruct) { memset(&ddstruct,0,sizeof(ddstruct)); ddstruct.dwSize=sizeof(ddstruct); }
#define KEYDOWN(vk_code) ((GetAsyncKeyState(vk_code) & 0x8000) ? 1 : 0)
#define KEYUP(vk_code)   ((GetAsyncKeyState(vk_code) & 0x8000) ? 0 : 1)
//----------------------------------------------------------------------------

typedef struct BITMAP_FILE_TAG
{
	BITMAPFILEHEADER	bitmapfileheader;
   BITMAPINFOHEADER	bitmapinfoheader;
   PALETTEENTRY		palette[256];
   UCHAR					*buffer;
}  BITMAP_FILE, *BITMAP_FILE_PTR;
//---------------------------------------------------------------------------

#define MAX_COLORS_PALETTE   256
#define INITGUID
//---------------------------------------------------------------------------

const int BITMAP_ID = 0x4D42;
//---------------------------------------------------------------------------

typedef unsigned short USHORT;
typedef unsigned short WORD;
typedef unsigned char  UCHAR;
typedef unsigned char  BYTE;
//----------------------------------------------------------------------------

//When sent a DirectX error code outputs actual errors name to error log file

void ErrorCode2Log(HRESULT errcd);
//Copies a bitmap to a surface at given xy coordinates

void Bmp2Surface(BITMAP_FILE_PTR Bitmap, LPDIRECTDRAWSURFACE4 &lpddsSurface, int x, int y);
//Logs given text to a error log file. Exits program if desired

void LogProg(char *ErrorMessage, bool Exit);
//Loads a bitmap file into memory

int Load_Bitmap_File(BITMAP_FILE_PTR bitmap, char *filename);
//Unloads a nbitmap file from memory

int UnloadBitmapFile(BITMAP_FILE_PTR Bitmap);
//Attaches a clipper to desired surface

LPDIRECTDRAWCLIPPER AttachClipper(LPDIRECTDRAWSURFACE4 lpdds, int num_rects, LPRECT clip_list);
//Creates desired surface

LPDIRECTDRAWSURFACE4 CreateSurface(int width, int height, int mem_flags, int color_key=0);
//Creates a new surface for given bitmap and copies it there

LPDIRECTDRAWSURFACE4 File2NewSurface(BITMAP_FILE_PTR Bitmap);
//Copies one surface to the other using the hardware blitter. If dest>src image is stretched

void BlitSurface(LPDIRECTDRAWSURFACE4 &lpddsSource, LPDIRECTDRAWSURFACE4 &lpddsDest, int Swidth, int Sheight,int Dwidth, int Dheight, int x, int y);
//Draws desired text using GDI

void Draw_Text_GDI(char *text, int x,int y,COLORREF color, LPDIRECTDRAWSURFACE4 lpdds);
//Fills screen desired colour

void FillScreen(LPDIRECTDRAWSURFACE4 &lpddsSurf, COLORREF Colour);
//----------------------------------------------------------------------------

byte Get16bitFormat(LPDIRECTDRAWSURFACE4 lpDDSPrimary)
{
DDPIXELFORMAT 	ddpf;

memset(&ddpf,0,sizeof(DDPIXELFORMAT));
ddpf.dwSize=sizeof(DDPIXELFORMAT);

byte gfxmode=0;

if (lpDDSPrimary->GetPixelFormat(&ddpf)==DD_OK)
{
	if ((ddpf.dwGBitMask /32) == 31 )
   	gfxmode =1;
	if ((ddpf.dwGBitMask /32) == 63 )
   	gfxmode =2;
}
else
	gfxmode = 255;

return gfxmode;
}

//----------------------------------------------------------------------------

void FillScreen(LPDIRECTDRAWSURFACE4 &lpddsSurf, COLORREF Colour )
{
DDBLTFX ddbltfx; 												//The blitter fx structure


DDRAW_INIT_STRUCT(ddbltfx);     							//Initialise the structure

ddbltfx.dwFillColor = Colour;                        //Set the colour to blit


																	  //Blit colour to surface

if (FAILED(lpddsSurf->Blt(NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &ddbltfx)))
	LogProg("ERROR:    FillScreen, Blitting colour to surface", FALSE);

}
//----------------------------------------------------------------------------

void Draw_Text_GDI(char *text, int x,int y,COLORREF color, LPDIRECTDRAWSURFACE4 lpdds)
{

HDC xdc; 																	 //The working dc


if (FAILED(lpdds->GetDC(&xdc)))							 //Get the dc from surface

	LogProg("ERROR:    Draw_Text_GDI, Getting surface DC", TRUE);

SetTextColor(xdc,color);							//Set the colors for the text up


						 //Set background mode to transparent so black isn't copied

SetBkMode(xdc, TRANSPARENT);

TextOut(xdc,x,y,text,strlen(text));									  //Draw the text


lpdds->ReleaseDC(xdc);													  //Release the DC


}
//----------------------------------------------------------------------------

void ErrorCode2Log(HRESULT errcd)
{
char	ErrorString[255];

strcpy(ErrorString, "ERROR:    ErrorCode2Log ANALYSIS: ");

if (errcd == DDERR_GENERIC)
	strcat(ErrorString, "DDERR_GENERIC");
if (errcd == DDERR_INVALIDCLIPLIST)
   strcat(ErrorString, "DDERR_INVALIDCLIPLIST");
if (errcd == DDERR_INVALIDOBJECT)
  	strcat(ErrorString, "DDERR_INVALIDOBJECT");
if (errcd == DDERR_INVALIDPARAMS)
	strcat(ErrorString, "DDERR_INVALIDPARAMS");
if (errcd == DDERR_INVALIDRECT)
	strcat(ErrorString, "DDERR_INVALIDRECT");
if (errcd == DDERR_NOALPHAHW)
	strcat(ErrorString, "DDERR_NOALPHAHW");
if (errcd == DDERR_NOBLTHW)
	strcat(ErrorString, "DDERR_NOBLTHW");
if (errcd == DDERR_NOCLIPLIST)
	strcat(ErrorString, "DDERR_NOCLIPLIST");
if (errcd == DDERR_NODDROPSHW)
	strcat(ErrorString, "DDERR_NODDROPSHW");
if (errcd == DDERR_NOMIRRORHW)
	strcat(ErrorString, "DDERR_NOMIRRORHW");
if (errcd == DDERR_NORASTEROPHW)
	strcat(ErrorString, "DDERR_NORASTEROPHW");
if (errcd == DDERR_NOROTATIONHW)
	strcat(ErrorString, "DDERR_NOROTATIONHW");
if (errcd == DDERR_NOSTRETCHHW)
	strcat(ErrorString, "DDERR_NOSTRETCHHW");
if (errcd == DDERR_NOZBUFFERHW)
	strcat(ErrorString, "DDERR_NOZBUFFERHW");
if (errcd == DDERR_SURFACEBUSY)
	strcat(ErrorString, "DDERR_SURFACEBUSY");
if (errcd == DDERR_SURFACELOST)
	strcat(ErrorString, "DDERR_SURFACELOST");
if (errcd == DDERR_UNSUPPORTED)
	strcat(ErrorString, "DDERR_UNSUPPORTED");
if (errcd == DDERR_WASSTILLDRAWING)
	strcat(ErrorString, "DDERR_WASSTILLDRAWING");

   LogProg(ErrorString, FALSE);
}
//----------------------------------------------------------------------------

void BlitSurface(LPDIRECTDRAWSURFACE4 &lpddsSource, LPDIRECTDRAWSURFACE4 &lpddsDest, int Swidth, int Sheight,int Dwidth, int Dheight, int x, int y)
{
RECT	SourceRect, DestRect;

DestRect.left   = x;   										//Set the destination rect

DestRect.top    = y;
DestRect.right  = x+Dwidth-1;
DestRect.bottom = y+Dheight-1;

SourceRect.left   = 0;                               	  //Set the source rect

SourceRect.top    = 0;
SourceRect.right  = Swidth-1;
SourceRect.bottom = Sheight-1;

HRESULT errcd = lpddsDest->Blt(&DestRect, lpddsSource, &SourceRect, (DDBLT_WAIT | DDBLT_KEYSRC), NULL);
if (FAILED(errcd))
{
	char	ErrorString[255];
	wsprintf(ErrorString, "ERROR:    BlitSurface, Blitting image of %d*%d, to %d*%d, Error Code: %d", Swidth, Sheight, Dwidth, Dheight, errcd);

	LogProg(ErrorString, FALSE);
   ErrorCode2Log(errcd);

}
}
//----------------------------------------------------------------------------

LPDIRECTDRAWSURFACE4 File2NewSurface(char *FileName)
{
LPDIRECTDRAWSURFACE4	NewSurface;
BITMAP_FILE Bitmap;

Load_Bitmap_File(&Bitmap, FileName);    				 //Load the desired bitmap


                                                    //Create a surface for it

NewSurface=CreateSurface(int(Bitmap.bitmapinfoheader.biWidth), int(Bitmap.bitmapinfoheader.biHeight), DDSCAPS_SYSTEMMEMORY);     //DDSCAPS_VIDEOMEMORY


Bmp2Surface(&Bitmap, NewSurface, 0, 0);			      //Copy image to surface


UnloadBitmapFile(&Bitmap); 								  //Unload unneeded bitmap


return (NewSurface);									//Return new surface with bitmap

}
//----------------------------------------------------------------------------

LPDIRECTDRAWCLIPPER AttachClipper(LPDIRECTDRAWSURFACE4 lpdds, int num_rects, LPRECT clip_list)
{

int 						index;                          				 //Looping var

LPDIRECTDRAWCLIPPER 	lpddclipper;   //Pointer to the newly created dd clipper

LPRGNDATA 				region_data;  //Pointer to the region data that contains

                                                   //The header and clip list


													//First create the direct draw clipper

if (FAILED(lpdd4->CreateClipper(0,&lpddclipper,NULL)))
	LogProg("ERROR:    AttachClipper, Creating DDraw clipper", TRUE);

// now create the clip list from the sent data


// first allocate memory for region data

region_data = (LPRGNDATA)malloc(sizeof(RGNDATAHEADER)+num_rects*sizeof(RECT));

// now copy the rects into region data

memcpy(region_data->Buffer, clip_list, sizeof(RECT)*num_rects);

// set up fields of header

region_data->rdh.dwSize          = sizeof(RGNDATAHEADER);
region_data->rdh.iType           = RDH_RECTANGLES;
region_data->rdh.nCount          = num_rects;
region_data->rdh.nRgnSize        = num_rects*sizeof(RECT);

region_data->rdh.rcBound.left    =  64000;
region_data->rdh.rcBound.top     =  64000;
region_data->rdh.rcBound.right   = -64000;
region_data->rdh.rcBound.bottom  = -64000;

// find bounds of all clipping regions

for (index=0; index<num_rects; index++)
    {
    // test if the next rectangle unioned with the current bound is larger

    if (clip_list[index].left < region_data->rdh.rcBound.left)
       region_data->rdh.rcBound.left = clip_list[index].left;

    if (clip_list[index].right > region_data->rdh.rcBound.right)
       region_data->rdh.rcBound.right = clip_list[index].right;

    if (clip_list[index].top < region_data->rdh.rcBound.top)
       region_data->rdh.rcBound.top = clip_list[index].top;

    if (clip_list[index].bottom > region_data->rdh.rcBound.bottom)
       region_data->rdh.rcBound.bottom = clip_list[index].bottom;

    } // end for index


// now we have computed the bounding rectangle region and set up the data

// now let's set the clipping list


if (FAILED(lpddclipper->SetClipList(region_data, 0)))
   {
   // release memory and return error

   free(region_data);
   return(NULL);
   } // end if


// now attach the clipper to the surface

if (FAILED(lpdds->SetClipper(lpddclipper)))
   {
   // release memory and return error

   free(region_data);
   return(NULL);
   } // end if


// all is well, so release memory and send back the pointer to the new clipper
free(region_data);
return(lpddclipper);

} // end DDraw_Attach_Clipper

//----------------------------------------------------------------------------

int Flip_Bitmap(UCHAR *image, int bytes_per_line, int height)
{
// this function is used to flip bottom-up .BMP images


UCHAR *buffer; // used to perform the image processing

int index;     // looping index


// allocate the temporary buffer

if (!(buffer = (UCHAR *)malloc(bytes_per_line*height)))
   return(0);

// copy image to work area

memcpy(buffer,image,bytes_per_line*height);

// flip vertically

for (index=0; index < height; index++)
    memcpy(&image[((height-1) - index)*bytes_per_line],
           &buffer[index*bytes_per_line], bytes_per_line);

// release the memory

free(buffer);

// return success

return(1);

}
//----------------------------------------------------------------------------

void Bmp2Surface(BITMAP_FILE_PTR Bitmap, LPDIRECTDRAWSURFACE4 &lpddsSurface, int x, int y)
{

DDSURFACEDESC2 ddsd;		//Surface description


LogProg("STARTING: Bmp2Surface", FALSE);

DDRAW_INIT_STRUCT(ddsd);

lpddsSurface->Lock(NULL, &ddsd, DDLOCK_SURFACEMEMORYPTR | DDLOCK_WAIT, NULL);

USHORT *PrimaryBuffer=(USHORT *)ddsd.lpSurface;
// process each line and copy it into the primary buffer

for (int index_y = 0; index_y < Bitmap->bitmapinfoheader.biHeight; index_y++)
    {
    for (int index_x = 0; index_x < Bitmap->bitmapinfoheader.biWidth; index_x++)
        {
        // get BGR values, note the scaling down of the channels, so that they
        // fit into the 5.6.5 format

        UCHAR blue  = (Bitmap->buffer[index_y*Bitmap->bitmapinfoheader.biWidth*3 + index_x*3 + 0]) >> 3,
              green = (Bitmap->buffer[index_y*Bitmap->bitmapinfoheader.biWidth*3 + index_x*3 + 1]) >> 3,
              red   = (Bitmap->buffer[index_y*Bitmap->bitmapinfoheader.biWidth*3 + index_x*3 + 2]) >> 3;

        // this builds a 16 bit color value in 5.6.5 format (green dominant mode)
        USHORT pixel = _RGB16BIT565(red,green,blue);

        // write the pixel

        PrimaryBuffer[index_x+x + (index_y*ddsd.lPitch >> 1)+y*SCREEN_WIDTH] = pixel;

        } // end for index_x


    } // end for index_y



LogProg("          Unlocking primary surface", FALSE);
lpddsSurface->Unlock(NULL);
}
//----------------------------------------------------------------------------

void LogProg(char *ErrorMessage, bool Exit)
{

HFILE FileHandle;

	FileHandle=_lopen("ERRORS.LOG", OF_WRITE);
   _llseek(FileHandle, 0, FILE_END);
   _lwrite(FileHandle, ErrorMessage, lstrlen(ErrorMessage));
   _lwrite(FileHandle, "\r\n", 2);

   _lclose(FileHandle);

if (Exit)
   exit(0);
}
//----------------------------------------------------------------------------

int UnloadBitmapFile(BITMAP_FILE_PTR Bitmap)
{
	LogProg("STARTING: UnloadBitmapFile", FALSE);
	if (Bitmap->buffer)
   {
   	free(Bitmap->buffer);
      Bitmap->buffer = NULL;
   }
   LogProg("ENDING:   UnloadBitmapFile", FALSE);
   return(1);
}
//----------------------------------------------------------------------------

LPDIRECTDRAWSURFACE4 CreateSurface(int width, int height, int mem_flags, int color_key)
{
// this function creates an offscreen plain surface


DDSURFACEDESC2 ddsd;         // working description

LPDIRECTDRAWSURFACE4 lpdds;  // temporary surface

    
// set to access caps, width, and height
memset(&ddsd,0,sizeof(ddsd));
ddsd.dwSize  = sizeof(ddsd);
ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;

// set dimensions of the new bitmap surface

ddsd.dwWidth  =  width;
ddsd.dwHeight =  height;

// set surface to offscreen plain

ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | mem_flags;

// create the surface

if (FAILED(lpdd4->CreateSurface(&ddsd,&lpdds,NULL)))
   return(NULL);

// test if user wants a color key

if (color_key >= 0)
   {
   // set color key to color 0

   DDCOLORKEY color_key; // used to set color key

   color_key.dwColorSpaceLowValue  = 0;
   color_key.dwColorSpaceHighValue = 0;

   // now set the color key for source blitting

   lpdds->SetColorKey(DDCKEY_SRCBLT, &color_key);
   } // end if


// return surface

return(lpdds);
} // end DDraw_Create_Surface

//----------------------------------------------------------------------------

int Load_Bitmap_File(BITMAP_FILE_PTR bitmap, char *filename)
{
// this function opens a bitmap file and loads the data into bitmap


int file_handle,  // the file handle

    index;        // looping index


UCHAR   *temp_buffer = NULL; // used to convert 24 bit images to 16 bit

OFSTRUCT file_data;          // the file data information


// open the file if it exists

if ((file_handle = OpenFile(filename,&file_data,OF_READ))==-1)
   return(0);

// now load the bitmap file header

_lread(file_handle, &bitmap->bitmapfileheader,sizeof(BITMAPFILEHEADER));

// test if this is a bitmap file

if (bitmap->bitmapfileheader.bfType!=BITMAP_ID)
   {
   // close the file

   _lclose(file_handle);

   // return error

   return(0);
   } // end if


// now we know this is a bitmap, so read in all the sections

// first the bitmap infoheader


// now load the bitmap file header

_lread(file_handle, &bitmap->bitmapinfoheader,sizeof(BITMAPINFOHEADER));

// now load the color palette if there is one

if (bitmap->bitmapinfoheader.biBitCount == 8)
   {
   _lread(file_handle, &bitmap->palette,MAX_COLORS_PALETTE*sizeof(PALETTEENTRY));

   // now set all the flags in the palette correctly and fix the reversed 

   // BGR RGBQUAD data format

   for (index=0; index < MAX_COLORS_PALETTE; index++)
       {
       // reverse the red and green fields

       int temp_color                = bitmap->palette[index].peRed;
       bitmap->palette[index].peRed  = bitmap->palette[index].peBlue;
       bitmap->palette[index].peBlue = temp_color;
       
       // always set the flags word to this

       bitmap->palette[index].peFlags = PC_NOCOLLAPSE;
       } // end for index


    } // end if


// finally the image data itself

_llseek(file_handle,-(int)(bitmap->bitmapinfoheader.biSizeImage),SEEK_END);

// now read in the image, if the image is 8 or 16 bit then simply read it
// but if its 24 bit then read it into a temporary area and then convert

// it to a 16 bit image


if (bitmap->bitmapinfoheader.biBitCount==8 || bitmap->bitmapinfoheader.biBitCount==16 || 
    bitmap->bitmapinfoheader.biBitCount==24)
   {
   // delete the last image if there was one

  // if (bitmap->buffer)
     //  free(bitmap->buffer);

   // allocate the memory for the image

   if (!(bitmap->buffer = (UCHAR *)malloc(bitmap->bitmapinfoheader.biSizeImage)))
      {
      // close the file

      _lclose(file_handle);

      // return error

      return(0);
      } // end if


   // now read it in

   _lread(file_handle,bitmap->buffer,bitmap->bitmapinfoheader.biSizeImage);

   } // end if

else
   {
   // serious problem

   return(0);

   } // end else

// close the file

_lclose(file_handle);

// flip the bitmap

Flip_Bitmap(bitmap->buffer, 
            bitmap->bitmapinfoheader.biWidth*(bitmap->bitmapinfoheader.biBitCount/8), 
            bitmap->bitmapinfoheader.biHeight);

// return success

return(1);

} // end Load_Bitmap_File

//----------------------------------------------------------------------------


    
The errors.log file
STARTING: GameInit
          Setting coop level
          Setting display mode
          Creating surface
          Attaching clipper to primary buffer
          Attaching clipper to back buffer
          Loading and drawing logo to primary surface
STARTING: Bmp2Surface
          Unlocking primary surface
STARTING: UnloadBitmapFile
ENDING:   UnloadBitmapFile
          Loading oponent sprites
STARTING: Bmp2Surface
          Unlocking primary surface
STARTING: UnloadBitmapFile
ENDING:   UnloadBitmapFile
STARTING: Bmp2Surface
          Unlocking primary surface
STARTING: UnloadBitmapFile
ENDING:   UnloadBitmapFile
          Loading users animation frames
STARTING: Bmp2Surface
          Unlocking primary surface
STARTING: UnloadBitmapFile
ENDING:   UnloadBitmapFile
STARTING: Bmp2Surface
          Unlocking primary surface
STARTING: UnloadBitmapFile
ENDING:   UnloadBitmapFile
STARTING: Bmp2Surface
          Unlocking primary surface
STARTING: UnloadBitmapFile
ENDING:   UnloadBitmapFile
STARTING: Bmp2Surface
          Unlocking primary surface
STARTING: UnloadBitmapFile
ENDING:   UnloadBitmapFile
STARTING: Bmp2Surface
          Unlocking primary surface
STARTING: UnloadBitmapFile
ENDING:   UnloadBitmapFile
STARTING: Bmp2Surface
          Unlocking primary surface
STARTING: UnloadBitmapFile
ENDING:   UnloadBitmapFile
STARTING: Bmp2Surface
          Unlocking primary surface
STARTING: UnloadBitmapFile
ENDING:   UnloadBitmapFile
STARTING: Bmp2Surface
          Unlocking primary surface
STARTING: UnloadBitmapFile
ENDING:   UnloadBitmapFile
          Initialising sprites start positions
          Creating DINPUT object
          Creating a keyboard device
          Setting keyboard co-op level
          Setting keyboard data format
          Acquiring the keyboard
          Waiting for enter key before continuing
ENDING:   GameInit
ERROR:    BlitSurface, Blitting image of 140*100, to 50*30, Error Code: -2147024809
ERROR:    ErrorCode2Log ANALYSIS: DDERR_INVALIDPARAMS
ERROR:    BlitSurface, Blitting image of 140*100, to 50*30, Error Code: -2147024809
ERROR:    ErrorCode2Log ANALYSIS: DDERR_INVALIDPARAMS
STARTING: Game_Shutdown
          Releasing keyboard
          Releasing users sprite animation frames
          Releasing opponent sprite animation frames
          Releasing back buffer
          Releasing primary surface
          Releasing DDraw object
ENDING:   Game_Shutdown
*END*

 
Thanks.. Dave Edited by - n0p3x on 7/23/00 7:52:10 AM

Share this post


Link to post
Share on other sites