1.系统内核的实现——Core_System

 

 

Core_System.h

#ifndef _SYSTEM_H_
#define _SYSTEM_H_

class cApplication //系统类
{
  private:
    HINSTANCE     m_hInst;  //实例句柄
    HWND          m_hWnd;	//窗口句柄

  protected:
    char          m_Class[MAX_PATH]; //类名
    char          m_Caption[MAX_PATH]; //窗口标题

    WNDCLASSEX    m_wcex;  //Windows类结构体

    DWORD         m_Style;   //窗口样式
    DWORD         m_XPos;  //窗口的X坐标
    DWORD         m_YPos;  //窗口的Y坐标
    DWORD         m_Width; //窗口的默认宽度
    DWORD         m_Height; //窗口的默认高度

  public:
    cApplication();  //构造函数

    HWND      GethWnd();  //返回窗口句柄
    HINSTANCE GethInst(); //返回实例句柄

    BOOL Run();  //运行函数的代码
    BOOL Error(BOOL Fatal, char *Text, ...);  //显示出错的地方

    BOOL Move(long XPos, long YPos);  //窗口的移动
    BOOL Resize(long Width, long Height); //调整客户区的大小

    BOOL ShowMouse(BOOL Show = TRUE);  //显示或隐藏光标

	//缺省消息处理函数
    virtual FAR PASCAL MsgProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { return DefWindowProc(hWnd, uMsg, wParam, lParam); }
	//保存游戏代码的自定义函数
    virtual BOOL Init()       { return TRUE; }  //初始化函数
    virtual BOOL Shutdown()   { return TRUE; } //关闭函数
    virtual BOOL Frame()      { return TRUE; } //帧数函数
};

static cApplication *g_pApplication = NULL;
static long FAR PASCAL AppWindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);

enum Purposes {
    NOPURPOSE = 0,
    INITPURPOSE,
    SHUTDOWNPURPOSE,
    FRAMEPURPOSE
  };
    


//处理状态的类
class cStateManager  
{
	//状态函数指针（链表）
  typedef struct sState {
    void (*Function)(void *Ptr, long Purpose);
    sState *Next;

	//结构体的构造函数，用于清空指针
    sState()
    {
      Function = NULL;
      Next = NULL;
    }

	//结构体析构函数，用于删除链表
    ~sState()
    {
      delete Next;
    }
  } sState;

  protected:
    sState *m_StateParent;  //状态栈链表的父代

  public:
    cStateManager();  //构造函数
    ~cStateManager(); //析构函数

	//随同一个用户自定义的指针将状态压入栈中，Push函数将使用INTPURPOSE调用状态函数
    void Push(void (*Function)(void *Ptr, long Purpose), void *DataPtr = NULL); 

	//将最上面的状态从栈中弹出
	//使用SHUTDOWNPURPOSE调用Pop函数
    BOOL Pop(void *DataPtr = NULL); //

	//将所有状态从栈中弹出，调用目的都是SHUTDOWN
    void PopAll(void *DataPtr = NULL);

	//使用FRAMEPURPOSE目的处理最上面的状态
    BOOL Process(void *DataPtr = NULL);
};



//处理进程的类
class cProcessManager  
{
  typedef struct sProcess {
    void  (*Function)(void *Ptr, long Purpose);
    sProcess *Next;

    sProcess()
    {
      Function = NULL;
      Next = NULL;
    }

    ~sProcess()
    {
      delete Next; Next = NULL;
    }
  } sProcess;

  protected:
    sProcess *m_ProcessParent; 

  public:
    cProcessManager();
    ~cProcessManager();

    void Push(void (*Process)(void *Ptr, long Purpose), void *DataPtr = NULL);
    BOOL Pop(void *DataPtr = NULL);
    void PopAll(void *DataPtr = NULL);
    void Process(void *Ptr = NULL);
};


//数据管理类
class cDataPackage
{
  protected:
    void          *m_Buf;  //数据缓冲区
    unsigned long  m_Size;  //数据缓冲区的大小

  public:
    cDataPackage();    //构造函数
    ~cDataPackage(); //析构函数

    void *Create(unsigned long Size);  //创建缓冲区
    void Free();  //释放缓冲区

