一个到处跑的头程序

#define WIN32_LEAN_AND_MEAN  // just say no to MFC

#define INITGUID

#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 <ddraw.h> // include directdraw

// DEFINES ////////////////////////////////////////////////

// defines for windows
#define WINDOW_CLASS_NAME "WINCLASS1"

// default screen size
#define SCREEN_WIDTH    320  // size of screen
#define SCREEN_HEIGHT   240
#define SCREEN_BPP      8    // bits per pixel

// TYPES //////////////////////////////////////////////////////

// basic unsigned types
typedef unsigned short USHORT;
typedef unsigned short WORD;
typedef unsigned char  UCHAR;
typedef unsigned char  BYTE;

// MACROS /////////////////////////////////////////////////

#define KEYDOWN(vk_code) ((GetAsyncKeyState(vk_code) & 0x8000) ? 1 : 0)
#define KEYUP(vk_code)   ((GetAsyncKeyState(vk_code) & 0x8000) ? 0 : 1)

// this builds a 16 bit color value in 5.5.5 format (1-bit alpha mode)
#define _RGB16BIT555(r,g,b) ((b & 31) + ((g & 31) << 5) + ((r & 31) << 10))

// this builds a 16 bit color value in 5.6.5 format (green dominate mode)
#define _RGB16BIT565(r,g,b) ((b & 31) + ((g & 63) << 5) + ((r & 31) << 11))

// initializes a direct draw struct
#define DDRAW_INIT_STRUCT(ddstruct) { memset(&ddstruct,0,sizeof(ddstruct)); ddstruct.dwSize=sizeof(ddstruct); }

// GLOBALS ////////////////////////////////////////////////
HWND      main_window_handle = NULL; // globally track main window
HINSTANCE hinstance_app      = NULL; // globally track hinstance

// directdraw stuff

LPDIRECTDRAW7         lpdd         = NULL;   // dd object
LPDIRECTDRAWSURFACE7  lpddsprimary = NULL;   // dd primary surface
LPDIRECTDRAWSURFACE7  lpddsback    = NULL;   // dd back surface
LPDIRECTDRAWPALETTE   lpddpal      = NULL;   // a pointer to the created dd palette
LPDIRECTDRAWCLIPPER   lpddclipper  = NULL;   // dd clipper
PALETTEENTRY          palette[256];          // color palette
PALETTEENTRY          save_palette[256];     // used to save palettes
DDSURFACEDESC2        ddsd;                  // a direct draw surface description struct
DDBLTFX               ddbltfx;               // used to fill
DDSCAPS2              ddscaps;               // a direct draw surface capabilities struct
HRESULT               ddrval;                // result back from dd calls
DWORD                 start_clock_count = 0; // used for timing

UCHAR bitmap[64] = {1,0,0,1,1,0,0,1,
                    1,0,0,1,1,0,0,1,
                    1,1,1,0,0,1,1,1,
                    1,1,1,1,1,1,1,1,
                    1,1,0,0,0,0,1,1,
                    1,0,1,1,1,1,0,1,
                    1,1,0,0,0,0,1,1,
                    1,1,1,1,1,1,1,1};

UCHAR bitmap2[64] = {1,1,1,1,1,1,1,1,
                     1,0,0,1,1,0,0,1,
                     1,0,0,1,1,0,0,1,
                     1,1,1,1,1,1,1,1,
                     1,1,1,0,0,1,1,1,
                     1,0,1,1,1,1,0,1,
                     1,1,0,0,0,0,1,1,
                     1,1,1,1,1,1,1,1};

int laugh = 1;
int loop = 0;
int v_x = 1;
int v_y = 1;
int x_p = rand()%SCREEN_WIDTH;
int y_p = rand()%SCREEN_HEIGHT;
int win_close = 0;

int x_d;
int y_d;
int Order = 0;

char buffer[80];                     // general printing buffer
UCHAR *back_buffer = NULL;

// FUNCTIONS //////////////////////////////////////////////

void Move()
{
    x_p += v_x;
 y_p += v_y;

 if(x_p > SCREEN_WIDTH-10)
  v_x = -v_x;
 else if(x_p < 10)
  v_x = -v_x;

 if(y_p > SCREEN_HEIGHT-10)
  v_y = -v_y;
 else if(y_p < 10)
  v_y = -v_y;
}

void MoveTO()
{
 x_p += v_x;
    y_p += v_y;
 
}