    BOOL Save(char *Filename);  //将缓冲区保存到文件中
    void *Load(char *Filename, unsigned long *Size);  //从文件加载

    void          *GetPtr();  //得到一个指向数据缓冲区的指针
    unsigned long  GetSize(); //得到数据的大小
}; 

#endif

 

 

Core_System.cpp

#include "Core_Global.h"



//构造函数的实现
cApplication::cApplication() 
{
  //保存实例句柄
  g_pApplication = this;

  //获取实例句柄
  m_hInst = GetModuleHandle(NULL);

  //设置默认窗口类和标题 
  strcpy(m_Class, "AppClass");
  strcpy(m_Caption, "Application Caption");

  // 设置默认窗口样式，位置和宽度高度
  m_Style  = WS_OVERLAPPEDWINDOW;
  m_XPos   = 0;
  m_YPos   = 0;
  m_Width  = 256;
  m_Height = 256;

  // 设置默认WNDCLASSEX结构体
  m_wcex.cbSize        = sizeof(WNDCLASSEX);
  m_wcex.style         = CS_CLASSDC;
  m_wcex.lpfnWndProc   = AppWindowProc;
  m_wcex.cbClsExtra    = 0;
  m_wcex.cbWndExtra    = 0;
  m_wcex.hInstance     = m_hInst;
  m_wcex.hIcon         = LoadIcon(NULL, IDI_APPLICATION);
  m_wcex.hCursor       = LoadCursor(NULL, IDC_ARROW);
  m_wcex.hbrBackground = NULL;
  m_wcex.lpszMenuName  = NULL;
  m_wcex.lpszClassName = m_Class;
  m_wcex.hIconSm       = LoadIcon(NULL, IDI_APPLICATION);
}

HWND cApplication::GethWnd()//返回窗口句柄GethWnd函数的实现
{
  return m_hWnd;
}

HINSTANCE cApplication::GethInst() //返回实例句柄GethInst函数的实现
{
  return m_hInst;
}


//运行run函数的实现代码
BOOL cApplication::Run() 
{
  MSG Msg;

  // 注册窗口类
  if(!RegisterClassEx(&m_wcex))
    return FALSE;

  //创建主窗口
  m_hWnd = CreateWindow(m_Class, m_Caption,
        m_Style, 
        m_XPos, m_YPos,
        m_Width, m_Height,
        NULL, NULL, m_hInst, NULL);
  if(!m_hWnd)
    return FALSE;

  // 显示和更新窗口
  ShowWindow(m_hWnd, SW_NORMAL);
  UpdateWindow(m_hWnd);

  //确定客户区的尺寸的正确 
  Resize(m_Width, m_Height);

  // 初始化COM
  CoInitialize(NULL);

  if(Init() == TRUE) {
     // 进入消息循环
    ZeroMemory(&Msg, sizeof(MSG));
    while(Msg.message != WM_QUIT) {

      // 处理Wndows消息
      if(PeekMessage(&Msg, NULL, 0, 0, PM_REMOVE)) {
        TranslateMessage(&Msg);
        DispatchMessage(&Msg);
      } else {
        // 每帧都进行处理，如果有FALSE就break
        if(Frame() == FALSE)
          break;
      }
    }
  }

  Shutdown();

  // 关闭COM
  CoUninitialize();

  // 注销窗口类
  UnregisterClass(m_Class, m_hInst);

  return TRUE;
}



//打印出错信息Error的函数实现
BOOL cApplication::Error(BOOL Fatal, char *Text, ...) 
{
  char CaptionText[12];  //标题内容的字符串
  char ErrorText[2048];  //错误信息的字符串
  va_list valist;  //VA_LIST 是在C语言中解决变参问题的一组宏

  // 根据致命错误Fatal的标识，是否是致命错误，在CaptionText中加入不同的字符串。
  if(Fatal == FALSE)
    strcpy(CaptionText, "Error");
  else 
    strcpy(CaptionText, "Fatal Error");

  // 创建变量文字缓冲区，也就是把形参中的内容装进ErrorText中。
  va_start(valist, Text);
  vsprintf(ErrorText, Text, valist);
  va_end(valist);

  // 显示消息窗口
  MessageBox(NULL, ErrorText, CaptionText, MB_OK | MB_ICONEXCLAMATION);

  // 如果是致命的错误，向消息队列发放一个退出消息
  if(Fatal == TRUE)
    PostQuitMessage(0);

  return TRUE;
}