LRESULT CALLBACK WindowProc(HWND hwnd,
          UINT msg,
                            WPARAM wparam,
                            LPARAM lparam)
{
// this is the main message handler of the system
PAINTSTRUCT  ps;  // used in WM_PAINT
HDC    hdc; // handle to a device context
char buffer[80];        // used to print strings

// what is the message
switch(msg)
 { 
 case WM_CREATE:
        {
  // do initialization stuff here
        // return success
  return(0);
  } break;

 case WM_RBUTTONDOWN:
  {
            x_d = 100;
   y_d = 100;
   Order = 1;
  }break;
  
 case WM_PAINT:
  {
  // simply validate the window
        hdc = BeginPaint(hwnd,&ps); 

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

        // return success
  return(0);
     } break;

 case WM_DESTROY:
  {

  // kill the application, this sends a WM_QUIT message
  PostQuitMessage(0);

        // return success
  return(0);
  } break;

 default:break;

    } // end switch

// process any messages that we didn't take care of
return (DefWindowProc(hwnd, msg, wparam, lparam));

} // end WinProc

///////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////

int Game_Main(void *parms = NULL, int num_parms = 0)
{
// this is the main loop of the game, do all your processing
// here

if(win_close)
    return(0);

// for now test if user is hitting ESC and send WM_CLOSE
if (KEYDOWN(VK_ESCAPE))
{
    SendMessage(main_window_handle,WM_CLOSE,0,0);
 win_close = 1;
}
  
// plot 1000 random pixels to the primary surface and return
// clear ddsd and set size, never assume it's clean
DDRAW_INIT_STRUCT(ddsd);

// plot 1000 random pixels with random colors on the
// primary surface, they will be instantly visible

 

// lock the primary surface
if (FAILED(lpddsback->Lock(NULL, &ddsd,
                   DDLOCK_SURFACEMEMORYPTR | DDLOCK_WAIT,
                   NULL)))
   return(0);

// now ddsd.lPitch is valid and so is ddsd.lpSurface

// make a couple aliases to make code cleaner, so we don't
// have to cast
int lpitch = (int)ddsd.lPitch;
UCHAR *back_buffer = (UCHAR *)ddsd.lpSurface;

if(laugh == 1)
{
    if(lpitch==SCREEN_WIDTH)
 {
     memset((void *)back_buffer,0,SCREEN_WIDTH*SCREEN_HEIGHT);
 
 }
    else
 {
     UCHAR *des = back_buffer;
     for(int i = 0;i < SCREEN_HEIGHT;i ++)
  {
      memset((void *)des,0,SCREEN_WIDTH);

      des += lpitch;
  }
 }
    if(lpitch==SCREEN_WIDTH)
 {
     for(int i=0;i<8;i++)
  {
            for(int j=0;j<8;j++)
   {
          if(bitmap[j + i*8] == 1)
           back_buffer[x_p + y_p*SCREEN_WIDTH + j + i*SCREEN_WIDTH] = 1;
   }
  }
 }

    else
 {
     UCHAR *des = back_buffer;
        for(int i=0;i<8;i++)
  {
  
            for(int j=0;j<8;j++)
   {
          if(bitmap[j + i*8] == 1)
           des[x_p + y_p*lpitch + j] = 1;
   }
      des += lpitch;
  }
 }

 Move();
}

else if(laugh == 0)
{
    if(lpitch==SCREEN_WIDTH)
 {
     memset((void *)back_buffer,0,SCREEN_WIDTH*SCREEN_HEIGHT);
 
 }
    else
 {
     UCHAR *des = back_buffer;
     for(int i = 0;i < SCREEN_HEIGHT;i ++)
  {
      memset((void *)des,0,SCREEN_WIDTH);

      des += lpitch;
  }
 }
    if(lpitch==SCREEN_WIDTH)
 {
     for(int i=0;i<8;i++)
  {
            for(int j=0;j<8;j++)
   {
          if(bitmap2[j + i*8] == 1)
           back_buffer[x_p + y_p*SCREEN_WIDTH + j + i*SCREEN_WIDTH] = 1;
   }
  }
 }

    else
 {
     UCHAR *des = back_buffer;
        for(int i=0;i<8;i++)
  {
  
            for(int j=0;j<8;j++)
   {
          if(bitmap2[j + i*8] == 1)
           des[x_p + y_p*lpitch + j] = 1;
   }
      des += lpitch;
  }
 }

    Move();
    
 //else
        //Move();

}

// now unlock the primary surface
if (FAILED(lpddsback->Unlock(NULL)))
   return(0);

while(FAILED(lpddsprimary->Flip(NULL,DDFLIP_WAIT)));

Sleep(33);

loop++;

if(loop==10)
{
 loop = 0;
 if(laugh)
     laugh = 0;
 else
        laugh = 1;

}

   

// return success or failure or your own return code here
return(1);

} // end Game_Main