//窗口的移动，move函数的实现
BOOL cApplication::Move(long XPos, long YPos)
{
  RECT ClientRect;

  GetClientRect(m_hWnd, &ClientRect);
  MoveWindow(m_hWnd, XPos, YPos, ClientRect.right, ClientRect.bottom, TRUE);

  return TRUE;
}

//调整客户区的大小，Resize函数的实现
BOOL cApplication::Resize(long Width, long Height)
{
  RECT WndRect, ClientRect;
  long WndWidth, WndHeight;

  GetWindowRect(m_hWnd, &WndRect);
  GetClientRect(m_hWnd, &ClientRect);

  WndWidth  = (WndRect.right  - (ClientRect.right  - Width))  - WndRect.left;
  WndHeight = (WndRect.bottom - (ClientRect.bottom - Height)) - WndRect.top;

  MoveWindow(m_hWnd, WndRect.left, WndRect.top, WndWidth, WndHeight, TRUE);

  return TRUE;
}


//显示或隐藏光标，ShowMouse函数的实现
BOOL cApplication::ShowMouse(BOOL Show)
{
  ShowCursor(Show);
  return TRUE;
}

//消息处理函数，唯独响应的是WM_DESTROY消息
long FAR PASCAL AppWindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
  switch(uMsg) {
    case WM_DESTROY:
      PostQuitMessage(0);
      return 0;

    default: return g_pApplication->MsgProc(hWnd, uMsg, wParam, lParam);
  }
}

//cStateManager类的构造函数的实现
cStateManager::cStateManager() 
{ 
  m_StateParent = NULL; 
}

//cStateManager类的析构函数的实现
cStateManager::~cStateManager() 
{
  PopAll();
}

//cStateManager类Push函数的实现，推送一个函数到栈中
void cStateManager::Push(void (*Function)(void *Ptr, long Purpose), void *DataPtr)
{
  sState *StatePtr;

  // 如果值是NULL，就不推送了
  if(Function != NULL) {
    //分配一个新的状态并push到栈中
    StatePtr = new sState();

    StatePtr->Function = Function;
    StatePtr->Next = m_StateParent;

    m_StateParent = StatePtr;

    //用 INITPURPOSE调用状态 ， init purpose
    StatePtr->Function(DataPtr, INITPURPOSE);
  }
}

//cStateManager类Pop函数的实现，将最上面的状态从栈中弹出
BOOL cStateManager::Pop(void *DataPtr)
{
  sState *StatePtr;

  // 如果if成立，移除栈顶内容
  if((StatePtr = m_StateParent) != NULL) {
    // 用shutdown purpose进行第一次调用
    m_StateParent->Function(DataPtr, SHUTDOWNPURPOSE);

    m_StateParent = StatePtr->Next;
    StatePtr->Next = NULL;
    delete StatePtr;
  }

  // 如果存在多个状态返回TRUE，如果m_StateParent为NULL的话，返回FALSE
  if(m_StateParent == NULL)
    return FALSE;
  return TRUE;
}

//cStateManager类PopAll函数的实现，将所有状态从栈中弹出，调用目的都是SHUTDOWN
void cStateManager::PopAll(void *DataPtr)
{
  while(Pop(DataPtr) == TRUE);
}

//cStateManager类Process函数的实现，//使用FRAMEPURPOSE目的处理最上面的状态
BOOL cStateManager::Process(void *DataPtr)
{ 
  // 如果没有状态的话返回FALSE。
  if(m_StateParent == NULL)
    return FALSE;

  // 处理栈最上面的状态
  m_StateParent->Function(DataPtr, FRAMEPURPOSE); 

  return TRUE;
}


//cProcessManager类构造函数
cProcessManager::cProcessManager() 
{ 
  m_ProcessParent = NULL; 
}

//cProcessManager类析构函数
cProcessManager::~cProcessManager() 
{
  //弹出每一个Process
  while(Pop()==TRUE);
}