////////////////////////////////////////////////////////////

int Game_Init(void *parms = NULL, int num_parms = 0)
{
// this is called once after the initial window is created and
// before the main event loop is entered, do all your initialization
// here

// create IDirectDraw interface 7.0 object and test for error
if (FAILED(DirectDrawCreateEx(NULL, (void **)&lpdd, IID_IDirectDraw7, NULL)))
   return(0);

// set cooperation to full screen
if (FAILED(lpdd->SetCooperativeLevel(main_window_handle,
                                      DDSCL_FULLSCREEN | DDSCL_ALLOWMODEX |
                                      DDSCL_EXCLUSIVE | DDSCL_ALLOWREBOOT)))
   return(0);

// set display mode to 640x480x16
if (FAILED(lpdd->SetDisplayMode(SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_BPP,0,0)))
   return(0);

// clear ddsd and set size
memset(&ddsd,0,sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);

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

ddsd.dwBackBufferCount = 1;

// request primary surface
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE|DDSCAPS_COMPLEX|DDSCAPS_FLIP;

// create the primary surface
if (FAILED(lpdd->CreateSurface(&ddsd, &lpddsprimary, NULL)))
   return(0);

ddsd.ddsCaps.dwCaps = DDSCAPS_BACKBUFFER;

if(FAILED(lpddsprimary->GetAttachedSurface(&ddsd.ddsCaps,&lpddsback)))
    return(0);

palette[0].peRed = 0;
palette[0].peGreen = 0;
palette[0].peBlue = 0;
palette[0].peFlags = PC_NOCOLLAPSE;

palette[255].peRed = 255;
palette[255].peGreen = 255;
palette[255].peBlue = 255;
palette[255].peFlags = PC_NOCOLLAPSE;

palette[1].peRed = 255;
palette[1].peGreen = 255;
palette[1].peBlue = 0;
palette[1].peFlags = PC_NOCOLLAPSE;

if(FAILED(lpdd->CreatePalette(DDPCAPS_8BIT|DDPCAPS_ALLOW256|DDPCAPS_INITIALIZE,palette,&lpddpal,NULL)))
    return(0);

if(FAILED(lpddsprimary->SetPalette(lpddpal)))
    return(0);

//if ((back_buffer=new UCHAR[SCREEN_WIDTH * SCREEN_HEIGHT])==NULL)
 //  return(0);

// return success or failure or your own return code here
return(1);

} // end Game_Init

/////////////////////////////////////////////////////////////

int Game_Shutdown(void *parms = NULL, int num_parms = 0)
{
// this is called after the game is exited and the main event
// loop while is exited, do all you cleanup and shutdown here

// now the primary surface
if (lpddpal)
   {
   lpddpal->Release();
   lpddpal = NULL;
   } // end if

// now the primary surface
if (lpddsprimary)
   {
   lpddsprimary->Release();
   lpddsprimary = NULL;
   } // end if

// now blow away the IDirectDraw4 interface
if (lpdd)
   {
   lpdd->Release();
   lpdd = NULL;
   } // end if

// release the memory used for double buffer
//if (back_buffer)
//   {
//   delete back_buffer;
//   back_buffer = NULL;
//   } // end if
// return success or failure or your own return code here
return(1);

} // end Game_Shutdown

// WINMAIN ////////////////////////////////////////////////

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);

// save hinstance in global
hinstance_app = hinstance;

// register the window class
if (!RegisterClassEx(&winclass))
 return(0);

// create the window
if (!(hwnd = CreateWindowEx(NULL,                  // extended style
                            WINDOW_CLASS_NAME,     // class
          "DirectDraw 16-Bit Full-Screen Demo", // title
          WS_POPUP | WS_VISIBLE,
           0,0,   // initial x,y
          SCREEN_WIDTH,SCREEN_HEIGHT,  // initial width, height
          NULL,   // handle to parent
          NULL,   // handle to menu
          hinstance,// instance of this application
          NULL))) // extra creation parms
return(0);

// save main window handle
main_window_handle = hwnd;

// initialize game here
Game_Init();

// enter main event loop
while(TRUE)
 {
    // 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;
 
    // translate any accelerator keys
    TranslateMessage(&msg);

    // send the message to the window proc
    DispatchMessage(&msg);
    } // end if
   
       // main game processing goes here
       Game_Main();
      
 } // end while

// closedown game here
Game_Shutdown();

// return to Windows like this
return(msg.wParam);

} // end WinMain

///////////////////////////////////////////////////////////