//cProcessManager类Push函数的实现，推送一个function到栈中
void cProcessManager::Push(void (*Process)(void *Ptr, long Purpose), void *DataPtr)
{
   // 如果值是NULL，就不推送了
  if(Process != NULL) {
   //分配一个新的状态并push到栈中
    sProcess *ProcessPtr = new sProcess();
    ProcessPtr->Function = Process;
    ProcessPtr->Next = m_ProcessParent;
    m_ProcessParent = ProcessPtr;

    //用 INITPURPOSE调用过程 ， init purpose
    ProcessPtr->Function(DataPtr, INITPURPOSE);
  }
}

//cProcessManager类Pop函数的实现，将最上面的状态从栈中弹出
BOOL cProcessManager::Pop(void *DataPtr)
{
  sProcess *ProcessPtr;

   // 如果if成立，移除栈顶内容
  if((ProcessPtr = m_ProcessParent) != NULL) {
   // 用shutdown purpose进行第一次调用
    m_ProcessParent->Function(DataPtr, SHUTDOWNPURPOSE);

    m_ProcessParent = ProcessPtr->Next;
    ProcessPtr->Next = NULL;
    delete ProcessPtr;
  }

 // 如果存在多个状态返回TRUE，如果m_StateParent为NULL的话，返回FALSE
  if(m_ProcessParent == NULL)
    return FALSE;
  return TRUE;
}

//cProcessManager类PopAll函数的实现，将所有状态从栈中弹出
void cProcessManager::PopAll(void *DataPtr)
{
  while(Pop(DataPtr) == TRUE);
}

//cProcessManager类Process函数的实现，处理所有函数
void cProcessManager::Process(void *DataPtr)
{ 
  sProcess *ProcessPtr = m_ProcessParent;

  while(ProcessPtr != NULL) {
    ProcessPtr->Function(DataPtr, FRAMEPURPOSE);
    ProcessPtr = ProcessPtr->Next;
  }
}


//数据管理类cDataPackage的构造函数的实现
cDataPackage::cDataPackage()  
{  
  m_Buf = NULL; 
  m_Size = 0; 
}


//数据管理类cDataPackage的析构函数的实现
cDataPackage::~cDataPackage() 
{ 
  Free(); 
}


//数据管理类cDataPackage的Create函数的实现，创建缓冲区
void *cDataPackage::Create(unsigned long Size)
{
  // 释放之前创建的缓冲区，这个函数的实现在下面
  Free();

  //分配一些内存并返回一个指针 
  return (m_Buf = (void*)new char[(m_Size = Size)]);
}


//数据管理类cDataPackage的Free函数的实现， 释放缓冲区
void cDataPackage::Free() 
{ 
  delete m_Buf; 
  m_Buf = NULL; 
  m_Size = 0; 
}

//数据管理类cDataPackage的Save函数的实现，将缓冲区保存到文件中
BOOL cDataPackage::Save(char *Filename)
{
  FILE *fp;

  // 确保有东西可写
  if(m_Buf != NULL && m_Size) {
    // 打开文件，写入尺寸和数据
    if((fp=fopen(Filename, "wb")) != NULL) {
      fwrite(&m_Size, 1, 4, fp);
      fwrite(m_Buf, 1, m_Size, fp);
      fclose(fp);
      return TRUE;
    }
  }

  return FALSE;
}


//数据管理类cDataPackage的Save函数的实现，从文件加载
void *cDataPackage::Load(char *Filename, unsigned long *Size)
{
  FILE *fp;

  // 释放之前的缓冲区
  Free();

  if((fp=fopen(Filename, "rb"))!=NULL) {
    // 以尺寸和数据来读入
    fread(&m_Size, 1, 4, fp);
    if((m_Buf = (void*)new char[m_Size]) != NULL)
      fread(m_Buf, 1, m_Size, fp);
    fclose(fp);

    // 保存尺寸并退出
    if(Size != NULL)
      *Size = m_Size;

    // 返回指针
    return m_Buf;
  }

  return NULL;
}

//得到一个指向数据缓冲区的指针
void *cDataPackage::GetPtr()
{
  return m_Buf;
}


//得到数据的大小
unsigned long cDataPackage::GetSize()
{
  return m_Size;
}